Add files using upload-large-folder tool

.githooks/pre-commit

@@ -1,44 +1,44 @@
-#!/usr/bin/env bash
-# pre-commit -- refresh cheap repo stats without leaking local wiki state.
-#
-# Enable with:   git config core.hooksPath .githooks
-# Disable with:  git config --unset core.hooksPath
-#
-# This hook intentionally does not rebuild graph/wiki artifacts from
-# ~/.claude/skill-wiki. That directory can contain private local entities.
-# Release graph artifacts must be created by explicit, reproducible commands
-# and staged by the user or CI.
-
-set -u
-
-REPO_ROOT="$(git rev-parse --show-toplevel)"
-UPDATER="$REPO_ROOT/src/update_repo_stats.py"
-
-PYTHON="${PYTHON:-python3}"
-command -v "$PYTHON" >/dev/null 2>&1 || PYTHON="python"
-STATS_TIMEOUT="${CTX_REPO_STATS_TIMEOUT:-240s}"
-
-STAGED_CHANGES=$(git diff --cached --name-only)
-log() { echo "[pre-commit] $*" >&2; }
-
-if echo "$STAGED_CHANGES" | grep -qE '^(README\.md|docs/index\.md|graph/(wiki-graph\.tar\.gz|communities\.json|skills-sh-catalog\.json\.gz)|src/update_repo_stats\.py)$' ; then
-  if [[ -f "$UPDATER" ]]; then
-    STATS_CMD=("$PYTHON" "$UPDATER")
-    if command -v timeout >/dev/null 2>&1; then
-      STATS_CMD=(timeout "$STATS_TIMEOUT" "${STATS_CMD[@]}")
-    fi
-    if ! "${STATS_CMD[@]}" 2> >(sed 's/^/[pre-commit stats] /' >&2); then
-      log "stats updater failed or timed out; continuing without README refresh"
-    elif ! git diff --quiet -- README.md docs/index.md; then
-      git add README.md docs/index.md
-      log "README.md and docs/index.md refreshed and re-staged"
-    fi
-  fi
-fi
-
-if echo "$STAGED_CHANGES" | grep -qE '^(skills|agents|harnesses|imported-skills|graph/skills-sh-catalog\.json\.gz)' ; then
-  log "entity source changed; graph/wiki tarball not rebuilt by pre-commit"
-  log "run the explicit graph release command and stage graph/wiki-graph.tar.gz if needed"
-fi
-
-exit 0
+#!/usr/bin/env bash
+# pre-commit -- refresh cheap repo stats without leaking local wiki state.
+#
+# Enable with:   git config core.hooksPath .githooks
+# Disable with:  git config --unset core.hooksPath
+#
+# This hook intentionally does not rebuild graph/wiki artifacts from
+# ~/.claude/skill-wiki. That directory can contain private local entities.
+# Release graph artifacts must be created by explicit, reproducible commands
+# and staged by the user or CI.
+
+set -u
+
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+UPDATER="$REPO_ROOT/src/update_repo_stats.py"
+
+PYTHON="${PYTHON:-python3}"
+command -v "$PYTHON" >/dev/null 2>&1 || PYTHON="python"
+STATS_TIMEOUT="${CTX_REPO_STATS_TIMEOUT:-240s}"
+
+STAGED_CHANGES=$(git diff --cached --name-only)
+log() { echo "[pre-commit] $*" >&2; }
+
+if echo "$STAGED_CHANGES" | grep -qE '^(README\.md|docs/index\.md|graph/(wiki-graph\.tar\.gz|communities\.json|skills-sh-catalog\.json\.gz)|src/update_repo_stats\.py)$' ; then
+  if [[ -f "$UPDATER" ]]; then
+    STATS_CMD=("$PYTHON" "$UPDATER")
+    if command -v timeout >/dev/null 2>&1; then
+      STATS_CMD=(timeout "$STATS_TIMEOUT" "${STATS_CMD[@]}")
+    fi
+    if ! "${STATS_CMD[@]}" 2> >(sed 's/^/[pre-commit stats] /' >&2); then
+      log "stats updater failed or timed out; continuing without README refresh"
+    elif ! git diff --quiet -- README.md docs/index.md; then
+      git add README.md docs/index.md
+      log "README.md and docs/index.md refreshed and re-staged"
+    fi
+  fi
+fi
+
+if echo "$STAGED_CHANGES" | grep -qE '^(skills|agents|harnesses|imported-skills|graph/skills-sh-catalog\.json\.gz)' ; then
+  log "entity source changed; graph/wiki tarball not rebuilt by pre-commit"
+  log "run the explicit graph release command and stage graph/wiki-graph.tar.gz if needed"
+fi
+
+exit 0

internal/playbooks/playbook-live-load-unload.md

@@ -1,156 +1,156 @@
-# Live load / unload verification playbook
-
-> Does ctx actually observe skills and agents being loaded and unloaded
-> on the fly, in real time, during a live Claude Code session? If yes,
-> the telemetry pipeline is truly live. If no, this is a CODE RED — the
-> "real-time knowledge graph" claim is broken and we escalate to an
-> expert swarm.
-
-## What "live load/unload" means in ctx's model
-
-There is no central controller that "loads" a skill. Claude Code
-itself decides when a skill's content is injected into the prompt
-based on user intent + the skill's `description` match. ctx is an
-**observer**, not a driver. Its claim is:
-
-1. **Observe** — `PostToolUse` hook fires `context_monitor.py` on
-   every tool call. When a tool call's content matches a skill-name
-   signal, the event is recorded.
-2. **Suggest** — unmatched signals accumulate in
-   `~/.claude/pending-skills.json`. `skill_suggest.py` surfaces them
-   into Claude's context as `hookSpecificOutput.additionalContext`,
-   so Claude raises them to the user on next response.
-3. **Record** — when Claude actually uses a skill (via its own load
-   mechanism), the event lands in `~/.claude/skill-events.jsonl` as
-   `{"event": "load", "skill": "<slug>", ...}`.
-4. **Score** — the `Stop` hook runs `quality_on_session_end.py`,
-   which recomputes the sidecar for every slug with new events. The
-   telemetry signal reflects the load within seconds.
-
-The pipeline is **only live if every one of those four links works
-with no gap**. This playbook tests each.
-
-## Prerequisites
-
-- `claude-ctx` 0.5.0-rc6 installed (`pip install claude-ctx`).
-- `~/.claude/skill-wiki/` present and graph pre-built
-  (`graphify-out/graph.json` has 2,253 nodes / 454K edges).
-- `~/.claude/settings.json` has the PostToolUse + Stop hooks wired.
-- Baseline snapshot of `~/.claude/skill-events.jsonl` (line count).
-- Baseline snapshot of 3 sidecars (`python-patterns`, `fastapi-pro`,
-  `stripe-integration`) — raw JSON copies under `/tmp/baseline/`.
-
-## Test matrix — each must PASS
-
-### 1. Hook registration
-- [ ] `settings.json` `PostToolUse` contains
-      `context_monitor.py --from-stdin`.
-- [ ] `settings.json` `PostToolUse` contains
-      `skill_add_detector.py --from-stdin`.
-- [ ] `settings.json` `PostToolUse` contains `skill_suggest.py`.
-- [ ] `settings.json` `PostToolUse` contains
-      `backup_on_change.py` under an `Edit|Write|MultiEdit` matcher.
-- [ ] `settings.json` `Stop` contains `usage_tracker.py --sync`.
-- [ ] `settings.json` `Stop` contains `quality_on_session_end.py`.
-- [ ] All hook commands use `--from-stdin` (no
-      `$CLAUDE_TOOL_INPUT`/`$CLAUDE_TOOL_NAME` argv interpolation).
-
-### 2. Observe — context_monitor detects a known signal
-- [ ] Feed `context_monitor.py --from-stdin` a synthetic tool-use
-      event whose `tool_input.file_path` contains `fastapi`.
-- [ ] Before: read `~/.claude/pending-skills.json` line count (or
-      its `unmatched_signals` array length).
-- [ ] After: length grew OR `graph_suggestions` changed.
-- [ ] Repeat with `stripe`, `postgres`, `pci` — all three now in
-      `KEYWORD_SIGNALS` as of rc5.
-
-### 3. Suggest — skill_suggest surfaces pending skills
-- [ ] Run `skill_suggest.py` with no args.
-- [ ] Stdout is a valid JSON object with
-      `hookSpecificOutput.hookEventName == "PostToolUse"` and
-      `additionalContext` referencing at least one candidate skill
-      from the pending-signals added in step 2.
-
-### 4. Record — skill-events.jsonl grows on a simulated load
-- [ ] Before: `wc -l ~/.claude/skill-events.jsonl`.
-- [ ] Append three synthetic events:
-      `load fastapi-pro`,  `load pci-compliance`,
-      `unload fastapi-pro` (distinct `event_id`, realistic
-      timestamp, distinct `session_id` from baseline).
-- [ ] After: line count grew by exactly 3.
-
-### 5. Score — sidecar refreshes on session end
-- [ ] Save sidecar `fastapi-pro.json` copy → `/tmp/baseline/`.
-- [ ] Run `python hooks/quality_on_session_end.py`.
-- [ ] Stdout should include `fastapi-pro` in the "recomputed" list
-      (only slugs with new events should be touched).
-- [ ] Compare `~/.claude/skill-quality/fastapi-pro.json` mtime —
-      must be newer than baseline by >0 seconds.
-- [ ] Telemetry signal `load_count` increased by 2 (the two loads
-      we appended); `recent_load_count` increased by 2.
-- [ ] Overall `score` changed OR `grade` changed (F→D→C→B→A).
-
-### 6. End-to-end timing
-- [ ] From the moment the synthetic load event is written to
-      skill-events.jsonl, how many seconds until
-      `ctx-skill-quality explain fastapi-pro` reflects it?
-      - Required: **< 30 seconds** with `quality_on_session_end.py`
-        fired manually.
-      - Stretch: **< 5 seconds** if the Stop hook fires on session
-        close.
-- [ ] Record the measured latency.
-
-### 7. Session attribution — can we tell which session loaded what?
-- [ ] Scan `skill-events.jsonl` for the test `session_id`.
-- [ ] All 3 test events appear with that session_id.
-- [ ] `ctx-skill-quality explain <slug>` doesn't currently surface
-      per-session detail — **gap; track as future work**.
-
-## Pass / fail criteria
-
-**PASS** — all of 1–5 pass, and step 6 measured latency is under
-30 seconds. This proves the pipeline is live.
-
-**PARTIAL** — 4 of 5 pass; latency acceptable; one gap exists.
-Ship the rc, file the gap as a follow-up issue.
-
-**FAIL** — any of steps 2, 4, or 5 fails. The
-observe→record→score loop is broken. This is a **CODE RED**:
-
-1. Escalate to an expert swarm (Anthropic, OpenAI, Mistral,
-   Microsoft observability + agent-system engineers).
-2. Goal: design a minimum change set that makes the pipeline live.
-3. Output: a 1-pager plan with the smallest possible code change
-   and a test that would have caught the regression.
-
-## What "expert swarm" looks like
-
-Five sub-agents spawned in parallel, each briefed differently:
-
-- **Anthropic engineer** — Claude Code hook model, `stdin` format,
-  ordering guarantees of PostToolUse vs Stop. Tells us if what we
-  expect is actually guaranteed by Claude Code.
-- **OpenAI engineer** — event-driven telemetry design, how
-  function-call / tool-call streams are typically observed in
-  production ChatGPT-style systems. Tells us if our jsonl approach
-  is sound or if we're missing a standard pattern.
-- **Mistral engineer** — lightweight on-device observability, how
-  to keep the observer cheap when the agent environment is local.
-  Tells us whether our hook fan-out is causing latency.
-- **Microsoft engineer** — VS Code extension + language-server
-  observability. Tells us what hook contract an IDE-hosted agent
-  should expose for a pluggable observer like ctx.
-- **Consolidator** — takes the four reports and outputs a single
-  plan with a "minimum viable fix" ranked by effort/reward.
-
-Each agent gets **the same failing evidence**: the events.jsonl
-before/after, the sidecar mtime check, the captured hook output.
-Their job is to diagnose, not to re-run the test.
-
-## Next steps after verification
-
-- If PASS: ship the audit-log feature, ship `ctx-monitor serve`
-  with per-session view.
-- If PARTIAL: ship the gap fix, document the session-attribution
-  limitation in the README.
-- If FAIL: execute the expert-swarm plan, iterate until PASS.
+# Live load / unload verification playbook
+
+> Does ctx actually observe skills and agents being loaded and unloaded
+> on the fly, in real time, during a live Claude Code session? If yes,
+> the telemetry pipeline is truly live. If no, this is a CODE RED — the
+> "real-time knowledge graph" claim is broken and we escalate to an
+> expert swarm.
+
+## What "live load/unload" means in ctx's model
+
+There is no central controller that "loads" a skill. Claude Code
+itself decides when a skill's content is injected into the prompt
+based on user intent + the skill's `description` match. ctx is an
+**observer**, not a driver. Its claim is:
+
+1. **Observe** — `PostToolUse` hook fires `context_monitor.py` on
+   every tool call. When a tool call's content matches a skill-name
+   signal, the event is recorded.
+2. **Suggest** — unmatched signals accumulate in
+   `~/.claude/pending-skills.json`. `skill_suggest.py` surfaces them
+   into Claude's context as `hookSpecificOutput.additionalContext`,
+   so Claude raises them to the user on next response.
+3. **Record** — when Claude actually uses a skill (via its own load
+   mechanism), the event lands in `~/.claude/skill-events.jsonl` as
+   `{"event": "load", "skill": "<slug>", ...}`.
+4. **Score** — the `Stop` hook runs `quality_on_session_end.py`,
+   which recomputes the sidecar for every slug with new events. The
+   telemetry signal reflects the load within seconds.
+
+The pipeline is **only live if every one of those four links works
+with no gap**. This playbook tests each.
+
+## Prerequisites
+
+- `claude-ctx` 0.5.0-rc6 installed (`pip install claude-ctx`).
+- `~/.claude/skill-wiki/` present and graph pre-built
+  (`graphify-out/graph.json` has 2,253 nodes / 454K edges).
+- `~/.claude/settings.json` has the PostToolUse + Stop hooks wired.
+- Baseline snapshot of `~/.claude/skill-events.jsonl` (line count).
+- Baseline snapshot of 3 sidecars (`python-patterns`, `fastapi-pro`,
+  `stripe-integration`) — raw JSON copies under `/tmp/baseline/`.
+
+## Test matrix — each must PASS
+
+### 1. Hook registration
+- [ ] `settings.json` `PostToolUse` contains
+      `context_monitor.py --from-stdin`.
+- [ ] `settings.json` `PostToolUse` contains
+      `skill_add_detector.py --from-stdin`.
+- [ ] `settings.json` `PostToolUse` contains `skill_suggest.py`.
+- [ ] `settings.json` `PostToolUse` contains
+      `backup_on_change.py` under an `Edit|Write|MultiEdit` matcher.
+- [ ] `settings.json` `Stop` contains `usage_tracker.py --sync`.
+- [ ] `settings.json` `Stop` contains `quality_on_session_end.py`.
+- [ ] All hook commands use `--from-stdin` (no
+      `$CLAUDE_TOOL_INPUT`/`$CLAUDE_TOOL_NAME` argv interpolation).
+
+### 2. Observe — context_monitor detects a known signal
+- [ ] Feed `context_monitor.py --from-stdin` a synthetic tool-use
+      event whose `tool_input.file_path` contains `fastapi`.
+- [ ] Before: read `~/.claude/pending-skills.json` line count (or
+      its `unmatched_signals` array length).
+- [ ] After: length grew OR `graph_suggestions` changed.
+- [ ] Repeat with `stripe`, `postgres`, `pci` — all three now in
+      `KEYWORD_SIGNALS` as of rc5.
+
+### 3. Suggest — skill_suggest surfaces pending skills
+- [ ] Run `skill_suggest.py` with no args.
+- [ ] Stdout is a valid JSON object with
+      `hookSpecificOutput.hookEventName == "PostToolUse"` and
+      `additionalContext` referencing at least one candidate skill
+      from the pending-signals added in step 2.
+
+### 4. Record — skill-events.jsonl grows on a simulated load
+- [ ] Before: `wc -l ~/.claude/skill-events.jsonl`.
+- [ ] Append three synthetic events:
+      `load fastapi-pro`,  `load pci-compliance`,
+      `unload fastapi-pro` (distinct `event_id`, realistic
+      timestamp, distinct `session_id` from baseline).
+- [ ] After: line count grew by exactly 3.
+
+### 5. Score — sidecar refreshes on session end
+- [ ] Save sidecar `fastapi-pro.json` copy → `/tmp/baseline/`.
+- [ ] Run `python hooks/quality_on_session_end.py`.
+- [ ] Stdout should include `fastapi-pro` in the "recomputed" list
+      (only slugs with new events should be touched).
+- [ ] Compare `~/.claude/skill-quality/fastapi-pro.json` mtime —
+      must be newer than baseline by >0 seconds.
+- [ ] Telemetry signal `load_count` increased by 2 (the two loads
+      we appended); `recent_load_count` increased by 2.
+- [ ] Overall `score` changed OR `grade` changed (F→D→C→B→A).
+
+### 6. End-to-end timing
+- [ ] From the moment the synthetic load event is written to
+      skill-events.jsonl, how many seconds until
+      `ctx-skill-quality explain fastapi-pro` reflects it?
+      - Required: **< 30 seconds** with `quality_on_session_end.py`
+        fired manually.
+      - Stretch: **< 5 seconds** if the Stop hook fires on session
+        close.
+- [ ] Record the measured latency.
+
+### 7. Session attribution — can we tell which session loaded what?
+- [ ] Scan `skill-events.jsonl` for the test `session_id`.
+- [ ] All 3 test events appear with that session_id.
+- [ ] `ctx-skill-quality explain <slug>` doesn't currently surface
+      per-session detail — **gap; track as future work**.
+
+## Pass / fail criteria
+
+**PASS** — all of 1–5 pass, and step 6 measured latency is under
+30 seconds. This proves the pipeline is live.
+
+**PARTIAL** — 4 of 5 pass; latency acceptable; one gap exists.
+Ship the rc, file the gap as a follow-up issue.
+
+**FAIL** — any of steps 2, 4, or 5 fails. The
+observe→record→score loop is broken. This is a **CODE RED**:
+
+1. Escalate to an expert swarm (Anthropic, OpenAI, Mistral,
+   Microsoft observability + agent-system engineers).
+2. Goal: design a minimum change set that makes the pipeline live.
+3. Output: a 1-pager plan with the smallest possible code change
+   and a test that would have caught the regression.
+
+## What "expert swarm" looks like
+
+Five sub-agents spawned in parallel, each briefed differently:
+
+- **Anthropic engineer** — Claude Code hook model, `stdin` format,
+  ordering guarantees of PostToolUse vs Stop. Tells us if what we
+  expect is actually guaranteed by Claude Code.
+- **OpenAI engineer** — event-driven telemetry design, how
+  function-call / tool-call streams are typically observed in
+  production ChatGPT-style systems. Tells us if our jsonl approach
+  is sound or if we're missing a standard pattern.
+- **Mistral engineer** — lightweight on-device observability, how
+  to keep the observer cheap when the agent environment is local.
+  Tells us whether our hook fan-out is causing latency.
+- **Microsoft engineer** — VS Code extension + language-server
+  observability. Tells us what hook contract an IDE-hosted agent
+  should expose for a pluggable observer like ctx.
+- **Consolidator** — takes the four reports and outputs a single
+  plan with a "minimum viable fix" ranked by effort/reward.
+
+Each agent gets **the same failing evidence**: the events.jsonl
+before/after, the sidecar mtime check, the captured hook output.
+Their job is to diagnose, not to re-run the test.
+
+## Next steps after verification
+
+- If PASS: ship the audit-log feature, ship `ctx-monitor serve`
+  with per-session view.
+- If PARTIAL: ship the gap fix, document the session-attribution
+  limitation in the README.
+- If FAIL: execute the expert-swarm plan, iterate until PASS.

internal/playbooks/playbook-random-load-unload.md

@@ -1,294 +1,294 @@
-# Random load → unload playbook
-
-> Pick a skill the user hasn't touched recently, verify ctx suggests
-> loading it, verify the skill actually enters the loaded set, wait
-> for staleness, verify ctx suggests unloading it, verify it actually
-> leaves. Every claim is backed by a concrete file-system observation,
-> not a log-line assumption.
-
-## Why this scenario matters
-
-Previous playbooks verified the *pipeline* (observer → suggest →
-record → score). This one verifies the **economic** part: skills
-come in and go back out, and the user can observe both halves of
-the cycle. Without this, the "nothing rots" claim in the README is
-untested.
-
-## What we'll use
-
-- **ctx-monitor** (rc8+) to watch the audit log live via SSE. The
-  test agent keeps the dashboard open at
-  `http://127.0.0.1:8765/session/<test-session-id>` and screenshots
-  the audit timeline before/after.
-- **ctx_audit_log** event stream (`~/.claude/ctx-audit.jsonl`).
-- **skill-events.jsonl** for the ground-truth load/unload record.
-- **pending-unload.json** for the suggest-to-unload signal.
-- **skill_quality explain <slug>** to read the sidecar after each
-  phase.
-
-## Preconditions
-
-1. `claude-ctx` 0.5.0-rc8 installed from PyPI.
-2. `~/.claude/skill-wiki/` pre-built (2,253 nodes, 454K edges).
-3. `~/.claude/skills/` has ≥ 1,500 skills installed.
-4. `~/.claude/settings.json` has all rc7 hooks wired
-   (PostToolUse: context_monitor + skill_add_detector + skill_suggest
-   + backup_on_change; Stop: usage_tracker + quality_on_session_end).
-5. Stale-threshold override for the test run. Write it into
-   `~/.claude/skill-system-config.json` — there is no env var
-   shortcut; the threshold only comes from config:
-   ```bash
-   python -c "
-   import json, os
-   from pathlib import Path
-   p = Path(os.path.expanduser('~/.claude/skill-system-config.json'))
-   cfg = json.loads(p.read_text()) if p.exists() else {}
-   cfg.setdefault('usage_tracker', {})['stale_threshold_sessions'] = 3
-   p.write_text(json.dumps(cfg, indent=2))
-   "
-   ```
-   Default is 30 — too slow to observe in one sitting.
-6. `ctx-monitor serve --port 8765` running in a background tab.
-
-## The scenario
-
-### Step 1 — Pick a random candidate
-
-Pick a skill whose sidecar has:
-- `hard_floor: "never_loaded_stale"` — these all map to **grade D**
-  (grade F is reserved for `intake_fail`), AND
-- `intake.score >= 0.8` (structurally valid), AND
-- **tag overlap with `context_monitor.KEYWORD_SIGNALS`** — otherwise
-  the skill can never surface through the observe→suggest path
-  (learned the hard way on rc8's verification run), AND
-- not a meta-skill (`skill-router`, `file-reading`, etc.).
-
-```bash
-python - <<'PY'
-import json, random, re
-from pathlib import Path
-
-# Seed: installed KEYWORD_SIGNALS from context_monitor.
-# Load dynamically to survive future vocabulary changes.
-import importlib.util
-src = Path.home() / ".claude" / "skills"  # may differ per install
-spec_path = None
-for candidate in [
-    Path(__file__).resolve().parents[1] / "src" / "context_monitor.py",
-    Path.home() / ".local" / "lib" / "python3.11" / "site-packages" / "context_monitor.py",
-]:
-    if candidate.exists():
-        spec_path = candidate; break
-spec = importlib.util.spec_from_file_location("_cm", spec_path)
-cm = importlib.util.module_from_spec(spec); spec.loader.exec_module(cm)
-keywords = set(cm.KEYWORD_SIGNALS.keys())
-
-sidecar_dir = Path.home() / ".claude" / "skill-quality"
-candidates: list[str] = []
-for p in sidecar_dir.glob("*.json"):
-    if p.name.startswith(".") or p.name.endswith(".lifecycle.json"):
-        continue
-    try:
-        sc = json.loads(p.read_text())
-    except Exception:
-        continue
-    if sc.get("hard_floor") != "never_loaded_stale" or sc.get("grade") != "D":
-        continue
-    intake = (sc.get("signals") or {}).get("intake", {}) or {}
-    if intake.get("score", 0) < 0.8:
-        continue
-    slug = sc["slug"]
-    if slug in {"skill-router", "file-reading", "context-monitor"}:
-        continue
-    # Require ≥2 tag tokens in the slug that also appear as KEYWORD_SIGNALS
-    slug_tokens = set(re.split(r"[^a-z0-9]+", slug.lower()))
-    if len(slug_tokens & keywords) >= 2:
-        candidates.append(slug)
-
-random.shuffle(candidates)
-print(candidates[0] if candidates else "NONE_FOUND")
-PY
-```
-
-Record the picked slug. Call it `$TARGET`.
-
-**Expected**: $TARGET has `grade=D`, `load_count=0`,
-`never_loaded=True`, `hard_floor=never_loaded_stale`.
-
-### Step 2 — Inject a stack signal that should surface $TARGET
-
-Look at the target skill's `tags`. Synthesize a PostToolUse payload
-whose `tool_input.file_path` or content contains 3+ of those tags
-(crossing the `UNMATCHED_SIGNAL_THRESHOLD` in
-`context_monitor.py`).
-
-Pipe it into `context_monitor.py --from-stdin` 3 times. On the
-third call, ctx should add $TARGET to
-`~/.claude/pending-skills.json` under `graph_suggestions`.
-
-```bash
-for i in 1 2 3; do
-  echo '{"session_id":"random-load-test","tool_name":"Write",
-         "tool_input":{"file_path":"app/<tag-heavy-path>.py",
-         "content":"<content with target tags>"}}' \
-    | python -m context_monitor --from-stdin
-done
-
-cat ~/.claude/pending-skills.json | python -m json.tool | head -30
-```
-
-**Expected**: `graph_suggestions` array contains $TARGET with a
-non-empty `shared_tags` list and `score > 0`.
-
-### Step 3 — Run skill_suggest.py, verify the suggestion surfaces
-
-```bash
-python -m skill_suggest
-```
-
-**Expected**: stdout is valid JSON with
-`hookSpecificOutput.additionalContext` containing $TARGET's slug or
-its description. If absent: the graph-walk → suggestion path is
-broken.
-
-### Step 4 — Simulate the user accepting the suggestion (skill load)
-
-In a live session, Claude would invoke `skill_loader.py load
-$TARGET` here. Simulate by appending the load event:
-
-```bash
-python -c "
-import json, uuid
-from pathlib import Path
-from datetime import datetime, timezone
-e = Path.home()/'.claude'/'skill-events.jsonl'
-line = {
-  'event': 'load',
-  'event_id': uuid.uuid4().hex,
-  'meta': {'source':'random-load-test'},
-  'session_id': 'random-load-test',
-  'skill': '$TARGET',
-  'timestamp': datetime.now(timezone.utc).isoformat(),
-}
-with e.open('a') as f: f.write(json.dumps(line)+'\n')
-"
-```
-
-**Expected**:
-- `skill-events.jsonl` grew by exactly 1 line with `skill=$TARGET`.
-- Audit log (`ctx-audit.jsonl`) will not yet have a `skill.loaded`
-  row — that event is written by the hook Claude Code fires when
-  it actually injects the skill. For the simulation we record it
-  manually too:
-
-```bash
-python -c "from ctx_audit_log import log_skill_event; \
-  log_skill_event('skill.loaded','$TARGET', \
-    session_id='random-load-test', meta={'via':'sim'})"
-```
-
-### Step 5 — Verify the skill is loaded
-
-`skill_loader.py` (or its simulation) updates the manifest:
-
-```bash
-jq '.load[].skill' ~/.claude/skill-manifest.json | grep -x '"$TARGET"'
-```
-
-Plus read it from ctx-monitor's dashboard:
-
-```
-curl -s http://127.0.0.1:8765/api/sessions.json | \
-  jq '.[] | select(.session_id=="random-load-test")'
-```
-
-**Expected**: `skills_loaded` array of the test session includes
-$TARGET.
-
-### Step 6 — Force a Stop hook (end-of-session)
-
-The Stop hook reads `session_id` from stdin (Claude Code delivers
-the session payload there in production). **Do NOT use `< /dev/null`**
-— it strips the session_id and the `skill.score_updated` audit row
-gets a synthesized id instead of the real one, so the dashboard's
-per-session timeline drops the middle event in the triad.
-
-```bash
-SID="random-load-test"
-echo "{\"session_id\":\"$SID\"}" | python hooks/quality_on_session_end.py
-python -m usage_tracker --sync
-```
-
-**Expected**:
-- Sidecar for $TARGET now shows `load_count >= 1`,
-  `never_loaded=False`, `hard_floor=null`, grade shifted from D
-  to something higher (usually C or B).
-- Audit log has a new `skill.score_updated` row with
-  `session_id=random-load-test` for $TARGET. Confirm via
-  `grep score_updated ~/.claude/ctx-audit.jsonl | tail -1`.
-
-### Step 7 — Wait for staleness
-
-Run `usage_tracker --sync` two more times without any
-corresponding `used` signal (i.e., no recent intent-log entry for
-the tags that originally surfaced $TARGET). With
-`CTX_STALE_THRESHOLD_SESSIONS=3` and `session_count` bumped on each
-sync, $TARGET should cross the stale threshold on the 3rd sync.
-
-```bash
-for i in 1 2 3; do python -m usage_tracker --sync; done
-cat ~/.claude/pending-unload.json | python -m json.tool
-```
-
-**Expected**: `pending-unload.json` contains $TARGET with
-`reason: stale session_count=3 use_count=0`.
-
-### Step 8 — Simulate user approving the unload
-
-```bash
-python -m skill_unload --slug $TARGET --session-id random-load-test
-```
-
-(If `skill_unload` CLI isn't wired to the same module, append an
-`unload` event manually — same shape as step 4 with `event=unload`.)
-
-**Expected**:
-- `skill-events.jsonl` has an `unload` line for $TARGET.
-- `skill-manifest.json`'s `load[]` no longer contains $TARGET.
-- Audit log gains a `skill.unloaded` row.
-- ctx-monitor `/session/random-load-test` now shows $TARGET in
-  both `skills_loaded` AND `skills_unloaded`.
-
-### Step 9 — Final verification via dashboard
-
-Open `http://127.0.0.1:8765/session/random-load-test` in a browser.
-
-The audit timeline must show, in order:
-
-1. `skill.loaded` $TARGET
-2. `skill.score_updated` $TARGET (after Stop hook)
-3. `skill.unloaded` $TARGET
-
-Screenshot this. That is the end-to-end proof.
-
-## Pass / fail criteria
-
-- **PASS**: all 9 steps produce the expected on-disk + dashboard
-  evidence. The load → stale → unload cycle works.
-- **PARTIAL**: suggestion surfaces but `pending-unload.json` never
-  gains an entry (step 7 fails). Staleness detection is broken;
-  release but file the issue.
-- **FAIL**: step 5 fails — the skill can be "suggested" but never
-  actually reaches the manifest's `load[]` set. The observer is
-  blind to real loads. Release blocker — escalate.
-
-## Known honest limitations
-
-- We can't fully test Claude Code's own load mechanism from a
-  simulation — we simulate the load event write. The verification
-  is therefore of the ctx half of the contract (suggest → observe →
-  queue-for-unload), not the IDE half (inject skill into prompt).
-- `context_monitor` only suggests based on KEYWORD_SIGNALS +
-  graph walks. If $TARGET has no tags that match any keyword, the
-  suggestion won't surface. The candidate picker in step 1 filters
-  on tag richness for that reason.
+# Random load → unload playbook
+
+> Pick a skill the user hasn't touched recently, verify ctx suggests
+> loading it, verify the skill actually enters the loaded set, wait
+> for staleness, verify ctx suggests unloading it, verify it actually
+> leaves. Every claim is backed by a concrete file-system observation,
+> not a log-line assumption.
+
+## Why this scenario matters
+
+Previous playbooks verified the *pipeline* (observer → suggest →
+record → score). This one verifies the **economic** part: skills
+come in and go back out, and the user can observe both halves of
+the cycle. Without this, the "nothing rots" claim in the README is
+untested.
+
+## What we'll use
+
+- **ctx-monitor** (rc8+) to watch the audit log live via SSE. The
+  test agent keeps the dashboard open at
+  `http://127.0.0.1:8765/session/<test-session-id>` and screenshots
+  the audit timeline before/after.
+- **ctx_audit_log** event stream (`~/.claude/ctx-audit.jsonl`).
+- **skill-events.jsonl** for the ground-truth load/unload record.
+- **pending-unload.json** for the suggest-to-unload signal.
+- **skill_quality explain <slug>** to read the sidecar after each
+  phase.
+
+## Preconditions
+
+1. `claude-ctx` 0.5.0-rc8 installed from PyPI.
+2. `~/.claude/skill-wiki/` pre-built (2,253 nodes, 454K edges).
+3. `~/.claude/skills/` has ≥ 1,500 skills installed.
+4. `~/.claude/settings.json` has all rc7 hooks wired
+   (PostToolUse: context_monitor + skill_add_detector + skill_suggest
+   + backup_on_change; Stop: usage_tracker + quality_on_session_end).
+5. Stale-threshold override for the test run. Write it into
+   `~/.claude/skill-system-config.json` — there is no env var
+   shortcut; the threshold only comes from config:
+   ```bash
+   python -c "
+   import json, os
+   from pathlib import Path
+   p = Path(os.path.expanduser('~/.claude/skill-system-config.json'))
+   cfg = json.loads(p.read_text()) if p.exists() else {}
+   cfg.setdefault('usage_tracker', {})['stale_threshold_sessions'] = 3
+   p.write_text(json.dumps(cfg, indent=2))
+   "
+   ```
+   Default is 30 — too slow to observe in one sitting.
+6. `ctx-monitor serve --port 8765` running in a background tab.
+
+## The scenario
+
+### Step 1 — Pick a random candidate
+
+Pick a skill whose sidecar has:
+- `hard_floor: "never_loaded_stale"` — these all map to **grade D**
+  (grade F is reserved for `intake_fail`), AND
+- `intake.score >= 0.8` (structurally valid), AND
+- **tag overlap with `context_monitor.KEYWORD_SIGNALS`** — otherwise
+  the skill can never surface through the observe→suggest path
+  (learned the hard way on rc8's verification run), AND
+- not a meta-skill (`skill-router`, `file-reading`, etc.).
+
+```bash
+python - <<'PY'
+import json, random, re
+from pathlib import Path
+
+# Seed: installed KEYWORD_SIGNALS from context_monitor.
+# Load dynamically to survive future vocabulary changes.
+import importlib.util
+src = Path.home() / ".claude" / "skills"  # may differ per install
+spec_path = None
+for candidate in [
+    Path(__file__).resolve().parents[1] / "src" / "context_monitor.py",
+    Path.home() / ".local" / "lib" / "python3.11" / "site-packages" / "context_monitor.py",
+]:
+    if candidate.exists():
+        spec_path = candidate; break
+spec = importlib.util.spec_from_file_location("_cm", spec_path)
+cm = importlib.util.module_from_spec(spec); spec.loader.exec_module(cm)
+keywords = set(cm.KEYWORD_SIGNALS.keys())
+
+sidecar_dir = Path.home() / ".claude" / "skill-quality"
+candidates: list[str] = []
+for p in sidecar_dir.glob("*.json"):
+    if p.name.startswith(".") or p.name.endswith(".lifecycle.json"):
+        continue
+    try:
+        sc = json.loads(p.read_text())
+    except Exception:
+        continue
+    if sc.get("hard_floor") != "never_loaded_stale" or sc.get("grade") != "D":
+        continue
+    intake = (sc.get("signals") or {}).get("intake", {}) or {}
+    if intake.get("score", 0) < 0.8:
+        continue
+    slug = sc["slug"]
+    if slug in {"skill-router", "file-reading", "context-monitor"}:
+        continue
+    # Require ≥2 tag tokens in the slug that also appear as KEYWORD_SIGNALS
+    slug_tokens = set(re.split(r"[^a-z0-9]+", slug.lower()))
+    if len(slug_tokens & keywords) >= 2:
+        candidates.append(slug)
+
+random.shuffle(candidates)
+print(candidates[0] if candidates else "NONE_FOUND")
+PY
+```
+
+Record the picked slug. Call it `$TARGET`.
+
+**Expected**: $TARGET has `grade=D`, `load_count=0`,
+`never_loaded=True`, `hard_floor=never_loaded_stale`.
+
+### Step 2 — Inject a stack signal that should surface $TARGET
+
+Look at the target skill's `tags`. Synthesize a PostToolUse payload
+whose `tool_input.file_path` or content contains 3+ of those tags
+(crossing the `UNMATCHED_SIGNAL_THRESHOLD` in
+`context_monitor.py`).
+
+Pipe it into `context_monitor.py --from-stdin` 3 times. On the
+third call, ctx should add $TARGET to
+`~/.claude/pending-skills.json` under `graph_suggestions`.
+
+```bash
+for i in 1 2 3; do
+  echo '{"session_id":"random-load-test","tool_name":"Write",
+         "tool_input":{"file_path":"app/<tag-heavy-path>.py",
+         "content":"<content with target tags>"}}' \
+    | python -m context_monitor --from-stdin
+done
+
+cat ~/.claude/pending-skills.json | python -m json.tool | head -30
+```
+
+**Expected**: `graph_suggestions` array contains $TARGET with a
+non-empty `shared_tags` list and `score > 0`.
+
+### Step 3 — Run skill_suggest.py, verify the suggestion surfaces
+
+```bash
+python -m skill_suggest
+```
+
+**Expected**: stdout is valid JSON with
+`hookSpecificOutput.additionalContext` containing $TARGET's slug or
+its description. If absent: the graph-walk → suggestion path is
+broken.
+
+### Step 4 — Simulate the user accepting the suggestion (skill load)
+
+In a live session, Claude would invoke `skill_loader.py load
+$TARGET` here. Simulate by appending the load event:
+
+```bash
+python -c "
+import json, uuid
+from pathlib import Path
+from datetime import datetime, timezone
+e = Path.home()/'.claude'/'skill-events.jsonl'
+line = {
+  'event': 'load',
+  'event_id': uuid.uuid4().hex,
+  'meta': {'source':'random-load-test'},
+  'session_id': 'random-load-test',
+  'skill': '$TARGET',
+  'timestamp': datetime.now(timezone.utc).isoformat(),
+}
+with e.open('a') as f: f.write(json.dumps(line)+'\n')
+"
+```
+
+**Expected**:
+- `skill-events.jsonl` grew by exactly 1 line with `skill=$TARGET`.
+- Audit log (`ctx-audit.jsonl`) will not yet have a `skill.loaded`
+  row — that event is written by the hook Claude Code fires when
+  it actually injects the skill. For the simulation we record it
+  manually too:
+
+```bash
+python -c "from ctx_audit_log import log_skill_event; \
+  log_skill_event('skill.loaded','$TARGET', \
+    session_id='random-load-test', meta={'via':'sim'})"
+```
+
+### Step 5 — Verify the skill is loaded
+
+`skill_loader.py` (or its simulation) updates the manifest:
+
+```bash
+jq '.load[].skill' ~/.claude/skill-manifest.json | grep -x '"$TARGET"'
+```
+
+Plus read it from ctx-monitor's dashboard:
+
+```
+curl -s http://127.0.0.1:8765/api/sessions.json | \
+  jq '.[] | select(.session_id=="random-load-test")'
+```
+
+**Expected**: `skills_loaded` array of the test session includes
+$TARGET.
+
+### Step 6 — Force a Stop hook (end-of-session)
+
+The Stop hook reads `session_id` from stdin (Claude Code delivers
+the session payload there in production). **Do NOT use `< /dev/null`**
+— it strips the session_id and the `skill.score_updated` audit row
+gets a synthesized id instead of the real one, so the dashboard's
+per-session timeline drops the middle event in the triad.
+
+```bash
+SID="random-load-test"
+echo "{\"session_id\":\"$SID\"}" | python hooks/quality_on_session_end.py
+python -m usage_tracker --sync
+```
+
+**Expected**:
+- Sidecar for $TARGET now shows `load_count >= 1`,
+  `never_loaded=False`, `hard_floor=null`, grade shifted from D
+  to something higher (usually C or B).
+- Audit log has a new `skill.score_updated` row with
+  `session_id=random-load-test` for $TARGET. Confirm via
+  `grep score_updated ~/.claude/ctx-audit.jsonl | tail -1`.
+
+### Step 7 — Wait for staleness
+
+Run `usage_tracker --sync` two more times without any
+corresponding `used` signal (i.e., no recent intent-log entry for
+the tags that originally surfaced $TARGET). With
+`CTX_STALE_THRESHOLD_SESSIONS=3` and `session_count` bumped on each
+sync, $TARGET should cross the stale threshold on the 3rd sync.
+
+```bash
+for i in 1 2 3; do python -m usage_tracker --sync; done
+cat ~/.claude/pending-unload.json | python -m json.tool
+```
+
+**Expected**: `pending-unload.json` contains $TARGET with
+`reason: stale session_count=3 use_count=0`.
+
+### Step 8 — Simulate user approving the unload
+
+```bash
+python -m skill_unload --slug $TARGET --session-id random-load-test
+```
+
+(If `skill_unload` CLI isn't wired to the same module, append an
+`unload` event manually — same shape as step 4 with `event=unload`.)
+
+**Expected**:
+- `skill-events.jsonl` has an `unload` line for $TARGET.
+- `skill-manifest.json`'s `load[]` no longer contains $TARGET.
+- Audit log gains a `skill.unloaded` row.
+- ctx-monitor `/session/random-load-test` now shows $TARGET in
+  both `skills_loaded` AND `skills_unloaded`.
+
+### Step 9 — Final verification via dashboard
+
+Open `http://127.0.0.1:8765/session/random-load-test` in a browser.
+
+The audit timeline must show, in order:
+
+1. `skill.loaded` $TARGET
+2. `skill.score_updated` $TARGET (after Stop hook)
+3. `skill.unloaded` $TARGET
+
+Screenshot this. That is the end-to-end proof.
+
+## Pass / fail criteria
+
+- **PASS**: all 9 steps produce the expected on-disk + dashboard
+  evidence. The load → stale → unload cycle works.
+- **PARTIAL**: suggestion surfaces but `pending-unload.json` never
+  gains an entry (step 7 fails). Staleness detection is broken;
+  release but file the issue.
+- **FAIL**: step 5 fails — the skill can be "suggested" but never
+  actually reaches the manifest's `load[]` set. The observer is
+  blind to real loads. Release blocker — escalate.
+
+## Known honest limitations
+
+- We can't fully test Claude Code's own load mechanism from a
+  simulation — we simulate the load event write. The verification
+  is therefore of the ctx half of the contract (suggest → observe →
+  queue-for-unload), not the IDE half (inject skill into prompt).
+- `context_monitor` only suggests based on KEYWORD_SIGNALS +
+  graph walks. If $TARGET has no tags that match any keyword, the
+  suggestion won't surface. The candidate picker in step 1 filters
+  on tag richness for that reason.

internal/playbooks/playbook-real-world.md

@@ -1,274 +1,274 @@
-# Real-world ctx playbook
-
-> Canonical end-to-end scenario exercising every ctx surface: scan → graph
-> suggest → skill load/unload → toolbox council → skill_add → lifecycle
-> archive → KPI. Assumes the user's environment already has the graph
-> (`~/.claude/skill-wiki/graphify-out/graph.json`) and wiki
-> (`~/.claude/skill-wiki/`) **pre-built** — we do NOT rebuild in this
-> playbook.
-
-## Persona
-
-**Maya** — senior backend engineer at a B2C fintech. Installing `claude-ctx`
-fresh. First project on ctx: a **PCI-compliant checkout microservice**
-(FastAPI + SQLAlchemy + PostgreSQL + Stripe + pytest). Target: working
-endpoint + council-signed commit by end of day.
-
-She has `~/.claude/skills/` with 1,789 skills and `~/.claude/agents/`
-with 464 agents pre-installed (extracted from `graph/wiki-graph.tar.gz`).
-Graph is pre-built (2,253 nodes / 454K edges / 93 communities). She has
-never run ctx before.
-
-## Environment precondition
-
-```
-~/.claude/skill-wiki/graphify-out/graph.json   # pre-built, 454K edges
-~/.claude/skill-wiki/entities/                 # 2,253 entity pages
-~/.claude/skill-wiki/converted/                # 952 compressed skills
-~/.claude/skill-quality/                       # 1,891 sidecars
-```
-
-`pip install claude-ctx` is done. The four console scripts are on PATH.
-
----
-
-## Phase 1 — Project bootstrap + first stack scan
-
-```bash
-mkdir ~/work/checkout-svc && cd ~/work/checkout-svc
-git init
-cat > requirements.txt <<EOF
-fastapi
-sqlalchemy
-psycopg2-binary
-pydantic
-stripe
-pytest
-EOF
-echo "app" > .gitignore
-mkdir -p app tests
-```
-
-Maya runs:
-
-```bash
-ctx-scan-repo --repo . --output .ctx/stack.json
-```
-
-**Expected ctx behavior**
-1. `scan_repo` detects: python / fastapi / sqlalchemy / pytest /
-   stripe / postgres (from `psycopg2-binary` signature).
-2. `resolve_skills` walks the **pre-built graph** from those stack tags
-   and recommends ~10–15 skills:
-   - direct/fuzzy matches: `fastapi-pro`, `python-patterns`,
-     `python-fastapi-development`, `pydantic-models-py`,
-     `stripe-integration`, `payment-integration`, `pci-compliance`,
-     `postgresql-optimization`
-   - graph neighbors (edge-weight ≥ 1.5): `test-automator`,
-     `python-pro`, `async-python-patterns`, `backend-security-coder`,
-     `api-security-best-practices`
-
-**Verification**
-- Manifest has 10–15 `load` entries with mixed `reason` fields:
-  `fuzzy match for detected stack 'fastapi'`, `graph neighbor of ...`.
-- No warnings for "not installed" when fuzzy fallback found an alternative.
-
----
-
-## Phase 2 — Claude session starts; context monitor observes
-
-Maya launches Claude Code in `~/work/checkout-svc/`. `PostToolUse` hooks
-fire on every tool call; `Stop` fires at session end.
-
-Maya asks Claude: *"scaffold the checkout endpoint with Stripe payment
-intents".*
-
-**Expected ctx behavior during the session**
-1. **PostToolUse** fires `context_monitor.py --from-stdin` on every
-   tool call. The monitor reads the tool input, detects signals:
-   - file path `app/api/checkout.py` → stack signal `python`, `fastapi`
-   - content containing `stripe.PaymentIntent` → new signal `stripe`
-2. When an unmatched signal accumulates past threshold (3 by default),
-   `context_monitor` writes to `~/.claude/pending-skills.json` and
-   `skill_suggest.py` surfaces it to Claude's context as a
-   `hookSpecificOutput.additionalContext` blob.
-3. Claude reads the suggestion ("You may want to load `stripe-integration`
-   and `pci-compliance`") and asks Maya to confirm.
-4. Maya says *"yes, load pci-compliance"*. Claude loads it via its
-   normal skill-load mechanism; an event lands in `skill-events.jsonl`:
-   `{"event": "load", "skill": "pci-compliance", ...}`.
-5. The quality sidecar for `pci-compliance` increments `load_count`;
-   `telemetry` score rises on next recompute.
-
-**Verification**
-- `tail -1 ~/.claude/skill-events.jsonl` shows the new load event.
-- `ctx-skill-quality explain pci-compliance` shows `load_count ≥ 1`,
-  `never_loaded: False`, floor cleared, grade improved.
-
----
-
-## Phase 3 — First real feature + live suggestion cycle
-
-Maya writes `app/api/checkout.py`:
-
-```python
-from fastapi import APIRouter, HTTPException
-import stripe
-from app.schemas import CheckoutRequest, CheckoutResponse
-
-router = APIRouter()
-
-@router.post("/checkout", response_model=CheckoutResponse)
-async def create_checkout(req: CheckoutRequest) -> CheckoutResponse:
-    intent = stripe.PaymentIntent.create(
-        amount=req.amount_cents, currency="usd",
-        metadata={"user_id": req.user_id},
-    )
-    return CheckoutResponse(client_secret=intent.client_secret)
-```
-
-She runs `pytest` (no tests yet) → exits 0 (no-op). She realizes she
-needs test coverage.
-
-**Expected ctx behavior**
-1. Editing files under `tests/` triggers `context_monitor` to detect
-   the `testing` signal.
-2. `skill_suggest` surfaces `test-driven-development`,
-   `python-testing`, `pytest-patterns` from the graph.
-3. Maya loads `python-testing`. Sidecar updates.
-
----
-
-## Phase 4 — Pre-commit council (toolbox run)
-
-Before committing, Maya wants a security review. She has `toolbox init`
-output 5 starter toolboxes. She activates `security-sweep`:
-
-```bash
-ctx-toolbox activate security-sweep
-ctx-toolbox run --event pre-commit
-```
-
-**Expected ctx behavior**
-1. `toolbox.py run` reads the active toolbox config.
-2. Council is assembled: `security-reviewer`, `security-auditor`,
-   `penetration-tester`, `compliance-auditor`,
-   `threat-detection-engineer`.
-3. `council_runner.py` builds a `RunPlan` with scope=`diff` (files
-   changed since last commit), budget=300K tokens, guardrail=True.
-4. Claude Code picks up the plan, dispatches each agent, collects
-   findings.
-5. `toolbox_verdict.py` merges findings by stable id, escalates level.
-6. If any HIGH/CRITICAL finding exists, `run --event pre-commit`
-   exits 2 → blocks `git commit`.
-
-**Expected finding** (realistic): `security-reviewer` flags the
-checkout endpoint lacks webhook signature verification and Stripe key
-is read from env but never validated as non-empty → MEDIUM. No block.
-
----
-
-## Phase 5 — Custom skill for the domain (skill_add)
-
-Maya realizes her team reuses the same `PaymentIntent` error-mapping
-pattern across 3 services. She wants to capture it as a custom skill.
-
-```bash
-mkdir -p .skills/stripe-error-mapping
-cat > .skills/stripe-error-mapping/SKILL.md <<EOF
----
-name: stripe-error-mapping
-description: Canonical Stripe API error → domain exception mapping for fintech backends
-tags: [stripe, payments, error-handling, pci]
----
-
-# Stripe error mapping
-
-## When to use
-Whenever a service integrates with Stripe's PaymentIntent, Charge, or
-Setup Intent APIs. This skill ensures every Stripe error (rate-limit,
-card-declined, authentication, API connection, idempotency) maps to
-a stable domain exception with an actionable error code.
-
-## Mapping table
-
-| Stripe error class | Domain exception | HTTP status |
-| ... |
-
-EOF
-
-ctx-skill-quality recompute stripe-error-mapping  # will fail — not yet installed
-# Install path:
-python -m skill_add --skill-path .skills/stripe-error-mapping/SKILL.md
-```
-
-**Expected ctx behavior**
-1. `skill_add` runs the intake gate (`intake_gate.py`):
-   frontmatter-present, has-description, body-long-enough, has-H2.
-2. Similarity check against existing skills via embedding backend
-   (falls back to structural-only if sentence-transformers missing).
-3. If novel: writes `~/.claude/skills/stripe-error-mapping/SKILL.md`,
-   adds entity page at
-   `~/.claude/skill-wiki/entities/skills/stripe-error-mapping.md`
-   with frontmatter (tags, use_count=0, last_used=null, status=installed).
-4. Returns success: manifest counter `1,579 → 1,580`.
-
-**Post-add follow-ups**
-- Graph rebuild required to include the new skill as a node with edges
-  to `stripe`, `payments`, `pci` tag communities.
-- `ctx-skill-quality recompute stripe-error-mapping` seeds the sidecar.
-
----
-
-## Phase 6 — Session end + lifecycle pruning
-
-End of day. Claude's `Stop` hook fires:
-1. `usage_tracker.py --sync` updates skill usage stats from
-   `skill-events.jsonl`.
-2. `hooks/quality_on_session_end.py` recomputes sidecars for only
-   the slugs touched this session (incremental).
-3. `ctx_lifecycle` reviews sidecars; any skill that sat in `_demoted`
-   past the 14-day archive threshold is moved to `_archive`.
-
-Maya runs:
-
-```bash
-ctx-toolbox status
-python -m kpi_dashboard render
-open ~/.claude/skill-quality/kpi.md
-```
-
-She sees:
-- Grade distribution (A: 2, B: 18, C: 240, D: 1320, F: 311).
-- Hard-floor reasons.
-- Top demotion candidates. Skills she never used in 30 days get
-  auto-archived next tick.
-
-Optionally she launches the claude-mem web monitor:
-
-```bash
-npx claude-mem start
-# browser opens http://localhost:37777
-```
-
----
-
-## Success criteria (what "good" looks like at end of day)
-
-| Check | Pass when |
-|---|---|
-| Phase 1 manifest | 10–15 loads, mixed fuzzy + graph-neighbor reasons |
-| Phase 2 events log | Every Claude tool call produced a PostToolUse invocation |
-| Phase 3 suggest | `pending-skills.json` gained ≥ 1 new entry for Stripe |
-| Phase 4 verdict | Council runs, findings file written, exits 0 or 2 cleanly |
-| Phase 5 skill_add | New skill appears in skills dir + wiki; dedup fired |
-| Phase 6 KPI | `kpi.md` reflects today's sessions; archived skills moved |
-
-## Known gaps this playbook will surface
-
-- `wiki_sync` has no drift detection (skill edits don't re-sync wiki).
-- `batch_convert` hash-gated idempotency looks like no-op on re-run.
-- `scan_repo` doesn't detect pytest from pyproject `[dev]` deps.
-- `skill_add` CLI raises false `BODY_MISSING_H2` — in-process API works.
-
-Each gap is tracked as a separate issue and will be fixed post-playbook.
+# Real-world ctx playbook
+
+> Canonical end-to-end scenario exercising every ctx surface: scan → graph
+> suggest → skill load/unload → toolbox council → skill_add → lifecycle
+> archive → KPI. Assumes the user's environment already has the graph
+> (`~/.claude/skill-wiki/graphify-out/graph.json`) and wiki
+> (`~/.claude/skill-wiki/`) **pre-built** — we do NOT rebuild in this
+> playbook.
+
+## Persona
+
+**Maya** — senior backend engineer at a B2C fintech. Installing `claude-ctx`
+fresh. First project on ctx: a **PCI-compliant checkout microservice**
+(FastAPI + SQLAlchemy + PostgreSQL + Stripe + pytest). Target: working
+endpoint + council-signed commit by end of day.
+
+She has `~/.claude/skills/` with 1,789 skills and `~/.claude/agents/`
+with 464 agents pre-installed (extracted from `graph/wiki-graph.tar.gz`).
+Graph is pre-built (2,253 nodes / 454K edges / 93 communities). She has
+never run ctx before.
+
+## Environment precondition
+
+```
+~/.claude/skill-wiki/graphify-out/graph.json   # pre-built, 454K edges
+~/.claude/skill-wiki/entities/                 # 2,253 entity pages
+~/.claude/skill-wiki/converted/                # 952 compressed skills
+~/.claude/skill-quality/                       # 1,891 sidecars
+```
+
+`pip install claude-ctx` is done. The four console scripts are on PATH.
+
+---
+
+## Phase 1 — Project bootstrap + first stack scan
+
+```bash
+mkdir ~/work/checkout-svc && cd ~/work/checkout-svc
+git init
+cat > requirements.txt <<EOF
+fastapi
+sqlalchemy
+psycopg2-binary
+pydantic
+stripe
+pytest
+EOF
+echo "app" > .gitignore
+mkdir -p app tests
+```
+
+Maya runs:
+
+```bash
+ctx-scan-repo --repo . --output .ctx/stack.json
+```
+
+**Expected ctx behavior**
+1. `scan_repo` detects: python / fastapi / sqlalchemy / pytest /
+   stripe / postgres (from `psycopg2-binary` signature).
+2. `resolve_skills` walks the **pre-built graph** from those stack tags
+   and recommends ~10–15 skills:
+   - direct/fuzzy matches: `fastapi-pro`, `python-patterns`,
+     `python-fastapi-development`, `pydantic-models-py`,
+     `stripe-integration`, `payment-integration`, `pci-compliance`,
+     `postgresql-optimization`
+   - graph neighbors (edge-weight ≥ 1.5): `test-automator`,
+     `python-pro`, `async-python-patterns`, `backend-security-coder`,
+     `api-security-best-practices`
+
+**Verification**
+- Manifest has 10–15 `load` entries with mixed `reason` fields:
+  `fuzzy match for detected stack 'fastapi'`, `graph neighbor of ...`.
+- No warnings for "not installed" when fuzzy fallback found an alternative.
+
+---
+
+## Phase 2 — Claude session starts; context monitor observes
+
+Maya launches Claude Code in `~/work/checkout-svc/`. `PostToolUse` hooks
+fire on every tool call; `Stop` fires at session end.
+
+Maya asks Claude: *"scaffold the checkout endpoint with Stripe payment
+intents".*
+
+**Expected ctx behavior during the session**
+1. **PostToolUse** fires `context_monitor.py --from-stdin` on every
+   tool call. The monitor reads the tool input, detects signals:
+   - file path `app/api/checkout.py` → stack signal `python`, `fastapi`
+   - content containing `stripe.PaymentIntent` → new signal `stripe`
+2. When an unmatched signal accumulates past threshold (3 by default),
+   `context_monitor` writes to `~/.claude/pending-skills.json` and
+   `skill_suggest.py` surfaces it to Claude's context as a
+   `hookSpecificOutput.additionalContext` blob.
+3. Claude reads the suggestion ("You may want to load `stripe-integration`
+   and `pci-compliance`") and asks Maya to confirm.
+4. Maya says *"yes, load pci-compliance"*. Claude loads it via its
+   normal skill-load mechanism; an event lands in `skill-events.jsonl`:
+   `{"event": "load", "skill": "pci-compliance", ...}`.
+5. The quality sidecar for `pci-compliance` increments `load_count`;
+   `telemetry` score rises on next recompute.
+
+**Verification**
+- `tail -1 ~/.claude/skill-events.jsonl` shows the new load event.
+- `ctx-skill-quality explain pci-compliance` shows `load_count ≥ 1`,
+  `never_loaded: False`, floor cleared, grade improved.
+
+---
+
+## Phase 3 — First real feature + live suggestion cycle
+
+Maya writes `app/api/checkout.py`:
+
+```python
+from fastapi import APIRouter, HTTPException
+import stripe
+from app.schemas import CheckoutRequest, CheckoutResponse
+
+router = APIRouter()
+
+@router.post("/checkout", response_model=CheckoutResponse)
+async def create_checkout(req: CheckoutRequest) -> CheckoutResponse:
+    intent = stripe.PaymentIntent.create(
+        amount=req.amount_cents, currency="usd",
+        metadata={"user_id": req.user_id},
+    )
+    return CheckoutResponse(client_secret=intent.client_secret)
+```
+
+She runs `pytest` (no tests yet) → exits 0 (no-op). She realizes she
+needs test coverage.
+
+**Expected ctx behavior**
+1. Editing files under `tests/` triggers `context_monitor` to detect
+   the `testing` signal.
+2. `skill_suggest` surfaces `test-driven-development`,
+   `python-testing`, `pytest-patterns` from the graph.
+3. Maya loads `python-testing`. Sidecar updates.
+
+---
+
+## Phase 4 — Pre-commit council (toolbox run)
+
+Before committing, Maya wants a security review. She has `toolbox init`
+output 5 starter toolboxes. She activates `security-sweep`:
+
+```bash
+ctx-toolbox activate security-sweep
+ctx-toolbox run --event pre-commit
+```
+
+**Expected ctx behavior**
+1. `toolbox.py run` reads the active toolbox config.
+2. Council is assembled: `security-reviewer`, `security-auditor`,
+   `penetration-tester`, `compliance-auditor`,
+   `threat-detection-engineer`.
+3. `council_runner.py` builds a `RunPlan` with scope=`diff` (files
+   changed since last commit), budget=300K tokens, guardrail=True.
+4. Claude Code picks up the plan, dispatches each agent, collects
+   findings.
+5. `toolbox_verdict.py` merges findings by stable id, escalates level.
+6. If any HIGH/CRITICAL finding exists, `run --event pre-commit`
+   exits 2 → blocks `git commit`.
+
+**Expected finding** (realistic): `security-reviewer` flags the
+checkout endpoint lacks webhook signature verification and Stripe key
+is read from env but never validated as non-empty → MEDIUM. No block.
+
+---
+
+## Phase 5 — Custom skill for the domain (skill_add)
+
+Maya realizes her team reuses the same `PaymentIntent` error-mapping
+pattern across 3 services. She wants to capture it as a custom skill.
+
+```bash
+mkdir -p .skills/stripe-error-mapping
+cat > .skills/stripe-error-mapping/SKILL.md <<EOF
+---
+name: stripe-error-mapping
+description: Canonical Stripe API error → domain exception mapping for fintech backends
+tags: [stripe, payments, error-handling, pci]
+---
+
+# Stripe error mapping
+
+## When to use
+Whenever a service integrates with Stripe's PaymentIntent, Charge, or
+Setup Intent APIs. This skill ensures every Stripe error (rate-limit,
+card-declined, authentication, API connection, idempotency) maps to
+a stable domain exception with an actionable error code.
+
+## Mapping table
+
+| Stripe error class | Domain exception | HTTP status |
+| ... |
+
+EOF
+
+ctx-skill-quality recompute stripe-error-mapping  # will fail — not yet installed
+# Install path:
+python -m skill_add --skill-path .skills/stripe-error-mapping/SKILL.md
+```
+
+**Expected ctx behavior**
+1. `skill_add` runs the intake gate (`intake_gate.py`):
+   frontmatter-present, has-description, body-long-enough, has-H2.
+2. Similarity check against existing skills via embedding backend
+   (falls back to structural-only if sentence-transformers missing).
+3. If novel: writes `~/.claude/skills/stripe-error-mapping/SKILL.md`,
+   adds entity page at
+   `~/.claude/skill-wiki/entities/skills/stripe-error-mapping.md`
+   with frontmatter (tags, use_count=0, last_used=null, status=installed).
+4. Returns success: manifest counter `1,579 → 1,580`.
+
+**Post-add follow-ups**
+- Graph rebuild required to include the new skill as a node with edges
+  to `stripe`, `payments`, `pci` tag communities.
+- `ctx-skill-quality recompute stripe-error-mapping` seeds the sidecar.
+
+---
+
+## Phase 6 — Session end + lifecycle pruning
+
+End of day. Claude's `Stop` hook fires:
+1. `usage_tracker.py --sync` updates skill usage stats from
+   `skill-events.jsonl`.
+2. `hooks/quality_on_session_end.py` recomputes sidecars for only
+   the slugs touched this session (incremental).
+3. `ctx_lifecycle` reviews sidecars; any skill that sat in `_demoted`
+   past the 14-day archive threshold is moved to `_archive`.
+
+Maya runs:
+
+```bash
+ctx-toolbox status
+python -m kpi_dashboard render
+open ~/.claude/skill-quality/kpi.md
+```
+
+She sees:
+- Grade distribution (A: 2, B: 18, C: 240, D: 1320, F: 311).
+- Hard-floor reasons.
+- Top demotion candidates. Skills she never used in 30 days get
+  auto-archived next tick.
+
+Optionally she launches the claude-mem web monitor:
+
+```bash
+npx claude-mem start
+# browser opens http://localhost:37777
+```
+
+---
+
+## Success criteria (what "good" looks like at end of day)
+
+| Check | Pass when |
+|---|---|
+| Phase 1 manifest | 10–15 loads, mixed fuzzy + graph-neighbor reasons |
+| Phase 2 events log | Every Claude tool call produced a PostToolUse invocation |
+| Phase 3 suggest | `pending-skills.json` gained ≥ 1 new entry for Stripe |
+| Phase 4 verdict | Council runs, findings file written, exits 0 or 2 cleanly |
+| Phase 5 skill_add | New skill appears in skills dir + wiki; dedup fired |
+| Phase 6 KPI | `kpi.md` reflects today's sessions; archived skills moved |
+
+## Known gaps this playbook will surface
+
+- `wiki_sync` has no drift detection (skill edits don't re-sync wiki).
+- `batch_convert` hash-gated idempotency looks like no-op on re-run.
+- `scan_repo` doesn't detect pytest from pyproject `[dev]` deps.
+- `skill_add` CLI raises false `BODY_MISSING_H2` — in-process API works.
+
+Each gap is tracked as a separate issue and will be fixed post-playbook.

scripts/build_dashboard_graph_index.py

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

scripts/ci_classifier.py

@@ -1,150 +1,150 @@
-"""Classify changed paths for CI workflow decisions."""
-
-from __future__ import annotations
-
-import argparse
-import fnmatch
-import os
-from pathlib import Path
-from typing import Iterable
-
-OUTPUT_NAMES = (
-    "browser_changed",
-    "ci_changed",
-    "docs_changed",
-    "docs_only",
-    "graph_artifact_changed",
-    "graph_changed",
-    "graph_only",
-    "package_changed",
-    "similarity_changed",
-    "source_changed",
-)
-
-DOCS_PATTERNS = (
-    "*.md",
-    "docs/**",
-    "graph/README.md",
-    "LICENSE",
-    "mkdocs.yml",
-    "requirements-docs.txt",
-)
-GRAPH_ARTIFACT_PATTERNS = (
-    "graph/communities.json",
-    "graph/entity-overlays.jsonl",
-    "graph/skills-sh-catalog.json.gz",
-    "graph/wiki-graph-runtime.tar.gz",
-    "graph/wiki-graph.tar.gz",
-    "graph/*.html",
-)
-BROWSER_PATTERNS = (
-    ".github/workflows/test.yml",
-    "dashboard/**",
-    "pyproject.toml",
-    "src/**/browser/**",
-    "src/**/monitor/**",
-    "src/ctx_monitor.py",
-    "src/ctx/utils/_safe_name.py",
-    "src/tests/test_ctx_monitor_browser.py",
-)
-PACKAGE_PATTERNS = (
-    "MANIFEST.in",
-    "pyproject.toml",
-    "src/*.py",
-    "src/ctx/**",
-)
-SOURCE_PATTERNS = (
-    "hooks/**",
-    "pyproject.toml",
-    "scripts/**",
-    "src/**",
-)
-SIMILARITY_PATTERNS = (
-    ".github/workflows/test.yml",
-    "graph/entity-overlays.jsonl",
-    "pyproject.toml",
-    "src/corpus_cache.py",
-    "src/config.json",
-    "src/cosine_ranker.py",
-    "src/ctx/adapters/claude_code/hooks/context_monitor.py",
-    "src/ctx/adapters/generic/ctx_core_tools.py",
-    "src/ctx_config.py",
-    "src/ctx/core/graph/**",
-    "src/ctx/core/resolve/**",
-    "src/ctx/core/wiki/wiki_graphify.py",
-    "src/embedding_backend.py",
-    "src/intake_gate.py",
-    "src/tests/test_similarity_precision_recall.py",
-)
-
-
-def _matches(path: str, patterns: Iterable[str]) -> bool:
-    return any(fnmatch.fnmatch(path, pattern) for pattern in patterns)
-
-
-def _normalize_path(path: str) -> str:
-    return path.strip().lstrip("\ufeff").replace("\\", "/")
-
-
-def _is_graph_artifact_path(path: str) -> bool:
-    if _matches(path, GRAPH_ARTIFACT_PATTERNS):
-        return True
-    return _matches(path, ("graph/**",)) and path != "graph/README.md"
-
-
-def classify_paths(paths: Iterable[str]) -> dict[str, bool]:
-    files = [
-        normalized
-        for path in paths
-        if (normalized := _normalize_path(path))
-    ]
-    ci_changed = any(_matches(path, (".github/workflows/**",)) for path in files)
-    docs_changed = any(_matches(path, DOCS_PATTERNS) for path in files)
-    graph_artifact_changed = any(_is_graph_artifact_path(path) for path in files)
-    graph_only = bool(files) and all(_matches(path, ("graph/**",)) for path in files)
-    return {
-        "browser_changed": ci_changed
-        or any(_matches(path, BROWSER_PATTERNS) for path in files),
-        "ci_changed": ci_changed,
-        "docs_changed": docs_changed,
-        "docs_only": bool(files) and all(_matches(path, DOCS_PATTERNS) for path in files),
-        "graph_artifact_changed": graph_artifact_changed,
-        "graph_changed": any(_matches(path, ("graph/**",)) for path in files),
-        "graph_only": graph_only,
-        "package_changed": ci_changed
-        or any(_matches(path, PACKAGE_PATTERNS) for path in files),
-        "similarity_changed": ci_changed
-        or any(_matches(path, SIMILARITY_PATTERNS) for path in files),
-        "source_changed": ci_changed
-        or any(_matches(path, SOURCE_PATTERNS) for path in files),
-    }
-
-
-def write_github_outputs(flags: dict[str, bool], output_path: Path) -> None:
-    with output_path.open("a", encoding="utf-8") as output:
-        for name in OUTPUT_NAMES:
-            output.write(f"{name}={str(flags[name]).lower()}\n")
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("changed_files", type=Path)
-    args = parser.parse_args(argv)
-
-    files = args.changed_files.read_text(encoding="utf-8").splitlines()
-    flags = classify_paths(files)
-    github_output = os.environ.get("GITHUB_OUTPUT")
-    if github_output:
-        write_github_outputs(flags, Path(github_output))
-
-    print("Changed files:")
-    for path in [path for line in files if (path := _normalize_path(line))]:
-        print(f"  {path}")
-    print("Classification:")
-    for name in OUTPUT_NAMES:
-        print(f"  {name}={str(flags[name]).lower()}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+"""Classify changed paths for CI workflow decisions."""
+
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import os
+from pathlib import Path
+from typing import Iterable
+
+OUTPUT_NAMES = (
+    "browser_changed",
+    "ci_changed",
+    "docs_changed",
+    "docs_only",
+    "graph_artifact_changed",
+    "graph_changed",
+    "graph_only",
+    "package_changed",
+    "similarity_changed",
+    "source_changed",
+)
+
+DOCS_PATTERNS = (
+    "*.md",
+    "docs/**",
+    "graph/README.md",
+    "LICENSE",
+    "mkdocs.yml",
+    "requirements-docs.txt",
+)
+GRAPH_ARTIFACT_PATTERNS = (
+    "graph/communities.json",
+    "graph/entity-overlays.jsonl",
+    "graph/skills-sh-catalog.json.gz",
+    "graph/wiki-graph-runtime.tar.gz",
+    "graph/wiki-graph.tar.gz",
+    "graph/*.html",
+)
+BROWSER_PATTERNS = (
+    ".github/workflows/test.yml",
+    "dashboard/**",
+    "pyproject.toml",
+    "src/**/browser/**",
+    "src/**/monitor/**",
+    "src/ctx_monitor.py",
+    "src/ctx/utils/_safe_name.py",
+    "src/tests/test_ctx_monitor_browser.py",
+)
+PACKAGE_PATTERNS = (
+    "MANIFEST.in",
+    "pyproject.toml",
+    "src/*.py",
+    "src/ctx/**",
+)
+SOURCE_PATTERNS = (
+    "hooks/**",
+    "pyproject.toml",
+    "scripts/**",
+    "src/**",
+)
+SIMILARITY_PATTERNS = (
+    ".github/workflows/test.yml",
+    "graph/entity-overlays.jsonl",
+    "pyproject.toml",
+    "src/corpus_cache.py",
+    "src/config.json",
+    "src/cosine_ranker.py",
+    "src/ctx/adapters/claude_code/hooks/context_monitor.py",
+    "src/ctx/adapters/generic/ctx_core_tools.py",
+    "src/ctx_config.py",
+    "src/ctx/core/graph/**",
+    "src/ctx/core/resolve/**",
+    "src/ctx/core/wiki/wiki_graphify.py",
+    "src/embedding_backend.py",
+    "src/intake_gate.py",
+    "src/tests/test_similarity_precision_recall.py",
+)
+
+
+def _matches(path: str, patterns: Iterable[str]) -> bool:
+    return any(fnmatch.fnmatch(path, pattern) for pattern in patterns)
+
+
+def _normalize_path(path: str) -> str:
+    return path.strip().lstrip("\ufeff").replace("\\", "/")
+
+
+def _is_graph_artifact_path(path: str) -> bool:
+    if _matches(path, GRAPH_ARTIFACT_PATTERNS):
+        return True
+    return _matches(path, ("graph/**",)) and path != "graph/README.md"
+
+
+def classify_paths(paths: Iterable[str]) -> dict[str, bool]:
+    files = [
+        normalized
+        for path in paths
+        if (normalized := _normalize_path(path))
+    ]
+    ci_changed = any(_matches(path, (".github/workflows/**",)) for path in files)
+    docs_changed = any(_matches(path, DOCS_PATTERNS) for path in files)
+    graph_artifact_changed = any(_is_graph_artifact_path(path) for path in files)
+    graph_only = bool(files) and all(_matches(path, ("graph/**",)) for path in files)
+    return {
+        "browser_changed": ci_changed
+        or any(_matches(path, BROWSER_PATTERNS) for path in files),
+        "ci_changed": ci_changed,
+        "docs_changed": docs_changed,
+        "docs_only": bool(files) and all(_matches(path, DOCS_PATTERNS) for path in files),
+        "graph_artifact_changed": graph_artifact_changed,
+        "graph_changed": any(_matches(path, ("graph/**",)) for path in files),
+        "graph_only": graph_only,
+        "package_changed": ci_changed
+        or any(_matches(path, PACKAGE_PATTERNS) for path in files),
+        "similarity_changed": ci_changed
+        or any(_matches(path, SIMILARITY_PATTERNS) for path in files),
+        "source_changed": ci_changed
+        or any(_matches(path, SOURCE_PATTERNS) for path in files),
+    }
+
+
+def write_github_outputs(flags: dict[str, bool], output_path: Path) -> None:
+    with output_path.open("a", encoding="utf-8") as output:
+        for name in OUTPUT_NAMES:
+            output.write(f"{name}={str(flags[name]).lower()}\n")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("changed_files", type=Path)
+    args = parser.parse_args(argv)
+
+    files = args.changed_files.read_text(encoding="utf-8").splitlines()
+    flags = classify_paths(files)
+    github_output = os.environ.get("GITHUB_OUTPUT")
+    if github_output:
+        write_github_outputs(flags, Path(github_output))
+
+    print("Changed files:")
+    for path in [path for line in files if (path := _normalize_path(line))]:
+        print(f"  {path}")
+    print("Classification:")
+    for name in OUTPUT_NAMES:
+        print(f"  {name}={str(flags[name]).lower()}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/ci_no_test_policy.py

@@ -1,178 +1,178 @@
-"""Enforce that product/CI contract changes include test changes."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import subprocess
-from dataclasses import dataclass
-from typing import Iterable
-
-RELEASE_METADATA_FILES = {
-    "CHANGELOG.md",
-    "pyproject.toml",
-    "src/__init__.py",
-    "src/ctx/__init__.py",
-}
-RELEASE_GENERATED_STATS_FILES = {
-    "README.md",
-    "docs/index.md",
-}
-VERSION_LINE_RE = re.compile(r'version = "\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?"')
-INIT_VERSION_LINE_RE = re.compile(
-    r'__version__ = "\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?"'
-)
-TEST_COUNT_STATS_RE = re.compile(
-    r".*(Tests-\d+_collected|[\d,]+ tests collected).*"
-)
-RELEASE_DOCS_LINE_RE = re.compile(r"\*\*v\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?\*\*.*")
-
-
-@dataclass(frozen=True)
-class PolicyResult:
-    passed: bool
-    message: str
-    contract_files: tuple[str, ...] = ()
-    test_files: tuple[str, ...] = ()
-
-
-def is_contract_file(path: str) -> bool:
-    return (
-        (path.startswith("src/") and path.endswith((".py", ".json")))
-        or path.startswith("scripts/ci_")
-        or path == "scripts/clean_host_contract.py"
-        or path == "pyproject.toml"
-        or (
-            path.startswith(".github/workflows/")
-            and path.endswith((".yml", ".yaml"))
-        )
-    ) and not path.startswith("src/tests/")
-
-
-def is_test_file(path: str) -> bool:
-    return path.startswith("src/tests/") and path.endswith((".py", ".json"))
-
-
-def is_release_metadata_only(
-    changed_files: Iterable[str],
-    diffs_by_file: dict[str, str],
-) -> bool:
-    files = tuple(path.strip().replace("\\", "/") for path in changed_files if path)
-    allowed_files = RELEASE_METADATA_FILES | RELEASE_GENERATED_STATS_FILES
-    if not files or any(path not in allowed_files for path in files):
-        return False
-    if not any(path in RELEASE_METADATA_FILES for path in files):
-        return False
-
-    for path in files:
-        if path == "CHANGELOG.md":
-            continue
-        if path in RELEASE_GENERATED_STATS_FILES:
-            for line in diffs_by_file.get(path, "").splitlines():
-                if not line.startswith(("+", "-")) or line.startswith(("+++", "---")):
-                    continue
-                text = line[1:].strip()
-                if not TEST_COUNT_STATS_RE.fullmatch(text) and not (
-                    path == "docs/index.md" and RELEASE_DOCS_LINE_RE.fullmatch(text)
-                ):
-                    return False
-            continue
-        expected = VERSION_LINE_RE if path == "pyproject.toml" else INIT_VERSION_LINE_RE
-        for line in diffs_by_file.get(path, "").splitlines():
-            if not line.startswith(("+", "-")) or line.startswith(("+++", "---")):
-                continue
-            if not expected.fullmatch(line[1:].strip()):
-                return False
-    return True
-
-
-def evaluate_policy(
-    changed_files: Iterable[str],
-    labels: Iterable[str],
-    diffs_by_file: dict[str, str],
-) -> PolicyResult:
-    files = tuple(path.strip().replace("\\", "/") for path in changed_files if path)
-    contract = tuple(path for path in files if is_contract_file(path))
-    tests = tuple(path for path in files if is_test_file(path))
-    if not contract:
-        return PolicyResult(True, "No product or CI/package contract changes.")
-    if tests:
-        return PolicyResult(True, "Policy satisfied.", contract, tests)
-    if "no-tests-needed" in set(labels):
-        return PolicyResult(True, "Policy exempted by no-tests-needed label.", contract)
-    if is_release_metadata_only(files, diffs_by_file):
-        return PolicyResult(True, "Policy exempted for release metadata-only changes.", contract)
-    return PolicyResult(False, "Contract files changed without accompanying tests.", contract)
-
-
-def _git_lines(*args: str) -> tuple[str, ...]:
-    proc = subprocess.run(
-        ["git", *args],
-        check=True,
-        text=True,
-        stdout=subprocess.PIPE,
-    )
-    return tuple(line.strip() for line in proc.stdout.splitlines() if line.strip())
-
-
-def _git_text(*args: str) -> str:
-    proc = subprocess.run(
-        ["git", *args],
-        check=True,
-        text=True,
-        stdout=subprocess.PIPE,
-    )
-    return proc.stdout
-
-
-def _changed_files(base: str, head: str) -> tuple[str, ...]:
-    return _git_lines("diff", "--name-only", base, head)
-
-
-def _diffs_by_file(base: str, head: str, files: Iterable[str]) -> dict[str, str]:
-    return {
-        path: _git_text("diff", "--unified=0", base, head, "--", path)
-        for path in files
-    }
-
-
-def _parse_labels(raw: str) -> tuple[str, ...]:
-    try:
-        labels = json.loads(raw)
-    except json.JSONDecodeError:
-        return ()
-    if not isinstance(labels, list):
-        return ()
-    return tuple(label for label in labels if isinstance(label, str))
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--base", required=True)
-    parser.add_argument("--head", required=True)
-    parser.add_argument("--labels-json", default="[]")
-    args = parser.parse_args(argv)
-
-    files = _changed_files(args.base, args.head)
-    result = evaluate_policy(
-        files,
-        _parse_labels(args.labels_json),
-        _diffs_by_file(args.base, args.head, files),
-    )
-    print(result.message)
-    if result.contract_files:
-        print("Contract files:")
-        print("\n".join(result.contract_files))
-    if result.test_files:
-        print("Test files:")
-        print("\n".join(result.test_files))
-    if not result.passed:
-        print("::error::Policy violation - contract files changed but no tests changed.")
-        print("Fix: add/update tests, or use release metadata-only changes.")
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+"""Enforce that product/CI contract changes include test changes."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+from dataclasses import dataclass
+from typing import Iterable
+
+RELEASE_METADATA_FILES = {
+    "CHANGELOG.md",
+    "pyproject.toml",
+    "src/__init__.py",
+    "src/ctx/__init__.py",
+}
+RELEASE_GENERATED_STATS_FILES = {
+    "README.md",
+    "docs/index.md",
+}
+VERSION_LINE_RE = re.compile(r'version = "\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?"')
+INIT_VERSION_LINE_RE = re.compile(
+    r'__version__ = "\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?"'
+)
+TEST_COUNT_STATS_RE = re.compile(
+    r".*(Tests-\d+_collected|[\d,]+ tests collected).*"
+)
+RELEASE_DOCS_LINE_RE = re.compile(r"\*\*v\d+\.\d+\.\d+(?:[-+._a-zA-Z0-9]*)?\*\*.*")
+
+
+@dataclass(frozen=True)
+class PolicyResult:
+    passed: bool
+    message: str
+    contract_files: tuple[str, ...] = ()
+    test_files: tuple[str, ...] = ()
+
+
+def is_contract_file(path: str) -> bool:
+    return (
+        (path.startswith("src/") and path.endswith((".py", ".json")))
+        or path.startswith("scripts/ci_")
+        or path == "scripts/clean_host_contract.py"
+        or path == "pyproject.toml"
+        or (
+            path.startswith(".github/workflows/")
+            and path.endswith((".yml", ".yaml"))
+        )
+    ) and not path.startswith("src/tests/")
+
+
+def is_test_file(path: str) -> bool:
+    return path.startswith("src/tests/") and path.endswith((".py", ".json"))
+
+
+def is_release_metadata_only(
+    changed_files: Iterable[str],
+    diffs_by_file: dict[str, str],
+) -> bool:
+    files = tuple(path.strip().replace("\\", "/") for path in changed_files if path)
+    allowed_files = RELEASE_METADATA_FILES | RELEASE_GENERATED_STATS_FILES
+    if not files or any(path not in allowed_files for path in files):
+        return False
+    if not any(path in RELEASE_METADATA_FILES for path in files):
+        return False
+
+    for path in files:
+        if path == "CHANGELOG.md":
+            continue
+        if path in RELEASE_GENERATED_STATS_FILES:
+            for line in diffs_by_file.get(path, "").splitlines():
+                if not line.startswith(("+", "-")) or line.startswith(("+++", "---")):
+                    continue
+                text = line[1:].strip()
+                if not TEST_COUNT_STATS_RE.fullmatch(text) and not (
+                    path == "docs/index.md" and RELEASE_DOCS_LINE_RE.fullmatch(text)
+                ):
+                    return False
+            continue
+        expected = VERSION_LINE_RE if path == "pyproject.toml" else INIT_VERSION_LINE_RE
+        for line in diffs_by_file.get(path, "").splitlines():
+            if not line.startswith(("+", "-")) or line.startswith(("+++", "---")):
+                continue
+            if not expected.fullmatch(line[1:].strip()):
+                return False
+    return True
+
+
+def evaluate_policy(
+    changed_files: Iterable[str],
+    labels: Iterable[str],
+    diffs_by_file: dict[str, str],
+) -> PolicyResult:
+    files = tuple(path.strip().replace("\\", "/") for path in changed_files if path)
+    contract = tuple(path for path in files if is_contract_file(path))
+    tests = tuple(path for path in files if is_test_file(path))
+    if not contract:
+        return PolicyResult(True, "No product or CI/package contract changes.")
+    if tests:
+        return PolicyResult(True, "Policy satisfied.", contract, tests)
+    if "no-tests-needed" in set(labels):
+        return PolicyResult(True, "Policy exempted by no-tests-needed label.", contract)
+    if is_release_metadata_only(files, diffs_by_file):
+        return PolicyResult(True, "Policy exempted for release metadata-only changes.", contract)
+    return PolicyResult(False, "Contract files changed without accompanying tests.", contract)
+
+
+def _git_lines(*args: str) -> tuple[str, ...]:
+    proc = subprocess.run(
+        ["git", *args],
+        check=True,
+        text=True,
+        stdout=subprocess.PIPE,
+    )
+    return tuple(line.strip() for line in proc.stdout.splitlines() if line.strip())
+
+
+def _git_text(*args: str) -> str:
+    proc = subprocess.run(
+        ["git", *args],
+        check=True,
+        text=True,
+        stdout=subprocess.PIPE,
+    )
+    return proc.stdout
+
+
+def _changed_files(base: str, head: str) -> tuple[str, ...]:
+    return _git_lines("diff", "--name-only", base, head)
+
+
+def _diffs_by_file(base: str, head: str, files: Iterable[str]) -> dict[str, str]:
+    return {
+        path: _git_text("diff", "--unified=0", base, head, "--", path)
+        for path in files
+    }
+
+
+def _parse_labels(raw: str) -> tuple[str, ...]:
+    try:
+        labels = json.loads(raw)
+    except json.JSONDecodeError:
+        return ()
+    if not isinstance(labels, list):
+        return ()
+    return tuple(label for label in labels if isinstance(label, str))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base", required=True)
+    parser.add_argument("--head", required=True)
+    parser.add_argument("--labels-json", default="[]")
+    args = parser.parse_args(argv)
+
+    files = _changed_files(args.base, args.head)
+    result = evaluate_policy(
+        files,
+        _parse_labels(args.labels_json),
+        _diffs_by_file(args.base, args.head, files),
+    )
+    print(result.message)
+    if result.contract_files:
+        print("Contract files:")
+        print("\n".join(result.contract_files))
+    if result.test_files:
+        print("Test files:")
+        print("\n".join(result.test_files))
+    if not result.passed:
+        print("::error::Policy violation - contract files changed but no tests changed.")
+        print("Fix: add/update tests, or use release metadata-only changes.")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/ci_preflight.py

@@ -1,308 +1,308 @@
-"""Run local checks that mirror the required GitHub PR gates.
-
-This is intentionally conservative: it uses the same path classifier as
-`.github/workflows/test.yml`, runs the local equivalents of required jobs, and
-prints any CI-only coverage that cannot be reproduced on the current OS.
-"""
-
-from __future__ import annotations
-
-import argparse
-from dataclasses import dataclass
-import os
-from pathlib import Path
-import shutil
-import subprocess
-import sys
-import time
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-if str(REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(REPO_ROOT))
-
-from scripts.ci_classifier import classify_paths  # noqa: E402
-
-
-GRAPH_VALIDATE_ARGS = (
-    "src/validate_graph_artifacts.py",
-    "--graph-dir",
-    "graph",
-    "--deep",
-    "--min-nodes",
-    "100000",
-    "--min-edges",
-    "2000000",
-    "--min-skills-sh-nodes",
-    "89000",
-    "--min-semantic-edges",
-    "1000000",
-    "--expected-nodes",
-    "102928",
-    "--expected-edges",
-    "2913960",
-    "--expected-semantic-edges",
-    "1683193",
-    "--expected-harness-nodes",
-    "207",
-    "--expected-skills-sh-nodes",
-    "89471",
-    "--expected-skills-sh-catalog-entries",
-    "89465",
-    "--expected-skills-sh-converted",
-    "89465",
-    "--expected-skill-pages",
-    "91464",
-    "--expected-agent-pages",
-    "467",
-    "--expected-mcp-pages",
-    "10790",
-    "--expected-harness-pages",
-    "207",
-    "--line-threshold",
-    "180",
-    "--max-stage-lines",
-    "40",
-)
-
-
-@dataclass(frozen=True)
-class Check:
-    name: str
-    argv: tuple[str, ...]
-    env: dict[str, str] | None = None
-
-
-def _run_git(args: list[str], *, allow_failure: bool = False) -> list[str]:
-    proc = subprocess.run(
-        ["git", *args],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-    if proc.returncode != 0:
-        if allow_failure:
-            return []
-        raise RuntimeError(proc.stderr.strip() or proc.stdout.strip())
-    return [line.strip() for line in proc.stdout.splitlines() if line.strip()]
-
-
-def changed_files(base_ref: str) -> list[str]:
-    merge_base = _run_git(["merge-base", base_ref, "HEAD"], allow_failure=True)
-    base = merge_base[0] if merge_base else base_ref
-    paths = set(_run_git(["diff", "--name-only", base, "HEAD"], allow_failure=True))
-    paths.update(_run_git(["diff", "--name-only"], allow_failure=True))
-    paths.update(_run_git(["diff", "--cached", "--name-only"], allow_failure=True))
-    paths.update(
-        _run_git(["ls-files", "--others", "--exclude-standard"], allow_failure=True)
-    )
-    return sorted(path.replace("\\", "/") for path in paths)
-
-
-def select_checks(
-    *,
-    base_ref: str,
-    files: list[str],
-    profile: str,
-    python: str,
-) -> tuple[list[Check], list[str]]:
-    flags = classify_paths(files)
-    checks: list[Check] = [
-        Check("whitespace", ("git", "diff", "--check")),
-        Check("repo stats", (python, "src/update_repo_stats.py", "--check")),
-    ]
-    notes = [
-        "GitHub still runs Windows/macOS matrix jobs; local preflight covers the "
-        "same contracts on this host."
-    ]
-
-    source_required = profile == "full" or (
-        not flags["docs_only"] and not flags["graph_only"]
-    )
-    if source_required:
-        checks.extend(
-            [
-                Check("ruff", (python, "-m", "ruff", "check", "src", "hooks", "scripts")),
-                Check("mypy", (python, "-m", "mypy", "src")),
-                Check("pip check", (python, "-m", "pip", "check")),
-                Check(
-                    "unit-linux equivalent",
-                    (
-                        python,
-                        "-m",
-                        "pytest",
-                        "-q",
-                        "-m",
-                        "not browser and not integration",
-                        "--cov=src",
-                        "--cov-report=term-missing",
-                        "--cov-fail-under=40",
-                    ),
-                ),
-                Check(
-                    "A-Z canary",
-                    (
-                        python,
-                        "-m",
-                        "pytest",
-                        "-q",
-                        "--no-cov",
-                        "src/tests/test_alive_loop_e2e.py",
-                        "src/tests/test_fuzz_yaml_rendering.py",
-                    ),
-                ),
-                Check(
-                    "contract compatibility local",
-                    (
-                        python,
-                        "-m",
-                        "pytest",
-                        "-q",
-                        "--no-cov",
-                        "src/tests/test_clean_host_contract.py",
-                        "src/tests/test_package_scaffold.py",
-                    ),
-                ),
-                Check(
-                    "clean host contract",
-                    (python, "scripts/clean_host_contract.py", "--fast"),
-                ),
-            ]
-        )
-
-    if flags["docs_changed"]:
-        checks.append(
-            Check("docs strict build", (python, "-m", "mkdocs", "build", "--strict"))
-        )
-
-    if flags["graph_artifact_changed"]:
-        checks.append(Check("graph artifact validation", (python, *GRAPH_VALIDATE_ARGS)))
-
-    if source_required and flags["similarity_changed"]:
-        checks.append(
-            Check(
-                "similarity precision/recall",
-                (
-                    python,
-                    "-m",
-                    "pytest",
-                    "-q",
-                    "--no-cov",
-                    "-m",
-                    "integration",
-                    "src/tests/test_similarity_precision_recall.py",
-                ),
-                env={"CTX_REQUIRE_SIMILARITY_EVAL": "1"},
-            )
-        )
-
-    if source_required and flags["browser_changed"]:
-        checks.append(
-            Check(
-                "browser monitor security",
-                (
-                    python,
-                    "-m",
-                    "pytest",
-                    "-q",
-                    "--no-cov",
-                    "-m",
-                    "browser",
-                    "src/tests/test_ctx_monitor_browser.py",
-                ),
-            )
-        )
-
-    if source_required:
-        out_dir = ".ci-preflight-dist"
-        twine_script = (
-            "import glob, subprocess, sys; "
-            f"files=glob.glob({str(out_dir + '/*')!r}); "
-            "sys.exit(2 if not files else subprocess.call("
-            "[sys.executable, '-m', 'twine', 'check', *files]))"
-        )
-        checks.extend(
-            [
-                Check(
-                    "clean preflight dist",
-                    (
-                        python,
-                        "-c",
-                        f"import shutil; shutil.rmtree({out_dir!r}, ignore_errors=True)",
-                    ),
-                ),
-                Check("build wheel", (python, "-m", "build", "--outdir", out_dir)),
-                Check("twine check", (python, "-c", twine_script)),
-            ]
-        )
-
-    if files:
-        notes.insert(0, f"Changed files vs {base_ref}: {len(files)}")
-    else:
-        notes.insert(0, "No changed files detected; running baseline cheap checks only.")
-
-    return checks, notes
-
-
-def run_checks(checks: list[Check], *, dry_run: bool) -> int:
-    for index, check in enumerate(checks, start=1):
-        print(f"[{index}/{len(checks)}] {check.name}: {' '.join(check.argv)}", flush=True)
-        if dry_run:
-            continue
-        env = os.environ.copy()
-        if check.env:
-            env.update(check.env)
-        start = time.monotonic()
-        proc = subprocess.run(check.argv, check=False, env=env)
-        elapsed = time.monotonic() - start
-        if proc.returncode != 0:
-            print(
-                f"[fail] {check.name} exited {proc.returncode} after {elapsed:.1f}s",
-                file=sys.stderr,
-            )
-            return proc.returncode
-        print(f"[pass] {check.name} in {elapsed:.1f}s", flush=True)
-    return 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "--base",
-        default="origin/main",
-        help="base ref for changed-file detection",
-    )
-    parser.add_argument(
-        "--profile",
-        choices=("pr", "full"),
-        default="pr",
-        help="pr mirrors required PR checks; full forces source gates for any change set",
-    )
-    parser.add_argument(
-        "--python",
-        default=sys.executable,
-        help="Python executable to run checks with",
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="print selected checks without running them",
-    )
-    args = parser.parse_args(argv)
-
-    if not shutil.which("git"):
-        raise SystemExit("git is required for ci_preflight")
-
-    files = changed_files(args.base)
-    checks, notes = select_checks(
-        base_ref=args.base,
-        files=files,
-        profile=args.profile,
-        python=args.python,
-    )
-    for note in notes:
-        print(f"[note] {note}")
-    return run_checks(checks, dry_run=args.dry_run)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+"""Run local checks that mirror the required GitHub PR gates.
+
+This is intentionally conservative: it uses the same path classifier as
+`.github/workflows/test.yml`, runs the local equivalents of required jobs, and
+prints any CI-only coverage that cannot be reproduced on the current OS.
+"""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from scripts.ci_classifier import classify_paths  # noqa: E402
+
+
+GRAPH_VALIDATE_ARGS = (
+    "src/validate_graph_artifacts.py",
+    "--graph-dir",
+    "graph",
+    "--deep",
+    "--min-nodes",
+    "100000",
+    "--min-edges",
+    "2000000",
+    "--min-skills-sh-nodes",
+    "89000",
+    "--min-semantic-edges",
+    "1000000",
+    "--expected-nodes",
+    "102928",
+    "--expected-edges",
+    "2913960",
+    "--expected-semantic-edges",
+    "1683193",
+    "--expected-harness-nodes",
+    "207",
+    "--expected-skills-sh-nodes",
+    "89471",
+    "--expected-skills-sh-catalog-entries",
+    "89465",
+    "--expected-skills-sh-converted",
+    "89465",
+    "--expected-skill-pages",
+    "91464",
+    "--expected-agent-pages",
+    "467",
+    "--expected-mcp-pages",
+    "10790",
+    "--expected-harness-pages",
+    "207",
+    "--line-threshold",
+    "180",
+    "--max-stage-lines",
+    "40",
+)
+
+
+@dataclass(frozen=True)
+class Check:
+    name: str
+    argv: tuple[str, ...]
+    env: dict[str, str] | None = None
+
+
+def _run_git(args: list[str], *, allow_failure: bool = False) -> list[str]:
+    proc = subprocess.run(
+        ["git", *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        if allow_failure:
+            return []
+        raise RuntimeError(proc.stderr.strip() or proc.stdout.strip())
+    return [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+
+
+def changed_files(base_ref: str) -> list[str]:
+    merge_base = _run_git(["merge-base", base_ref, "HEAD"], allow_failure=True)
+    base = merge_base[0] if merge_base else base_ref
+    paths = set(_run_git(["diff", "--name-only", base, "HEAD"], allow_failure=True))
+    paths.update(_run_git(["diff", "--name-only"], allow_failure=True))
+    paths.update(_run_git(["diff", "--cached", "--name-only"], allow_failure=True))
+    paths.update(
+        _run_git(["ls-files", "--others", "--exclude-standard"], allow_failure=True)
+    )
+    return sorted(path.replace("\\", "/") for path in paths)
+
+
+def select_checks(
+    *,
+    base_ref: str,
+    files: list[str],
+    profile: str,
+    python: str,
+) -> tuple[list[Check], list[str]]:
+    flags = classify_paths(files)
+    checks: list[Check] = [
+        Check("whitespace", ("git", "diff", "--check")),
+        Check("repo stats", (python, "src/update_repo_stats.py", "--check")),
+    ]
+    notes = [
+        "GitHub still runs Windows/macOS matrix jobs; local preflight covers the "
+        "same contracts on this host."
+    ]
+
+    source_required = profile == "full" or (
+        not flags["docs_only"] and not flags["graph_only"]
+    )
+    if source_required:
+        checks.extend(
+            [
+                Check("ruff", (python, "-m", "ruff", "check", "src", "hooks", "scripts")),
+                Check("mypy", (python, "-m", "mypy", "src")),
+                Check("pip check", (python, "-m", "pip", "check")),
+                Check(
+                    "unit-linux equivalent",
+                    (
+                        python,
+                        "-m",
+                        "pytest",
+                        "-q",
+                        "-m",
+                        "not browser and not integration",
+                        "--cov=src",
+                        "--cov-report=term-missing",
+                        "--cov-fail-under=40",
+                    ),
+                ),
+                Check(
+                    "A-Z canary",
+                    (
+                        python,
+                        "-m",
+                        "pytest",
+                        "-q",
+                        "--no-cov",
+                        "src/tests/test_alive_loop_e2e.py",
+                        "src/tests/test_fuzz_yaml_rendering.py",
+                    ),
+                ),
+                Check(
+                    "contract compatibility local",
+                    (
+                        python,
+                        "-m",
+                        "pytest",
+                        "-q",
+                        "--no-cov",
+                        "src/tests/test_clean_host_contract.py",
+                        "src/tests/test_package_scaffold.py",
+                    ),
+                ),
+                Check(
+                    "clean host contract",
+                    (python, "scripts/clean_host_contract.py", "--fast"),
+                ),
+            ]
+        )
+
+    if flags["docs_changed"]:
+        checks.append(
+            Check("docs strict build", (python, "-m", "mkdocs", "build", "--strict"))
+        )
+
+    if flags["graph_artifact_changed"]:
+        checks.append(Check("graph artifact validation", (python, *GRAPH_VALIDATE_ARGS)))
+
+    if source_required and flags["similarity_changed"]:
+        checks.append(
+            Check(
+                "similarity precision/recall",
+                (
+                    python,
+                    "-m",
+                    "pytest",
+                    "-q",
+                    "--no-cov",
+                    "-m",
+                    "integration",
+                    "src/tests/test_similarity_precision_recall.py",
+                ),
+                env={"CTX_REQUIRE_SIMILARITY_EVAL": "1"},
+            )
+        )
+
+    if source_required and flags["browser_changed"]:
+        checks.append(
+            Check(
+                "browser monitor security",
+                (
+                    python,
+                    "-m",
+                    "pytest",
+                    "-q",
+                    "--no-cov",
+                    "-m",
+                    "browser",
+                    "src/tests/test_ctx_monitor_browser.py",
+                ),
+            )
+        )
+
+    if source_required:
+        out_dir = ".ci-preflight-dist"
+        twine_script = (
+            "import glob, subprocess, sys; "
+            f"files=glob.glob({str(out_dir + '/*')!r}); "
+            "sys.exit(2 if not files else subprocess.call("
+            "[sys.executable, '-m', 'twine', 'check', *files]))"
+        )
+        checks.extend(
+            [
+                Check(
+                    "clean preflight dist",
+                    (
+                        python,
+                        "-c",
+                        f"import shutil; shutil.rmtree({out_dir!r}, ignore_errors=True)",
+                    ),
+                ),
+                Check("build wheel", (python, "-m", "build", "--outdir", out_dir)),
+                Check("twine check", (python, "-c", twine_script)),
+            ]
+        )
+
+    if files:
+        notes.insert(0, f"Changed files vs {base_ref}: {len(files)}")
+    else:
+        notes.insert(0, "No changed files detected; running baseline cheap checks only.")
+
+    return checks, notes
+
+
+def run_checks(checks: list[Check], *, dry_run: bool) -> int:
+    for index, check in enumerate(checks, start=1):
+        print(f"[{index}/{len(checks)}] {check.name}: {' '.join(check.argv)}", flush=True)
+        if dry_run:
+            continue
+        env = os.environ.copy()
+        if check.env:
+            env.update(check.env)
+        start = time.monotonic()
+        proc = subprocess.run(check.argv, check=False, env=env)
+        elapsed = time.monotonic() - start
+        if proc.returncode != 0:
+            print(
+                f"[fail] {check.name} exited {proc.returncode} after {elapsed:.1f}s",
+                file=sys.stderr,
+            )
+            return proc.returncode
+        print(f"[pass] {check.name} in {elapsed:.1f}s", flush=True)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--base",
+        default="origin/main",
+        help="base ref for changed-file detection",
+    )
+    parser.add_argument(
+        "--profile",
+        choices=("pr", "full"),
+        default="pr",
+        help="pr mirrors required PR checks; full forces source gates for any change set",
+    )
+    parser.add_argument(
+        "--python",
+        default=sys.executable,
+        help="Python executable to run checks with",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="print selected checks without running them",
+    )
+    args = parser.parse_args(argv)
+
+    if not shutil.which("git"):
+        raise SystemExit("git is required for ci_preflight")
+
+    files = changed_files(args.base)
+    checks, notes = select_checks(
+        base_ref=args.base,
+        files=files,
+        profile=args.profile,
+        python=args.python,
+    )
+    for note in notes:
+        print(f"[note] {note}")
+    return run_checks(checks, dry_run=args.dry_run)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/ci_required.py

@@ -1,146 +1,146 @@
-"""Validate GitHub Actions dependency results for the stable CI check."""
-
-from __future__ import annotations
-
-import json
-import os
-from typing import Any
-
-CHEAP_PR_SKIPPABLE_JOBS = {
-    "clean-host-contract",
-    "contract-compat",
-    "e2e-canary",
-    "no-test-no-merge",
-    "package-build",
-    "package-smoke",
-    "similarity-integration",
-    "static",
-    "unit-linux",
-}
-REQUIRED_JOBS = {
-    "browser-security",
-    "classify",
-    "clean-host-contract",
-    "contract-compat",
-    "docs-check",
-    "e2e-canary",
-    "graph-check",
-    "no-test-no-merge",
-    "package-build",
-    "package-smoke",
-    "similarity-integration",
-    "static",
-    "test",
-    "unit-linux",
-}
-
-
-def _job_output(
-    needs: dict[str, dict[str, Any]],
-    job_name: str,
-    output_name: str,
-) -> str | None:
-    outputs = needs.get(job_name, {}).get("outputs", {})
-    if not isinstance(outputs, dict):
-        return None
-    output = outputs.get(output_name)
-    return output if isinstance(output, str) else None
-
-
-def failed_required_jobs(
-    needs: dict[str, dict[str, Any]],
-    *,
-    event_name: str,
-) -> dict[str, str | None]:
-    failures: dict[str, str | None] = {}
-    for name in sorted(REQUIRED_JOBS - set(needs)):
-        failures[name] = "missing"
-    docs_only_pr = (
-        event_name == "pull_request"
-        and _job_output(needs, "classify", "docs_only") == "true"
-    )
-    docs_changed_pr = (
-        event_name == "pull_request"
-        and _job_output(needs, "classify", "docs_changed") == "true"
-    )
-    graph_only_pr = (
-        event_name == "pull_request"
-        and _job_output(needs, "classify", "graph_only") == "true"
-    )
-    graph_artifact_changed_pr = (
-        event_name == "pull_request"
-        and _job_output(needs, "classify", "graph_artifact_changed") == "true"
-    )
-    similarity_changed_pr = (
-        event_name == "pull_request"
-        and _job_output(needs, "classify", "similarity_changed") == "true"
-    )
-    cheap_pr = docs_only_pr or graph_only_pr
-    for name, details in sorted(needs.items()):
-        result = details.get("result")
-        if result == "success":
-            continue
-        if (
-            event_name != "pull_request"
-            and name in {"docs-check", "graph-check", "no-test-no-merge"}
-            and result == "skipped"
-        ):
-            continue
-        if (
-            cheap_pr
-            and name in CHEAP_PR_SKIPPABLE_JOBS
-            and not (name == "similarity-integration" and similarity_changed_pr)
-            and result == "skipped"
-        ):
-            continue
-        if (
-            event_name == "pull_request"
-            and name == "docs-check"
-            and result == "skipped"
-            and not docs_changed_pr
-        ):
-            continue
-        if (
-            event_name == "pull_request"
-            and name == "graph-check"
-            and result == "skipped"
-            and not graph_artifact_changed_pr
-        ):
-            continue
-        if (
-            event_name == "pull_request"
-            and name == "browser-security"
-            and result == "skipped"
-            and _job_output(needs, "classify", "browser_changed") == "false"
-        ):
-            continue
-        if (
-            event_name == "pull_request"
-            and name == "similarity-integration"
-            and result == "skipped"
-            and _job_output(needs, "classify", "similarity_changed") == "false"
-        ):
-            continue
-        if event_name == "pull_request" and name == "test" and result == "skipped":
-            continue
-        failures[name] = result
-    return failures
-
-
-def main() -> int:
-    event_name = os.environ["EVENT_NAME"]
-    needs = json.loads(os.environ["NEEDS_JSON"])
-    bad = failed_required_jobs(needs, event_name=event_name)
-
-    for name, details in sorted(needs.items()):
-        print(f"{name}: {details.get('result')}")
-
-    if bad:
-        for name, result in bad.items():
-            print(f"::error::{name} finished with {result}")
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+"""Validate GitHub Actions dependency results for the stable CI check."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+CHEAP_PR_SKIPPABLE_JOBS = {
+    "clean-host-contract",
+    "contract-compat",
+    "e2e-canary",
+    "no-test-no-merge",
+    "package-build",
+    "package-smoke",
+    "similarity-integration",
+    "static",
+    "unit-linux",
+}
+REQUIRED_JOBS = {
+    "browser-security",
+    "classify",
+    "clean-host-contract",
+    "contract-compat",
+    "docs-check",
+    "e2e-canary",
+    "graph-check",
+    "no-test-no-merge",
+    "package-build",
+    "package-smoke",
+    "similarity-integration",
+    "static",
+    "test",
+    "unit-linux",
+}
+
+
+def _job_output(
+    needs: dict[str, dict[str, Any]],
+    job_name: str,
+    output_name: str,
+) -> str | None:
+    outputs = needs.get(job_name, {}).get("outputs", {})
+    if not isinstance(outputs, dict):
+        return None
+    output = outputs.get(output_name)
+    return output if isinstance(output, str) else None
+
+
+def failed_required_jobs(
+    needs: dict[str, dict[str, Any]],
+    *,
+    event_name: str,
+) -> dict[str, str | None]:
+    failures: dict[str, str | None] = {}
+    for name in sorted(REQUIRED_JOBS - set(needs)):
+        failures[name] = "missing"
+    docs_only_pr = (
+        event_name == "pull_request"
+        and _job_output(needs, "classify", "docs_only") == "true"
+    )
+    docs_changed_pr = (
+        event_name == "pull_request"
+        and _job_output(needs, "classify", "docs_changed") == "true"
+    )
+    graph_only_pr = (
+        event_name == "pull_request"
+        and _job_output(needs, "classify", "graph_only") == "true"
+    )
+    graph_artifact_changed_pr = (
+        event_name == "pull_request"
+        and _job_output(needs, "classify", "graph_artifact_changed") == "true"
+    )
+    similarity_changed_pr = (
+        event_name == "pull_request"
+        and _job_output(needs, "classify", "similarity_changed") == "true"
+    )
+    cheap_pr = docs_only_pr or graph_only_pr
+    for name, details in sorted(needs.items()):
+        result = details.get("result")
+        if result == "success":
+            continue
+        if (
+            event_name != "pull_request"
+            and name in {"docs-check", "graph-check", "no-test-no-merge"}
+            and result == "skipped"
+        ):
+            continue
+        if (
+            cheap_pr
+            and name in CHEAP_PR_SKIPPABLE_JOBS
+            and not (name == "similarity-integration" and similarity_changed_pr)
+            and result == "skipped"
+        ):
+            continue
+        if (
+            event_name == "pull_request"
+            and name == "docs-check"
+            and result == "skipped"
+            and not docs_changed_pr
+        ):
+            continue
+        if (
+            event_name == "pull_request"
+            and name == "graph-check"
+            and result == "skipped"
+            and not graph_artifact_changed_pr
+        ):
+            continue
+        if (
+            event_name == "pull_request"
+            and name == "browser-security"
+            and result == "skipped"
+            and _job_output(needs, "classify", "browser_changed") == "false"
+        ):
+            continue
+        if (
+            event_name == "pull_request"
+            and name == "similarity-integration"
+            and result == "skipped"
+            and _job_output(needs, "classify", "similarity_changed") == "false"
+        ):
+            continue
+        if event_name == "pull_request" and name == "test" and result == "skipped":
+            continue
+        failures[name] = result
+    return failures
+
+
+def main() -> int:
+    event_name = os.environ["EVENT_NAME"]
+    needs = json.loads(os.environ["NEEDS_JSON"])
+    bad = failed_required_jobs(needs, event_name=event_name)
+
+    for name, details in sorted(needs.items()):
+        print(f"{name}: {details.get('result')}")
+
+    if bad:
+        for name, result in bad.items():
+            print(f"::error::{name} finished with {result}")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/clean_host_contract.py

@@ -1,57 +1,57 @@
-"""Clean-host contract runner for ctx release hardening.
-
-The contract builds the current tree into a wheel, installs it into a
-fresh virtualenv, points all user-state environment variables at a temp
-root, then drives real console scripts. It is intentionally not a public
-entrypoint yet; this is release infrastructure.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import shlex
-import shutil
-import subprocess
-import sys
-import tempfile
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Mapping, Sequence
-
-
-LIVE_CLAUDE_ACK_ENV = "CTX_LIVE_CLAUDE_ACK"
-LIVE_CLAUDE_ACK_VALUE = "uses_quota"
-LIVE_CLAUDE_DEFAULT_BUDGET_USD = 0.05
-LIVE_CLAUDE_MAX_BUDGET_USD = 1.0
-LIVE_CLAUDE_PROMPT_TIMEOUT_SECONDS = 180.0
-LIVE_CLAUDE_PREFLIGHT_TIMEOUT_SECONDS = 30.0
-
-_LIVE_CLAUDE_AUTH_EXACT_ENV = {
-    "ANTHROPIC_API_KEY",
-    "ANTHROPIC_AUTH_TOKEN",
-    "ANTHROPIC_BASE_URL",
-    "ANTHROPIC_BETA_HEADERS",
-    "CLAUDE_CODE_USE_BEDROCK",
-    "CLAUDE_CODE_USE_VERTEX",
-    "CLAUDE_CODE_USE_FOUNDRY",
-}
-_LIVE_CLAUDE_AUTH_PREFIX_ENV = (
-    "AWS_",
-    "GOOGLE_",
-    "GCLOUD_",
-    "VERTEXAI_",
-    "ANTHROPIC_",
-)
+"""Clean-host contract runner for ctx release hardening.
+
+The contract builds the current tree into a wheel, installs it into a
+fresh virtualenv, points all user-state environment variables at a temp
+root, then drives real console scripts. It is intentionally not a public
+entrypoint yet; this is release infrastructure.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+
+LIVE_CLAUDE_ACK_ENV = "CTX_LIVE_CLAUDE_ACK"
+LIVE_CLAUDE_ACK_VALUE = "uses_quota"
+LIVE_CLAUDE_DEFAULT_BUDGET_USD = 0.05
+LIVE_CLAUDE_MAX_BUDGET_USD = 1.0
+LIVE_CLAUDE_PROMPT_TIMEOUT_SECONDS = 180.0
+LIVE_CLAUDE_PREFLIGHT_TIMEOUT_SECONDS = 30.0
+
+_LIVE_CLAUDE_AUTH_EXACT_ENV = {
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_BETA_HEADERS",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+}
+_LIVE_CLAUDE_AUTH_PREFIX_ENV = (
+    "AWS_",
+    "GOOGLE_",
+    "GCLOUD_",
+    "VERTEXAI_",
+    "ANTHROPIC_",
+)
 _LIVE_CLAUDE_PLATFORM_ENV = {
     "PATH",
     "Path",
     "PATHEXT",
     "SYSTEMROOT",
-    "SystemRoot",
-    "WINDIR",
-    "COMSPEC",
+    "SystemRoot",
+    "WINDIR",
+    "COMSPEC",
     "TEMP",
     "TMP",
 }
@@ -61,110 +61,110 @@ _CLEAN_HOST_PLATFORM_ENV = _LIVE_CLAUDE_PLATFORM_ENV | {
     "TZ",
 }
 _EXPECTED_LIVE_CLAUDE_EVENTS = ("PostToolUse", "Stop")
-
-
-@dataclass(frozen=True)
-class ContractPaths:
-    root: Path
-    home: Path
-    appdata: Path
-    localappdata: Path
-    xdg_config: Path
-    xdg_cache: Path
-    pip_cache: Path
-    dist: Path
-    venv: Path
-    fake_modules: Path
-    tiny_repo: Path
-    sessions: Path
-
-
-@dataclass(frozen=True)
-class CompletedCommand:
-    args: tuple[str, ...]
-    cwd: Path
-    returncode: int
-    stdout: str
-    stderr: str
-
-
-class CommandRunner:
-    def run(
-        self,
-        args: Sequence[str],
-        *,
-        cwd: Path,
-        env: Mapping[str, str],
-        check: bool = True,
-        timeout_seconds: float | None = None,
-    ) -> CompletedCommand:
-        print("+ " + " ".join(args), flush=True)
-        try:
-            result = subprocess.run(
-                list(args),
-                cwd=cwd,
-                env=dict(env),
-                text=True,
-                capture_output=True,
-                check=False,
-                timeout=timeout_seconds,
-            )
-        except subprocess.TimeoutExpired as exc:
-            raise SystemExit(
-                f"command timed out after {timeout_seconds}s: {' '.join(args)}"
-            ) from exc
-        if result.stdout.strip():
-            print(result.stdout.rstrip())
-        if result.stderr.strip():
-            print(result.stderr.rstrip(), file=sys.stderr)
-        completed = CompletedCommand(
-            args=tuple(args),
-            cwd=cwd,
-            returncode=result.returncode,
-            stdout=result.stdout,
-            stderr=result.stderr,
-        )
-        if check and result.returncode != 0:
-            raise SystemExit(
-                f"command failed with exit {result.returncode}: {' '.join(args)}"
-            )
-        return completed
-
-
-def repo_root() -> Path:
-    return Path(__file__).resolve().parents[1]
-
-
-def make_paths(root: Path) -> ContractPaths:
-    return ContractPaths(
-        root=root,
-        home=root / "home",
-        appdata=root / "appdata",
-        localappdata=root / "localappdata",
-        xdg_config=root / "xdg-config",
-        xdg_cache=root / "xdg-cache",
-        pip_cache=root / "pip-cache",
-        dist=root / "dist",
-        venv=root / "venv",
-        fake_modules=root / "fake-modules",
-        tiny_repo=root / "tiny-fastapi-repo",
-        sessions=root / "sessions",
-    )
-
-
-def _is_relative_to(path: Path, root: Path) -> bool:
-    try:
-        path.resolve().relative_to(root.resolve())
-    except ValueError:
-        return False
-    return True
-
-
-def assert_inside(path: Path, root: Path) -> None:
-    if not _is_relative_to(path, root):
-        raise AssertionError(f"path escaped temp root: {path} not under {root}")
-
-
+
+
+@dataclass(frozen=True)
+class ContractPaths:
+    root: Path
+    home: Path
+    appdata: Path
+    localappdata: Path
+    xdg_config: Path
+    xdg_cache: Path
+    pip_cache: Path
+    dist: Path
+    venv: Path
+    fake_modules: Path
+    tiny_repo: Path
+    sessions: Path
+
+
+@dataclass(frozen=True)
+class CompletedCommand:
+    args: tuple[str, ...]
+    cwd: Path
+    returncode: int
+    stdout: str
+    stderr: str
+
+
+class CommandRunner:
+    def run(
+        self,
+        args: Sequence[str],
+        *,
+        cwd: Path,
+        env: Mapping[str, str],
+        check: bool = True,
+        timeout_seconds: float | None = None,
+    ) -> CompletedCommand:
+        print("+ " + " ".join(args), flush=True)
+        try:
+            result = subprocess.run(
+                list(args),
+                cwd=cwd,
+                env=dict(env),
+                text=True,
+                capture_output=True,
+                check=False,
+                timeout=timeout_seconds,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise SystemExit(
+                f"command timed out after {timeout_seconds}s: {' '.join(args)}"
+            ) from exc
+        if result.stdout.strip():
+            print(result.stdout.rstrip())
+        if result.stderr.strip():
+            print(result.stderr.rstrip(), file=sys.stderr)
+        completed = CompletedCommand(
+            args=tuple(args),
+            cwd=cwd,
+            returncode=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+        )
+        if check and result.returncode != 0:
+            raise SystemExit(
+                f"command failed with exit {result.returncode}: {' '.join(args)}"
+            )
+        return completed
+
+
+def repo_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def make_paths(root: Path) -> ContractPaths:
+    return ContractPaths(
+        root=root,
+        home=root / "home",
+        appdata=root / "appdata",
+        localappdata=root / "localappdata",
+        xdg_config=root / "xdg-config",
+        xdg_cache=root / "xdg-cache",
+        pip_cache=root / "pip-cache",
+        dist=root / "dist",
+        venv=root / "venv",
+        fake_modules=root / "fake-modules",
+        tiny_repo=root / "tiny-fastapi-repo",
+        sessions=root / "sessions",
+    )
+
+
+def _is_relative_to(path: Path, root: Path) -> bool:
+    try:
+        path.resolve().relative_to(root.resolve())
+    except ValueError:
+        return False
+    return True
+
+
+def assert_inside(path: Path, root: Path) -> None:
+    if not _is_relative_to(path, root):
+        raise AssertionError(f"path escaped temp root: {path} not under {root}")
+
+
 def isolated_env(paths: ContractPaths, *, extra_pythonpath: Path | None = None) -> dict[str, str]:
     env = {
         key: value
@@ -175,167 +175,167 @@ def isolated_env(paths: ContractPaths, *, extra_pythonpath: Path | None = None)
         "HOME": str(paths.home),
         "USERPROFILE": str(paths.home),
         "APPDATA": str(paths.appdata),
-        "LOCALAPPDATA": str(paths.localappdata),
-        "XDG_CONFIG_HOME": str(paths.xdg_config),
-        "XDG_CACHE_HOME": str(paths.xdg_cache),
+        "LOCALAPPDATA": str(paths.localappdata),
+        "XDG_CONFIG_HOME": str(paths.xdg_config),
+        "XDG_CACHE_HOME": str(paths.xdg_cache),
         "PIP_CACHE_DIR": str(paths.pip_cache),
         "PYTHONUTF8": "1",
     })
     if extra_pythonpath is not None:
         env["PYTHONPATH"] = str(extra_pythonpath)
     return env
-
-
-def live_claude_env(paths: ContractPaths) -> dict[str, str]:
-    """Build a narrow env for opt-in live Claude checks.
-
-    The fake contract can inherit the parent env because it never calls a
-    hosted model. The live gate is different: it should keep auth and platform
-    plumbing, but not point Claude back at the user's real home/config tree.
-    """
-    env: dict[str, str] = {}
-    for key, value in os.environ.items():
-        if (
-            key in _LIVE_CLAUDE_PLATFORM_ENV
-            or key in _LIVE_CLAUDE_AUTH_EXACT_ENV
-            or key.startswith(_LIVE_CLAUDE_AUTH_PREFIX_ENV)
-        ):
-            env[key] = value
-    env.update({
-        "HOME": str(paths.home),
-        "USERPROFILE": str(paths.home),
-        "APPDATA": str(paths.appdata),
-        "LOCALAPPDATA": str(paths.localappdata),
-        "XDG_CONFIG_HOME": str(paths.xdg_config),
-        "XDG_CACHE_HOME": str(paths.xdg_cache),
-        "PYTHONUTF8": "1",
-    })
-    env.pop("CLAUDE_HOME", None)
-    return env
-
-
-def venv_python(venv: Path) -> Path:
-    if os.name == "nt":
-        return venv / "Scripts" / "python.exe"
-    return venv / "bin" / "python"
-
-
-def venv_script(venv: Path, name: str) -> Path:
-    candidates = (
-        [venv / "Scripts" / f"{name}.exe", venv / "Scripts" / name]
-        if os.name == "nt"
-        else [venv / "bin" / name]
-    )
-    for candidate in candidates:
-        if candidate.exists():
-            return candidate
-    return candidates[0]
-
-
-def write_fake_litellm(fake_modules: Path) -> Path:
-    fake_modules.mkdir(parents=True, exist_ok=True)
-    path = fake_modules / "litellm.py"
-    path.write_text(
-        '''"""Process-local fake LiteLLM for clean-host contract runs."""\n'''
-        "from __future__ import annotations\n\n"
-        "import json\n"
-        "import os\n\n"
-        "def completion(**kwargs):\n"
-        "    tool_name = os.environ.get('CTX_FAKE_LITELLM_TOOL_CALL')\n"
-        "    if tool_name:\n"
-        "        return {\n"
-        "            'choices': [{\n"
-        "                'message': {\n"
-        "                    'content': '',\n"
-        "                    'tool_calls': [{\n"
-        "                        'id': 'clean-host-call-1',\n"
-        "                        'type': 'function',\n"
-        "                        'function': {\n"
-        "                            'name': tool_name,\n"
-        "                            'arguments': json.dumps({'slug': 'python-patterns'}),\n"
-        "                        },\n"
-        "                    }],\n"
-        "                },\n"
-        "                'finish_reason': 'tool_calls',\n"
-        "            }],\n"
-        "            'usage': {'prompt_tokens': 5, 'completion_tokens': 1},\n"
-        "        }\n"
-        "    return {\n"
-        "        'choices': [{\n"
-        "            'message': {'content': 'clean host contract response', 'tool_calls': None},\n"
-        "            'finish_reason': 'stop',\n"
-        "        }],\n"
-        "        'usage': {'prompt_tokens': 5, 'completion_tokens': 3},\n"
-        "    }\n",
-        encoding="utf-8",
-    )
-    return path
-
-
-def write_fake_claude_cli(fake_modules: Path) -> Path:
-    """Write a tiny Claude-Code-like host that executes generated hooks.
-
-    This does not call Anthropic APIs. It reads the isolated settings.json
-    produced by ctx-init and invokes the configured hook command strings with
-    representative stdin payloads, which catches broken module paths and hook
-    schema drift from the installed wheel.
-    """
-    fake_modules.mkdir(parents=True, exist_ok=True)
-    path = fake_modules / "fake_claude.py"
-    path.write_text(
-        '''"""Deterministic Claude Code hook smoke host for clean-host tests."""\n'''
-        "from __future__ import annotations\n\n"
-        "import argparse\n"
-        "import json\n"
-        "import os\n"
-        "import re\n"
+
+
+def live_claude_env(paths: ContractPaths) -> dict[str, str]:
+    """Build a narrow env for opt-in live Claude checks.
+
+    The fake contract can inherit the parent env because it never calls a
+    hosted model. The live gate is different: it should keep auth and platform
+    plumbing, but not point Claude back at the user's real home/config tree.
+    """
+    env: dict[str, str] = {}
+    for key, value in os.environ.items():
+        if (
+            key in _LIVE_CLAUDE_PLATFORM_ENV
+            or key in _LIVE_CLAUDE_AUTH_EXACT_ENV
+            or key.startswith(_LIVE_CLAUDE_AUTH_PREFIX_ENV)
+        ):
+            env[key] = value
+    env.update({
+        "HOME": str(paths.home),
+        "USERPROFILE": str(paths.home),
+        "APPDATA": str(paths.appdata),
+        "LOCALAPPDATA": str(paths.localappdata),
+        "XDG_CONFIG_HOME": str(paths.xdg_config),
+        "XDG_CACHE_HOME": str(paths.xdg_cache),
+        "PYTHONUTF8": "1",
+    })
+    env.pop("CLAUDE_HOME", None)
+    return env
+
+
+def venv_python(venv: Path) -> Path:
+    if os.name == "nt":
+        return venv / "Scripts" / "python.exe"
+    return venv / "bin" / "python"
+
+
+def venv_script(venv: Path, name: str) -> Path:
+    candidates = (
+        [venv / "Scripts" / f"{name}.exe", venv / "Scripts" / name]
+        if os.name == "nt"
+        else [venv / "bin" / name]
+    )
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+def write_fake_litellm(fake_modules: Path) -> Path:
+    fake_modules.mkdir(parents=True, exist_ok=True)
+    path = fake_modules / "litellm.py"
+    path.write_text(
+        '''"""Process-local fake LiteLLM for clean-host contract runs."""\n'''
+        "from __future__ import annotations\n\n"
+        "import json\n"
+        "import os\n\n"
+        "def completion(**kwargs):\n"
+        "    tool_name = os.environ.get('CTX_FAKE_LITELLM_TOOL_CALL')\n"
+        "    if tool_name:\n"
+        "        return {\n"
+        "            'choices': [{\n"
+        "                'message': {\n"
+        "                    'content': '',\n"
+        "                    'tool_calls': [{\n"
+        "                        'id': 'clean-host-call-1',\n"
+        "                        'type': 'function',\n"
+        "                        'function': {\n"
+        "                            'name': tool_name,\n"
+        "                            'arguments': json.dumps({'slug': 'python-patterns'}),\n"
+        "                        },\n"
+        "                    }],\n"
+        "                },\n"
+        "                'finish_reason': 'tool_calls',\n"
+        "            }],\n"
+        "            'usage': {'prompt_tokens': 5, 'completion_tokens': 1},\n"
+        "        }\n"
+        "    return {\n"
+        "        'choices': [{\n"
+        "            'message': {'content': 'clean host contract response', 'tool_calls': None},\n"
+        "            'finish_reason': 'stop',\n"
+        "        }],\n"
+        "        'usage': {'prompt_tokens': 5, 'completion_tokens': 3},\n"
+        "    }\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def write_fake_claude_cli(fake_modules: Path) -> Path:
+    """Write a tiny Claude-Code-like host that executes generated hooks.
+
+    This does not call Anthropic APIs. It reads the isolated settings.json
+    produced by ctx-init and invokes the configured hook command strings with
+    representative stdin payloads, which catches broken module paths and hook
+    schema drift from the installed wheel.
+    """
+    fake_modules.mkdir(parents=True, exist_ok=True)
+    path = fake_modules / "fake_claude.py"
+    path.write_text(
+        '''"""Deterministic Claude Code hook smoke host for clean-host tests."""\n'''
+        "from __future__ import annotations\n\n"
+        "import argparse\n"
+        "import json\n"
+        "import os\n"
+        "import re\n"
         "import subprocess\n"
-        "import sys\n"
-        "from pathlib import Path\n\n"
-        "PAYLOADS = {\n"
-        "    'PostToolUse': {\n"
-        "        'hook_event_name': 'PostToolUse',\n"
-        "        'tool_name': 'Bash',\n"
-        "        'tool_input': {'command': 'pip install fastapi pytest'},\n"
-        "    },\n"
-        "    'Stop': {\n"
-        "        'hook_event_name': 'Stop',\n"
-        "        'session_id': 'clean-host-fake-claude',\n"
-        "    },\n"
-        "}\n\n"
-        "def _settings_path(raw: str) -> Path:\n"
-        "    if raw:\n"
-        "        return Path(raw)\n"
-        "    return Path(os.path.expanduser('~/.claude/settings.json'))\n\n"
-        "def _commands(settings: dict, event: str) -> list[str]:\n"
-        "    payload = PAYLOADS[event]\n"
-        "    tool_name = str(payload.get('tool_name') or '')\n"
-        "    out: list[str] = []\n"
-        "    for entry in settings.get('hooks', {}).get(event, []):\n"
-        "        if not isinstance(entry, dict):\n"
-        "            continue\n"
-        "        matcher = str(entry.get('matcher') or '.*')\n"
-        "        if event == 'PostToolUse' and not re.search(matcher, tool_name):\n"
-        "            continue\n"
-        "        for hook in entry.get('hooks', []):\n"
-        "            if isinstance(hook, dict) and hook.get('type') == 'command':\n"
-        "                command = hook.get('command')\n"
-        "                if isinstance(command, str) and command.strip():\n"
-        "                    out.append(command)\n"
-        "    return out\n\n"
-        "def main() -> int:\n"
-        "    parser = argparse.ArgumentParser()\n"
-        "    parser.add_argument('--settings', default='')\n"
-        "    parser.add_argument('--cwd', default='')\n"
-        "    parser.add_argument('-p', '--print', action='store_true')\n"
-        "    parser.add_argument('prompt', nargs='*')\n"
-        "    args = parser.parse_args()\n"
-        "    settings = json.loads(_settings_path(args.settings).read_text(encoding='utf-8'))\n"
-        "    cwd = args.cwd or os.getcwd()\n"
-        "    records = []\n"
-        "    for event in ('PostToolUse', 'Stop'):\n"
-        "        payload = json.dumps(PAYLOADS[event])\n"
-        "        for command in _commands(settings, event):\n"
+        "import sys\n"
+        "from pathlib import Path\n\n"
+        "PAYLOADS = {\n"
+        "    'PostToolUse': {\n"
+        "        'hook_event_name': 'PostToolUse',\n"
+        "        'tool_name': 'Bash',\n"
+        "        'tool_input': {'command': 'pip install fastapi pytest'},\n"
+        "    },\n"
+        "    'Stop': {\n"
+        "        'hook_event_name': 'Stop',\n"
+        "        'session_id': 'clean-host-fake-claude',\n"
+        "    },\n"
+        "}\n\n"
+        "def _settings_path(raw: str) -> Path:\n"
+        "    if raw:\n"
+        "        return Path(raw)\n"
+        "    return Path(os.path.expanduser('~/.claude/settings.json'))\n\n"
+        "def _commands(settings: dict, event: str) -> list[str]:\n"
+        "    payload = PAYLOADS[event]\n"
+        "    tool_name = str(payload.get('tool_name') or '')\n"
+        "    out: list[str] = []\n"
+        "    for entry in settings.get('hooks', {}).get(event, []):\n"
+        "        if not isinstance(entry, dict):\n"
+        "            continue\n"
+        "        matcher = str(entry.get('matcher') or '.*')\n"
+        "        if event == 'PostToolUse' and not re.search(matcher, tool_name):\n"
+        "            continue\n"
+        "        for hook in entry.get('hooks', []):\n"
+        "            if isinstance(hook, dict) and hook.get('type') == 'command':\n"
+        "                command = hook.get('command')\n"
+        "                if isinstance(command, str) and command.strip():\n"
+        "                    out.append(command)\n"
+        "    return out\n\n"
+        "def main() -> int:\n"
+        "    parser = argparse.ArgumentParser()\n"
+        "    parser.add_argument('--settings', default='')\n"
+        "    parser.add_argument('--cwd', default='')\n"
+        "    parser.add_argument('-p', '--print', action='store_true')\n"
+        "    parser.add_argument('prompt', nargs='*')\n"
+        "    args = parser.parse_args()\n"
+        "    settings = json.loads(_settings_path(args.settings).read_text(encoding='utf-8'))\n"
+        "    cwd = args.cwd or os.getcwd()\n"
+        "    records = []\n"
+        "    for event in ('PostToolUse', 'Stop'):\n"
+        "        payload = json.dumps(PAYLOADS[event])\n"
+        "        for command in _commands(settings, event):\n"
         "            result = subprocess.run(\n"
         "                command,\n"
         "                cwd=cwd,\n"
@@ -346,551 +346,551 @@ def write_fake_claude_cli(fake_modules: Path) -> Path:
         "                check=False,\n"
         "                shell=True,\n"
         "            )\n"
-        "            records.append({\n"
-        "                'event': event,\n"
-        "                'command': command,\n"
-        "                'returncode': result.returncode,\n"
-        "                'stdout': result.stdout[-500:],\n"
-        "                'stderr': result.stderr[-500:],\n"
-        "            })\n"
-        "    failed = [r for r in records if r['returncode'] != 0]\n"
-        "    print(json.dumps({'hook_commands': len(records), 'failed': len(failed), 'commands': records}))\n"
-        "    return 1 if failed else 0\n\n"
-        "if __name__ == '__main__':\n"
-        "    raise SystemExit(main())\n",
-        encoding="utf-8",
-    )
-    return path
-
-
-def write_tiny_repo(path: Path) -> None:
-    (path / "app").mkdir(parents=True, exist_ok=True)
-    (path / "tests").mkdir(parents=True, exist_ok=True)
-    (path / "pyproject.toml").write_text(
-        "[project]\n"
-        "name = \"tiny-fastapi-contract\"\n"
-        "version = \"0.1.0\"\n"
-        "dependencies = [\"fastapi\", \"pytest\"]\n",
-        encoding="utf-8",
-    )
-    (path / "app" / "main.py").write_text(
-        "from fastapi import FastAPI\n\n"
-        "app = FastAPI()\n\n"
-        "@app.get('/health')\n"
-        "def health():\n"
-        "    return {'ok': True}\n",
-        encoding="utf-8",
-    )
-    (path / "tests" / "test_health.py").write_text(
-        "def test_contract_fixture():\n"
-        "    assert True\n",
-        encoding="utf-8",
-    )
-
-
-def _single_wheel(dist: Path) -> Path:
-    wheels = sorted(dist.glob("*.whl"))
-    if len(wheels) != 1:
-        raise AssertionError(f"expected exactly one wheel in {dist}, found {len(wheels)}")
-    return wheels[0]
-
-
-def _prepare_dirs(paths: ContractPaths) -> None:
-    for path in (
-        paths.home,
-        paths.appdata,
-        paths.localappdata,
-        paths.xdg_config,
-        paths.xdg_cache,
-        paths.pip_cache,
-        paths.dist,
-        paths.fake_modules,
-        paths.sessions,
-    ):
-        path.mkdir(parents=True, exist_ok=True)
-
-
-def _assert_fake_claude_hook_output(stdout: str) -> None:
-    try:
-        result = json.loads(stdout)
-    except json.JSONDecodeError as exc:
-        raise AssertionError(f"fake Claude hook smoke returned invalid JSON: {stdout!r}") from exc
-    if result.get("failed") != 0:
-        raise AssertionError(f"fake Claude hook smoke had failures: {stdout}")
-    hook_commands = int(result.get("hook_commands") or 0)
-    if hook_commands < 5:
-        raise AssertionError(f"expected at least 5 generated hook commands, got {hook_commands}")
-    rendered = "\n".join(
-        str(row.get("command", ""))
-        for row in result.get("commands", [])
-        if isinstance(row, dict)
-    )
-    for expected in (
-        "ctx.adapters.claude_code.hooks.context_monitor",
-        "skill_add_detector",
-        "ctx.adapters.claude_code.hooks.bundle_orchestrator",
-        "usage_tracker",
-        "ctx.adapters.claude_code.hooks.lifecycle_hooks",
-    ):
-        if expected not in rendered:
-            raise AssertionError(f"fake Claude hook smoke did not run {expected}")
-
-
+        "            records.append({\n"
+        "                'event': event,\n"
+        "                'command': command,\n"
+        "                'returncode': result.returncode,\n"
+        "                'stdout': result.stdout[-500:],\n"
+        "                'stderr': result.stderr[-500:],\n"
+        "            })\n"
+        "    failed = [r for r in records if r['returncode'] != 0]\n"
+        "    print(json.dumps({'hook_commands': len(records), 'failed': len(failed), 'commands': records}))\n"
+        "    return 1 if failed else 0\n\n"
+        "if __name__ == '__main__':\n"
+        "    raise SystemExit(main())\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def write_tiny_repo(path: Path) -> None:
+    (path / "app").mkdir(parents=True, exist_ok=True)
+    (path / "tests").mkdir(parents=True, exist_ok=True)
+    (path / "pyproject.toml").write_text(
+        "[project]\n"
+        "name = \"tiny-fastapi-contract\"\n"
+        "version = \"0.1.0\"\n"
+        "dependencies = [\"fastapi\", \"pytest\"]\n",
+        encoding="utf-8",
+    )
+    (path / "app" / "main.py").write_text(
+        "from fastapi import FastAPI\n\n"
+        "app = FastAPI()\n\n"
+        "@app.get('/health')\n"
+        "def health():\n"
+        "    return {'ok': True}\n",
+        encoding="utf-8",
+    )
+    (path / "tests" / "test_health.py").write_text(
+        "def test_contract_fixture():\n"
+        "    assert True\n",
+        encoding="utf-8",
+    )
+
+
+def _single_wheel(dist: Path) -> Path:
+    wheels = sorted(dist.glob("*.whl"))
+    if len(wheels) != 1:
+        raise AssertionError(f"expected exactly one wheel in {dist}, found {len(wheels)}")
+    return wheels[0]
+
+
+def _prepare_dirs(paths: ContractPaths) -> None:
+    for path in (
+        paths.home,
+        paths.appdata,
+        paths.localappdata,
+        paths.xdg_config,
+        paths.xdg_cache,
+        paths.pip_cache,
+        paths.dist,
+        paths.fake_modules,
+        paths.sessions,
+    ):
+        path.mkdir(parents=True, exist_ok=True)
+
+
+def _assert_fake_claude_hook_output(stdout: str) -> None:
+    try:
+        result = json.loads(stdout)
+    except json.JSONDecodeError as exc:
+        raise AssertionError(f"fake Claude hook smoke returned invalid JSON: {stdout!r}") from exc
+    if result.get("failed") != 0:
+        raise AssertionError(f"fake Claude hook smoke had failures: {stdout}")
+    hook_commands = int(result.get("hook_commands") or 0)
+    if hook_commands < 5:
+        raise AssertionError(f"expected at least 5 generated hook commands, got {hook_commands}")
+    rendered = "\n".join(
+        str(row.get("command", ""))
+        for row in result.get("commands", [])
+        if isinstance(row, dict)
+    )
+    for expected in (
+        "ctx.adapters.claude_code.hooks.context_monitor",
+        "skill_add_detector",
+        "ctx.adapters.claude_code.hooks.bundle_orchestrator",
+        "usage_tracker",
+        "ctx.adapters.claude_code.hooks.lifecycle_hooks",
+    ):
+        if expected not in rendered:
+            raise AssertionError(f"fake Claude hook smoke did not run {expected}")
+
+
 def _quote_command(parts: Sequence[str | Path]) -> str:
     values = [str(part) for part in parts]
     if os.name == "nt":
         return subprocess.list2cmdline(values)
     return " ".join(shlex.quote(part) for part in values)
-
-
-def write_live_claude_sentinel_script(path: Path) -> None:
-    path.write_text(
-        '''"""Append Claude Code hook events to a clean-host sentinel file."""\n'''
-        "from __future__ import annotations\n\n"
-        "import argparse\n"
-        "import json\n"
-        "import os\n"
-        "import sys\n"
-        "from pathlib import Path\n\n"
-        "def main() -> int:\n"
-        "    parser = argparse.ArgumentParser()\n"
-        "    parser.add_argument('--event', required=True)\n"
-        "    parser.add_argument('--out', required=True)\n"
-        "    args = parser.parse_args()\n"
-        "    raw = sys.stdin.read()\n"
-        "    try:\n"
-        "        payload = json.loads(raw) if raw.strip() else {}\n"
-        "    except json.JSONDecodeError:\n"
-        "        payload = {'invalid_json_prefix': raw[:200]}\n"
-        "    out = Path(args.out)\n"
-        "    out.parent.mkdir(parents=True, exist_ok=True)\n"
-        "    record = {\n"
-        "        'event': args.event,\n"
-        "        'hook_event_name': payload.get('hook_event_name'),\n"
-        "        'tool_name': payload.get('tool_name'),\n"
-        "        'cwd': os.getcwd(),\n"
-        "        'argv': sys.argv[1:],\n"
-        "    }\n"
-        "    with out.open('a', encoding='utf-8') as handle:\n"
-        "        handle.write(json.dumps(record, sort_keys=True) + '\\n')\n"
-        "    return 0\n\n"
-        "if __name__ == '__main__':\n"
-        "    raise SystemExit(main())\n",
-        encoding="utf-8",
-    )
-
-
-def _append_live_claude_sentinel_hooks(
-    *,
-    settings_json: Path,
-    python_bin: Path,
-    sentinel_script: Path,
-    sentinel_jsonl: Path,
-) -> None:
-    settings = json.loads(settings_json.read_text(encoding="utf-8"))
-    hooks = settings.setdefault("hooks", {})
-    post_command = _quote_command((
-        python_bin,
-        sentinel_script,
-        "--event",
-        "PostToolUse",
-        "--out",
-        sentinel_jsonl,
-    ))
-    stop_command = _quote_command((
-        python_bin,
-        sentinel_script,
-        "--event",
-        "Stop",
-        "--out",
-        sentinel_jsonl,
-    ))
-    hooks.setdefault("PostToolUse", []).append({
-        "matcher": ".*",
-        "hooks": [{"type": "command", "command": post_command}],
-    })
-    hooks.setdefault("Stop", []).append({
-        "hooks": [{"type": "command", "command": stop_command}],
-    })
-    tmp_path = settings_json.with_name(f"{settings_json.name}.live.tmp")
-    tmp_path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
-    os.replace(tmp_path, settings_json)
-
-
-def _sentinel_records(path: Path) -> list[dict[str, Any]]:
-    if not path.exists():
-        raise AssertionError(f"live Claude sentinel was not written: {path}")
-    records: list[dict[str, Any]] = []
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if not line.strip():
-            continue
-        try:
-            record = json.loads(line)
-        except json.JSONDecodeError as exc:
-            raise AssertionError(f"live Claude sentinel has invalid JSONL: {line}") from exc
-        if not isinstance(record, dict):
-            raise AssertionError(f"live Claude sentinel record is not an object: {line}")
-        records.append(record)
-    return records
-
-
-def _assert_live_claude_sentinel(path: Path, *, expected_cwd: Path) -> None:
-    records = _sentinel_records(path)
-    events = {str(record.get("event") or "") for record in records}
-    for expected in _EXPECTED_LIVE_CLAUDE_EVENTS:
-        if expected not in events:
-            raise AssertionError(f"live Claude sentinel did not record {expected}")
-    expected_resolved = expected_cwd.resolve()
-    for record in records:
-        cwd = record.get("cwd")
-        if cwd is None or Path(str(cwd)).resolve() != expected_resolved:
-            raise AssertionError(
-                "live Claude sentinel recorded unexpected cwd: "
-                f"{cwd!r}, expected {expected_resolved}"
-            )
-        hook_event = record.get("hook_event_name")
-        event = record.get("event")
-        if hook_event not in (None, event):
-            raise AssertionError(
-                f"live Claude sentinel event mismatch: event={event!r}, "
-                f"hook_event_name={hook_event!r}"
-            )
-
-
-def _require_live_claude_ack(max_budget_usd: float) -> None:
-    if os.environ.get(LIVE_CLAUDE_ACK_ENV) != LIVE_CLAUDE_ACK_VALUE:
-        raise AssertionError(
-            f"set {LIVE_CLAUDE_ACK_ENV}={LIVE_CLAUDE_ACK_VALUE} to run "
-            "the quota-consuming live Claude Code gate"
-        )
-    if max_budget_usd <= 0 or max_budget_usd > LIVE_CLAUDE_MAX_BUDGET_USD:
-        raise AssertionError(
-            "live Claude budget must be greater than 0 and no more than "
-            f"{LIVE_CLAUDE_MAX_BUDGET_USD} USD"
-        )
-
-
-def _live_claude_command(
-    *,
-    claude_bin: Path,
-    settings_json: Path,
-    max_budget_usd: float,
-) -> list[str]:
-    return [
-        str(claude_bin),
-        "--settings",
-        str(settings_json),
-        "--setting-sources",
-        "user",
-        "--output-format",
-        "stream-json",
-        "--include-hook-events",
-        "--no-session-persistence",
-        "--max-budget-usd",
-        str(max_budget_usd),
-        "--allowedTools",
-        "Bash(python --version)",
-        "-p",
-        "Use Bash to run exactly `python --version`, then stop.",
-    ]
-
-
-def _run_live_claude_gate(
-    *,
-    runner: CommandRunner,
-    paths: ContractPaths,
-    python_bin: Path,
-    settings_json: Path,
-    max_budget_usd: float,
-    claude_bin: Path | None,
-) -> None:
-    _require_live_claude_ack(max_budget_usd)
-    resolved_claude = claude_bin if claude_bin is not None else None
-    if resolved_claude is None:
-        claude = shutil.which("claude")
-        resolved_claude = Path(claude) if claude is not None else None
-    if resolved_claude is None:
-        raise AssertionError("claude executable was not found on PATH")
-    live_env = live_claude_env(paths)
-    runner.run(
-        [str(resolved_claude), "--version"],
-        cwd=paths.tiny_repo,
-        env=live_env,
-        timeout_seconds=LIVE_CLAUDE_PREFLIGHT_TIMEOUT_SECONDS,
-    )
-    runner.run(
-        [str(resolved_claude), "auth", "status"],
-        cwd=paths.tiny_repo,
-        env=live_env,
-        timeout_seconds=LIVE_CLAUDE_PREFLIGHT_TIMEOUT_SECONDS,
-    )
-    sentinel_script = paths.root / "live-claude-hook-sentinel.py"
-    sentinel_jsonl = paths.root / "live-claude-hooks.jsonl"
-    write_live_claude_sentinel_script(sentinel_script)
-    _append_live_claude_sentinel_hooks(
-        settings_json=settings_json,
-        python_bin=python_bin,
-        sentinel_script=sentinel_script,
-        sentinel_jsonl=sentinel_jsonl,
-    )
-    runner.run(
-        _live_claude_command(
-            claude_bin=resolved_claude,
-            settings_json=settings_json,
-            max_budget_usd=max_budget_usd,
-        ),
-        cwd=paths.tiny_repo,
-        env=live_env,
-        timeout_seconds=LIVE_CLAUDE_PROMPT_TIMEOUT_SECONDS,
-    )
-    _assert_live_claude_sentinel(sentinel_jsonl, expected_cwd=paths.tiny_repo)
-
-
-def run_contract(
-    *,
-    project_root: Path,
-    temp_root: Path,
-    fast: bool,
-    runner: CommandRunner | None = None,
-    run_live_claude: bool = False,
-    live_claude_max_budget_usd: float = LIVE_CLAUDE_DEFAULT_BUDGET_USD,
-    live_claude_bin: Path | None = None,
-) -> None:
-    runner = runner or CommandRunner()
-    paths = make_paths(temp_root)
-    _prepare_dirs(paths)
-    write_tiny_repo(paths.tiny_repo)
-    write_fake_litellm(paths.fake_modules)
-    fake_claude = write_fake_claude_cli(paths.fake_modules)
-
-    env = isolated_env(paths)
-    runner.run(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "wheel",
-            "--no-deps",
-            "--wheel-dir",
-            str(paths.dist),
-            str(project_root),
-        ],
-        cwd=project_root,
-        env=env,
-    )
-    runner.run([sys.executable, "-m", "venv", str(paths.venv)], cwd=project_root, env=env)
-    wheel = _single_wheel(paths.dist)
-    py = venv_python(paths.venv)
-    runner.run([str(py), "-m", "pip", "install", str(wheel)], cwd=project_root, env=env)
-
-    run_env = isolated_env(paths, extra_pythonpath=paths.fake_modules)
-    ctx_init = venv_script(paths.venv, "ctx-init")
-    ctx_scan_repo = venv_script(paths.venv, "ctx-scan-repo")
-    ctx = venv_script(paths.venv, "ctx")
-
-    runner.run([str(ctx_init), "--hooks"], cwd=paths.tiny_repo, env=run_env)
-    claude_dir = paths.home / ".claude"
-    assert_inside(claude_dir, paths.root)
-    if not (claude_dir / "settings.json").exists():
-        raise AssertionError("ctx-init --hooks did not write isolated settings.json")
-    fake_claude_result = runner.run(
-        [
-            str(py),
-            str(fake_claude),
-            "--settings",
-            str(claude_dir / "settings.json"),
-            "--cwd",
-            str(paths.tiny_repo),
-            "-p",
-            "trigger clean-host hook smoke",
-        ],
-        cwd=paths.tiny_repo,
-        env=run_env,
-    )
-    _assert_fake_claude_hook_output(fake_claude_result.stdout)
-    if run_live_claude:
-        _run_live_claude_gate(
-            runner=runner,
-            paths=paths,
-            python_bin=py,
-            settings_json=claude_dir / "settings.json",
-            max_budget_usd=live_claude_max_budget_usd,
-            claude_bin=live_claude_bin,
-        )
-
-    stack_profile = paths.root / "stack-profile.json"
-    runner.run(
-        [
-            str(ctx_scan_repo),
-            "--repo",
-            str(paths.tiny_repo),
-            "--output",
-            str(stack_profile),
-            "--recommend",
-        ],
-        cwd=paths.tiny_repo,
-        env=run_env,
-    )
-    if not stack_profile.exists():
-        raise AssertionError("ctx-scan-repo did not write stack profile")
-
-    runner.run(
-        [
-            str(ctx),
-            "run",
-            "--model",
-            "ollama/clean-host-fake",
-            "--task",
-            "Return a one-sentence clean-host contract response.",
-            "--no-ctx-tools",
-            "--sessions-dir",
-            str(paths.sessions),
-            "--session-id",
-            "clean-host-contract",
-            "--quiet",
-        ],
-        cwd=paths.tiny_repo,
-        env=run_env,
-    )
-    runner.run(
-        [
-            str(ctx),
-            "resume",
-            "clean-host-contract",
-            "--task",
-            "Confirm resume works.",
-            "--sessions-dir",
-            str(paths.sessions),
-            "--quiet",
-        ],
-        cwd=paths.tiny_repo,
-        env=run_env,
-    )
-
-    denied_env = dict(run_env)
-    denied_env["CTX_FAKE_LITELLM_TOOL_CALL"] = "ctx__wiki_get"
-    denied = runner.run(
-        [
-            str(ctx),
-            "run",
-            "--model",
-            "ollama/clean-host-fake",
-            "--task",
-            "Attempt the wiki tool so policy can deny it.",
-            "--sessions-dir",
-            str(paths.sessions),
-            "--session-id",
-            "clean-host-denied-tool",
-            "--deny-tool",
-            "ctx__wiki_get",
-            "--quiet",
-            "--json",
-        ],
-        cwd=paths.tiny_repo,
-        env=denied_env,
-        check=False,
-    )
-    if denied.returncode != 2 or '"tool_denied"' not in denied.stdout:
-        raise AssertionError(
-            "expected denied tool run to exit 2 with tool_denied JSON; "
-            f"got rc={denied.returncode}"
-        )
-
-    if not fast:
-        runner.run([str(ctx_init), "--help"], cwd=paths.tiny_repo, env=run_env)
-        runner.run([str(ctx_scan_repo), "--help"], cwd=paths.tiny_repo, env=run_env)
-        runner.run([str(ctx), "--help"], cwd=paths.tiny_repo, env=run_env)
-
-    for expected in (paths.home, paths.appdata, paths.localappdata, paths.sessions):
-        assert_inside(expected, paths.root)
-
-
-def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Build/install ctx into a temp clean host and exercise core flows.",
-    )
-    parser.add_argument(
-        "--fast",
-        action="store_true",
-        help="Run the core contract only; skip extra help probes.",
-    )
-    parser.add_argument(
-        "--keep-temp",
-        action="store_true",
-        help="Keep the temp root after the run for debugging.",
-    )
-    parser.add_argument(
-        "--temp-root",
-        type=Path,
-        help="Use an explicit temp root. Must not already contain important data.",
-    )
-    parser.add_argument(
-        "--repo-root",
-        type=Path,
-        default=repo_root(),
-        help="Repository root to build. Default: inferred from this script.",
-    )
-    parser.add_argument(
-        "--run-live-claude",
-        action="store_true",
-        help=(
-            "Also run a real Claude Code host smoke. Requires "
-            f"{LIVE_CLAUDE_ACK_ENV}={LIVE_CLAUDE_ACK_VALUE} and can consume quota."
-        ),
-    )
-    parser.add_argument(
-        "--live-claude-max-budget-usd",
-        type=float,
-        default=LIVE_CLAUDE_DEFAULT_BUDGET_USD,
-        help=(
-            "Maximum live Claude Code API budget for --run-live-claude. "
-            f"Default: {LIVE_CLAUDE_DEFAULT_BUDGET_USD}."
-        ),
-    )
-    parser.add_argument(
-        "--claude-bin",
-        type=Path,
-        help="Explicit Claude Code executable path for --run-live-claude.",
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: Sequence[str] | None = None) -> int:
-    args = parse_args(argv)
-    project_root = args.repo_root.resolve()
-    if args.temp_root is not None:
-        temp_root = args.temp_root.resolve()
-        temp_root.mkdir(parents=True, exist_ok=True)
-        run_contract(
-            project_root=project_root,
-            temp_root=temp_root,
-            fast=args.fast,
-            run_live_claude=args.run_live_claude,
-            live_claude_max_budget_usd=args.live_claude_max_budget_usd,
-            live_claude_bin=args.claude_bin,
-        )
-        print(f"clean-host contract passed; temp root kept at {temp_root}")
-        return 0
-
-    temp_dir = tempfile.mkdtemp(prefix="ctx-clean-host-")
-    temp_root = Path(temp_dir).resolve()
-    try:
-        run_contract(
-            project_root=project_root,
-            temp_root=temp_root,
-            fast=args.fast,
-            run_live_claude=args.run_live_claude,
-            live_claude_max_budget_usd=args.live_claude_max_budget_usd,
-            live_claude_bin=args.claude_bin,
-        )
-        print(f"clean-host contract passed under {temp_root}")
-        return 0
-    finally:
-        if args.keep_temp:
-            print(f"kept temp root: {temp_root}")
-        else:
-            shutil.rmtree(temp_root, ignore_errors=True)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+
+
+def write_live_claude_sentinel_script(path: Path) -> None:
+    path.write_text(
+        '''"""Append Claude Code hook events to a clean-host sentinel file."""\n'''
+        "from __future__ import annotations\n\n"
+        "import argparse\n"
+        "import json\n"
+        "import os\n"
+        "import sys\n"
+        "from pathlib import Path\n\n"
+        "def main() -> int:\n"
+        "    parser = argparse.ArgumentParser()\n"
+        "    parser.add_argument('--event', required=True)\n"
+        "    parser.add_argument('--out', required=True)\n"
+        "    args = parser.parse_args()\n"
+        "    raw = sys.stdin.read()\n"
+        "    try:\n"
+        "        payload = json.loads(raw) if raw.strip() else {}\n"
+        "    except json.JSONDecodeError:\n"
+        "        payload = {'invalid_json_prefix': raw[:200]}\n"
+        "    out = Path(args.out)\n"
+        "    out.parent.mkdir(parents=True, exist_ok=True)\n"
+        "    record = {\n"
+        "        'event': args.event,\n"
+        "        'hook_event_name': payload.get('hook_event_name'),\n"
+        "        'tool_name': payload.get('tool_name'),\n"
+        "        'cwd': os.getcwd(),\n"
+        "        'argv': sys.argv[1:],\n"
+        "    }\n"
+        "    with out.open('a', encoding='utf-8') as handle:\n"
+        "        handle.write(json.dumps(record, sort_keys=True) + '\\n')\n"
+        "    return 0\n\n"
+        "if __name__ == '__main__':\n"
+        "    raise SystemExit(main())\n",
+        encoding="utf-8",
+    )
+
+
+def _append_live_claude_sentinel_hooks(
+    *,
+    settings_json: Path,
+    python_bin: Path,
+    sentinel_script: Path,
+    sentinel_jsonl: Path,
+) -> None:
+    settings = json.loads(settings_json.read_text(encoding="utf-8"))
+    hooks = settings.setdefault("hooks", {})
+    post_command = _quote_command((
+        python_bin,
+        sentinel_script,
+        "--event",
+        "PostToolUse",
+        "--out",
+        sentinel_jsonl,
+    ))
+    stop_command = _quote_command((
+        python_bin,
+        sentinel_script,
+        "--event",
+        "Stop",
+        "--out",
+        sentinel_jsonl,
+    ))
+    hooks.setdefault("PostToolUse", []).append({
+        "matcher": ".*",
+        "hooks": [{"type": "command", "command": post_command}],
+    })
+    hooks.setdefault("Stop", []).append({
+        "hooks": [{"type": "command", "command": stop_command}],
+    })
+    tmp_path = settings_json.with_name(f"{settings_json.name}.live.tmp")
+    tmp_path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+    os.replace(tmp_path, settings_json)
+
+
+def _sentinel_records(path: Path) -> list[dict[str, Any]]:
+    if not path.exists():
+        raise AssertionError(f"live Claude sentinel was not written: {path}")
+    records: list[dict[str, Any]] = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        try:
+            record = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise AssertionError(f"live Claude sentinel has invalid JSONL: {line}") from exc
+        if not isinstance(record, dict):
+            raise AssertionError(f"live Claude sentinel record is not an object: {line}")
+        records.append(record)
+    return records
+
+
+def _assert_live_claude_sentinel(path: Path, *, expected_cwd: Path) -> None:
+    records = _sentinel_records(path)
+    events = {str(record.get("event") or "") for record in records}
+    for expected in _EXPECTED_LIVE_CLAUDE_EVENTS:
+        if expected not in events:
+            raise AssertionError(f"live Claude sentinel did not record {expected}")
+    expected_resolved = expected_cwd.resolve()
+    for record in records:
+        cwd = record.get("cwd")
+        if cwd is None or Path(str(cwd)).resolve() != expected_resolved:
+            raise AssertionError(
+                "live Claude sentinel recorded unexpected cwd: "
+                f"{cwd!r}, expected {expected_resolved}"
+            )
+        hook_event = record.get("hook_event_name")
+        event = record.get("event")
+        if hook_event not in (None, event):
+            raise AssertionError(
+                f"live Claude sentinel event mismatch: event={event!r}, "
+                f"hook_event_name={hook_event!r}"
+            )
+
+
+def _require_live_claude_ack(max_budget_usd: float) -> None:
+    if os.environ.get(LIVE_CLAUDE_ACK_ENV) != LIVE_CLAUDE_ACK_VALUE:
+        raise AssertionError(
+            f"set {LIVE_CLAUDE_ACK_ENV}={LIVE_CLAUDE_ACK_VALUE} to run "
+            "the quota-consuming live Claude Code gate"
+        )
+    if max_budget_usd <= 0 or max_budget_usd > LIVE_CLAUDE_MAX_BUDGET_USD:
+        raise AssertionError(
+            "live Claude budget must be greater than 0 and no more than "
+            f"{LIVE_CLAUDE_MAX_BUDGET_USD} USD"
+        )
+
+
+def _live_claude_command(
+    *,
+    claude_bin: Path,
+    settings_json: Path,
+    max_budget_usd: float,
+) -> list[str]:
+    return [
+        str(claude_bin),
+        "--settings",
+        str(settings_json),
+        "--setting-sources",
+        "user",
+        "--output-format",
+        "stream-json",
+        "--include-hook-events",
+        "--no-session-persistence",
+        "--max-budget-usd",
+        str(max_budget_usd),
+        "--allowedTools",
+        "Bash(python --version)",
+        "-p",
+        "Use Bash to run exactly `python --version`, then stop.",
+    ]
+
+
+def _run_live_claude_gate(
+    *,
+    runner: CommandRunner,
+    paths: ContractPaths,
+    python_bin: Path,
+    settings_json: Path,
+    max_budget_usd: float,
+    claude_bin: Path | None,
+) -> None:
+    _require_live_claude_ack(max_budget_usd)
+    resolved_claude = claude_bin if claude_bin is not None else None
+    if resolved_claude is None:
+        claude = shutil.which("claude")
+        resolved_claude = Path(claude) if claude is not None else None
+    if resolved_claude is None:
+        raise AssertionError("claude executable was not found on PATH")
+    live_env = live_claude_env(paths)
+    runner.run(
+        [str(resolved_claude), "--version"],
+        cwd=paths.tiny_repo,
+        env=live_env,
+        timeout_seconds=LIVE_CLAUDE_PREFLIGHT_TIMEOUT_SECONDS,
+    )
+    runner.run(
+        [str(resolved_claude), "auth", "status"],
+        cwd=paths.tiny_repo,
+        env=live_env,
+        timeout_seconds=LIVE_CLAUDE_PREFLIGHT_TIMEOUT_SECONDS,
+    )
+    sentinel_script = paths.root / "live-claude-hook-sentinel.py"
+    sentinel_jsonl = paths.root / "live-claude-hooks.jsonl"
+    write_live_claude_sentinel_script(sentinel_script)
+    _append_live_claude_sentinel_hooks(
+        settings_json=settings_json,
+        python_bin=python_bin,
+        sentinel_script=sentinel_script,
+        sentinel_jsonl=sentinel_jsonl,
+    )
+    runner.run(
+        _live_claude_command(
+            claude_bin=resolved_claude,
+            settings_json=settings_json,
+            max_budget_usd=max_budget_usd,
+        ),
+        cwd=paths.tiny_repo,
+        env=live_env,
+        timeout_seconds=LIVE_CLAUDE_PROMPT_TIMEOUT_SECONDS,
+    )
+    _assert_live_claude_sentinel(sentinel_jsonl, expected_cwd=paths.tiny_repo)
+
+
+def run_contract(
+    *,
+    project_root: Path,
+    temp_root: Path,
+    fast: bool,
+    runner: CommandRunner | None = None,
+    run_live_claude: bool = False,
+    live_claude_max_budget_usd: float = LIVE_CLAUDE_DEFAULT_BUDGET_USD,
+    live_claude_bin: Path | None = None,
+) -> None:
+    runner = runner or CommandRunner()
+    paths = make_paths(temp_root)
+    _prepare_dirs(paths)
+    write_tiny_repo(paths.tiny_repo)
+    write_fake_litellm(paths.fake_modules)
+    fake_claude = write_fake_claude_cli(paths.fake_modules)
+
+    env = isolated_env(paths)
+    runner.run(
+        [
+            sys.executable,
+            "-m",
+            "pip",
+            "wheel",
+            "--no-deps",
+            "--wheel-dir",
+            str(paths.dist),
+            str(project_root),
+        ],
+        cwd=project_root,
+        env=env,
+    )
+    runner.run([sys.executable, "-m", "venv", str(paths.venv)], cwd=project_root, env=env)
+    wheel = _single_wheel(paths.dist)
+    py = venv_python(paths.venv)
+    runner.run([str(py), "-m", "pip", "install", str(wheel)], cwd=project_root, env=env)
+
+    run_env = isolated_env(paths, extra_pythonpath=paths.fake_modules)
+    ctx_init = venv_script(paths.venv, "ctx-init")
+    ctx_scan_repo = venv_script(paths.venv, "ctx-scan-repo")
+    ctx = venv_script(paths.venv, "ctx")
+
+    runner.run([str(ctx_init), "--hooks"], cwd=paths.tiny_repo, env=run_env)
+    claude_dir = paths.home / ".claude"
+    assert_inside(claude_dir, paths.root)
+    if not (claude_dir / "settings.json").exists():
+        raise AssertionError("ctx-init --hooks did not write isolated settings.json")
+    fake_claude_result = runner.run(
+        [
+            str(py),
+            str(fake_claude),
+            "--settings",
+            str(claude_dir / "settings.json"),
+            "--cwd",
+            str(paths.tiny_repo),
+            "-p",
+            "trigger clean-host hook smoke",
+        ],
+        cwd=paths.tiny_repo,
+        env=run_env,
+    )
+    _assert_fake_claude_hook_output(fake_claude_result.stdout)
+    if run_live_claude:
+        _run_live_claude_gate(
+            runner=runner,
+            paths=paths,
+            python_bin=py,
+            settings_json=claude_dir / "settings.json",
+            max_budget_usd=live_claude_max_budget_usd,
+            claude_bin=live_claude_bin,
+        )
+
+    stack_profile = paths.root / "stack-profile.json"
+    runner.run(
+        [
+            str(ctx_scan_repo),
+            "--repo",
+            str(paths.tiny_repo),
+            "--output",
+            str(stack_profile),
+            "--recommend",
+        ],
+        cwd=paths.tiny_repo,
+        env=run_env,
+    )
+    if not stack_profile.exists():
+        raise AssertionError("ctx-scan-repo did not write stack profile")
+
+    runner.run(
+        [
+            str(ctx),
+            "run",
+            "--model",
+            "ollama/clean-host-fake",
+            "--task",
+            "Return a one-sentence clean-host contract response.",
+            "--no-ctx-tools",
+            "--sessions-dir",
+            str(paths.sessions),
+            "--session-id",
+            "clean-host-contract",
+            "--quiet",
+        ],
+        cwd=paths.tiny_repo,
+        env=run_env,
+    )
+    runner.run(
+        [
+            str(ctx),
+            "resume",
+            "clean-host-contract",
+            "--task",
+            "Confirm resume works.",
+            "--sessions-dir",
+            str(paths.sessions),
+            "--quiet",
+        ],
+        cwd=paths.tiny_repo,
+        env=run_env,
+    )
+
+    denied_env = dict(run_env)
+    denied_env["CTX_FAKE_LITELLM_TOOL_CALL"] = "ctx__wiki_get"
+    denied = runner.run(
+        [
+            str(ctx),
+            "run",
+            "--model",
+            "ollama/clean-host-fake",
+            "--task",
+            "Attempt the wiki tool so policy can deny it.",
+            "--sessions-dir",
+            str(paths.sessions),
+            "--session-id",
+            "clean-host-denied-tool",
+            "--deny-tool",
+            "ctx__wiki_get",
+            "--quiet",
+            "--json",
+        ],
+        cwd=paths.tiny_repo,
+        env=denied_env,
+        check=False,
+    )
+    if denied.returncode != 2 or '"tool_denied"' not in denied.stdout:
+        raise AssertionError(
+            "expected denied tool run to exit 2 with tool_denied JSON; "
+            f"got rc={denied.returncode}"
+        )
+
+    if not fast:
+        runner.run([str(ctx_init), "--help"], cwd=paths.tiny_repo, env=run_env)
+        runner.run([str(ctx_scan_repo), "--help"], cwd=paths.tiny_repo, env=run_env)
+        runner.run([str(ctx), "--help"], cwd=paths.tiny_repo, env=run_env)
+
+    for expected in (paths.home, paths.appdata, paths.localappdata, paths.sessions):
+        assert_inside(expected, paths.root)
+
+
+def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Build/install ctx into a temp clean host and exercise core flows.",
+    )
+    parser.add_argument(
+        "--fast",
+        action="store_true",
+        help="Run the core contract only; skip extra help probes.",
+    )
+    parser.add_argument(
+        "--keep-temp",
+        action="store_true",
+        help="Keep the temp root after the run for debugging.",
+    )
+    parser.add_argument(
+        "--temp-root",
+        type=Path,
+        help="Use an explicit temp root. Must not already contain important data.",
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=repo_root(),
+        help="Repository root to build. Default: inferred from this script.",
+    )
+    parser.add_argument(
+        "--run-live-claude",
+        action="store_true",
+        help=(
+            "Also run a real Claude Code host smoke. Requires "
+            f"{LIVE_CLAUDE_ACK_ENV}={LIVE_CLAUDE_ACK_VALUE} and can consume quota."
+        ),
+    )
+    parser.add_argument(
+        "--live-claude-max-budget-usd",
+        type=float,
+        default=LIVE_CLAUDE_DEFAULT_BUDGET_USD,
+        help=(
+            "Maximum live Claude Code API budget for --run-live-claude. "
+            f"Default: {LIVE_CLAUDE_DEFAULT_BUDGET_USD}."
+        ),
+    )
+    parser.add_argument(
+        "--claude-bin",
+        type=Path,
+        help="Explicit Claude Code executable path for --run-live-claude.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = parse_args(argv)
+    project_root = args.repo_root.resolve()
+    if args.temp_root is not None:
+        temp_root = args.temp_root.resolve()
+        temp_root.mkdir(parents=True, exist_ok=True)
+        run_contract(
+            project_root=project_root,
+            temp_root=temp_root,
+            fast=args.fast,
+            run_live_claude=args.run_live_claude,
+            live_claude_max_budget_usd=args.live_claude_max_budget_usd,
+            live_claude_bin=args.claude_bin,
+        )
+        print(f"clean-host contract passed; temp root kept at {temp_root}")
+        return 0
+
+    temp_dir = tempfile.mkdtemp(prefix="ctx-clean-host-")
+    temp_root = Path(temp_dir).resolve()
+    try:
+        run_contract(
+            project_root=project_root,
+            temp_root=temp_root,
+            fast=args.fast,
+            run_live_claude=args.run_live_claude,
+            live_claude_max_budget_usd=args.live_claude_max_budget_usd,
+            live_claude_bin=args.claude_bin,
+        )
+        print(f"clean-host contract passed under {temp_root}")
+        return 0
+    finally:
+        if args.keep_temp:
+            print(f"kept temp root: {temp_root}")
+        else:
+            shutil.rmtree(temp_root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/graph_artifact_guard.py

@@ -1,196 +1,196 @@
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-from typing import Iterable
-
-DEFAULT_ARTIFACTS = (
-    "graph/wiki-graph.tar.gz",
-    "graph/wiki-graph-runtime.tar.gz",
-    "graph/skills-sh-catalog.json.gz",
-    "graph/communities.json",
-    "graph/entity-overlays.jsonl",
-)
-
-STALE_GRAPH_PATTERNS = (
-    "*.staged",
-    "*.partial",
-    "*.lock",
-    "*.tmp",
-)
-
-
-def _run_git(
-    repo: Path,
-    args: Iterable[str],
-    *,
-    check: bool = True,
-    capture: bool = False,
-) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(
-        ["git", *args],
-        cwd=repo,
-        check=check,
-        text=True,
-        stdout=subprocess.PIPE if capture else None,
-        stderr=subprocess.PIPE if capture else None,
-    )
-
-
-def _repo_root(path: Path) -> Path:
-    result = _run_git(path, ["rev-parse", "--show-toplevel"], capture=True)
-    return Path(result.stdout.strip()).resolve()
-
-
-def _tracked_artifacts(repo: Path, artifacts: Iterable[str]) -> list[str]:
-    tracked: list[str] = []
-    for artifact in artifacts:
-        result = _run_git(
-            repo,
-            ["ls-files", "--error-unmatch", artifact],
-            check=False,
-            capture=True,
-        )
-        if result.returncode == 0:
-            tracked.append(artifact)
-    return tracked
-
-
-def _set_skip_worktree(repo: Path, artifacts: list[str], *, enabled: bool) -> None:
-    if not artifacts:
-        print("No tracked graph artifacts matched.")
-        return
-    flag = "--skip-worktree" if enabled else "--no-skip-worktree"
-    _run_git(repo, ["update-index", flag, *artifacts])
-    action = "parked" if enabled else "unparked"
-    for artifact in artifacts:
-        print(f"{action}: {artifact}")
-
-
-def _print_status(repo: Path, artifacts: list[str]) -> None:
-    if not artifacts:
-        print("No tracked graph artifacts matched.")
-        return
-    result = _run_git(repo, ["ls-files", "-v", *artifacts], capture=True)
-    for line in result.stdout.splitlines():
-        state = "parked" if line.startswith("S ") else "active"
-        print(f"{state}: {line[2:]}")
-    print()
-    sys.stdout.flush()
-    _run_git(repo, ["count-objects", "-vH"])
-
-
-def _prune(repo: Path, *, include_lfs: bool, include_git_prune: bool) -> None:
-    if include_git_prune:
-        _run_git(repo, ["prune", "--expire=now", "--verbose"])
-    if include_lfs:
-        result = _run_git(repo, ["lfs", "prune", "--verbose"], check=False)
-        if result.returncode != 0:
-            raise SystemExit(result.returncode)
-    if not include_lfs and not include_git_prune:
-        print("No prune action selected.")
-
-
-def _clean_stale_graph_files(repo: Path, *, dry_run: bool) -> None:
-    graph_dir = (repo / "graph").resolve()
-    repo = repo.resolve()
-    if not graph_dir.is_dir():
-        print("No graph directory found.")
-        return
-
-    stale_files: list[Path] = []
-    for pattern in STALE_GRAPH_PATTERNS:
-        stale_files.extend(
-            path.resolve()
-            for path in graph_dir.glob(pattern)
-            if path.is_file() and path.resolve().is_relative_to(graph_dir)
-        )
-
-    for path in sorted(set(stale_files)):
-        rel = path.relative_to(repo).as_posix()
-        if dry_run:
-            print(f"would remove: {rel}")
-        else:
-            path.unlink()
-            print(f"removed: {rel}")
-
-
-def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Park or unpark heavyweight generated graph artifacts so background "
-            "Git integrations do not repeatedly LFS-clean them while they are dirty."
-        )
-    )
-    parser.add_argument(
-        "command",
-        choices=("status", "park", "unpark", "prune", "clean-stale"),
-        help=(
-            "status shows skip-worktree state; park hides generated archives from "
-            "normal Git status/stage scans; unpark re-enables release staging; "
-            "prune removes prunable local LFS cache entries; clean-stale "
-            "removes interrupted graph promotion leftovers."
-        ),
-    )
-    parser.add_argument(
-        "--repo",
-        type=Path,
-        default=Path.cwd(),
-        help="Repository path. Defaults to the current directory.",
-    )
-    parser.add_argument(
-        "--artifact",
-        action="append",
-        dest="artifacts",
-        help=(
-            "Artifact path to manage. May be passed more than once. Defaults to "
-            "the shipped graph tarballs and Skills.sh catalog gzip."
-        ),
-    )
-    parser.add_argument(
-        "--skip-lfs",
-        action="store_true",
-        help="For prune only: skip git lfs prune.",
-    )
-    parser.add_argument(
-        "--include-git-prune",
-        action="store_true",
-        help=(
-            "For prune only: also run repo-wide git prune --expire=now. "
-            "This can discard unrelated dangling recovery objects."
-        ),
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="For clean-stale only: print stale files without deleting them.",
-    )
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = _parser().parse_args(argv)
-    repo = _repo_root(args.repo)
-    artifacts = _tracked_artifacts(repo, args.artifacts or DEFAULT_ARTIFACTS)
-
-    if args.command == "status":
-        _print_status(repo, artifacts)
-    elif args.command == "park":
-        _set_skip_worktree(repo, artifacts, enabled=True)
-    elif args.command == "unpark":
-        _set_skip_worktree(repo, artifacts, enabled=False)
-    elif args.command == "prune":
-        _prune(
-            repo,
-            include_lfs=not args.skip_lfs,
-            include_git_prune=args.include_git_prune,
-        )
-    elif args.command == "clean-stale":
-        _clean_stale_graph_files(repo, dry_run=args.dry_run)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+from typing import Iterable
+
+DEFAULT_ARTIFACTS = (
+    "graph/wiki-graph.tar.gz",
+    "graph/wiki-graph-runtime.tar.gz",
+    "graph/skills-sh-catalog.json.gz",
+    "graph/communities.json",
+    "graph/entity-overlays.jsonl",
+)
+
+STALE_GRAPH_PATTERNS = (
+    "*.staged",
+    "*.partial",
+    "*.lock",
+    "*.tmp",
+)
+
+
+def _run_git(
+    repo: Path,
+    args: Iterable[str],
+    *,
+    check: bool = True,
+    capture: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        check=check,
+        text=True,
+        stdout=subprocess.PIPE if capture else None,
+        stderr=subprocess.PIPE if capture else None,
+    )
+
+
+def _repo_root(path: Path) -> Path:
+    result = _run_git(path, ["rev-parse", "--show-toplevel"], capture=True)
+    return Path(result.stdout.strip()).resolve()
+
+
+def _tracked_artifacts(repo: Path, artifacts: Iterable[str]) -> list[str]:
+    tracked: list[str] = []
+    for artifact in artifacts:
+        result = _run_git(
+            repo,
+            ["ls-files", "--error-unmatch", artifact],
+            check=False,
+            capture=True,
+        )
+        if result.returncode == 0:
+            tracked.append(artifact)
+    return tracked
+
+
+def _set_skip_worktree(repo: Path, artifacts: list[str], *, enabled: bool) -> None:
+    if not artifacts:
+        print("No tracked graph artifacts matched.")
+        return
+    flag = "--skip-worktree" if enabled else "--no-skip-worktree"
+    _run_git(repo, ["update-index", flag, *artifacts])
+    action = "parked" if enabled else "unparked"
+    for artifact in artifacts:
+        print(f"{action}: {artifact}")
+
+
+def _print_status(repo: Path, artifacts: list[str]) -> None:
+    if not artifacts:
+        print("No tracked graph artifacts matched.")
+        return
+    result = _run_git(repo, ["ls-files", "-v", *artifacts], capture=True)
+    for line in result.stdout.splitlines():
+        state = "parked" if line.startswith("S ") else "active"
+        print(f"{state}: {line[2:]}")
+    print()
+    sys.stdout.flush()
+    _run_git(repo, ["count-objects", "-vH"])
+
+
+def _prune(repo: Path, *, include_lfs: bool, include_git_prune: bool) -> None:
+    if include_git_prune:
+        _run_git(repo, ["prune", "--expire=now", "--verbose"])
+    if include_lfs:
+        result = _run_git(repo, ["lfs", "prune", "--verbose"], check=False)
+        if result.returncode != 0:
+            raise SystemExit(result.returncode)
+    if not include_lfs and not include_git_prune:
+        print("No prune action selected.")
+
+
+def _clean_stale_graph_files(repo: Path, *, dry_run: bool) -> None:
+    graph_dir = (repo / "graph").resolve()
+    repo = repo.resolve()
+    if not graph_dir.is_dir():
+        print("No graph directory found.")
+        return
+
+    stale_files: list[Path] = []
+    for pattern in STALE_GRAPH_PATTERNS:
+        stale_files.extend(
+            path.resolve()
+            for path in graph_dir.glob(pattern)
+            if path.is_file() and path.resolve().is_relative_to(graph_dir)
+        )
+
+    for path in sorted(set(stale_files)):
+        rel = path.relative_to(repo).as_posix()
+        if dry_run:
+            print(f"would remove: {rel}")
+        else:
+            path.unlink()
+            print(f"removed: {rel}")
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Park or unpark heavyweight generated graph artifacts so background "
+            "Git integrations do not repeatedly LFS-clean them while they are dirty."
+        )
+    )
+    parser.add_argument(
+        "command",
+        choices=("status", "park", "unpark", "prune", "clean-stale"),
+        help=(
+            "status shows skip-worktree state; park hides generated archives from "
+            "normal Git status/stage scans; unpark re-enables release staging; "
+            "prune removes prunable local LFS cache entries; clean-stale "
+            "removes interrupted graph promotion leftovers."
+        ),
+    )
+    parser.add_argument(
+        "--repo",
+        type=Path,
+        default=Path.cwd(),
+        help="Repository path. Defaults to the current directory.",
+    )
+    parser.add_argument(
+        "--artifact",
+        action="append",
+        dest="artifacts",
+        help=(
+            "Artifact path to manage. May be passed more than once. Defaults to "
+            "the shipped graph tarballs and Skills.sh catalog gzip."
+        ),
+    )
+    parser.add_argument(
+        "--skip-lfs",
+        action="store_true",
+        help="For prune only: skip git lfs prune.",
+    )
+    parser.add_argument(
+        "--include-git-prune",
+        action="store_true",
+        help=(
+            "For prune only: also run repo-wide git prune --expire=now. "
+            "This can discard unrelated dangling recovery objects."
+        ),
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="For clean-stale only: print stale files without deleting them.",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    repo = _repo_root(args.repo)
+    artifacts = _tracked_artifacts(repo, args.artifacts or DEFAULT_ARTIFACTS)
+
+    if args.command == "status":
+        _print_status(repo, artifacts)
+    elif args.command == "park":
+        _set_skip_worktree(repo, artifacts, enabled=True)
+    elif args.command == "unpark":
+        _set_skip_worktree(repo, artifacts, enabled=False)
+    elif args.command == "prune":
+        _prune(
+            repo,
+            include_lfs=not args.skip_lfs,
+            include_git_prune=args.include_git_prune,
+        )
+    elif args.command == "clean-stale":
+        _clean_stale_graph_files(repo, dry_run=args.dry_run)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

scripts/overlay_wiki_entities.py

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

scripts/sync_huggingface.py

@@ -1,282 +1,309 @@
-#!/usr/bin/env python3
-"""Sync the current git tree to Hugging Face with HF-only card metadata."""
-
-from __future__ import annotations
-
-import argparse
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-from typing import Any
-
-DEFAULT_REPO_ID = "Stevesolun/ctx"
-DEFAULT_REPO_TYPE = "dataset"
-
-HF_CARD_METADATA = """---
-license: mit
-pretty_name: ctx
-tags:
-  - agents
-  - mcp
-  - skills
-  - knowledge-graph
-  - llm-wiki
-  - recommendation-system
-  - harness
-  - codex
-  - claude-code
----
-
-"""
-
-LFS_POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1"
-HYDRATED_ARTIFACT_MIN_BYTES = {
-    Path("graph/wiki-graph.tar.gz"): 100_000_000,
-    Path("graph/wiki-graph-runtime.tar.gz"): 10_000_000,
-    Path("graph/skills-sh-catalog.json.gz"): 1_000_000,
-}
-
-
-def with_hf_repo_card_metadata(readme_text: str) -> str:
-    """Return README text with Hugging Face repo-card metadata prepended."""
-    return HF_CARD_METADATA + _strip_leading_yaml_frontmatter(readme_text)
-
-
-def _strip_leading_yaml_frontmatter(text: str) -> str:
-    if not text.startswith("---\n"):
-        return text
-    end = text.find("\n---\n", 4)
-    if end == -1:
-        return text
-    return text[end + len("\n---\n") :].lstrip("\n")
-
-
-def _git(repo: Path, *args: str) -> str:
-    return subprocess.check_output(["git", *args], cwd=repo, text=True).strip()
-
-
-def _git_bytes(repo: Path, *args: str) -> bytes:
-    return subprocess.check_output(["git", *args], cwd=repo)
-
-
-def _iter_tracked_files(repo: Path) -> list[Path]:
-    output = _git_bytes(repo, "ls-files", "-z")
-    files: list[Path] = []
-    for raw in output.split(b"\0"):
-        if not raw:
-            continue
-        rel = Path(raw.decode("utf-8"))
-        if rel.is_absolute() or ".." in rel.parts:
-            raise ValueError(f"unsafe git path: {rel}")
-        files.append(rel)
-    return files
-
-
-def _assert_hydrated_artifacts(repo: Path) -> None:
-    for rel, min_bytes in HYDRATED_ARTIFACT_MIN_BYTES.items():
-        artifact = repo / rel
-        if not artifact.is_file():
-            raise FileNotFoundError(
-                f"{rel.as_posix()} is required before Hugging Face sync"
-            )
-        size = artifact.stat().st_size
-        if size < min_bytes:
-            raise RuntimeError(
-                f"{rel.as_posix()} is {size:,} bytes; expected at least "
-                f"{min_bytes:,}. Run git lfs pull before publishing."
-            )
-        with artifact.open("rb") as fh:
-            prefix = fh.read(len(LFS_POINTER_PREFIX))
-        if prefix == LFS_POINTER_PREFIX:
-            raise RuntimeError(
-                f"{rel.as_posix()} is a Git LFS pointer, not the hydrated artifact"
-            )
-    _validate_graph_artifact_integrity(repo)
-
-
-def _validate_graph_artifact_integrity(repo: Path) -> None:
-    src_dir = repo / "src"
-    if str(src_dir) not in sys.path:
-        sys.path.insert(0, str(src_dir))
-    try:
-        from validate_graph_artifacts import validate_graph_artifacts
-
-        validate_graph_artifacts(repo / "graph")
-    except Exception as exc:  # noqa: BLE001
-        raise RuntimeError(
-            "graph artifact integrity validation failed before Hugging Face sync: "
-            f"{exc}"
-        ) from exc
-
-
-def _export_tracked_tree(repo: Path, export_dir: Path) -> None:
-    _assert_hydrated_artifacts(repo)
-    repo_root = repo.resolve()
-    export_root = export_dir.resolve()
-    for rel in _iter_tracked_files(repo):
-        source = (repo_root / rel).resolve()
-        if source != repo_root and not source.is_relative_to(repo_root):
-            raise ValueError(f"unsafe source path: {rel}")
-        if source.is_symlink():
-            raise ValueError(f"refusing to follow symlink during HF sync: {rel}")
-        if not source.is_file():
-            continue
-        target = (export_root / rel).resolve()
-        if target != export_root and not target.is_relative_to(export_root):
-            raise ValueError(f"unsafe export path: {rel}")
-        target.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(source, target)
-
-
-def _patch_export_readme(export_dir: Path) -> None:
-    readme = export_dir / "README.md"
-    readme.write_text(
-        with_hf_repo_card_metadata(readme.read_text(encoding="utf-8")),
-        encoding="utf-8",
-        newline="\n",
-    )
-
-
-def _iter_export_file_names(export_dir: Path) -> set[str]:
-    names: set[str] = set()
-    for path in export_dir.rglob("*"):
-        if not path.is_file():
-            continue
-        rel = path.relative_to(export_dir).as_posix()
-        if rel == ".cache" or rel.startswith(".cache/"):
-            continue
-        names.add(rel)
-    return names
-
-
-def _repo_url(*, repo_id: str, repo_type: str) -> str:
-    prefix = {"dataset": "datasets", "space": "spaces"}.get(repo_type)
-    repo_path = f"{prefix}/{repo_id}" if prefix else repo_id
-    return f"https://huggingface.co/{repo_path}"
-
-
-def _repo_commit_url(*, repo_id: str, repo_type: str, sha: str) -> str:
-    return f"{_repo_url(repo_id=repo_id, repo_type=repo_type)}/commit/{sha}"
-
-
-def _remote_has_no_stale_paths(
-    *,
-    api: Any,
-    export_dir: Path,
-    repo_id: str,
-    repo_type: str,
-) -> bool:
-    try:
-        remote_files = set(api.list_repo_files(repo_id=repo_id, repo_type=repo_type))
-    except Exception:
-        return False
-    return remote_files <= _iter_export_file_names(export_dir)
-
-
-def _upload_export(
-    *,
-    api: Any,
-    export_dir: Path,
-    repo_id: str,
-    repo_type: str,
-    head: str,
-    prefer_large_upload: bool,
-) -> str:
-    if (
-        prefer_large_upload
-        and hasattr(api, "upload_large_folder")
-        and _remote_has_no_stale_paths(
-            api=api,
-            export_dir=export_dir,
-            repo_id=repo_id,
-            repo_type=repo_type,
-        )
-    ):
-        api.upload_large_folder(
-            repo_id=repo_id,
-            repo_type=repo_type,
-            folder_path=str(export_dir),
-            print_report=True,
-        )
-        info = api.repo_info(repo_id=repo_id, repo_type=repo_type)
-        sha = getattr(info, "sha", None)
-        if sha:
-            return _repo_commit_url(repo_id=repo_id, repo_type=repo_type, sha=str(sha))
-        return _repo_url(repo_id=repo_id, repo_type=repo_type)
-
-    info = api.upload_folder(
-        repo_id=repo_id,
-        repo_type=repo_type,
-        folder_path=str(export_dir),
-        commit_message=f"Sync ctx {head[:7]}",
-        commit_description=f"GitHub commit: {head}",
-        delete_patterns="*",
-    )
-    return str(getattr(info, "commit_url", info))
-
-
-def sync_to_huggingface(
-    *,
-    repo: Path,
-    repo_id: str,
-    repo_type: str,
-    token: str,
-) -> str:
-    """Upload HEAD to Hugging Face and return the commit URL."""
-    from huggingface_hub import HfApi
-
-    head = _git(repo, "rev-parse", "HEAD")
-    workspace = Path(tempfile.mkdtemp(prefix="ctx-hf-upload-"))
-    export_dir = workspace / "export"
-    try:
-        export_dir.mkdir()
-        _export_tracked_tree(repo, export_dir)
-        _patch_export_readme(export_dir)
-        api = HfApi(token=token)
-        api.create_repo(repo_id, repo_type=repo_type, exist_ok=True)
-        return _upload_export(
-            api=api,
-            repo_id=repo_id,
-            repo_type=repo_type,
-            export_dir=export_dir,
-            head=head,
-            prefer_large_upload=True,
-        )
-    finally:
-        shutil.rmtree(workspace, ignore_errors=True)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Upload this git checkout to Hugging Face with repo-card metadata"
-    )
-    parser.add_argument("--repo", default=".", help="Git checkout path")
-    parser.add_argument(
-        "--repo-id",
-        default=os.environ.get("HF_REPO_ID", DEFAULT_REPO_ID),
-        help="Hugging Face repo ID",
-    )
-    parser.add_argument(
-        "--repo-type",
-        default=os.environ.get("HF_REPO_TYPE", DEFAULT_REPO_TYPE),
-        help="Hugging Face repo type",
-    )
-    args = parser.parse_args()
-    token = os.environ.get("HF_TOKEN")
-    if not token:
-        raise SystemExit("HF_TOKEN is required")
-    print(
-        sync_to_huggingface(
-            repo=Path(args.repo).resolve(),
-            repo_id=args.repo_id,
-            repo_type=args.repo_type,
-            token=token,
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Sync the current git tree to Hugging Face with HF-only card metadata."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+DEFAULT_REPO_ID = "Stevesolun/ctx"
+DEFAULT_REPO_TYPE = "dataset"
+
+HF_CARD_METADATA = """---
+license: mit
+pretty_name: ctx
+tags:
+  - agents
+  - mcp
+  - skills
+  - knowledge-graph
+  - llm-wiki
+  - recommendation-system
+  - harness
+  - codex
+  - claude-code
+---
+
+"""
+
+LFS_POINTER_PREFIX = b"version https://git-lfs.github.com/spec/v1"
+HYDRATED_ARTIFACT_MIN_BYTES = {
+    Path("graph/wiki-graph.tar.gz"): 100_000_000,
+    Path("graph/wiki-graph-runtime.tar.gz"): 10_000_000,
+    Path("graph/skills-sh-catalog.json.gz"): 1_000_000,
+}
+
+
+def with_hf_repo_card_metadata(readme_text: str) -> str:
+    """Return README text with Hugging Face repo-card metadata prepended."""
+    return HF_CARD_METADATA + _strip_leading_yaml_frontmatter(readme_text)
+
+
+def _strip_leading_yaml_frontmatter(text: str) -> str:
+    if not text.startswith("---\n"):
+        return text
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        return text
+    return text[end + len("\n---\n") :].lstrip("\n")
+
+
+def _git(repo: Path, *args: str) -> str:
+    return subprocess.check_output(["git", *args], cwd=repo, text=True).strip()
+
+
+def _git_bytes(repo: Path, *args: str) -> bytes:
+    return subprocess.check_output(["git", *args], cwd=repo)
+
+
+def _iter_tracked_files(repo: Path) -> list[Path]:
+    output = _git_bytes(repo, "ls-files", "-z")
+    files: list[Path] = []
+    for raw in output.split(b"\0"):
+        if not raw:
+            continue
+        rel = Path(raw.decode("utf-8"))
+        if rel.is_absolute() or ".." in rel.parts:
+            raise ValueError(f"unsafe git path: {rel}")
+        files.append(rel)
+    return files
+
+
+def _assert_hydrated_artifacts(repo: Path) -> None:
+    for rel, min_bytes in HYDRATED_ARTIFACT_MIN_BYTES.items():
+        artifact = repo / rel
+        if not artifact.is_file():
+            raise FileNotFoundError(
+                f"{rel.as_posix()} is required before Hugging Face sync"
+            )
+        size = artifact.stat().st_size
+        if size < min_bytes:
+            raise RuntimeError(
+                f"{rel.as_posix()} is {size:,} bytes; expected at least "
+                f"{min_bytes:,}. Download or rebuild graph release artifacts "
+                "before publishing."
+            )
+        with artifact.open("rb") as fh:
+            prefix = fh.read(len(LFS_POINTER_PREFIX))
+        if prefix == LFS_POINTER_PREFIX:
+            raise RuntimeError(
+                f"{rel.as_posix()} is a Git LFS pointer, not the hydrated artifact"
+            )
+    _validate_graph_artifact_integrity(repo)
+
+
+def _validate_graph_artifact_integrity(repo: Path) -> None:
+    src_dir = repo / "src"
+    if str(src_dir) not in sys.path:
+        sys.path.insert(0, str(src_dir))
+    try:
+        from validate_graph_artifacts import validate_graph_artifacts
+
+        validate_graph_artifacts(repo / "graph")
+    except Exception as exc:  # noqa: BLE001
+        raise RuntimeError(
+            "graph artifact integrity validation failed before Hugging Face sync: "
+            f"{exc}"
+        ) from exc
+
+
+def _assert_repo_stats_current(repo: Path) -> None:
+    updater = repo / "src" / "update_repo_stats.py"
+    if not updater.is_file():
+        raise FileNotFoundError("src/update_repo_stats.py is required before Hugging Face sync")
+    subprocess.run(
+        [sys.executable, str(updater), "--check"],
+        cwd=repo,
+        check=True,
+    )
+
+
+def _export_tracked_tree(repo: Path, export_dir: Path) -> None:
+    _assert_repo_stats_current(repo)
+    _assert_hydrated_artifacts(repo)
+    repo_root = repo.resolve()
+    export_root = export_dir.resolve()
+    for rel in _iter_tracked_files(repo):
+        source = (repo_root / rel).resolve()
+        if source != repo_root and not source.is_relative_to(repo_root):
+            raise ValueError(f"unsafe source path: {rel}")
+        if source.is_symlink():
+            raise ValueError(f"refusing to follow symlink during HF sync: {rel}")
+        if not source.is_file():
+            continue
+        target = (export_root / rel).resolve()
+        if target != export_root and not target.is_relative_to(export_root):
+            raise ValueError(f"unsafe export path: {rel}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+    _copy_hydrated_artifacts(repo_root, export_root)
+
+
+def _copy_hydrated_artifacts(repo_root: Path, export_root: Path) -> None:
+    """Copy required graph artifacts even when they are intentionally untracked."""
+    for rel in HYDRATED_ARTIFACT_MIN_BYTES:
+        source = (repo_root / rel).resolve()
+        if source != repo_root and not source.is_relative_to(repo_root):
+            raise ValueError(f"unsafe artifact source path: {rel}")
+        target = (export_root / rel).resolve()
+        if target != export_root and not target.is_relative_to(export_root):
+            raise ValueError(f"unsafe artifact export path: {rel}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+
+
+def _patch_export_readme(export_dir: Path) -> None:
+    readme = export_dir / "README.md"
+    readme.write_text(
+        with_hf_repo_card_metadata(readme.read_text(encoding="utf-8")),
+        encoding="utf-8",
+        newline="\n",
+    )
+
+
+def _iter_export_file_names(export_dir: Path) -> set[str]:
+    names: set[str] = set()
+    for path in export_dir.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(export_dir).as_posix()
+        if rel == ".cache" or rel.startswith(".cache/"):
+            continue
+        names.add(rel)
+    return names
+
+
+def _repo_url(*, repo_id: str, repo_type: str) -> str:
+    prefix = {"dataset": "datasets", "space": "spaces"}.get(repo_type)
+    repo_path = f"{prefix}/{repo_id}" if prefix else repo_id
+    return f"https://huggingface.co/{repo_path}"
+
+
+def _repo_commit_url(*, repo_id: str, repo_type: str, sha: str) -> str:
+    return f"{_repo_url(repo_id=repo_id, repo_type=repo_type)}/commit/{sha}"
+
+
+def _remote_has_no_stale_paths(
+    *,
+    api: Any,
+    export_dir: Path,
+    repo_id: str,
+    repo_type: str,
+) -> bool:
+    try:
+        remote_files = set(api.list_repo_files(repo_id=repo_id, repo_type=repo_type))
+    except Exception:
+        return False
+    return remote_files <= _iter_export_file_names(export_dir)
+
+
+def _upload_export(
+    *,
+    api: Any,
+    export_dir: Path,
+    repo_id: str,
+    repo_type: str,
+    head: str,
+    prefer_large_upload: bool,
+) -> str:
+    if (
+        prefer_large_upload
+        and hasattr(api, "upload_large_folder")
+        and _remote_has_no_stale_paths(
+            api=api,
+            export_dir=export_dir,
+            repo_id=repo_id,
+            repo_type=repo_type,
+        )
+    ):
+        api.upload_large_folder(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            folder_path=str(export_dir),
+            print_report=True,
+        )
+        info = api.repo_info(repo_id=repo_id, repo_type=repo_type)
+        sha = getattr(info, "sha", None)
+        if sha:
+            return _repo_commit_url(repo_id=repo_id, repo_type=repo_type, sha=str(sha))
+        return _repo_url(repo_id=repo_id, repo_type=repo_type)
+
+    info = api.upload_folder(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        folder_path=str(export_dir),
+        commit_message=f"Sync ctx {head[:7]}",
+        commit_description=f"GitHub commit: {head}",
+        delete_patterns="*",
+    )
+    return str(getattr(info, "commit_url", info))
+
+
+def sync_to_huggingface(
+    *,
+    repo: Path,
+    repo_id: str,
+    repo_type: str,
+    token: str,
+) -> str:
+    """Upload HEAD to Hugging Face and return the commit URL."""
+    from huggingface_hub import HfApi
+
+    head = _git(repo, "rev-parse", "HEAD")
+    workspace = Path(tempfile.mkdtemp(prefix="ctx-hf-upload-"))
+    export_dir = workspace / "export"
+    try:
+        export_dir.mkdir()
+        _export_tracked_tree(repo, export_dir)
+        _patch_export_readme(export_dir)
+        api = HfApi(token=token)
+        api.create_repo(repo_id, repo_type=repo_type, exist_ok=True)
+        return _upload_export(
+            api=api,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            export_dir=export_dir,
+            head=head,
+            prefer_large_upload=True,
+        )
+    finally:
+        shutil.rmtree(workspace, ignore_errors=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Upload this git checkout to Hugging Face with repo-card metadata"
+    )
+    parser.add_argument("--repo", default=".", help="Git checkout path")
+    parser.add_argument(
+        "--repo-id",
+        default=os.environ.get("HF_REPO_ID", DEFAULT_REPO_ID),
+        help="Hugging Face repo ID",
+    )
+    parser.add_argument(
+        "--repo-type",
+        default=os.environ.get("HF_REPO_TYPE", DEFAULT_REPO_TYPE),
+        help="Hugging Face repo type",
+    )
+    args = parser.parse_args()
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        raise SystemExit("HF_TOKEN is required")
+    print(
+        sync_to_huggingface(
+            repo=Path(args.repo).resolve(),
+            repo_id=args.repo_id,
+            repo_type=args.repo_type,
+            token=token,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

src/tests/fixtures/fake_mcp_server.py

@@ -1,224 +1,224 @@
-"""fake_mcp_server.py — minimal MCP server stub used by test_mcp_router.
-
-Runs as a standalone subprocess launched by the tests. Reads JSON-RPC
-lines on stdin, writes responses on stdout. Designed to be small and
-scriptable: its behaviour is configurable via env vars so a single
-script covers initialize + tools/list + tools/call + failure modes.
-
-Env vars (all optional):
-  FAKE_MCP_FAIL_INIT=1          - respond with an error to initialize
-  FAKE_MCP_CRASH_ON_TOOL=1      - crash (exit 1) on any tools/call
-  FAKE_MCP_TOOL_ERROR=1         - return isError=True on any tools/call
-  FAKE_MCP_IGNORE_TOOL=1        - accept tools/call but never answer
-  FAKE_MCP_NOISY_STDERR=1       - write a warning line to stderr on startup
-  FAKE_MCP_STDERR_LINE=<text>   - write this exact line to stderr on startup
-  FAKE_MCP_EMIT_NOTIFICATION=1  - emit a progress notification before each
-                                  tools/call response
-  FAKE_MCP_EXTRA_TOOL=<name>    - add a second tool with this name (for
-                                  testing multi-tool list_tools)
-
-Tool catalog:
-  echo(text: str) -> str
-      returns the input text verbatim. Used to confirm args round-trip.
-  add(a: int, b: int) -> str
-      returns str(a+b). Integer-args coverage.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-
-
-_PROTOCOL_VERSION = "2024-11-05"
-
-
-def _echo_tool(args: dict) -> dict:
-    text = str(args.get("text", ""))
-    return {
-        "content": [{"type": "text", "text": text}],
-        "isError": False,
-    }
-
-
-def _add_tool(args: dict) -> dict:
-    a = int(args.get("a", 0))
-    b = int(args.get("b", 0))
-    return {
-        "content": [{"type": "text", "text": str(a + b)}],
-        "isError": False,
-    }
-
-
-def _env_tool(args: dict) -> dict:
-    name = str(args.get("name", ""))
-    return {
-        "content": [{"type": "text", "text": os.environ.get(name, "")}],
-        "isError": False,
-    }
-
-
-TOOLS = {"echo": _echo_tool, "add": _add_tool, "echo_env": _env_tool}
-
-
-def _tool_defs() -> list[dict]:
-    defs = [
-        {
-            "name": "echo",
-            "description": "Echo the input text verbatim.",
-            "inputSchema": {
-                "type": "object",
-                "properties": {"text": {"type": "string"}},
-                "required": ["text"],
-            },
-        },
-        {
-            "name": "add",
-            "description": "Return the sum of two integers.",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "a": {"type": "integer"},
-                    "b": {"type": "integer"},
-                },
-                "required": ["a", "b"],
-            },
-        },
-        {
-            "name": "echo_env",
-            "description": "Return the value of an environment variable.",
-            "inputSchema": {
-                "type": "object",
-                "properties": {"name": {"type": "string"}},
-                "required": ["name"],
-            },
-        },
-    ]
-    extra = os.environ.get("FAKE_MCP_EXTRA_TOOL")
-    if extra:
-        defs.append(
-            {
-                "name": extra,
-                "description": f"Extra tool {extra} (test-only).",
-                "inputSchema": {"type": "object", "properties": {}},
-            }
-        )
-    return defs
-
-
-def _emit(frame: dict) -> None:
-    sys.stdout.write(json.dumps(frame) + "\n")
-    sys.stdout.flush()
-
-
-def main() -> None:
-    if os.environ.get("FAKE_MCP_NOISY_STDERR") == "1":
-        sys.stderr.write("fake-mcp-server: starting up\n")
-        sys.stderr.flush()
-    stderr_line = os.environ.get("FAKE_MCP_STDERR_LINE")
-    if stderr_line:
-        sys.stderr.write(stderr_line + "\n")
-        sys.stderr.flush()
-
-    while True:
-        line = sys.stdin.readline()
-        if not line:
-            return
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            req = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-
-        method = req.get("method", "")
-        req_id = req.get("id")
-        params = req.get("params") or {}
-
-        if method == "initialize":
-            if os.environ.get("FAKE_MCP_FAIL_INIT") == "1":
-                _emit({
-                    "jsonrpc": "2.0",
-                    "id": req_id,
-                    "error": {"code": -32603, "message": "init-forbidden"},
-                })
-                continue
-            _emit({
-                "jsonrpc": "2.0",
-                "id": req_id,
-                "result": {
-                    "protocolVersion": _PROTOCOL_VERSION,
-                    "capabilities": {"tools": {}},
-                    "serverInfo": {"name": "fake-mcp", "version": "0.1"},
-                },
-            })
-            continue
-
-        if method == "notifications/initialized":
-            continue
-
-        if method == "tools/list":
-            _emit({
-                "jsonrpc": "2.0",
-                "id": req_id,
-                "result": {"tools": _tool_defs()},
-            })
-            continue
-
-        if method == "tools/call":
-            if os.environ.get("FAKE_MCP_CRASH_ON_TOOL") == "1":
-                sys.exit(1)
-            if os.environ.get("FAKE_MCP_IGNORE_TOOL") == "1":
-                continue
-
-            name = params.get("name", "")
-            args = params.get("arguments") or {}
-
-            if os.environ.get("FAKE_MCP_EMIT_NOTIFICATION") == "1":
-                _emit({
-                    "jsonrpc": "2.0",
-                    "method": "notifications/progress",
-                    "params": {"progress": 0.5},
-                })
-
-            if os.environ.get("FAKE_MCP_TOOL_ERROR") == "1":
-                _emit({
-                    "jsonrpc": "2.0",
-                    "id": req_id,
-                    "result": {
-                        "content": [{"type": "text", "text": "forced error"}],
-                        "isError": True,
-                    },
-                })
-                continue
-
-            handler = TOOLS.get(name)
-            if handler is None:
-                _emit({
-                    "jsonrpc": "2.0",
-                    "id": req_id,
-                    "error": {
-                        "code": -32601,
-                        "message": f"unknown tool {name!r}",
-                    },
-                })
-                continue
-            _emit({
-                "jsonrpc": "2.0",
-                "id": req_id,
-                "result": handler(args),
-            })
-            continue
-
-        # Unknown method.
-        _emit({
-            "jsonrpc": "2.0",
-            "id": req_id,
-            "error": {"code": -32601, "message": f"method not found: {method}"},
-        })
-
-
-if __name__ == "__main__":
-    main()
+"""fake_mcp_server.py — minimal MCP server stub used by test_mcp_router.
+
+Runs as a standalone subprocess launched by the tests. Reads JSON-RPC
+lines on stdin, writes responses on stdout. Designed to be small and
+scriptable: its behaviour is configurable via env vars so a single
+script covers initialize + tools/list + tools/call + failure modes.
+
+Env vars (all optional):
+  FAKE_MCP_FAIL_INIT=1          - respond with an error to initialize
+  FAKE_MCP_CRASH_ON_TOOL=1      - crash (exit 1) on any tools/call
+  FAKE_MCP_TOOL_ERROR=1         - return isError=True on any tools/call
+  FAKE_MCP_IGNORE_TOOL=1        - accept tools/call but never answer
+  FAKE_MCP_NOISY_STDERR=1       - write a warning line to stderr on startup
+  FAKE_MCP_STDERR_LINE=<text>   - write this exact line to stderr on startup
+  FAKE_MCP_EMIT_NOTIFICATION=1  - emit a progress notification before each
+                                  tools/call response
+  FAKE_MCP_EXTRA_TOOL=<name>    - add a second tool with this name (for
+                                  testing multi-tool list_tools)
+
+Tool catalog:
+  echo(text: str) -> str
+      returns the input text verbatim. Used to confirm args round-trip.
+  add(a: int, b: int) -> str
+      returns str(a+b). Integer-args coverage.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+
+_PROTOCOL_VERSION = "2024-11-05"
+
+
+def _echo_tool(args: dict) -> dict:
+    text = str(args.get("text", ""))
+    return {
+        "content": [{"type": "text", "text": text}],
+        "isError": False,
+    }
+
+
+def _add_tool(args: dict) -> dict:
+    a = int(args.get("a", 0))
+    b = int(args.get("b", 0))
+    return {
+        "content": [{"type": "text", "text": str(a + b)}],
+        "isError": False,
+    }
+
+
+def _env_tool(args: dict) -> dict:
+    name = str(args.get("name", ""))
+    return {
+        "content": [{"type": "text", "text": os.environ.get(name, "")}],
+        "isError": False,
+    }
+
+
+TOOLS = {"echo": _echo_tool, "add": _add_tool, "echo_env": _env_tool}
+
+
+def _tool_defs() -> list[dict]:
+    defs = [
+        {
+            "name": "echo",
+            "description": "Echo the input text verbatim.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {"text": {"type": "string"}},
+                "required": ["text"],
+            },
+        },
+        {
+            "name": "add",
+            "description": "Return the sum of two integers.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "a": {"type": "integer"},
+                    "b": {"type": "integer"},
+                },
+                "required": ["a", "b"],
+            },
+        },
+        {
+            "name": "echo_env",
+            "description": "Return the value of an environment variable.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+            },
+        },
+    ]
+    extra = os.environ.get("FAKE_MCP_EXTRA_TOOL")
+    if extra:
+        defs.append(
+            {
+                "name": extra,
+                "description": f"Extra tool {extra} (test-only).",
+                "inputSchema": {"type": "object", "properties": {}},
+            }
+        )
+    return defs
+
+
+def _emit(frame: dict) -> None:
+    sys.stdout.write(json.dumps(frame) + "\n")
+    sys.stdout.flush()
+
+
+def main() -> None:
+    if os.environ.get("FAKE_MCP_NOISY_STDERR") == "1":
+        sys.stderr.write("fake-mcp-server: starting up\n")
+        sys.stderr.flush()
+    stderr_line = os.environ.get("FAKE_MCP_STDERR_LINE")
+    if stderr_line:
+        sys.stderr.write(stderr_line + "\n")
+        sys.stderr.flush()
+
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            return
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        method = req.get("method", "")
+        req_id = req.get("id")
+        params = req.get("params") or {}
+
+        if method == "initialize":
+            if os.environ.get("FAKE_MCP_FAIL_INIT") == "1":
+                _emit({
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32603, "message": "init-forbidden"},
+                })
+                continue
+            _emit({
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {
+                    "protocolVersion": _PROTOCOL_VERSION,
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "fake-mcp", "version": "0.1"},
+                },
+            })
+            continue
+
+        if method == "notifications/initialized":
+            continue
+
+        if method == "tools/list":
+            _emit({
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {"tools": _tool_defs()},
+            })
+            continue
+
+        if method == "tools/call":
+            if os.environ.get("FAKE_MCP_CRASH_ON_TOOL") == "1":
+                sys.exit(1)
+            if os.environ.get("FAKE_MCP_IGNORE_TOOL") == "1":
+                continue
+
+            name = params.get("name", "")
+            args = params.get("arguments") or {}
+
+            if os.environ.get("FAKE_MCP_EMIT_NOTIFICATION") == "1":
+                _emit({
+                    "jsonrpc": "2.0",
+                    "method": "notifications/progress",
+                    "params": {"progress": 0.5},
+                })
+
+            if os.environ.get("FAKE_MCP_TOOL_ERROR") == "1":
+                _emit({
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "content": [{"type": "text", "text": "forced error"}],
+                        "isError": True,
+                    },
+                })
+                continue
+
+            handler = TOOLS.get(name)
+            if handler is None:
+                _emit({
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {
+                        "code": -32601,
+                        "message": f"unknown tool {name!r}",
+                    },
+                })
+                continue
+            _emit({
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": handler(args),
+            })
+            continue
+
+        # Unknown method.
+        _emit({
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "error": {"code": -32601, "message": f"method not found: {method}"},
+        })
+
+
+if __name__ == "__main__":
+    main()

src/tests/fixtures/pulsemcp_listing_excerpt.html

@@ -1,170 +1,170 @@
-<div class="servers-listing">
-<a href="/servers/microsoft-playwright">
-      <div class="relative flex flex-col rounded border border-pulse-gray-border h-full hover:border-pulse-purple hover:shadow-lg transition-all duration-300 bg-white" data-test-id="mcp-server-card-microsoft-playwright">
-
-  <div class="flex flex-col h-full p-6">
-    <!-- Header section -->
-    <div class="flex-grow">
-      <div class="flex items-center gap-3 mb-2">
-        <h3 class="text-20 text-pulse-black font-sans font-normal leading-tight">
-          Playwright Browser Automation
-        </h3>
-      </div>
-
-        <p class="text-14 text-gray-500 mb-3">Microsoft</p>
-
-        <p class="text-15 text-pulse-black leading-relaxed">
-          Enables web browser control for navigating websites, capturing page snapshots, interacting with elements, and taking...
-        </p>
-    </div>
-
-    <!-- Bottom stats section -->
-      <div class="mt-6 pt-4 border-t border-gray-200">
-        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 text-sm">
-          <!-- Classification -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Classification</p>
-            <div class="flex items-center gap-2">
-              <div class="w-4 h-4 flex-shrink-0">
-                <img class="w-4 h-4" alt="Official repository icon" src="https://storage.googleapis.com/pulse_public/static/official-repo-icon.svg" />
-              </div>
-              <p class="text-14 capitalize text-pulse-black">official</p>
-            </div>
-          </div>
-
-          <!-- Visitors -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">
-              Est Visitors (Week)
-            </p>
-            <p class="text-14 text-pulse-black">
-              2.5m
-            </p>
-          </div>
-
-          <!-- Release Date -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Release Date</p>
-            <p class="text-14 text-pulse-black">
-                Mar 22, 2025
-            </p>
-          </div>
-        </div>
-      </div>
-  </div>
-</div>
-
-</a>
-<a href="/servers/ktanaka101-duckdb">
-      <div class="relative flex flex-col rounded border border-pulse-gray-border h-full hover:border-pulse-purple hover:shadow-lg transition-all duration-300 bg-white" data-test-id="mcp-server-card-ktanaka101-duckdb">
-
-  <div class="flex flex-col h-full p-6">
-    <!-- Header section -->
-    <div class="flex-grow">
-      <div class="flex items-center gap-3 mb-2">
-        <h3 class="text-20 text-pulse-black font-sans font-normal leading-tight">
-          DuckDB
-        </h3>
-      </div>
-
-        <p class="text-14 text-gray-500 mb-3">ktanaka101</p>
-
-        <p class="text-15 text-pulse-black leading-relaxed">
-          Execute SQL queries and analyze data in DuckDB databases.
-        </p>
-    </div>
-
-    <!-- Bottom stats section -->
-      <div class="mt-6 pt-4 border-t border-gray-200">
-        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 text-sm">
-          <!-- Classification -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Classification</p>
-            <div class="flex items-center gap-2">
-              <div class="w-4 h-4 flex-shrink-0">
-                <img class="w-4 h-4" alt="Community icon" src="https://storage.googleapis.com/pulse_public/static/community-icon.svg" />
-              </div>
-              <p class="text-14 capitalize text-pulse-black">community</p>
-            </div>
-          </div>
-
-          <!-- Visitors -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">
-              Est Visitors (Week)
-            </p>
-            <p class="text-14 text-pulse-black">
-              1.7m
-            </p>
-          </div>
-
-          <!-- Release Date -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Release Date</p>
-            <p class="text-14 text-pulse-black">
-                Nov 30, 2024
-            </p>
-          </div>
-        </div>
-      </div>
-  </div>
-</div>
-
-</a>
-<a href="/servers/haris-musa-excel">
-      <div class="relative flex flex-col rounded border border-pulse-gray-border h-full hover:border-pulse-purple hover:shadow-lg transition-all duration-300 bg-white" data-test-id="mcp-server-card-haris-musa-excel">
-
-  <div class="flex flex-col h-full p-6">
-    <!-- Header section -->
-    <div class="flex-grow">
-      <div class="flex items-center gap-3 mb-2">
-        <h3 class="text-20 text-pulse-black font-sans font-normal leading-tight">
-          Excel File Manipulation
-        </h3>
-      </div>
-
-        <p class="text-14 text-gray-500 mb-3">Haris Musa</p>
-
-        <p class="text-15 text-pulse-black leading-relaxed">
-          Enables Excel file manipulation without Microsoft Excel installation using openpyxl, providing workbook operations,...
-        </p>
-    </div>
-
-    <!-- Bottom stats section -->
-      <div class="mt-6 pt-4 border-t border-gray-200">
-        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 text-sm">
-          <!-- Classification -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Classification</p>
-            <div class="flex items-center gap-2">
-              <div class="w-4 h-4 flex-shrink-0">
-                <img class="w-4 h-4" alt="Community icon" src="https://storage.googleapis.com/pulse_public/static/community-icon.svg" />
-              </div>
-              <p class="text-14 capitalize text-pulse-black">community</p>
-            </div>
-          </div>
-
-          <!-- Visitors -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">
-              Est Visitors (Week)
-            </p>
-            <p class="text-14 text-pulse-black">
-              1.6m
-            </p>
-          </div>
-
-          <!-- Release Date -->
-          <div>
-            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Release Date</p>
-            <p class="text-14 text-pulse-black">
-                Feb 12, 2025
-            </p>
-          </div>
-        </div>
-      </div>
-  </div>
-</div>
-
-</a>
-</div>
+<div class="servers-listing">
+<a href="/servers/microsoft-playwright">
+      <div class="relative flex flex-col rounded border border-pulse-gray-border h-full hover:border-pulse-purple hover:shadow-lg transition-all duration-300 bg-white" data-test-id="mcp-server-card-microsoft-playwright">
+
+  <div class="flex flex-col h-full p-6">
+    <!-- Header section -->
+    <div class="flex-grow">
+      <div class="flex items-center gap-3 mb-2">
+        <h3 class="text-20 text-pulse-black font-sans font-normal leading-tight">
+          Playwright Browser Automation
+        </h3>
+      </div>
+
+        <p class="text-14 text-gray-500 mb-3">Microsoft</p>
+
+        <p class="text-15 text-pulse-black leading-relaxed">
+          Enables web browser control for navigating websites, capturing page snapshots, interacting with elements, and taking...
+        </p>
+    </div>
+
+    <!-- Bottom stats section -->
+      <div class="mt-6 pt-4 border-t border-gray-200">
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 text-sm">
+          <!-- Classification -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Classification</p>
+            <div class="flex items-center gap-2">
+              <div class="w-4 h-4 flex-shrink-0">
+                <img class="w-4 h-4" alt="Official repository icon" src="https://storage.googleapis.com/pulse_public/static/official-repo-icon.svg" />
+              </div>
+              <p class="text-14 capitalize text-pulse-black">official</p>
+            </div>
+          </div>
+
+          <!-- Visitors -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">
+              Est Visitors (Week)
+            </p>
+            <p class="text-14 text-pulse-black">
+              2.5m
+            </p>
+          </div>
+
+          <!-- Release Date -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Release Date</p>
+            <p class="text-14 text-pulse-black">
+                Mar 22, 2025
+            </p>
+          </div>
+        </div>
+      </div>
+  </div>
+</div>
+
+</a>
+<a href="/servers/ktanaka101-duckdb">
+      <div class="relative flex flex-col rounded border border-pulse-gray-border h-full hover:border-pulse-purple hover:shadow-lg transition-all duration-300 bg-white" data-test-id="mcp-server-card-ktanaka101-duckdb">
+
+  <div class="flex flex-col h-full p-6">
+    <!-- Header section -->
+    <div class="flex-grow">
+      <div class="flex items-center gap-3 mb-2">
+        <h3 class="text-20 text-pulse-black font-sans font-normal leading-tight">
+          DuckDB
+        </h3>
+      </div>
+
+        <p class="text-14 text-gray-500 mb-3">ktanaka101</p>
+
+        <p class="text-15 text-pulse-black leading-relaxed">
+          Execute SQL queries and analyze data in DuckDB databases.
+        </p>
+    </div>
+
+    <!-- Bottom stats section -->
+      <div class="mt-6 pt-4 border-t border-gray-200">
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 text-sm">
+          <!-- Classification -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Classification</p>
+            <div class="flex items-center gap-2">
+              <div class="w-4 h-4 flex-shrink-0">
+                <img class="w-4 h-4" alt="Community icon" src="https://storage.googleapis.com/pulse_public/static/community-icon.svg" />
+              </div>
+              <p class="text-14 capitalize text-pulse-black">community</p>
+            </div>
+          </div>
+
+          <!-- Visitors -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">
+              Est Visitors (Week)
+            </p>
+            <p class="text-14 text-pulse-black">
+              1.7m
+            </p>
+          </div>
+
+          <!-- Release Date -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Release Date</p>
+            <p class="text-14 text-pulse-black">
+                Nov 30, 2024
+            </p>
+          </div>
+        </div>
+      </div>
+  </div>
+</div>
+
+</a>
+<a href="/servers/haris-musa-excel">
+      <div class="relative flex flex-col rounded border border-pulse-gray-border h-full hover:border-pulse-purple hover:shadow-lg transition-all duration-300 bg-white" data-test-id="mcp-server-card-haris-musa-excel">
+
+  <div class="flex flex-col h-full p-6">
+    <!-- Header section -->
+    <div class="flex-grow">
+      <div class="flex items-center gap-3 mb-2">
+        <h3 class="text-20 text-pulse-black font-sans font-normal leading-tight">
+          Excel File Manipulation
+        </h3>
+      </div>
+
+        <p class="text-14 text-gray-500 mb-3">Haris Musa</p>
+
+        <p class="text-15 text-pulse-black leading-relaxed">
+          Enables Excel file manipulation without Microsoft Excel installation using openpyxl, providing workbook operations,...
+        </p>
+    </div>
+
+    <!-- Bottom stats section -->
+      <div class="mt-6 pt-4 border-t border-gray-200">
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 text-sm">
+          <!-- Classification -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Classification</p>
+            <div class="flex items-center gap-2">
+              <div class="w-4 h-4 flex-shrink-0">
+                <img class="w-4 h-4" alt="Community icon" src="https://storage.googleapis.com/pulse_public/static/community-icon.svg" />
+              </div>
+              <p class="text-14 capitalize text-pulse-black">community</p>
+            </div>
+          </div>
+
+          <!-- Visitors -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">
+              Est Visitors (Week)
+            </p>
+            <p class="text-14 text-pulse-black">
+              1.6m
+            </p>
+          </div>
+
+          <!-- Release Date -->
+          <div>
+            <p class="text-12 font-semibold text-pulse-black uppercase tracking-wide mb-1">Release Date</p>
+            <p class="text-14 text-pulse-black">
+                Feb 12, 2025
+            </p>
+          </div>
+        </div>
+      </div>
+  </div>
+</div>
+
+</a>
+</div>

src/tests/test_agent_add.py

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

src/tests/test_artifact_promotion.py

@@ -1,143 +1,143 @@
-from __future__ import annotations
-
-import gzip
-import json
-from datetime import datetime, timezone
-from pathlib import Path
-
-import pytest
-
-from ctx.core.wiki import artifact_promotion
-
-
-def test_promote_staged_artifact_validates_replaces_and_records_metadata(
-    tmp_path: Path,
-) -> None:
-    target = tmp_path / "artifact.txt"
-    staged = tmp_path / "candidate.txt"
-    target.write_bytes(b"old\n")
-    staged.write_bytes(b"new\n")
-    validated: list[Path] = []
-
-    result = artifact_promotion.promote_staged_artifact(
-        staged,
-        target,
-        validate=lambda path: validated.append(path),
-        now=datetime(2026, 5, 4, tzinfo=timezone.utc),
-    )
-
-    metadata = json.loads(result.metadata_path.read_text(encoding="utf-8"))
-    assert validated == [staged]
-    assert target.read_bytes() == b"new\n"
-    assert not staged.exists()
-    assert metadata["status"] == "promoted"
-    assert metadata["previous"]["exists"] is True
-    assert metadata["previous"]["size"] == 4
-    assert metadata["candidate"]["size"] == 4
-    assert metadata["current"]["sha256"] == metadata["candidate"]["sha256"]
-    assert metadata["last_good"] == metadata["previous"]
-    assert metadata["rollback"]["available"] is True
-    assert metadata["rollback"]["sha256"] == metadata["previous"]["sha256"]
-
-
-def test_promote_staged_artifact_validation_failure_preserves_target(
-    tmp_path: Path,
-) -> None:
-    target = tmp_path / "artifact.txt"
-    staged = tmp_path / "candidate.txt"
-    target.write_bytes(b"old\n")
-    staged.write_bytes(b"new\n")
-
-    def fail_validation(_path: Path) -> None:
-        raise ValueError("candidate failed validation")
-
-    with pytest.raises(ValueError, match="candidate failed validation"):
-        artifact_promotion.promote_staged_artifact(
-            staged,
-            target,
-            validate=fail_validation,
-        )
-
-    assert target.read_bytes() == b"old\n"
-    assert staged.exists()
-    assert not target.with_name("artifact.txt.promotion.json").exists()
-
-    malformed_json = tmp_path / "broken.json"
-    malformed_json.write_text("{", encoding="utf-8")
-    with pytest.raises(ValueError, match="invalid JSON artifact"):
-        artifact_promotion.validate_json_artifact(malformed_json)
-
-    truncated_gzip = tmp_path / "broken.json.gz"
-    truncated_gzip.write_bytes(b"\x1f\x8b")
-    with pytest.raises(ValueError, match="invalid gzip JSON artifact"):
-        artifact_promotion.validate_gzip_json_artifact(truncated_gzip)
-
-    valid_gzip = tmp_path / "catalog.json.gz"
-    with gzip.open(valid_gzip, "wt", encoding="utf-8") as fh:
-        json.dump({"skills": []}, fh)
-    artifact_promotion.validate_gzip_json_artifact(valid_gzip, required_keys=("skills",))
-
-
-def test_promote_staged_artifact_replace_failure_preserves_target_and_last_good(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    target = tmp_path / "artifact.txt"
-    staged = tmp_path / "candidate.txt"
-    target.write_bytes(b"old\n")
-    staged.write_bytes(b"new\n")
-
-    def locked_replace(_src: Path, _dst: Path) -> None:
-        raise PermissionError("locked")
-
-    monkeypatch.setattr(artifact_promotion, "_replace_with_retry", locked_replace)
-
-    with pytest.raises(PermissionError, match="locked"):
-        artifact_promotion.promote_staged_artifact(staged, target)
-
-    metadata = json.loads(
-        target.with_name("artifact.txt.promotion.json").read_text(encoding="utf-8")
-    )
-    assert target.read_bytes() == b"old\n"
-    assert staged.exists()
-    assert metadata["status"] == "staged"
-    assert metadata["previous"]["sha256"] != metadata["candidate"]["sha256"]
-    assert metadata["last_good"] == metadata["previous"]
-    assert metadata["rollback"]["available"] is True
-
-
-def test_promote_staged_artifact_recovers_after_post_replace_crash(
-    tmp_path: Path,
-) -> None:
-    target = tmp_path / "artifact.txt"
-    staged = tmp_path / "candidate.txt"
-    metadata_path = target.with_name("artifact.txt.promotion.json")
-    target.write_bytes(b"new\n")
-    candidate = artifact_promotion._snapshot(target)
-    previous = {
-        "path": str(target),
-        "exists": True,
-        "size": 4,
-        "sha256": "old-sha",
-        "mtime_ns": 1,
-    }
-    metadata_path.write_text(
-        json.dumps({
-            "schema_version": 1,
-            "status": "staged",
-            "target": str(target),
-            "started_at": "2026-05-04T00:00:00+00:00",
-            "previous": previous,
-            "candidate": candidate,
-        }),
-        encoding="utf-8",
-    )
-
-    result = artifact_promotion.promote_staged_artifact(staged, target)
-
-    metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
-    assert result.current["sha256"] == candidate["sha256"]
-    assert metadata["status"] == "promoted"
-    assert metadata["previous"] == previous
-    assert metadata["candidate"]["sha256"] == candidate["sha256"]
-    assert metadata["current"]["sha256"] == candidate["sha256"]
+from __future__ import annotations
+
+import gzip
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+from ctx.core.wiki import artifact_promotion
+
+
+def test_promote_staged_artifact_validates_replaces_and_records_metadata(
+    tmp_path: Path,
+) -> None:
+    target = tmp_path / "artifact.txt"
+    staged = tmp_path / "candidate.txt"
+    target.write_bytes(b"old\n")
+    staged.write_bytes(b"new\n")
+    validated: list[Path] = []
+
+    result = artifact_promotion.promote_staged_artifact(
+        staged,
+        target,
+        validate=lambda path: validated.append(path),
+        now=datetime(2026, 5, 4, tzinfo=timezone.utc),
+    )
+
+    metadata = json.loads(result.metadata_path.read_text(encoding="utf-8"))
+    assert validated == [staged]
+    assert target.read_bytes() == b"new\n"
+    assert not staged.exists()
+    assert metadata["status"] == "promoted"
+    assert metadata["previous"]["exists"] is True
+    assert metadata["previous"]["size"] == 4
+    assert metadata["candidate"]["size"] == 4
+    assert metadata["current"]["sha256"] == metadata["candidate"]["sha256"]
+    assert metadata["last_good"] == metadata["previous"]
+    assert metadata["rollback"]["available"] is True
+    assert metadata["rollback"]["sha256"] == metadata["previous"]["sha256"]
+
+
+def test_promote_staged_artifact_validation_failure_preserves_target(
+    tmp_path: Path,
+) -> None:
+    target = tmp_path / "artifact.txt"
+    staged = tmp_path / "candidate.txt"
+    target.write_bytes(b"old\n")
+    staged.write_bytes(b"new\n")
+
+    def fail_validation(_path: Path) -> None:
+        raise ValueError("candidate failed validation")
+
+    with pytest.raises(ValueError, match="candidate failed validation"):
+        artifact_promotion.promote_staged_artifact(
+            staged,
+            target,
+            validate=fail_validation,
+        )
+
+    assert target.read_bytes() == b"old\n"
+    assert staged.exists()
+    assert not target.with_name("artifact.txt.promotion.json").exists()
+
+    malformed_json = tmp_path / "broken.json"
+    malformed_json.write_text("{", encoding="utf-8")
+    with pytest.raises(ValueError, match="invalid JSON artifact"):
+        artifact_promotion.validate_json_artifact(malformed_json)
+
+    truncated_gzip = tmp_path / "broken.json.gz"
+    truncated_gzip.write_bytes(b"\x1f\x8b")
+    with pytest.raises(ValueError, match="invalid gzip JSON artifact"):
+        artifact_promotion.validate_gzip_json_artifact(truncated_gzip)
+
+    valid_gzip = tmp_path / "catalog.json.gz"
+    with gzip.open(valid_gzip, "wt", encoding="utf-8") as fh:
+        json.dump({"skills": []}, fh)
+    artifact_promotion.validate_gzip_json_artifact(valid_gzip, required_keys=("skills",))
+
+
+def test_promote_staged_artifact_replace_failure_preserves_target_and_last_good(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    target = tmp_path / "artifact.txt"
+    staged = tmp_path / "candidate.txt"
+    target.write_bytes(b"old\n")
+    staged.write_bytes(b"new\n")
+
+    def locked_replace(_src: Path, _dst: Path) -> None:
+        raise PermissionError("locked")
+
+    monkeypatch.setattr(artifact_promotion, "_replace_with_retry", locked_replace)
+
+    with pytest.raises(PermissionError, match="locked"):
+        artifact_promotion.promote_staged_artifact(staged, target)
+
+    metadata = json.loads(
+        target.with_name("artifact.txt.promotion.json").read_text(encoding="utf-8")
+    )
+    assert target.read_bytes() == b"old\n"
+    assert staged.exists()
+    assert metadata["status"] == "staged"
+    assert metadata["previous"]["sha256"] != metadata["candidate"]["sha256"]
+    assert metadata["last_good"] == metadata["previous"]
+    assert metadata["rollback"]["available"] is True
+
+
+def test_promote_staged_artifact_recovers_after_post_replace_crash(
+    tmp_path: Path,
+) -> None:
+    target = tmp_path / "artifact.txt"
+    staged = tmp_path / "candidate.txt"
+    metadata_path = target.with_name("artifact.txt.promotion.json")
+    target.write_bytes(b"new\n")
+    candidate = artifact_promotion._snapshot(target)
+    previous = {
+        "path": str(target),
+        "exists": True,
+        "size": 4,
+        "sha256": "old-sha",
+        "mtime_ns": 1,
+    }
+    metadata_path.write_text(
+        json.dumps({
+            "schema_version": 1,
+            "status": "staged",
+            "target": str(target),
+            "started_at": "2026-05-04T00:00:00+00:00",
+            "previous": previous,
+            "candidate": candidate,
+        }),
+        encoding="utf-8",
+    )
+
+    result = artifact_promotion.promote_staged_artifact(staged, target)
+
+    metadata = json.loads(metadata_path.read_text(encoding="utf-8"))
+    assert result.current["sha256"] == candidate["sha256"]
+    assert metadata["status"] == "promoted"
+    assert metadata["previous"] == previous
+    assert metadata["candidate"]["sha256"] == candidate["sha256"]
+    assert metadata["current"]["sha256"] == candidate["sha256"]

src/tests/test_bundle_orchestrator.py

@@ -1,42 +1,42 @@
-"""
-test_bundle_orchestrator.py -- pins the cross-type bundle contract.
-
+"""
+test_bundle_orchestrator.py -- pins the cross-type bundle contract.
+
 Covers:
   - categorise_bundle: top-K across all types (not per-type), preserves
     graph-score order within each type, supports all-one-type and mixed.
-  - render_bundle_message: categorised output with install-cli hints,
-    omits empty type sections, includes unmatched signals + unload block.
-  - main(): reads pending-skills.json, caps at cfg.recommendation_top_k,
-    emits the Claude Code hook JSON envelope.
-  - Backward compat: skill_suggest.py shim still calls the new main().
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).parents[1]))
-
-from ctx.adapters.claude_code.hooks import bundle_orchestrator as _bo
-
-
-# ────────────────────────────────────────────────────────────────────
-# categorise_bundle — top-K is TOTAL, not per-type
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestCategoriseBundle:
-    def _sug(self, *entries) -> list[dict]:
-        return [
-            {"name": n, "type": t, "score": s, "matching_tags": ["x"]}
-            for n, t, s in entries
-        ]
-
+  - render_bundle_message: categorised output with install-cli hints,
+    omits empty type sections, includes unmatched signals + unload block.
+  - main(): reads pending-skills.json, caps at cfg.recommendation_top_k,
+    emits the Claude Code hook JSON envelope.
+  - Backward compat: skill_suggest.py shim still calls the new main().
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parents[1]))
+
+from ctx.adapters.claude_code.hooks import bundle_orchestrator as _bo
+
+
+# ────────────────────────────────────────────────────────────────────
+# categorise_bundle — top-K is TOTAL, not per-type
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestCategoriseBundle:
+    def _sug(self, *entries) -> list[dict]:
+        return [
+            {"name": n, "type": t, "score": s, "matching_tags": ["x"]}
+            for n, t, s in entries
+        ]
+
     def test_bundle_excludes_harnesses_from_execution_bundle(self):
         """Harnesses are recommended by model onboarding, not hook bundles."""
         sugs = self._sug(
@@ -51,58 +51,58 @@ class TestCategoriseBundle:
         assert len(grouped["agent"]) == 1
         assert len(grouped["mcp-server"]) == 1
         assert "harness" not in grouped
-
-    def test_bundle_can_be_single_type(self):
-        """If the top-K entries are all skills, the bundle contains only
-        skills — agents/MCPs lists are empty (caller omits their headers)."""
-        sugs = self._sug(
-            ("python-a", "skill", 90),
-            ("python-b", "skill", 85),
-            ("python-c", "skill", 80),
-        )
+
+    def test_bundle_can_be_single_type(self):
+        """If the top-K entries are all skills, the bundle contains only
+        skills — agents/MCPs lists are empty (caller omits their headers)."""
+        sugs = self._sug(
+            ("python-a", "skill", 90),
+            ("python-b", "skill", 85),
+            ("python-c", "skill", 80),
+        )
         grouped = _bo.categorise_bundle(sugs, top_k=5)
         assert len(grouped["skill"]) == 3
         assert grouped["agent"] == []
         assert grouped["mcp-server"] == []
-
-    def test_top_k_is_total_not_per_type(self):
-        """top_k=5 with 10 skills available returns 5 skills TOTAL,
-        not 5 per type. User ask: 'don't show a lot of options'."""
-        sugs = self._sug(*[(f"skill-{i}", "skill", 100 - i) for i in range(10)])
-        grouped = _bo.categorise_bundle(sugs, top_k=5)
-        assert sum(len(v) for v in grouped.values()) == 5
-
-    def test_input_order_preserved_within_type(self):
-        """Graph-score order from context_monitor.graph_suggest is
-        authoritative. categorise_bundle must not re-sort."""
-        sugs = self._sug(
-            ("alpha", "skill", 99),
-            ("beta", "skill", 50),
-            ("gamma", "skill", 70),
-        )
-        grouped = _bo.categorise_bundle(sugs, top_k=5)
-        names = [e["name"] for e in grouped["skill"]]
-        # Called input order: alpha, beta, gamma -- caller has already
-        # sorted by score. categorise_bundle preserves that order.
-        assert names == ["alpha", "beta", "gamma"]
-
-    def test_top_k_one(self):
-        """Edge case: top_k=1 returns one entry total."""
-        sugs = self._sug(
-            ("skill-a", "skill", 90),
-            ("agent-a", "agent", 85),
-        )
-        grouped = _bo.categorise_bundle(sugs, top_k=1)
-        assert sum(len(v) for v in grouped.values()) == 1
-
-    def test_empty_input(self):
+
+    def test_top_k_is_total_not_per_type(self):
+        """top_k=5 with 10 skills available returns 5 skills TOTAL,
+        not 5 per type. User ask: 'don't show a lot of options'."""
+        sugs = self._sug(*[(f"skill-{i}", "skill", 100 - i) for i in range(10)])
+        grouped = _bo.categorise_bundle(sugs, top_k=5)
+        assert sum(len(v) for v in grouped.values()) == 5
+
+    def test_input_order_preserved_within_type(self):
+        """Graph-score order from context_monitor.graph_suggest is
+        authoritative. categorise_bundle must not re-sort."""
+        sugs = self._sug(
+            ("alpha", "skill", 99),
+            ("beta", "skill", 50),
+            ("gamma", "skill", 70),
+        )
+        grouped = _bo.categorise_bundle(sugs, top_k=5)
+        names = [e["name"] for e in grouped["skill"]]
+        # Called input order: alpha, beta, gamma -- caller has already
+        # sorted by score. categorise_bundle preserves that order.
+        assert names == ["alpha", "beta", "gamma"]
+
+    def test_top_k_one(self):
+        """Edge case: top_k=1 returns one entry total."""
+        sugs = self._sug(
+            ("skill-a", "skill", 90),
+            ("agent-a", "agent", 85),
+        )
+        grouped = _bo.categorise_bundle(sugs, top_k=1)
+        assert sum(len(v) for v in grouped.values()) == 1
+
+    def test_empty_input(self):
         grouped = _bo.categorise_bundle([], top_k=5)
         assert grouped == {
             "skill": [],
             "agent": [],
             "mcp-server": [],
         }
-
+
     def test_unknown_type_is_ignored(self):
         """A suggestion with an unexpected ``type`` value doesn't crash
         the categoriser; it is skipped. Defensive — the
@@ -112,21 +112,21 @@ class TestCategoriseBundle:
         grouped = _bo.categorise_bundle(sugs, top_k=5)
         assert "future-type" not in grouped
         assert sum(len(v) for v in grouped.values()) == 0
-
-
-# ────────────────────────────────────────────────────────────────────
-# render_bundle_message — user-facing layout
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestRenderBundleMessage:
-    def _sug(self, *entries) -> list[dict]:
-        return [
-            {"name": n, "type": t, "score": s, "matching_tags": ["stack-x"]}
-            for n, t, s in entries
-        ]
-
-    def test_categorised_headers_only_for_types_with_entries(self):
+
+
+# ────────────────────────────────────────────────────────────────────
+# render_bundle_message — user-facing layout
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestRenderBundleMessage:
+    def _sug(self, *entries) -> list[dict]:
+        return [
+            {"name": n, "type": t, "score": s, "matching_tags": ["stack-x"]}
+            for n, t, s in entries
+        ]
+
+    def test_categorised_headers_only_for_types_with_entries(self):
         """Skills/Agents/MCPs headers appear ONLY when that type has
         entries in the bundle. Empty sections are omitted so the user
         doesn't see dead headers."""
@@ -154,69 +154,69 @@ class TestRenderBundleMessage:
         msg = _bo.render_bundle_message(sugs, [], [], top_k=5)
         assert "Suggested bundle" not in msg
         assert "langgraph" not in msg
-
-    def test_unmatched_signals_surfaced(self):
-        msg = _bo.render_bundle_message([], ["fastapi", "docker"], [], top_k=5)
-        assert "Unmatched signals" in msg
-        assert "fastapi" in msg
-        assert "docker" in msg
-
-    def test_unload_block_separate_from_bundle(self):
-        unload = [{"name": "old-skill", "reason": "unused for 30 days"}]
-        msg = _bo.render_bundle_message([], [], unload, top_k=5)
-        assert "loaded but never used" in msg
-        assert "old-skill" in msg
-
-    def test_empty_everything_yields_empty_message(self):
-        assert _bo.render_bundle_message([], [], [], top_k=5).strip() == ""
-
-    def test_top_k_enforced_in_render(self):
-        """If input has 10 suggestions but top_k=3, only 3 show."""
-        sugs = self._sug(*[(f"s-{i}", "skill", 100 - i) for i in range(10)])
-        msg = _bo.render_bundle_message(sugs, [], [], top_k=3)
-        # Count the bullet lines that start with "- " (our bundle-item marker).
-        item_lines = [line for line in msg.splitlines() if line.strip().startswith("- ")]
-        assert len(item_lines) == 3
-
-
-# ────────────────────────────────────────────────────────────────────
-# main() — reads pending files, emits Claude-Code hook payload
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestMainEndToEnd:
-    def _setup_paths(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_bo, "CLAUDE_DIR", tmp_path)
-        monkeypatch.setattr(_bo, "PENDING_SKILLS", tmp_path / "pending-skills.json")
-        monkeypatch.setattr(_bo, "PENDING_UNLOAD", tmp_path / "pending-unload.json")
-        monkeypatch.setattr(_bo, "SHOWN_FLAG", tmp_path / ".bundle-shown")
-
-    def test_no_pending_exits_0(self, tmp_path, monkeypatch):
-        self._setup_paths(tmp_path, monkeypatch)
-        with pytest.raises(SystemExit) as exc:
-            _bo.main()
-        assert exc.value.code == 0
-
+
+    def test_unmatched_signals_surfaced(self):
+        msg = _bo.render_bundle_message([], ["fastapi", "docker"], [], top_k=5)
+        assert "Unmatched signals" in msg
+        assert "fastapi" in msg
+        assert "docker" in msg
+
+    def test_unload_block_separate_from_bundle(self):
+        unload = [{"name": "old-skill", "reason": "unused for 30 days"}]
+        msg = _bo.render_bundle_message([], [], unload, top_k=5)
+        assert "loaded but never used" in msg
+        assert "old-skill" in msg
+
+    def test_empty_everything_yields_empty_message(self):
+        assert _bo.render_bundle_message([], [], [], top_k=5).strip() == ""
+
+    def test_top_k_enforced_in_render(self):
+        """If input has 10 suggestions but top_k=3, only 3 show."""
+        sugs = self._sug(*[(f"s-{i}", "skill", 100 - i) for i in range(10)])
+        msg = _bo.render_bundle_message(sugs, [], [], top_k=3)
+        # Count the bullet lines that start with "- " (our bundle-item marker).
+        item_lines = [line for line in msg.splitlines() if line.strip().startswith("- ")]
+        assert len(item_lines) == 3
+
+
+# ────────────────────────────────────────────────────────────────────
+# main() — reads pending files, emits Claude-Code hook payload
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestMainEndToEnd:
+    def _setup_paths(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_bo, "CLAUDE_DIR", tmp_path)
+        monkeypatch.setattr(_bo, "PENDING_SKILLS", tmp_path / "pending-skills.json")
+        monkeypatch.setattr(_bo, "PENDING_UNLOAD", tmp_path / "pending-unload.json")
+        monkeypatch.setattr(_bo, "SHOWN_FLAG", tmp_path / ".bundle-shown")
+
+    def test_no_pending_exits_0(self, tmp_path, monkeypatch):
+        self._setup_paths(tmp_path, monkeypatch)
+        with pytest.raises(SystemExit) as exc:
+            _bo.main()
+        assert exc.value.code == 0
+
     def test_pending_with_bundle_emits_hook_json(
         self, tmp_path, monkeypatch, capsys,
     ):
-        self._setup_paths(tmp_path, monkeypatch)
-        pending = {
-            "generated_at": datetime.now(timezone.utc).isoformat(),
-            "unmatched_signals": ["fastapi"],
-            "graph_suggestions": [
-                {"name": "fastapi-pro", "type": "skill", "score": 90,
-                 "matching_tags": ["fastapi"]},
+        self._setup_paths(tmp_path, monkeypatch)
+        pending = {
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "unmatched_signals": ["fastapi"],
+            "graph_suggestions": [
+                {"name": "fastapi-pro", "type": "skill", "score": 90,
+                 "matching_tags": ["fastapi"]},
                 {"name": "anthropic-python-sdk", "type": "mcp-server",
                  "score": 75, "matching_tags": []},
             ],
         }
-        (tmp_path / "pending-skills.json").write_text(json.dumps(pending))
-
-        _bo.main()
-        out = capsys.readouterr().out.strip()
-        payload = json.loads(out)
-        assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
+        (tmp_path / "pending-skills.json").write_text(json.dumps(pending))
+
+        _bo.main()
+        out = capsys.readouterr().out.strip()
+        payload = json.loads(out)
+        assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
         msg = payload["hookSpecificOutput"]["additionalContext"]
         assert "fastapi-pro" in msg
         assert "anthropic-python-sdk" in msg
@@ -245,69 +245,69 @@ class TestMainEndToEnd:
 
     def test_already_shown_suppresses_output(
         self, tmp_path, monkeypatch, capsys,
-    ):
-        """Second invocation in the same session doesn't re-emit."""
-        self._setup_paths(tmp_path, monkeypatch)
-        pending_at = datetime.now(timezone.utc).isoformat()
-        (tmp_path / "pending-skills.json").write_text(json.dumps({
-            "generated_at": pending_at,
-            "unmatched_signals": ["x"],
-            "graph_suggestions": [
-                {"name": "a", "type": "skill", "score": 50, "matching_tags": []},
-            ],
-        }))
-        # Pre-mark shown with a timestamp AFTER pending_at so the guard trips.
-        later = datetime.now(timezone.utc).isoformat()
-        (tmp_path / ".bundle-shown").write_text(json.dumps({"shown_at": later}))
-
-        with pytest.raises(SystemExit) as exc:
-            _bo.main()
-        assert exc.value.code == 0
-        assert capsys.readouterr().out == ""
-
-    def test_top_k_from_config(self, tmp_path, monkeypatch, capsys):
-        """A user override of recommendation_top_k in config propagates."""
-        self._setup_paths(tmp_path, monkeypatch)
-
-        # Monkey-patch the lazy ctx_config import path used inside _top_k.
-        import ctx_config as _cfg_mod
-        monkeypatch.setattr(_cfg_mod.cfg, "recommendation_top_k", 2)
-
-        pending = {
-            "generated_at": datetime.now(timezone.utc).isoformat(),
-            "unmatched_signals": [],
-            "graph_suggestions": [
-                {"name": f"s-{i}", "type": "skill", "score": 100 - i, "matching_tags": []}
-                for i in range(10)
-            ],
-        }
-        (tmp_path / "pending-skills.json").write_text(json.dumps(pending))
-
-        _bo.main()
-        out = capsys.readouterr().out
-        payload = json.loads(out.strip())
-        msg = payload["hookSpecificOutput"]["additionalContext"]
-        item_lines = [line for line in msg.splitlines() if line.strip().startswith("- ")]
-        assert len(item_lines) == 2, f"expected top_k=2 cap, got {len(item_lines)}"
-
-
-# ────────────────────────────────────────────────────────────────────
-# Backward-compat: skill_suggest shim
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestSkillSuggestShim:
-    """skill_suggest.py must remain importable and call through to
-    bundle_orchestrator.main — otherwise existing ~/.claude/settings.json
-    hook configs that invoke ``python skill_suggest.py`` break silently."""
-
-    def test_shim_re_exports_main(self):
-        from ctx.adapters.claude_code.hooks import skill_suggest
-        # The shim re-imports main from bundle_orchestrator. The function
-        # object must be the SAME instance to guarantee behavioural parity.
-        assert skill_suggest.main is _bo.main
-
-    def test_shim_re_exports_constants(self):
-        from ctx.adapters.claude_code.hooks import skill_suggest
-        assert skill_suggest.PENDING_SKILLS == _bo.PENDING_SKILLS
-        assert skill_suggest.PENDING_UNLOAD == _bo.PENDING_UNLOAD
+    ):
+        """Second invocation in the same session doesn't re-emit."""
+        self._setup_paths(tmp_path, monkeypatch)
+        pending_at = datetime.now(timezone.utc).isoformat()
+        (tmp_path / "pending-skills.json").write_text(json.dumps({
+            "generated_at": pending_at,
+            "unmatched_signals": ["x"],
+            "graph_suggestions": [
+                {"name": "a", "type": "skill", "score": 50, "matching_tags": []},
+            ],
+        }))
+        # Pre-mark shown with a timestamp AFTER pending_at so the guard trips.
+        later = datetime.now(timezone.utc).isoformat()
+        (tmp_path / ".bundle-shown").write_text(json.dumps({"shown_at": later}))
+
+        with pytest.raises(SystemExit) as exc:
+            _bo.main()
+        assert exc.value.code == 0
+        assert capsys.readouterr().out == ""
+
+    def test_top_k_from_config(self, tmp_path, monkeypatch, capsys):
+        """A user override of recommendation_top_k in config propagates."""
+        self._setup_paths(tmp_path, monkeypatch)
+
+        # Monkey-patch the lazy ctx_config import path used inside _top_k.
+        import ctx_config as _cfg_mod
+        monkeypatch.setattr(_cfg_mod.cfg, "recommendation_top_k", 2)
+
+        pending = {
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "unmatched_signals": [],
+            "graph_suggestions": [
+                {"name": f"s-{i}", "type": "skill", "score": 100 - i, "matching_tags": []}
+                for i in range(10)
+            ],
+        }
+        (tmp_path / "pending-skills.json").write_text(json.dumps(pending))
+
+        _bo.main()
+        out = capsys.readouterr().out
+        payload = json.loads(out.strip())
+        msg = payload["hookSpecificOutput"]["additionalContext"]
+        item_lines = [line for line in msg.splitlines() if line.strip().startswith("- ")]
+        assert len(item_lines) == 2, f"expected top_k=2 cap, got {len(item_lines)}"
+
+
+# ────────────────────────────────────────────────────────────────────
+# Backward-compat: skill_suggest shim
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestSkillSuggestShim:
+    """skill_suggest.py must remain importable and call through to
+    bundle_orchestrator.main — otherwise existing ~/.claude/settings.json
+    hook configs that invoke ``python skill_suggest.py`` break silently."""
+
+    def test_shim_re_exports_main(self):
+        from ctx.adapters.claude_code.hooks import skill_suggest
+        # The shim re-imports main from bundle_orchestrator. The function
+        # object must be the SAME instance to guarantee behavioural parity.
+        assert skill_suggest.main is _bo.main
+
+    def test_shim_re_exports_constants(self):
+        from ctx.adapters.claude_code.hooks import skill_suggest
+        assert skill_suggest.PENDING_SKILLS == _bo.PENDING_SKILLS
+        assert skill_suggest.PENDING_UNLOAD == _bo.PENDING_UNLOAD

src/tests/test_catalog_builder.py

@@ -1,917 +1,917 @@
-"""
-test_catalog_builder.py -- Coverage for catalog_builder.py (226 LOC).
-
-catalog_builder scans skills and agents directories, builds catalog.md,
-and optionally updates index.md and log.md inside the wiki. A regression
-in any of the four public functions silently corrupts the master index
-used by every downstream router call, so each branch is explicitly covered.
-"""
-
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Any
-from unittest.mock import MagicMock
-
-import pytest
-
-import catalog_builder
-
-
-# ── Helpers ───────────────────────────────────────────────────────────────────
-
-
-def _make_skill(base: Path, name: str, line_count: int) -> Path:
-    """Create skills_dir/<name>/SKILL.md with the requested number of lines."""
-    d = base / name
-    d.mkdir(parents=True, exist_ok=True)
-    content = "\n".join(f"# line {i}" for i in range(line_count))
-    (d / "SKILL.md").write_text(content, encoding="utf-8")
-    return d
-
-
-def _make_agent(base: Path, name: str, line_count: int) -> Path:
-    """Create agents_dir/<name>.md with the requested number of lines."""
-    base.mkdir(parents=True, exist_ok=True)
-    content = "\n".join(f"# line {i}" for i in range(line_count))
-    p = base / f"{name}.md"
-    p.write_text(content, encoding="utf-8")
-    return p
-
-
-def _patched_cfg(monkeypatch: pytest.MonkeyPatch, threshold: int = 180) -> MagicMock:
-    """Return a mock cfg with a configurable line_threshold."""
-    fake = MagicMock()
-    fake.line_threshold = threshold
-    monkeypatch.setattr(catalog_builder, "cfg", fake)
-    return fake
-
-
-# ── scan_skills_dir ───────────────────────────────────────────────────────────
-
-
-class TestScanSkillsDir:
-    def test_nonexistent_dir_returns_empty(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch)
-        result = catalog_builder.scan_skills_dir(tmp_path / "does-not-exist")
-        assert result == []
-
-    def test_empty_dir_returns_empty(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch)
-        skills_dir = tmp_path / "skills"
-        skills_dir.mkdir()
-        assert catalog_builder.scan_skills_dir(skills_dir) == []
-
-    def test_dir_without_skill_md_skipped(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch)
-        skills_dir = tmp_path / "skills"
-        (skills_dir / "no-skill-md").mkdir(parents=True)
-        # directory exists but has no SKILL.md
-        assert catalog_builder.scan_skills_dir(skills_dir) == []
-
-    def test_flat_file_in_skills_dir_skipped(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Regular .md files at the top level of skills_dir are not skills."""
-        _patched_cfg(monkeypatch)
-        skills_dir = tmp_path / "skills"
-        skills_dir.mkdir()
-        (skills_dir / "flat.md").write_text("# flat", encoding="utf-8")
-        assert catalog_builder.scan_skills_dir(skills_dir) == []
-
-    def test_single_skill_parsed(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "my-skill", 10)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert len(result) == 1
-        r = result[0]
-        assert r["name"] == "my-skill"
-        assert r["type"] == "skill"
-        assert r["lines"] == 10
-        assert r["over_180"] is False
-        assert "SKILL.md" in r["path"]
-
-    def test_over_threshold_flag(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "fat-skill", 200)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["over_180"] is True
-
-    def test_exactly_at_threshold_not_over(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "boundary-skill", 180)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["over_180"] is False
-
-    def test_one_above_threshold_is_over(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "just-over", 181)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["over_180"] is True
-
-    def test_multiple_skills_sorted(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "zebra", 5)
-        _make_skill(skills_dir, "alpha", 5)
-        _make_skill(skills_dir, "middle", 5)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        names = [r["name"] for r in result]
-        assert names == sorted(names)
-
-    def test_empty_skill_md_yields_zero_lines(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        d = skills_dir / "empty-skill"
-        d.mkdir(parents=True)
-        (d / "SKILL.md").write_text("", encoding="utf-8")
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["lines"] == 0
-
-    def test_unicode_content_handled(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        d = skills_dir / "unicode-skill"
-        d.mkdir(parents=True)
-        content = "# 日本語\n# Ärger\n# emoji 🐍\n"
-        (d / "SKILL.md").write_text(content, encoding="utf-8")
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["lines"] == 3
-
-    def test_unreadable_skill_warns_and_uses_zero(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        """When read_text raises, lines falls back to 0 and a warning goes to stderr."""
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        d = skills_dir / "bad-skill"
-        d.mkdir(parents=True)
-        skill_md = d / "SKILL.md"
-        skill_md.write_text("content", encoding="utf-8")
-
-        original_read = Path.read_text
-
-        def _boom(self: Path, **kwargs: Any) -> str:  # type: ignore[override]
-            if self.name == "SKILL.md":
-                raise OSError("permission denied")
-            return original_read(self, **kwargs)
-
-        monkeypatch.setattr(Path, "read_text", _boom)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["lines"] == 0
-        err = capsys.readouterr().err
-        assert "Warning" in err
-
-
-# ── scan_agents_dir ───────────────────────────────────────────────────────────
-
-
-class TestScanAgentsDir:
-    def test_nonexistent_dir_returns_empty(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch)
-        result = catalog_builder.scan_agents_dir(tmp_path / "no-agents")
-        assert result == []
-
-    def test_empty_dir_returns_empty(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch)
-        agents_dir = tmp_path / "agents"
-        agents_dir.mkdir()
-        assert catalog_builder.scan_agents_dir(agents_dir) == []
-
-    def test_non_md_files_ignored(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch)
-        agents_dir = tmp_path / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "script.py").write_text("x=1", encoding="utf-8")
-        (agents_dir / "data.json").write_text("{}", encoding="utf-8")
-        assert catalog_builder.scan_agents_dir(agents_dir) == []
-
-    def test_single_agent_parsed(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        _make_agent(agents_dir, "my-agent", 50)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert len(result) == 1
-        r = result[0]
-        assert r["name"] == "my-agent"
-        assert r["type"] == "agent"
-        assert r["lines"] == 50
-        assert r["over_180"] is False
-        assert r["path"].endswith("my-agent.md")
-
-    def test_over_threshold_flag(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        _make_agent(agents_dir, "fat-agent", 200)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert result[0]["over_180"] is True
-
-    def test_exactly_at_threshold_not_over(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        _make_agent(agents_dir, "boundary", 180)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert result[0]["over_180"] is False
-
-    def test_stem_used_as_name(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Agent name should be the stem (filename without .md extension)."""
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        _make_agent(agents_dir, "code-reviewer", 10)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert result[0]["name"] == "code-reviewer"
-
-    def test_multiple_agents_sorted(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        for name in ("zzz", "aaa", "mmm"):
-            _make_agent(agents_dir, name, 5)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        names = [r["name"] for r in result]
-        assert names == sorted(names)
-
-    def test_unreadable_agent_warns_and_uses_zero(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        _make_agent(agents_dir, "broken-agent", 10)
-
-        original_read = Path.read_text
-
-        def _boom(self: Path, **kwargs: Any) -> str:  # type: ignore[override]
-            if self.suffix == ".md":
-                raise OSError("permission denied")
-            return original_read(self, **kwargs)
-
-        monkeypatch.setattr(Path, "read_text", _boom)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert result[0]["lines"] == 0
-        err = capsys.readouterr().err
-        assert "Warning" in err
-
-    def test_unicode_agent_content(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        agents_dir.mkdir()
-        content = "# αβγδ\n# 中文\n# emoji 🤖\n"
-        (agents_dir / "unicode-agent.md").write_text(content, encoding="utf-8")
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert result[0]["lines"] == 3
-
-
-# ── build_catalog ─────────────────────────────────────────────────────────────
-
-
-class TestBuildCatalog:
-    def test_empty_dirs_catalog_written(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-
-        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
-
-        catalog_path = wiki_dir / "catalog.md"
-        assert catalog_path.exists()
-        assert stats["total"] == 0
-        assert stats["skills"] == 0
-        assert stats["agents"] == 0
-        assert stats["over_180"] == 0
-        assert stats["catalog_path"] == str(catalog_path)
-
-    def test_catalog_md_header_present(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-
-        catalog_builder.build_catalog(wiki_dir, tmp_path / "s", tmp_path / "a", [])
-
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        assert "# Skill Catalog" in content
-        assert "## Summary" in content
-        assert "## All Skills" in content
-
-    def test_stats_counts_skills_and_agents(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-        _make_skill(skills_dir, "skill-a", 10)
-        _make_skill(skills_dir, "skill-b", 10)
-        _make_agent(agents_dir, "agent-x", 5)
-
-        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
-        assert stats["total"] == 3
-        assert stats["skills"] == 2
-        assert stats["agents"] == 1
-
-    def test_over_180_count_correct(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-        _make_skill(skills_dir, "short-skill", 10)
-        _make_skill(skills_dir, "long-skill", 200)
-        _make_agent(agents_dir, "fat-agent", 250)
-
-        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
-        assert stats["over_180"] == 2
-
-    def test_catalog_table_rows_present(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-        _make_skill(skills_dir, "my-skill", 10)
-        _make_agent(agents_dir, "my-agent", 5)
-
-        catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        assert "my-skill" in content
-        assert "my-agent" in content
-
-    def test_over_180_flag_in_table(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """The warning character should appear for over-threshold items."""
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "fat-skill", 200)
-
-        catalog_builder.build_catalog(wiki_dir, skills_dir, tmp_path / "a", [])
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        # The warning flag character should be present somewhere in the row
-        assert "⚠" in content  # ⚠
-
-    def test_under_threshold_no_flag(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "short", 10)
-
-        catalog_builder.build_catalog(wiki_dir, skills_dir, tmp_path / "a", [])
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        assert "⚠" not in content
-
-    def test_extra_dirs_skills_pattern(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Extra dir with SKILL.md subdirs should be treated as skills."""
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        extra = tmp_path / "extra-skills"
-        _make_skill(extra, "extra-skill", 10)
-
-        stats = catalog_builder.build_catalog(
-            wiki_dir, tmp_path / "s", tmp_path / "a", [extra]
-        )
-        assert stats["total"] == 1
-        assert stats["skills"] == 1
-
-    def test_extra_dirs_agents_pattern(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """Extra dir with flat .md files (no SKILL.md subdirs) treated as agents."""
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        extra = tmp_path / "extra-agents"
-        _make_agent(extra, "extra-agent", 10)
-
-        stats = catalog_builder.build_catalog(
-            wiki_dir, tmp_path / "s", tmp_path / "a", [extra]
-        )
-        assert stats["total"] == 1
-        assert stats["agents"] == 1
-
-    def test_extra_dir_nonexistent_skipped(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-
-        stats = catalog_builder.build_catalog(
-            wiki_dir, tmp_path / "s", tmp_path / "a",
-            [tmp_path / "ghost-dir"]
-        )
-        assert stats["total"] == 0
-
-    def test_catalog_overwrites_existing(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        catalog_path = wiki_dir / "catalog.md"
-        catalog_path.write_text("OLD CONTENT", encoding="utf-8")
-
-        catalog_builder.build_catalog(wiki_dir, tmp_path / "s", tmp_path / "a", [])
-        content = catalog_path.read_text(encoding="utf-8")
-        assert "OLD CONTENT" not in content
-        assert "# Skill Catalog" in content
-
-    def test_summary_table_total_row(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "sk", 10)
-
-        catalog_builder.build_catalog(wiki_dir, skills_dir, tmp_path / "a", [])
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        assert "Total items" in content
-        assert "| 1 |" in content
-
-    def test_catalog_path_in_stats(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-
-        stats = catalog_builder.build_catalog(wiki_dir, tmp_path / "s", tmp_path / "a", [])
-        assert stats["catalog_path"] == str(wiki_dir / "catalog.md")
-
-    def test_many_items_all_appear_in_table(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-        for i in range(5):
-            _make_skill(skills_dir, f"skill-{i}", 10 + i)
-        for i in range(3):
-            _make_agent(agents_dir, f"agent-{i}", 5 + i)
-
-        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
-        assert stats["total"] == 8
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        for i in range(5):
-            assert f"skill-{i}" in content
-        for i in range(3):
-            assert f"agent-{i}" in content
-
-
-# ── update_wiki_index ─────────────────────────────────────────────────────────
-
-
-class TestUpdateWikiIndex:
-    def _stats(self, total: int = 5) -> dict:
-        return {
-            "total": total,
-            "skills": 3,
-            "agents": 2,
-            "over_180": 1,
-            "catalog_path": "/tmp/catalog.md",
-        }
-
-    def test_no_index_md_is_noop(
-        self, tmp_path: Path
-    ) -> None:
-        """If index.md doesn't exist, function returns without error."""
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        # no index.md created — should be a silent no-op
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        assert not (wiki_dir / "index.md").exists()
-
-    def test_catalog_ref_inserted_once(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text("# Index\n\n## Skills\n\nSome content\n", encoding="utf-8")
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        content = index_path.read_text(encoding="utf-8")
-        assert content.count("[[catalog]]") == 1
-
-    def test_catalog_ref_not_duplicated_on_second_call(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text("# Index\n\n## Skills\n\n", encoding="utf-8")
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        content = index_path.read_text(encoding="utf-8")
-        assert content.count("[[catalog]]") == 1
-
-    def test_catalog_ref_inserted_under_skills_section(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text("# Index\n\n## Skills\n\n## Other\n", encoding="utf-8")
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        content = index_path.read_text(encoding="utf-8")
-        lines = content.split("\n")
-        skills_idx = next(i for i, line in enumerate(lines) if line.strip() == "## Skills")
-        catalog_idx = next(i for i, line in enumerate(lines) if "[[catalog]]" in line)
-        assert catalog_idx == skills_idx + 1
-
-    def test_catalog_ref_appended_when_no_skills_section(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text("# Index\n\nNo skills section here.\n", encoding="utf-8")
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        content = index_path.read_text(encoding="utf-8")
-        assert "[[catalog]]" in content
-
-    def test_total_pages_updated(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text(
-            "# Index\n\nTotal pages: 0\n\nLast updated: 2020-01-01\n",
-            encoding="utf-8",
-        )
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats(total=42))
-        content = index_path.read_text(encoding="utf-8")
-        assert "Total pages: 42" in content
-        assert "Total pages: 0" not in content
-
-    def test_last_updated_replaced(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text(
-            "# Index\n\nLast updated: 1999-12-31\n",
-            encoding="utf-8",
-        )
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        content = index_path.read_text(encoding="utf-8")
-        assert "Last updated: 1999-12-31" not in content
-        # The new date should match YYYY-MM-DD pattern
-        assert re.search(r"Last updated: \d{4}-\d{2}-\d{2}", content)
-
-    def test_index_with_existing_catalog_ref_updates_counts(
-        self, tmp_path: Path
-    ) -> None:
-        """Already-present [[catalog]] should not be duplicated; total should update."""
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text(
-            "# Index\n\n[[catalog]]\n\nTotal pages: 1\n",
-            encoding="utf-8",
-        )
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats(total=99))
-        content = index_path.read_text(encoding="utf-8")
-        assert content.count("[[catalog]]") == 1
-        assert "Total pages: 99" in content
-
-    def test_empty_index_md(
-        self, tmp_path: Path
-    ) -> None:
-        """Empty index.md should not raise; catalog ref is appended."""
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        index_path = wiki_dir / "index.md"
-        index_path.write_text("", encoding="utf-8")
-
-        catalog_builder.update_wiki_index(wiki_dir, self._stats())
-        content = index_path.read_text(encoding="utf-8")
-        assert "[[catalog]]" in content
-
-
-# ── append_log ────────────────────────────────────────────────────────────────
-
-
-class TestAppendLog:
-    def _stats(self) -> dict:
-        return {
-            "total": 7,
-            "skills": 4,
-            "agents": 3,
-            "over_180": 2,
-            "catalog_path": "/tmp/wiki/catalog.md",
-        }
-
-    def test_no_log_md_is_noop(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        # log.md does not exist — must not raise
-        catalog_builder.append_log(wiki_dir, self._stats())
-        assert not (wiki_dir / "log.md").exists()
-
-    def test_entry_appended_to_existing_log(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        log_path = wiki_dir / "log.md"
-        log_path.write_text("# Log\n\nOld entry.\n", encoding="utf-8")
-
-        catalog_builder.append_log(wiki_dir, self._stats())
-        content = log_path.read_text(encoding="utf-8")
-        assert "Old entry." in content
-        assert "catalog-build" in content
-
-    def test_log_contains_counts(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        log_path = wiki_dir / "log.md"
-        log_path.write_text("", encoding="utf-8")
-
-        catalog_builder.append_log(wiki_dir, self._stats())
-        content = log_path.read_text(encoding="utf-8")
-        assert "7" in content   # total
-        assert "4" in content   # skills
-        assert "3" in content   # agents
-        assert "2" in content   # over_180
-
-    def test_log_contains_catalog_path(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        (wiki_dir / "log.md").write_text("", encoding="utf-8")
-
-        catalog_builder.append_log(wiki_dir, self._stats())
-        content = (wiki_dir / "log.md").read_text(encoding="utf-8")
-        assert "/tmp/wiki/catalog.md" in content
-
-    def test_log_contains_date(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        (wiki_dir / "log.md").write_text("", encoding="utf-8")
-
-        catalog_builder.append_log(wiki_dir, self._stats())
-        content = (wiki_dir / "log.md").read_text(encoding="utf-8")
-        assert re.search(r"\d{4}-\d{2}-\d{2}", content)
-
-    def test_multiple_appends_accumulate(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        log_path = wiki_dir / "log.md"
-        log_path.write_text("", encoding="utf-8")
-
-        catalog_builder.append_log(wiki_dir, self._stats())
-        catalog_builder.append_log(wiki_dir, self._stats())
-        content = log_path.read_text(encoding="utf-8")
-        assert content.count("catalog-build") == 2
-
-    def test_empty_log_md_gets_entry(
-        self, tmp_path: Path
-    ) -> None:
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        (wiki_dir / "log.md").write_text("", encoding="utf-8")
-
-        catalog_builder.append_log(wiki_dir, self._stats())
-        content = (wiki_dir / "log.md").read_text(encoding="utf-8")
-        assert len(content) > 0
-
-
-# ── Parametric edge-case coverage ────────────────────────────────────────────
-
-
-class TestScanSkillsDirParametric:
-    @pytest.mark.parametrize("line_count", [0, 1, 179, 180, 181, 500])
-    def test_over_threshold_boundary(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, line_count: int
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        skills_dir = tmp_path / "skills"
-        _make_skill(skills_dir, "skill", line_count)
-        result = catalog_builder.scan_skills_dir(skills_dir)
-        assert result[0]["over_180"] == (line_count > 180)
-
-
-class TestScanAgentsDirParametric:
-    @pytest.mark.parametrize("line_count", [0, 1, 179, 180, 181, 500])
-    def test_over_threshold_boundary(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, line_count: int
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        agents_dir = tmp_path / "agents"
-        _make_agent(agents_dir, "agent", line_count)
-        result = catalog_builder.scan_agents_dir(agents_dir)
-        assert result[0]["over_180"] == (line_count > 180)
-
-
-class TestBuildCatalogParametric:
-    @pytest.mark.parametrize(
-        "n_skills,n_agents,expected_total",
-        [
-            (0, 0, 0),
-            (1, 0, 1),
-            (0, 1, 1),
-            (3, 3, 6),
-            (10, 5, 15),
-        ],
-    )
-    def test_total_count(
-        self,
-        tmp_path: Path,
-        monkeypatch: pytest.MonkeyPatch,
-        n_skills: int,
-        n_agents: int,
-        expected_total: int,
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-        for i in range(n_skills):
-            _make_skill(skills_dir, f"skill-{i}", 10)
-        for i in range(n_agents):
-            _make_agent(agents_dir, f"agent-{i}", 10)
-        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
-        assert stats["total"] == expected_total
-
-
-# ── main() CLI entrypoint ────────────────────────────────────────────────────
-
-
-class TestMain:
-    """Exercise the argparse entrypoint without touching real ~/.claude paths."""
-
-    def test_missing_wiki_exits_1(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki-missing"
-        # wiki_dir intentionally not created
-        monkeypatch.setattr(
-            "sys.argv",
-            [
-                "catalog_builder",
-                "--wiki", str(wiki_dir),
-                "--skills-dir", str(tmp_path / "skills"),
-                "--agents-dir", str(tmp_path / "agents"),
-            ],
-        )
-        with pytest.raises(SystemExit) as exc_info:
-            catalog_builder.main()
-        assert exc_info.value.code == 1
-        err = capsys.readouterr().err
-        assert "Wiki not initialized" in err
-
-    def test_happy_path_prints_summary(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        skills_dir = tmp_path / "skills"
-        agents_dir = tmp_path / "agents"
-        _make_skill(skills_dir, "demo-skill", 10)
-        _make_agent(agents_dir, "demo-agent", 5)
-
-        monkeypatch.setattr(
-            "sys.argv",
-            [
-                "catalog_builder",
-                "--wiki", str(wiki_dir),
-                "--skills-dir", str(skills_dir),
-                "--agents-dir", str(agents_dir),
-            ],
-        )
-        catalog_builder.main()
-        out = capsys.readouterr().out
-        assert "Catalog built:" in out
-        assert "Written to:" in out
-
-    def test_extra_dirs_passed_through(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        extra = tmp_path / "extra"
-        _make_skill(extra, "extra-skill", 10)
-
-        monkeypatch.setattr(
-            "sys.argv",
-            [
-                "catalog_builder",
-                "--wiki", str(wiki_dir),
-                "--skills-dir", str(tmp_path / "skills"),
-                "--agents-dir", str(tmp_path / "agents"),
-                "--extra-dirs", str(extra),
-            ],
-        )
-        catalog_builder.main()
-        # catalog.md should exist and reference the extra skill
-        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
-        assert "extra-skill" in content
-
-    def test_catalog_and_log_written_by_main(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-    ) -> None:
-        _patched_cfg(monkeypatch, threshold=180)
-        wiki_dir = tmp_path / "wiki"
-        wiki_dir.mkdir()
-        # Pre-create log.md and index.md so update_wiki_index/append_log have targets
-        (wiki_dir / "log.md").write_text("", encoding="utf-8")
-        (wiki_dir / "index.md").write_text("# Index\n\nTotal pages: 0\n", encoding="utf-8")
-
-        monkeypatch.setattr(
-            "sys.argv",
-            [
-                "catalog_builder",
-                "--wiki", str(wiki_dir),
-                "--skills-dir", str(tmp_path / "skills"),
-                "--agents-dir", str(tmp_path / "agents"),
-            ],
-        )
-        catalog_builder.main()
-        assert (wiki_dir / "catalog.md").exists()
-        log_content = (wiki_dir / "log.md").read_text(encoding="utf-8")
-        assert "catalog-build" in log_content
+"""
+test_catalog_builder.py -- Coverage for catalog_builder.py (226 LOC).
+
+catalog_builder scans skills and agents directories, builds catalog.md,
+and optionally updates index.md and log.md inside the wiki. A regression
+in any of the four public functions silently corrupts the master index
+used by every downstream router call, so each branch is explicitly covered.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+import catalog_builder
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+
+def _make_skill(base: Path, name: str, line_count: int) -> Path:
+    """Create skills_dir/<name>/SKILL.md with the requested number of lines."""
+    d = base / name
+    d.mkdir(parents=True, exist_ok=True)
+    content = "\n".join(f"# line {i}" for i in range(line_count))
+    (d / "SKILL.md").write_text(content, encoding="utf-8")
+    return d
+
+
+def _make_agent(base: Path, name: str, line_count: int) -> Path:
+    """Create agents_dir/<name>.md with the requested number of lines."""
+    base.mkdir(parents=True, exist_ok=True)
+    content = "\n".join(f"# line {i}" for i in range(line_count))
+    p = base / f"{name}.md"
+    p.write_text(content, encoding="utf-8")
+    return p
+
+
+def _patched_cfg(monkeypatch: pytest.MonkeyPatch, threshold: int = 180) -> MagicMock:
+    """Return a mock cfg with a configurable line_threshold."""
+    fake = MagicMock()
+    fake.line_threshold = threshold
+    monkeypatch.setattr(catalog_builder, "cfg", fake)
+    return fake
+
+
+# ── scan_skills_dir ───────────────────────────────────────────────────────────
+
+
+class TestScanSkillsDir:
+    def test_nonexistent_dir_returns_empty(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch)
+        result = catalog_builder.scan_skills_dir(tmp_path / "does-not-exist")
+        assert result == []
+
+    def test_empty_dir_returns_empty(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch)
+        skills_dir = tmp_path / "skills"
+        skills_dir.mkdir()
+        assert catalog_builder.scan_skills_dir(skills_dir) == []
+
+    def test_dir_without_skill_md_skipped(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch)
+        skills_dir = tmp_path / "skills"
+        (skills_dir / "no-skill-md").mkdir(parents=True)
+        # directory exists but has no SKILL.md
+        assert catalog_builder.scan_skills_dir(skills_dir) == []
+
+    def test_flat_file_in_skills_dir_skipped(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Regular .md files at the top level of skills_dir are not skills."""
+        _patched_cfg(monkeypatch)
+        skills_dir = tmp_path / "skills"
+        skills_dir.mkdir()
+        (skills_dir / "flat.md").write_text("# flat", encoding="utf-8")
+        assert catalog_builder.scan_skills_dir(skills_dir) == []
+
+    def test_single_skill_parsed(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "my-skill", 10)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert len(result) == 1
+        r = result[0]
+        assert r["name"] == "my-skill"
+        assert r["type"] == "skill"
+        assert r["lines"] == 10
+        assert r["over_180"] is False
+        assert "SKILL.md" in r["path"]
+
+    def test_over_threshold_flag(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "fat-skill", 200)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["over_180"] is True
+
+    def test_exactly_at_threshold_not_over(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "boundary-skill", 180)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["over_180"] is False
+
+    def test_one_above_threshold_is_over(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "just-over", 181)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["over_180"] is True
+
+    def test_multiple_skills_sorted(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "zebra", 5)
+        _make_skill(skills_dir, "alpha", 5)
+        _make_skill(skills_dir, "middle", 5)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        names = [r["name"] for r in result]
+        assert names == sorted(names)
+
+    def test_empty_skill_md_yields_zero_lines(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        d = skills_dir / "empty-skill"
+        d.mkdir(parents=True)
+        (d / "SKILL.md").write_text("", encoding="utf-8")
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["lines"] == 0
+
+    def test_unicode_content_handled(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        d = skills_dir / "unicode-skill"
+        d.mkdir(parents=True)
+        content = "# 日本語\n# Ärger\n# emoji 🐍\n"
+        (d / "SKILL.md").write_text(content, encoding="utf-8")
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["lines"] == 3
+
+    def test_unreadable_skill_warns_and_uses_zero(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        """When read_text raises, lines falls back to 0 and a warning goes to stderr."""
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        d = skills_dir / "bad-skill"
+        d.mkdir(parents=True)
+        skill_md = d / "SKILL.md"
+        skill_md.write_text("content", encoding="utf-8")
+
+        original_read = Path.read_text
+
+        def _boom(self: Path, **kwargs: Any) -> str:  # type: ignore[override]
+            if self.name == "SKILL.md":
+                raise OSError("permission denied")
+            return original_read(self, **kwargs)
+
+        monkeypatch.setattr(Path, "read_text", _boom)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["lines"] == 0
+        err = capsys.readouterr().err
+        assert "Warning" in err
+
+
+# ── scan_agents_dir ───────────────────────────────────────────────────────────
+
+
+class TestScanAgentsDir:
+    def test_nonexistent_dir_returns_empty(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch)
+        result = catalog_builder.scan_agents_dir(tmp_path / "no-agents")
+        assert result == []
+
+    def test_empty_dir_returns_empty(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch)
+        agents_dir = tmp_path / "agents"
+        agents_dir.mkdir()
+        assert catalog_builder.scan_agents_dir(agents_dir) == []
+
+    def test_non_md_files_ignored(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch)
+        agents_dir = tmp_path / "agents"
+        agents_dir.mkdir()
+        (agents_dir / "script.py").write_text("x=1", encoding="utf-8")
+        (agents_dir / "data.json").write_text("{}", encoding="utf-8")
+        assert catalog_builder.scan_agents_dir(agents_dir) == []
+
+    def test_single_agent_parsed(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        _make_agent(agents_dir, "my-agent", 50)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert len(result) == 1
+        r = result[0]
+        assert r["name"] == "my-agent"
+        assert r["type"] == "agent"
+        assert r["lines"] == 50
+        assert r["over_180"] is False
+        assert r["path"].endswith("my-agent.md")
+
+    def test_over_threshold_flag(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        _make_agent(agents_dir, "fat-agent", 200)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert result[0]["over_180"] is True
+
+    def test_exactly_at_threshold_not_over(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        _make_agent(agents_dir, "boundary", 180)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert result[0]["over_180"] is False
+
+    def test_stem_used_as_name(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Agent name should be the stem (filename without .md extension)."""
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        _make_agent(agents_dir, "code-reviewer", 10)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert result[0]["name"] == "code-reviewer"
+
+    def test_multiple_agents_sorted(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        for name in ("zzz", "aaa", "mmm"):
+            _make_agent(agents_dir, name, 5)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        names = [r["name"] for r in result]
+        assert names == sorted(names)
+
+    def test_unreadable_agent_warns_and_uses_zero(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        _make_agent(agents_dir, "broken-agent", 10)
+
+        original_read = Path.read_text
+
+        def _boom(self: Path, **kwargs: Any) -> str:  # type: ignore[override]
+            if self.suffix == ".md":
+                raise OSError("permission denied")
+            return original_read(self, **kwargs)
+
+        monkeypatch.setattr(Path, "read_text", _boom)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert result[0]["lines"] == 0
+        err = capsys.readouterr().err
+        assert "Warning" in err
+
+    def test_unicode_agent_content(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        agents_dir.mkdir()
+        content = "# αβγδ\n# 中文\n# emoji 🤖\n"
+        (agents_dir / "unicode-agent.md").write_text(content, encoding="utf-8")
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert result[0]["lines"] == 3
+
+
+# ── build_catalog ─────────────────────────────────────────────────────────────
+
+
+class TestBuildCatalog:
+    def test_empty_dirs_catalog_written(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+
+        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+
+        catalog_path = wiki_dir / "catalog.md"
+        assert catalog_path.exists()
+        assert stats["total"] == 0
+        assert stats["skills"] == 0
+        assert stats["agents"] == 0
+        assert stats["over_180"] == 0
+        assert stats["catalog_path"] == str(catalog_path)
+
+    def test_catalog_md_header_present(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+
+        catalog_builder.build_catalog(wiki_dir, tmp_path / "s", tmp_path / "a", [])
+
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        assert "# Skill Catalog" in content
+        assert "## Summary" in content
+        assert "## All Skills" in content
+
+    def test_stats_counts_skills_and_agents(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        _make_skill(skills_dir, "skill-a", 10)
+        _make_skill(skills_dir, "skill-b", 10)
+        _make_agent(agents_dir, "agent-x", 5)
+
+        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+        assert stats["total"] == 3
+        assert stats["skills"] == 2
+        assert stats["agents"] == 1
+
+    def test_over_180_count_correct(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        _make_skill(skills_dir, "short-skill", 10)
+        _make_skill(skills_dir, "long-skill", 200)
+        _make_agent(agents_dir, "fat-agent", 250)
+
+        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+        assert stats["over_180"] == 2
+
+    def test_catalog_table_rows_present(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        _make_skill(skills_dir, "my-skill", 10)
+        _make_agent(agents_dir, "my-agent", 5)
+
+        catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        assert "my-skill" in content
+        assert "my-agent" in content
+
+    def test_over_180_flag_in_table(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """The warning character should appear for over-threshold items."""
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "fat-skill", 200)
+
+        catalog_builder.build_catalog(wiki_dir, skills_dir, tmp_path / "a", [])
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        # The warning flag character should be present somewhere in the row
+        assert "⚠" in content  # ⚠
+
+    def test_under_threshold_no_flag(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "short", 10)
+
+        catalog_builder.build_catalog(wiki_dir, skills_dir, tmp_path / "a", [])
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        assert "⚠" not in content
+
+    def test_extra_dirs_skills_pattern(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Extra dir with SKILL.md subdirs should be treated as skills."""
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        extra = tmp_path / "extra-skills"
+        _make_skill(extra, "extra-skill", 10)
+
+        stats = catalog_builder.build_catalog(
+            wiki_dir, tmp_path / "s", tmp_path / "a", [extra]
+        )
+        assert stats["total"] == 1
+        assert stats["skills"] == 1
+
+    def test_extra_dirs_agents_pattern(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Extra dir with flat .md files (no SKILL.md subdirs) treated as agents."""
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        extra = tmp_path / "extra-agents"
+        _make_agent(extra, "extra-agent", 10)
+
+        stats = catalog_builder.build_catalog(
+            wiki_dir, tmp_path / "s", tmp_path / "a", [extra]
+        )
+        assert stats["total"] == 1
+        assert stats["agents"] == 1
+
+    def test_extra_dir_nonexistent_skipped(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+
+        stats = catalog_builder.build_catalog(
+            wiki_dir, tmp_path / "s", tmp_path / "a",
+            [tmp_path / "ghost-dir"]
+        )
+        assert stats["total"] == 0
+
+    def test_catalog_overwrites_existing(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        catalog_path = wiki_dir / "catalog.md"
+        catalog_path.write_text("OLD CONTENT", encoding="utf-8")
+
+        catalog_builder.build_catalog(wiki_dir, tmp_path / "s", tmp_path / "a", [])
+        content = catalog_path.read_text(encoding="utf-8")
+        assert "OLD CONTENT" not in content
+        assert "# Skill Catalog" in content
+
+    def test_summary_table_total_row(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "sk", 10)
+
+        catalog_builder.build_catalog(wiki_dir, skills_dir, tmp_path / "a", [])
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        assert "Total items" in content
+        assert "| 1 |" in content
+
+    def test_catalog_path_in_stats(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+
+        stats = catalog_builder.build_catalog(wiki_dir, tmp_path / "s", tmp_path / "a", [])
+        assert stats["catalog_path"] == str(wiki_dir / "catalog.md")
+
+    def test_many_items_all_appear_in_table(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        for i in range(5):
+            _make_skill(skills_dir, f"skill-{i}", 10 + i)
+        for i in range(3):
+            _make_agent(agents_dir, f"agent-{i}", 5 + i)
+
+        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+        assert stats["total"] == 8
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        for i in range(5):
+            assert f"skill-{i}" in content
+        for i in range(3):
+            assert f"agent-{i}" in content
+
+
+# ── update_wiki_index ─────────────────────────────────────────────────────────
+
+
+class TestUpdateWikiIndex:
+    def _stats(self, total: int = 5) -> dict:
+        return {
+            "total": total,
+            "skills": 3,
+            "agents": 2,
+            "over_180": 1,
+            "catalog_path": "/tmp/catalog.md",
+        }
+
+    def test_no_index_md_is_noop(
+        self, tmp_path: Path
+    ) -> None:
+        """If index.md doesn't exist, function returns without error."""
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        # no index.md created — should be a silent no-op
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        assert not (wiki_dir / "index.md").exists()
+
+    def test_catalog_ref_inserted_once(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text("# Index\n\n## Skills\n\nSome content\n", encoding="utf-8")
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        content = index_path.read_text(encoding="utf-8")
+        assert content.count("[[catalog]]") == 1
+
+    def test_catalog_ref_not_duplicated_on_second_call(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text("# Index\n\n## Skills\n\n", encoding="utf-8")
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        content = index_path.read_text(encoding="utf-8")
+        assert content.count("[[catalog]]") == 1
+
+    def test_catalog_ref_inserted_under_skills_section(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text("# Index\n\n## Skills\n\n## Other\n", encoding="utf-8")
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        content = index_path.read_text(encoding="utf-8")
+        lines = content.split("\n")
+        skills_idx = next(i for i, line in enumerate(lines) if line.strip() == "## Skills")
+        catalog_idx = next(i for i, line in enumerate(lines) if "[[catalog]]" in line)
+        assert catalog_idx == skills_idx + 1
+
+    def test_catalog_ref_appended_when_no_skills_section(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text("# Index\n\nNo skills section here.\n", encoding="utf-8")
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        content = index_path.read_text(encoding="utf-8")
+        assert "[[catalog]]" in content
+
+    def test_total_pages_updated(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text(
+            "# Index\n\nTotal pages: 0\n\nLast updated: 2020-01-01\n",
+            encoding="utf-8",
+        )
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats(total=42))
+        content = index_path.read_text(encoding="utf-8")
+        assert "Total pages: 42" in content
+        assert "Total pages: 0" not in content
+
+    def test_last_updated_replaced(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text(
+            "# Index\n\nLast updated: 1999-12-31\n",
+            encoding="utf-8",
+        )
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        content = index_path.read_text(encoding="utf-8")
+        assert "Last updated: 1999-12-31" not in content
+        # The new date should match YYYY-MM-DD pattern
+        assert re.search(r"Last updated: \d{4}-\d{2}-\d{2}", content)
+
+    def test_index_with_existing_catalog_ref_updates_counts(
+        self, tmp_path: Path
+    ) -> None:
+        """Already-present [[catalog]] should not be duplicated; total should update."""
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text(
+            "# Index\n\n[[catalog]]\n\nTotal pages: 1\n",
+            encoding="utf-8",
+        )
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats(total=99))
+        content = index_path.read_text(encoding="utf-8")
+        assert content.count("[[catalog]]") == 1
+        assert "Total pages: 99" in content
+
+    def test_empty_index_md(
+        self, tmp_path: Path
+    ) -> None:
+        """Empty index.md should not raise; catalog ref is appended."""
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        index_path = wiki_dir / "index.md"
+        index_path.write_text("", encoding="utf-8")
+
+        catalog_builder.update_wiki_index(wiki_dir, self._stats())
+        content = index_path.read_text(encoding="utf-8")
+        assert "[[catalog]]" in content
+
+
+# ── append_log ────────────────────────────────────────────────────────────────
+
+
+class TestAppendLog:
+    def _stats(self) -> dict:
+        return {
+            "total": 7,
+            "skills": 4,
+            "agents": 3,
+            "over_180": 2,
+            "catalog_path": "/tmp/wiki/catalog.md",
+        }
+
+    def test_no_log_md_is_noop(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        # log.md does not exist — must not raise
+        catalog_builder.append_log(wiki_dir, self._stats())
+        assert not (wiki_dir / "log.md").exists()
+
+    def test_entry_appended_to_existing_log(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        log_path = wiki_dir / "log.md"
+        log_path.write_text("# Log\n\nOld entry.\n", encoding="utf-8")
+
+        catalog_builder.append_log(wiki_dir, self._stats())
+        content = log_path.read_text(encoding="utf-8")
+        assert "Old entry." in content
+        assert "catalog-build" in content
+
+    def test_log_contains_counts(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        log_path = wiki_dir / "log.md"
+        log_path.write_text("", encoding="utf-8")
+
+        catalog_builder.append_log(wiki_dir, self._stats())
+        content = log_path.read_text(encoding="utf-8")
+        assert "7" in content   # total
+        assert "4" in content   # skills
+        assert "3" in content   # agents
+        assert "2" in content   # over_180
+
+    def test_log_contains_catalog_path(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        (wiki_dir / "log.md").write_text("", encoding="utf-8")
+
+        catalog_builder.append_log(wiki_dir, self._stats())
+        content = (wiki_dir / "log.md").read_text(encoding="utf-8")
+        assert "/tmp/wiki/catalog.md" in content
+
+    def test_log_contains_date(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        (wiki_dir / "log.md").write_text("", encoding="utf-8")
+
+        catalog_builder.append_log(wiki_dir, self._stats())
+        content = (wiki_dir / "log.md").read_text(encoding="utf-8")
+        assert re.search(r"\d{4}-\d{2}-\d{2}", content)
+
+    def test_multiple_appends_accumulate(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        log_path = wiki_dir / "log.md"
+        log_path.write_text("", encoding="utf-8")
+
+        catalog_builder.append_log(wiki_dir, self._stats())
+        catalog_builder.append_log(wiki_dir, self._stats())
+        content = log_path.read_text(encoding="utf-8")
+        assert content.count("catalog-build") == 2
+
+    def test_empty_log_md_gets_entry(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        (wiki_dir / "log.md").write_text("", encoding="utf-8")
+
+        catalog_builder.append_log(wiki_dir, self._stats())
+        content = (wiki_dir / "log.md").read_text(encoding="utf-8")
+        assert len(content) > 0
+
+
+# ── Parametric edge-case coverage ──────────────────────────────────────────��─
+
+
+class TestScanSkillsDirParametric:
+    @pytest.mark.parametrize("line_count", [0, 1, 179, 180, 181, 500])
+    def test_over_threshold_boundary(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, line_count: int
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        skills_dir = tmp_path / "skills"
+        _make_skill(skills_dir, "skill", line_count)
+        result = catalog_builder.scan_skills_dir(skills_dir)
+        assert result[0]["over_180"] == (line_count > 180)
+
+
+class TestScanAgentsDirParametric:
+    @pytest.mark.parametrize("line_count", [0, 1, 179, 180, 181, 500])
+    def test_over_threshold_boundary(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, line_count: int
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        agents_dir = tmp_path / "agents"
+        _make_agent(agents_dir, "agent", line_count)
+        result = catalog_builder.scan_agents_dir(agents_dir)
+        assert result[0]["over_180"] == (line_count > 180)
+
+
+class TestBuildCatalogParametric:
+    @pytest.mark.parametrize(
+        "n_skills,n_agents,expected_total",
+        [
+            (0, 0, 0),
+            (1, 0, 1),
+            (0, 1, 1),
+            (3, 3, 6),
+            (10, 5, 15),
+        ],
+    )
+    def test_total_count(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        n_skills: int,
+        n_agents: int,
+        expected_total: int,
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        for i in range(n_skills):
+            _make_skill(skills_dir, f"skill-{i}", 10)
+        for i in range(n_agents):
+            _make_agent(agents_dir, f"agent-{i}", 10)
+        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+        assert stats["total"] == expected_total
+
+
+# ── main() CLI entrypoint ────────────────────────────────────────────────────
+
+
+class TestMain:
+    """Exercise the argparse entrypoint without touching real ~/.claude paths."""
+
+    def test_missing_wiki_exits_1(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki-missing"
+        # wiki_dir intentionally not created
+        monkeypatch.setattr(
+            "sys.argv",
+            [
+                "catalog_builder",
+                "--wiki", str(wiki_dir),
+                "--skills-dir", str(tmp_path / "skills"),
+                "--agents-dir", str(tmp_path / "agents"),
+            ],
+        )
+        with pytest.raises(SystemExit) as exc_info:
+            catalog_builder.main()
+        assert exc_info.value.code == 1
+        err = capsys.readouterr().err
+        assert "Wiki not initialized" in err
+
+    def test_happy_path_prints_summary(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        _make_skill(skills_dir, "demo-skill", 10)
+        _make_agent(agents_dir, "demo-agent", 5)
+
+        monkeypatch.setattr(
+            "sys.argv",
+            [
+                "catalog_builder",
+                "--wiki", str(wiki_dir),
+                "--skills-dir", str(skills_dir),
+                "--agents-dir", str(agents_dir),
+            ],
+        )
+        catalog_builder.main()
+        out = capsys.readouterr().out
+        assert "Catalog built:" in out
+        assert "Written to:" in out
+
+    def test_extra_dirs_passed_through(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        extra = tmp_path / "extra"
+        _make_skill(extra, "extra-skill", 10)
+
+        monkeypatch.setattr(
+            "sys.argv",
+            [
+                "catalog_builder",
+                "--wiki", str(wiki_dir),
+                "--skills-dir", str(tmp_path / "skills"),
+                "--agents-dir", str(tmp_path / "agents"),
+                "--extra-dirs", str(extra),
+            ],
+        )
+        catalog_builder.main()
+        # catalog.md should exist and reference the extra skill
+        content = (wiki_dir / "catalog.md").read_text(encoding="utf-8")
+        assert "extra-skill" in content
+
+    def test_catalog_and_log_written_by_main(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        wiki_dir.mkdir()
+        # Pre-create log.md and index.md so update_wiki_index/append_log have targets
+        (wiki_dir / "log.md").write_text("", encoding="utf-8")
+        (wiki_dir / "index.md").write_text("# Index\n\nTotal pages: 0\n", encoding="utf-8")
+
+        monkeypatch.setattr(
+            "sys.argv",
+            [
+                "catalog_builder",
+                "--wiki", str(wiki_dir),
+                "--skills-dir", str(tmp_path / "skills"),
+                "--agents-dir", str(tmp_path / "agents"),
+            ],
+        )
+        catalog_builder.main()
+        assert (wiki_dir / "catalog.md").exists()
+        log_content = (wiki_dir / "log.md").read_text(encoding="utf-8")
+        assert "catalog-build" in log_content

src/tests/test_change_detector.py

@@ -1,869 +1,869 @@
-"""
-test_change_detector.py -- Coverage sprint for change_detector.py.
-
-change_detector is a pure-function diff engine: it hashes live files,
-loads a manifest from the last snapshot directory, and returns a
-ChangeReport dataclass.  No filesystem writes, no subprocess calls.
-
-Tests are grouped by the internal helper they exercise so regressions
-surface at the exact layer where they occur.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-import change_detector
-from backup_config import BackupConfig, BackupTree
-
-
-# ── Helpers ──────────────────────────────────────────────────────────────────
-
-
-def _default_cfg(**kwargs: Any) -> BackupConfig:
-    """Return a BackupConfig with trees=() and memory_glob=False by default."""
-    base = {
-        "top_files": (),
-        "trees": (),
-        "memory_glob": False,
-    }
-    base.update(kwargs)
-    return BackupConfig(**base)  # type: ignore[arg-type]
-
-
-def _manifest_json(
-    entries: list[dict[str, Any]],
-    snapshot_id: str = "snap-001",
-) -> str:
-    return json.dumps({"snapshot_id": snapshot_id, "entries": entries})
-
-
-# ── TestChangeReport ─────────────────────────────────────────────────────────
-
-
-class TestChangeReport:
-    """Unit tests for the ChangeReport dataclass properties and methods."""
-
-    def test_has_changes_false_when_all_empty(self) -> None:
-        r = change_detector.ChangeReport(
-            new=(), changed=(), removed=(), unchanged=5, baseline_snapshot="x"
-        )
-        assert r.has_changes is False
-
-    def test_has_changes_true_when_new(self) -> None:
-        r = change_detector.ChangeReport(
-            new=("a.txt",), changed=(), removed=(), unchanged=0, baseline_snapshot=None
-        )
-        assert r.has_changes is True
-
-    def test_has_changes_true_when_changed(self) -> None:
-        r = change_detector.ChangeReport(
-            new=(), changed=("b.txt",), removed=(), unchanged=3, baseline_snapshot="x"
-        )
-        assert r.has_changes is True
-
-    def test_has_changes_true_when_removed(self) -> None:
-        r = change_detector.ChangeReport(
-            new=(), changed=(), removed=("c.txt",), unchanged=2, baseline_snapshot="x"
-        )
-        assert r.has_changes is True
-
-    def test_total_current_sums_new_changed_unchanged(self) -> None:
-        r = change_detector.ChangeReport(
-            new=("a",), changed=("b", "c"), removed=("z",), unchanged=7, baseline_snapshot="x"
-        )
-        # removed does NOT count toward total_current
-        assert r.total_current == 1 + 2 + 7
-
-    def test_total_current_zero_when_nothing_tracked(self) -> None:
-        r = change_detector.ChangeReport(
-            new=(), changed=(), removed=(), unchanged=0, baseline_snapshot=None
-        )
-        assert r.total_current == 0
-
-    def test_to_dict_includes_computed_properties(self) -> None:
-        r = change_detector.ChangeReport(
-            new=("f",), changed=(), removed=(), unchanged=2, baseline_snapshot="s1"
-        )
-        d = r.to_dict()
-        assert d["has_changes"] is True
-        assert d["total_current"] == 3
-        assert d["new"] == ("f",)
-        assert d["baseline_snapshot"] == "s1"
-
-    def test_to_dict_has_changes_false_path(self) -> None:
-        r = change_detector.ChangeReport(
-            new=(), changed=(), removed=(), unchanged=1, baseline_snapshot="s1"
-        )
-        d = r.to_dict()
-        assert d["has_changes"] is False
-        assert d["total_current"] == 1
-
-    def test_report_is_frozen_dataclass(self) -> None:
-        r = change_detector.ChangeReport(
-            new=(), changed=(), removed=(), unchanged=0, baseline_snapshot=None
-        )
-        with pytest.raises((AttributeError, TypeError)):
-            r.unchanged = 99  # type: ignore[misc]
-
-
-# ── TestSha256File ────────────────────────────────────────────────────────────
-
-
-class TestSha256File:
-    """Tests for the internal _sha256_file helper."""
-
-    def test_known_content_matches_expected_digest(self, tmp_path: Path) -> None:
-        f = tmp_path / "known.txt"
-        f.write_bytes(b"hello world")
-        expected = hashlib.sha256(b"hello world").hexdigest()
-        assert change_detector._sha256_file(f) == expected
-
-    def test_empty_file_has_stable_digest(self, tmp_path: Path) -> None:
-        f = tmp_path / "empty.bin"
-        f.write_bytes(b"")
-        digest = change_detector._sha256_file(f)
-        assert digest == hashlib.sha256(b"").hexdigest()
-
-    def test_same_content_same_digest(self, tmp_path: Path) -> None:
-        f1 = tmp_path / "a.txt"
-        f2 = tmp_path / "b.txt"
-        f1.write_bytes(b"content")
-        f2.write_bytes(b"content")
-        assert change_detector._sha256_file(f1) == change_detector._sha256_file(f2)
-
-    def test_different_content_different_digest(self, tmp_path: Path) -> None:
-        f1 = tmp_path / "a.txt"
-        f2 = tmp_path / "b.txt"
-        f1.write_bytes(b"content-A")
-        f2.write_bytes(b"content-B")
-        assert change_detector._sha256_file(f1) != change_detector._sha256_file(f2)
-
-    def test_single_byte_change_changes_digest(self, tmp_path: Path) -> None:
-        f = tmp_path / "data.bin"
-        f.write_bytes(b"abcdefgh")
-        d1 = change_detector._sha256_file(f)
-        f.write_bytes(b"abcdefgX")
-        d2 = change_detector._sha256_file(f)
-        assert d1 != d2
-
-    def test_symlink_returns_none(self, tmp_path: Path) -> None:
-        target = tmp_path / "real.txt"
-        target.write_bytes(b"data")
-        link = tmp_path / "link.txt"
-        try:
-            link.symlink_to(target)
-        except (OSError, NotImplementedError):
-            pytest.skip("symlinks not supported on this platform")
-        assert change_detector._sha256_file(link) is None
-
-    def test_missing_file_returns_none(self, tmp_path: Path) -> None:
-        assert change_detector._sha256_file(tmp_path / "ghost.txt") is None
-
-    def test_returns_lowercase_hex_string(self, tmp_path: Path) -> None:
-        f = tmp_path / "f.bin"
-        f.write_bytes(b"\xff\xfe")
-        digest = change_detector._sha256_file(f)
-        assert digest is not None
-        assert digest == digest.lower()
-        assert len(digest) == 64
-
-
-# ── TestIterTopFiles ──────────────────────────────────────────────────────────
-
-
-class TestIterTopFiles:
-    """Tests for _iter_top_files."""
-
-    def test_yields_existing_regular_files(self, tmp_path: Path) -> None:
-        (tmp_path / "settings.json").write_text("{}", encoding="utf-8")
-        cfg = _default_cfg(top_files=("settings.json",))
-        results = list(change_detector._iter_top_files(cfg, tmp_path))
-        assert len(results) == 1
-        name, path = results[0]
-        assert name == "settings.json"
-        assert path == tmp_path / "settings.json"
-
-    def test_missing_file_not_yielded(self, tmp_path: Path) -> None:
-        cfg = _default_cfg(top_files=("missing.json",))
-        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
-
-    def test_symlink_not_yielded(self, tmp_path: Path) -> None:
-        target = tmp_path / "real.json"
-        target.write_text("{}", encoding="utf-8")
-        link = tmp_path / "link.json"
-        try:
-            link.symlink_to(target)
-        except (OSError, NotImplementedError):
-            pytest.skip("symlinks not supported on this platform")
-        cfg = _default_cfg(top_files=("link.json",))
-        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
-
-    def test_empty_top_files_yields_nothing(self, tmp_path: Path) -> None:
-        cfg = _default_cfg(top_files=())
-        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
-
-    def test_multiple_files_all_yielded(self, tmp_path: Path) -> None:
-        for name in ("a.json", "b.md", "c.json"):
-            (tmp_path / name).write_text("x", encoding="utf-8")
-        cfg = _default_cfg(top_files=("a.json", "b.md", "c.json"))
-        names = [n for n, _ in change_detector._iter_top_files(cfg, tmp_path)]
-        assert sorted(names) == ["a.json", "b.md", "c.json"]
-
-    def test_directory_not_yielded(self, tmp_path: Path) -> None:
-        (tmp_path / "notafile").mkdir()
-        cfg = _default_cfg(top_files=("notafile",))
-        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
-
-
-# ── TestIterTreeFiles ─────────────────────────────────────────────────────────
-
-
-class TestIterTreeFiles:
-    """Tests for _iter_tree_files."""
-
-    def _make_tree(self, base: Path, subpath: str, content: bytes = b"data") -> Path:
-        p = base / subpath
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_bytes(content)
-        return p
-
-    def test_yields_files_under_tree(self, tmp_path: Path) -> None:
-        self._make_tree(tmp_path, "skills/python/SKILL.md")
-        cfg = _default_cfg(trees=(BackupTree(src="skills", dest="skills"),))
-        results = list(change_detector._iter_tree_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "skills/python/SKILL.md" in dest_rels
-
-    def test_missing_tree_root_yields_nothing(self, tmp_path: Path) -> None:
-        cfg = _default_cfg(trees=(BackupTree(src="nonexistent", dest="nonexistent"),))
-        assert list(change_detector._iter_tree_files(cfg, tmp_path)) == []
-
-    def test_file_exceeding_max_bytes_skipped(self, tmp_path: Path) -> None:
-        big = tmp_path / "agents" / "big.md"
-        big.parent.mkdir(parents=True)
-        big.write_bytes(b"x" * 100)
-        cfg = _default_cfg(
-            trees=(BackupTree(src="agents", dest="agents"),),
-            max_file_bytes=50,
-        )
-        assert list(change_detector._iter_tree_files(cfg, tmp_path)) == []
-
-    def test_file_exactly_at_max_bytes_included(self, tmp_path: Path) -> None:
-        f = tmp_path / "agents" / "exact.md"
-        f.parent.mkdir(parents=True)
-        f.write_bytes(b"x" * 50)
-        cfg = _default_cfg(
-            trees=(BackupTree(src="agents", dest="agents"),),
-            max_file_bytes=50,
-        )
-        results = list(change_detector._iter_tree_files(cfg, tmp_path))
-        assert len(results) == 1
-
-    def test_symlink_file_skipped(self, tmp_path: Path) -> None:
-        target = tmp_path / "agents" / "real.md"
-        target.parent.mkdir(parents=True)
-        target.write_bytes(b"content")
-        link = tmp_path / "agents" / "link.md"
-        try:
-            link.symlink_to(target)
-        except (OSError, NotImplementedError):
-            pytest.skip("symlinks not supported on this platform")
-        cfg = _default_cfg(trees=(BackupTree(src="agents", dest="agents"),))
-        # Only the real file should appear, not the symlink.
-        results = list(change_detector._iter_tree_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "agents/link.md" not in dest_rels
-        assert "agents/real.md" in dest_rels
-
-    def test_dest_rel_uses_tree_dest_prefix(self, tmp_path: Path) -> None:
-        self._make_tree(tmp_path, "raw_agents/subdir/file.md")
-        cfg = _default_cfg(trees=(BackupTree(src="raw_agents", dest="my_agents"),))
-        results = list(change_detector._iter_tree_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "my_agents/subdir/file.md" in dest_rels
-
-    def test_empty_trees_yields_nothing(self, tmp_path: Path) -> None:
-        cfg = _default_cfg(trees=())
-        assert list(change_detector._iter_tree_files(cfg, tmp_path)) == []
-
-    def test_nested_subdirectories_walked(self, tmp_path: Path) -> None:
-        for subpath in ("skills/a/b/c/deep.md", "skills/top.md"):
-            self._make_tree(tmp_path, subpath)
-        cfg = _default_cfg(trees=(BackupTree(src="skills", dest="skills"),))
-        results = list(change_detector._iter_tree_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "skills/a/b/c/deep.md" in dest_rels
-        assert "skills/top.md" in dest_rels
-
-
-# ── TestIterMemoryFiles ───────────────────────────────────────────────────────
-
-
-class TestIterMemoryFiles:
-    """Tests for _iter_memory_files."""
-
-    def _make_memory_file(
-        self, base: Path, slug: str, filename: str, content: bytes = b"mem"
-    ) -> Path:
-        p = base / "projects" / slug / "memory" / filename
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_bytes(content)
-        return p
-
-    def test_memory_glob_false_yields_nothing(self, tmp_path: Path) -> None:
-        self._make_memory_file(tmp_path, "proj-slug", "MEMORY.md")
-        cfg = _default_cfg(memory_glob=False)
-        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
-
-    def test_missing_projects_dir_yields_nothing(self, tmp_path: Path) -> None:
-        cfg = _default_cfg(memory_glob=True)
-        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
-
-    def test_yields_memory_files_under_projects(self, tmp_path: Path) -> None:
-        self._make_memory_file(tmp_path, "my-proj", "NOTE.md")
-        cfg = _default_cfg(memory_glob=True)
-        results = list(change_detector._iter_memory_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "memory/my-proj/NOTE.md" in dest_rels
-
-    def test_dest_rel_includes_slug_and_filename(self, tmp_path: Path) -> None:
-        self._make_memory_file(tmp_path, "alpha", "a.md")
-        self._make_memory_file(tmp_path, "beta", "b.md")
-        cfg = _default_cfg(memory_glob=True)
-        results = list(change_detector._iter_memory_files(cfg, tmp_path))
-        dest_rels = {d for d, _ in results}
-        assert "memory/alpha/a.md" in dest_rels
-        assert "memory/beta/b.md" in dest_rels
-
-    def test_file_exceeding_max_bytes_skipped(self, tmp_path: Path) -> None:
-        self._make_memory_file(tmp_path, "proj", "big.md", content=b"x" * 200)
-        cfg = _default_cfg(memory_glob=True, max_file_bytes=100)
-        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
-
-    def test_symlink_memory_file_skipped(self, tmp_path: Path) -> None:
-        target = self._make_memory_file(tmp_path, "proj", "real.md")
-        link = tmp_path / "projects" / "proj" / "memory" / "link.md"
-        try:
-            link.symlink_to(target)
-        except (OSError, NotImplementedError):
-            pytest.skip("symlinks not supported on this platform")
-        cfg = _default_cfg(memory_glob=True)
-        results = list(change_detector._iter_memory_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "memory/proj/link.md" not in dest_rels
-        assert "memory/proj/real.md" in dest_rels
-
-    def test_project_file_not_dir_ignored(self, tmp_path: Path) -> None:
-        """A file directly inside projects/ (not a dir) must be skipped."""
-        projects = tmp_path / "projects"
-        projects.mkdir(parents=True)
-        (projects / "stray-file.txt").write_text("x", encoding="utf-8")
-        cfg = _default_cfg(memory_glob=True)
-        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
-
-    def test_slug_without_memory_subdir_skipped(self, tmp_path: Path) -> None:
-        slug_dir = tmp_path / "projects" / "no-memory"
-        slug_dir.mkdir(parents=True)
-        cfg = _default_cfg(memory_glob=True)
-        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
-
-    def test_nested_memory_path_dest_rel(self, tmp_path: Path) -> None:
-        nested = tmp_path / "projects" / "proj" / "memory" / "sub" / "deep.md"
-        nested.parent.mkdir(parents=True, exist_ok=True)
-        nested.write_bytes(b"content")
-        cfg = _default_cfg(memory_glob=True)
-        results = list(change_detector._iter_memory_files(cfg, tmp_path))
-        dest_rels = [d for d, _ in results]
-        assert "memory/proj/sub/deep.md" in dest_rels
-
-
-# ── TestLoadSnapshotHashes ────────────────────────────────────────────────────
-
-
-class TestLoadSnapshotHashes:
-    """Tests for the internal _load_snapshot_hashes helper."""
-
-    def test_missing_manifest_returns_empty(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        assert change_detector._load_snapshot_hashes(snap) == {}
-
-    def test_corrupt_json_returns_empty(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text("{NOT JSON", encoding="utf-8")
-        assert change_detector._load_snapshot_hashes(snap) == {}
-
-    def test_valid_manifest_returns_mapping(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            _manifest_json([{"dest": "settings.json", "sha256": "abc123"}]),
-            encoding="utf-8",
-        )
-        result = change_detector._load_snapshot_hashes(snap)
-        assert result == {"settings.json": "abc123"}
-
-    def test_entries_missing_dest_skipped(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            _manifest_json([{"sha256": "abc"}, {"dest": "ok.md", "sha256": "def"}]),
-            encoding="utf-8",
-        )
-        result = change_detector._load_snapshot_hashes(snap)
-        assert "ok.md" in result
-        assert len(result) == 1
-
-    def test_entries_missing_sha256_skipped(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            _manifest_json([{"dest": "x.md"}, {"dest": "y.md", "sha256": "hash"}]),
-            encoding="utf-8",
-        )
-        result = change_detector._load_snapshot_hashes(snap)
-        assert result == {"y.md": "hash"}
-
-    def test_entries_null_values_skipped(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            _manifest_json([{"dest": None, "sha256": "x"}, {"dest": "z.md", "sha256": "y"}]),
-            encoding="utf-8",
-        )
-        result = change_detector._load_snapshot_hashes(snap)
-        assert result == {"z.md": "y"}
-
-    def test_empty_entries_returns_empty(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            json.dumps({"snapshot_id": "s", "entries": []}),
-            encoding="utf-8",
-        )
-        assert change_detector._load_snapshot_hashes(snap) == {}
-
-    def test_manifest_without_entries_key_returns_empty(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            json.dumps({"snapshot_id": "s"}),
-            encoding="utf-8",
-        )
-        assert change_detector._load_snapshot_hashes(snap) == {}
-
-    def test_multiple_entries_all_loaded(self, tmp_path: Path) -> None:
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        entries = [
-            {"dest": "a.md", "sha256": "hash-a"},
-            {"dest": "b.md", "sha256": "hash-b"},
-            {"dest": "c.md", "sha256": "hash-c"},
-        ]
-        (snap / "manifest.json").write_text(
-            _manifest_json(entries), encoding="utf-8"
-        )
-        result = change_detector._load_snapshot_hashes(snap)
-        assert len(result) == 3
-        assert result["b.md"] == "hash-b"
-
-
-# ── TestSnapshotId ────────────────────────────────────────────────────────────
-
-
-class TestSnapshotId:
-    """Tests for the internal _snapshot_id helper."""
-
-    def test_reads_snapshot_id_from_manifest(self, tmp_path: Path) -> None:
-        snap = tmp_path / "20240101T120000Z"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            json.dumps({"snapshot_id": "custom-id-42", "entries": []}),
-            encoding="utf-8",
-        )
-        assert change_detector._snapshot_id(snap) == "custom-id-42"
-
-    def test_falls_back_to_dir_name_on_missing_manifest(self, tmp_path: Path) -> None:
-        snap = tmp_path / "fallback-name"
-        snap.mkdir()
-        assert change_detector._snapshot_id(snap) == "fallback-name"
-
-    def test_falls_back_to_dir_name_on_corrupt_json(self, tmp_path: Path) -> None:
-        snap = tmp_path / "fallback-corrupt"
-        snap.mkdir()
-        (snap / "manifest.json").write_text("{BAD JSON", encoding="utf-8")
-        assert change_detector._snapshot_id(snap) == "fallback-corrupt"
-
-    def test_falls_back_to_dir_name_when_snapshot_id_absent(self, tmp_path: Path) -> None:
-        snap = tmp_path / "dir-name-fallback"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            json.dumps({"entries": []}), encoding="utf-8"
-        )
-        assert change_detector._snapshot_id(snap) == "dir-name-fallback"
-
-    def test_snapshot_id_none_falls_back_to_dir_name(self, tmp_path: Path) -> None:
-        snap = tmp_path / "none-id-fallback"
-        snap.mkdir()
-        (snap / "manifest.json").write_text(
-            json.dumps({"snapshot_id": None, "entries": []}),
-            encoding="utf-8",
-        )
-        # None -> falsy -> falls back to snap.name
-        assert change_detector._snapshot_id(snap) == "none-id-fallback"
-
-
-# ── TestDetectChanges ─────────────────────────────────────────────────────────
-
-
-class TestDetectChanges:
-    """Integration tests for the public detect_changes function."""
-
-    def _write_file(self, path: Path, content: bytes = b"content") -> None:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_bytes(content)
-
-    def _write_manifest(
-        self,
-        snap: Path,
-        entries: list[dict[str, Any]],
-        snapshot_id: str = "baseline-snap",
-    ) -> None:
-        snap.mkdir(parents=True, exist_ok=True)
-        (snap / "manifest.json").write_text(
-            _manifest_json(entries, snapshot_id), encoding="utf-8"
-        )
-
-    # -- No baseline --
-
-    def test_no_baseline_all_files_are_new(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        (claude_home / "settings.json").write_text("{}", encoding="utf-8")
-        cfg = _default_cfg(top_files=("settings.json",))
-        report = change_detector.detect_changes(cfg, claude_home, last_snapshot=None)
-        assert "settings.json" in report.new
-        assert report.changed == ()
-        assert report.removed == ()
-        assert report.unchanged == 0
-        assert report.baseline_snapshot is None
-
-    def test_none_snapshot_no_tracked_files(self, tmp_path: Path) -> None:
-        cfg = _default_cfg()
-        report = change_detector.detect_changes(cfg, tmp_path, last_snapshot=None)
-        assert report.new == ()
-        assert report.has_changes is False
-        assert report.baseline_snapshot is None
-
-    def test_nonexistent_snapshot_dir_treated_as_no_baseline(
-        self, tmp_path: Path
-    ) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        (claude_home / "CLAUDE.md").write_text("hi", encoding="utf-8")
-        cfg = _default_cfg(top_files=("CLAUDE.md",))
-        ghost_snap = tmp_path / "nonexistent-snap"
-        report = change_detector.detect_changes(cfg, claude_home, ghost_snap)
-        assert "CLAUDE.md" in report.new
-        assert report.baseline_snapshot is None
-
-    # -- All unchanged --
-
-    def test_all_files_unchanged(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        f = claude_home / "settings.json"
-        f.write_bytes(b"same")
-        digest = hashlib.sha256(b"same").hexdigest()
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [{"dest": "settings.json", "sha256": digest}])
-        cfg = _default_cfg(top_files=("settings.json",))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert report.new == ()
-        assert report.changed == ()
-        assert report.removed == ()
-        assert report.unchanged == 1
-        assert report.has_changes is False
-
-    # -- New files --
-
-    def test_file_absent_from_baseline_is_new(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        (claude_home / "new.json").write_bytes(b"new content")
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [])  # empty baseline
-        cfg = _default_cfg(top_files=("new.json",))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert "new.json" in report.new
-        assert report.changed == ()
-        assert report.removed == ()
-
-    # -- Changed files --
-
-    def test_file_with_different_hash_is_changed(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        f = claude_home / "CLAUDE.md"
-        f.write_bytes(b"new-content")
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [{"dest": "CLAUDE.md", "sha256": "old-stale-hash"}])
-        cfg = _default_cfg(top_files=("CLAUDE.md",))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert "CLAUDE.md" in report.changed
-        assert report.new == ()
-        assert report.removed == ()
-
-    # -- Removed files --
-
-    def test_file_in_baseline_not_on_disk_is_removed(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [{"dest": "gone.json", "sha256": "dead"}])
-        cfg = _default_cfg(top_files=("gone.json",))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert "gone.json" in report.removed
-        assert report.new == ()
-        assert report.changed == ()
-
-    # -- Combined --
-
-    def test_mixed_new_changed_removed_unchanged(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-
-        # new — present now, absent in baseline
-        (claude_home / "new.json").write_bytes(b"fresh")
-        # changed — present now, different hash in baseline
-        (claude_home / "changed.json").write_bytes(b"modified")
-        hashlib.sha256(b"modified").hexdigest()
-        # unchanged — present now, same hash
-        (claude_home / "same.json").write_bytes(b"identical")
-        same_digest = hashlib.sha256(b"identical").hexdigest()
-        # removed — in baseline, not on disk
-
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [
-            {"dest": "changed.json", "sha256": "stale-hash"},
-            {"dest": "same.json",    "sha256": same_digest},
-            {"dest": "removed.json", "sha256": "any-hash"},
-        ])
-        cfg = _default_cfg(top_files=("new.json", "changed.json", "same.json", "removed.json"))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-
-        assert "new.json" in report.new
-        assert "changed.json" in report.changed
-        assert "removed.json" in report.removed
-        assert report.unchanged == 1
-        assert report.has_changes is True
-        assert report.baseline_snapshot == "baseline-snap"
-
-    # -- Snapshot ID propagation --
-
-    def test_baseline_snapshot_id_propagated(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [], snapshot_id="my-snap-xyz")
-        cfg = _default_cfg()
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert report.baseline_snapshot == "my-snap-xyz"
-
-    # -- Trees integration --
-
-    def test_tree_files_compared_against_baseline(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        skill_file = claude_home / "skills" / "py" / "SKILL.md"
-        skill_file.parent.mkdir(parents=True)
-        skill_file.write_bytes(b"skill content")
-        digest = hashlib.sha256(b"skill content").hexdigest()
-
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [{"dest": "skills/py/SKILL.md", "sha256": digest}])
-        cfg = BackupConfig(
-            top_files=(),
-            trees=(BackupTree(src="skills", dest="skills"),),
-            memory_glob=False,
-        )
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert report.unchanged == 1
-        assert report.has_changes is False
-
-    # -- Memory files integration --
-
-    def test_memory_files_detected_as_new(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        mem_file = claude_home / "projects" / "proj-x" / "memory" / "MEMORY.md"
-        mem_file.parent.mkdir(parents=True)
-        mem_file.write_bytes(b"mem data")
-
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [])  # empty baseline
-        cfg = _default_cfg(memory_glob=True)
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert any("memory/proj-x" in d for d in report.new)
-
-    # -- Sorted output --
-
-    def test_new_files_are_sorted(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        for name in ("z.json", "a.json", "m.json"):
-            (claude_home / name).write_bytes(b"x")
-        cfg = _default_cfg(top_files=("z.json", "a.json", "m.json"))
-        report = change_detector.detect_changes(cfg, claude_home, last_snapshot=None)
-        assert list(report.new) == sorted(report.new)
-
-    def test_changed_files_are_sorted(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        files = ["z.json", "a.json", "m.json"]
-        for name in files:
-            (claude_home / name).write_bytes(b"current")
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [{"dest": n, "sha256": "old"} for n in files])
-        cfg = _default_cfg(top_files=tuple(files))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert list(report.changed) == sorted(report.changed)
-
-    # -- Symlink in tracked path --
-
-    def test_symlink_top_file_not_counted(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        target = claude_home / "real.json"
-        target.write_bytes(b"content")
-        link = claude_home / "settings.json"
-        try:
-            link.symlink_to(target)
-        except (OSError, NotImplementedError):
-            pytest.skip("symlinks not supported on this platform")
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [])
-        cfg = _default_cfg(top_files=("settings.json",))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        # _iter_top_files skips the symlink → nothing in current state
-        assert report.new == ()
-
-    # -- Large file skipped by max_file_bytes --
-
-    def test_oversized_tree_file_never_counted_as_new(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        big = claude_home / "agents" / "huge.md"
-        big.parent.mkdir(parents=True)
-        big.write_bytes(b"x" * 1000)
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [])
-        cfg = BackupConfig(
-            top_files=(),
-            trees=(BackupTree(src="agents", dest="agents"),),
-            memory_glob=False,
-            max_file_bytes=500,
-        )
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert report.new == ()
-
-    # -- Parametrized: baseline_snapshot vs no baseline --
-
-    @pytest.mark.parametrize(
-        "last_snapshot_is_none,expected_baseline",
-        [
-            (True, None),
-            (False, "snap-id"),
-        ],
-    )
-    def test_baseline_snapshot_field(
-        self,
-        tmp_path: Path,
-        last_snapshot_is_none: bool,
-        expected_baseline: str | None,
-    ) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        if last_snapshot_is_none:
-            snap = None
-        else:
-            snap = tmp_path / "snap"
-            self._write_manifest(snap, [], snapshot_id="snap-id")
-        cfg = _default_cfg()
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        assert report.baseline_snapshot == expected_baseline
-
-    # -- Parametrized: has_changes conditions --
-
-    @pytest.mark.parametrize(
-        "new,changed,removed,unchanged,expect_changes",
-        [
-            ((), (), (), 0, False),
-            (("a",), (), (), 0, True),
-            ((), ("b",), (), 0, True),
-            ((), (), ("c",), 0, True),
-            ((), (), (), 5, False),
-            (("a",), ("b",), ("c",), 2, True),
-        ],
-    )
-    def test_has_changes_parametrized(
-        self,
-        new: tuple[str, ...],
-        changed: tuple[str, ...],
-        removed: tuple[str, ...],
-        unchanged: int,
-        expect_changes: bool,
-    ) -> None:
-        r = change_detector.ChangeReport(
-            new=new,
-            changed=changed,
-            removed=removed,
-            unchanged=unchanged,
-            baseline_snapshot=None,
-        )
-        assert r.has_changes is expect_changes
-
-    # -- Corrupt manifest in snapshot dir --
-
-    def test_corrupt_manifest_treats_all_current_as_new(self, tmp_path: Path) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        (claude_home / "settings.json").write_bytes(b"data")
-        snap = tmp_path / "snap"
-        snap.mkdir()
-        (snap / "manifest.json").write_text("{INVALID", encoding="utf-8")
-        cfg = _default_cfg(top_files=("settings.json",))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        # Corrupt manifest → empty baseline → settings.json treated as new
-        assert "settings.json" in report.new
-        assert report.removed == ()
-
-    # -- total_current property via detect_changes --
-
-    def test_total_current_counts_new_changed_unchanged_not_removed(
-        self, tmp_path: Path
-    ) -> None:
-        claude_home = tmp_path / "home"
-        claude_home.mkdir()
-        # 2 new files
-        (claude_home / "a.json").write_bytes(b"a")
-        (claude_home / "b.json").write_bytes(b"b")
-        # 1 unchanged
-        (claude_home / "c.json").write_bytes(b"same")
-        same_d = hashlib.sha256(b"same").hexdigest()
-        # 1 changed
-        (claude_home / "d.json").write_bytes(b"new")
-        snap = tmp_path / "snap"
-        self._write_manifest(snap, [
-            {"dest": "c.json", "sha256": same_d},
-            {"dest": "d.json", "sha256": "old-hash"},
-            {"dest": "removed.json", "sha256": "r-hash"},
-        ])
-        cfg = _default_cfg(top_files=("a.json", "b.json", "c.json", "d.json"))
-        report = change_detector.detect_changes(cfg, claude_home, snap)
-        # new=2, changed=1, unchanged=1  → total_current=4
-        assert report.total_current == 4
+"""
+test_change_detector.py -- Coverage sprint for change_detector.py.
+
+change_detector is a pure-function diff engine: it hashes live files,
+loads a manifest from the last snapshot directory, and returns a
+ChangeReport dataclass.  No filesystem writes, no subprocess calls.
+
+Tests are grouped by the internal helper they exercise so regressions
+surface at the exact layer where they occur.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import change_detector
+from backup_config import BackupConfig, BackupTree
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _default_cfg(**kwargs: Any) -> BackupConfig:
+    """Return a BackupConfig with trees=() and memory_glob=False by default."""
+    base = {
+        "top_files": (),
+        "trees": (),
+        "memory_glob": False,
+    }
+    base.update(kwargs)
+    return BackupConfig(**base)  # type: ignore[arg-type]
+
+
+def _manifest_json(
+    entries: list[dict[str, Any]],
+    snapshot_id: str = "snap-001",
+) -> str:
+    return json.dumps({"snapshot_id": snapshot_id, "entries": entries})
+
+
+# ── TestChangeReport ─────────────────────────────────────────────────────────
+
+
+class TestChangeReport:
+    """Unit tests for the ChangeReport dataclass properties and methods."""
+
+    def test_has_changes_false_when_all_empty(self) -> None:
+        r = change_detector.ChangeReport(
+            new=(), changed=(), removed=(), unchanged=5, baseline_snapshot="x"
+        )
+        assert r.has_changes is False
+
+    def test_has_changes_true_when_new(self) -> None:
+        r = change_detector.ChangeReport(
+            new=("a.txt",), changed=(), removed=(), unchanged=0, baseline_snapshot=None
+        )
+        assert r.has_changes is True
+
+    def test_has_changes_true_when_changed(self) -> None:
+        r = change_detector.ChangeReport(
+            new=(), changed=("b.txt",), removed=(), unchanged=3, baseline_snapshot="x"
+        )
+        assert r.has_changes is True
+
+    def test_has_changes_true_when_removed(self) -> None:
+        r = change_detector.ChangeReport(
+            new=(), changed=(), removed=("c.txt",), unchanged=2, baseline_snapshot="x"
+        )
+        assert r.has_changes is True
+
+    def test_total_current_sums_new_changed_unchanged(self) -> None:
+        r = change_detector.ChangeReport(
+            new=("a",), changed=("b", "c"), removed=("z",), unchanged=7, baseline_snapshot="x"
+        )
+        # removed does NOT count toward total_current
+        assert r.total_current == 1 + 2 + 7
+
+    def test_total_current_zero_when_nothing_tracked(self) -> None:
+        r = change_detector.ChangeReport(
+            new=(), changed=(), removed=(), unchanged=0, baseline_snapshot=None
+        )
+        assert r.total_current == 0
+
+    def test_to_dict_includes_computed_properties(self) -> None:
+        r = change_detector.ChangeReport(
+            new=("f",), changed=(), removed=(), unchanged=2, baseline_snapshot="s1"
+        )
+        d = r.to_dict()
+        assert d["has_changes"] is True
+        assert d["total_current"] == 3
+        assert d["new"] == ("f",)
+        assert d["baseline_snapshot"] == "s1"
+
+    def test_to_dict_has_changes_false_path(self) -> None:
+        r = change_detector.ChangeReport(
+            new=(), changed=(), removed=(), unchanged=1, baseline_snapshot="s1"
+        )
+        d = r.to_dict()
+        assert d["has_changes"] is False
+        assert d["total_current"] == 1
+
+    def test_report_is_frozen_dataclass(self) -> None:
+        r = change_detector.ChangeReport(
+            new=(), changed=(), removed=(), unchanged=0, baseline_snapshot=None
+        )
+        with pytest.raises((AttributeError, TypeError)):
+            r.unchanged = 99  # type: ignore[misc]
+
+
+# ── TestSha256File ────────────────────────────────────────────────────────────
+
+
+class TestSha256File:
+    """Tests for the internal _sha256_file helper."""
+
+    def test_known_content_matches_expected_digest(self, tmp_path: Path) -> None:
+        f = tmp_path / "known.txt"
+        f.write_bytes(b"hello world")
+        expected = hashlib.sha256(b"hello world").hexdigest()
+        assert change_detector._sha256_file(f) == expected
+
+    def test_empty_file_has_stable_digest(self, tmp_path: Path) -> None:
+        f = tmp_path / "empty.bin"
+        f.write_bytes(b"")
+        digest = change_detector._sha256_file(f)
+        assert digest == hashlib.sha256(b"").hexdigest()
+
+    def test_same_content_same_digest(self, tmp_path: Path) -> None:
+        f1 = tmp_path / "a.txt"
+        f2 = tmp_path / "b.txt"
+        f1.write_bytes(b"content")
+        f2.write_bytes(b"content")
+        assert change_detector._sha256_file(f1) == change_detector._sha256_file(f2)
+
+    def test_different_content_different_digest(self, tmp_path: Path) -> None:
+        f1 = tmp_path / "a.txt"
+        f2 = tmp_path / "b.txt"
+        f1.write_bytes(b"content-A")
+        f2.write_bytes(b"content-B")
+        assert change_detector._sha256_file(f1) != change_detector._sha256_file(f2)
+
+    def test_single_byte_change_changes_digest(self, tmp_path: Path) -> None:
+        f = tmp_path / "data.bin"
+        f.write_bytes(b"abcdefgh")
+        d1 = change_detector._sha256_file(f)
+        f.write_bytes(b"abcdefgX")
+        d2 = change_detector._sha256_file(f)
+        assert d1 != d2
+
+    def test_symlink_returns_none(self, tmp_path: Path) -> None:
+        target = tmp_path / "real.txt"
+        target.write_bytes(b"data")
+        link = tmp_path / "link.txt"
+        try:
+            link.symlink_to(target)
+        except (OSError, NotImplementedError):
+            pytest.skip("symlinks not supported on this platform")
+        assert change_detector._sha256_file(link) is None
+
+    def test_missing_file_returns_none(self, tmp_path: Path) -> None:
+        assert change_detector._sha256_file(tmp_path / "ghost.txt") is None
+
+    def test_returns_lowercase_hex_string(self, tmp_path: Path) -> None:
+        f = tmp_path / "f.bin"
+        f.write_bytes(b"\xff\xfe")
+        digest = change_detector._sha256_file(f)
+        assert digest is not None
+        assert digest == digest.lower()
+        assert len(digest) == 64
+
+
+# ── TestIterTopFiles ──────────────────────────────────────────────────────────
+
+
+class TestIterTopFiles:
+    """Tests for _iter_top_files."""
+
+    def test_yields_existing_regular_files(self, tmp_path: Path) -> None:
+        (tmp_path / "settings.json").write_text("{}", encoding="utf-8")
+        cfg = _default_cfg(top_files=("settings.json",))
+        results = list(change_detector._iter_top_files(cfg, tmp_path))
+        assert len(results) == 1
+        name, path = results[0]
+        assert name == "settings.json"
+        assert path == tmp_path / "settings.json"
+
+    def test_missing_file_not_yielded(self, tmp_path: Path) -> None:
+        cfg = _default_cfg(top_files=("missing.json",))
+        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
+
+    def test_symlink_not_yielded(self, tmp_path: Path) -> None:
+        target = tmp_path / "real.json"
+        target.write_text("{}", encoding="utf-8")
+        link = tmp_path / "link.json"
+        try:
+            link.symlink_to(target)
+        except (OSError, NotImplementedError):
+            pytest.skip("symlinks not supported on this platform")
+        cfg = _default_cfg(top_files=("link.json",))
+        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
+
+    def test_empty_top_files_yields_nothing(self, tmp_path: Path) -> None:
+        cfg = _default_cfg(top_files=())
+        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
+
+    def test_multiple_files_all_yielded(self, tmp_path: Path) -> None:
+        for name in ("a.json", "b.md", "c.json"):
+            (tmp_path / name).write_text("x", encoding="utf-8")
+        cfg = _default_cfg(top_files=("a.json", "b.md", "c.json"))
+        names = [n for n, _ in change_detector._iter_top_files(cfg, tmp_path)]
+        assert sorted(names) == ["a.json", "b.md", "c.json"]
+
+    def test_directory_not_yielded(self, tmp_path: Path) -> None:
+        (tmp_path / "notafile").mkdir()
+        cfg = _default_cfg(top_files=("notafile",))
+        assert list(change_detector._iter_top_files(cfg, tmp_path)) == []
+
+
+# ── TestIterTreeFiles ─────────────────────────────────────────────────────────
+
+
+class TestIterTreeFiles:
+    """Tests for _iter_tree_files."""
+
+    def _make_tree(self, base: Path, subpath: str, content: bytes = b"data") -> Path:
+        p = base / subpath
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_bytes(content)
+        return p
+
+    def test_yields_files_under_tree(self, tmp_path: Path) -> None:
+        self._make_tree(tmp_path, "skills/python/SKILL.md")
+        cfg = _default_cfg(trees=(BackupTree(src="skills", dest="skills"),))
+        results = list(change_detector._iter_tree_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "skills/python/SKILL.md" in dest_rels
+
+    def test_missing_tree_root_yields_nothing(self, tmp_path: Path) -> None:
+        cfg = _default_cfg(trees=(BackupTree(src="nonexistent", dest="nonexistent"),))
+        assert list(change_detector._iter_tree_files(cfg, tmp_path)) == []
+
+    def test_file_exceeding_max_bytes_skipped(self, tmp_path: Path) -> None:
+        big = tmp_path / "agents" / "big.md"
+        big.parent.mkdir(parents=True)
+        big.write_bytes(b"x" * 100)
+        cfg = _default_cfg(
+            trees=(BackupTree(src="agents", dest="agents"),),
+            max_file_bytes=50,
+        )
+        assert list(change_detector._iter_tree_files(cfg, tmp_path)) == []
+
+    def test_file_exactly_at_max_bytes_included(self, tmp_path: Path) -> None:
+        f = tmp_path / "agents" / "exact.md"
+        f.parent.mkdir(parents=True)
+        f.write_bytes(b"x" * 50)
+        cfg = _default_cfg(
+            trees=(BackupTree(src="agents", dest="agents"),),
+            max_file_bytes=50,
+        )
+        results = list(change_detector._iter_tree_files(cfg, tmp_path))
+        assert len(results) == 1
+
+    def test_symlink_file_skipped(self, tmp_path: Path) -> None:
+        target = tmp_path / "agents" / "real.md"
+        target.parent.mkdir(parents=True)
+        target.write_bytes(b"content")
+        link = tmp_path / "agents" / "link.md"
+        try:
+            link.symlink_to(target)
+        except (OSError, NotImplementedError):
+            pytest.skip("symlinks not supported on this platform")
+        cfg = _default_cfg(trees=(BackupTree(src="agents", dest="agents"),))
+        # Only the real file should appear, not the symlink.
+        results = list(change_detector._iter_tree_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "agents/link.md" not in dest_rels
+        assert "agents/real.md" in dest_rels
+
+    def test_dest_rel_uses_tree_dest_prefix(self, tmp_path: Path) -> None:
+        self._make_tree(tmp_path, "raw_agents/subdir/file.md")
+        cfg = _default_cfg(trees=(BackupTree(src="raw_agents", dest="my_agents"),))
+        results = list(change_detector._iter_tree_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "my_agents/subdir/file.md" in dest_rels
+
+    def test_empty_trees_yields_nothing(self, tmp_path: Path) -> None:
+        cfg = _default_cfg(trees=())
+        assert list(change_detector._iter_tree_files(cfg, tmp_path)) == []
+
+    def test_nested_subdirectories_walked(self, tmp_path: Path) -> None:
+        for subpath in ("skills/a/b/c/deep.md", "skills/top.md"):
+            self._make_tree(tmp_path, subpath)
+        cfg = _default_cfg(trees=(BackupTree(src="skills", dest="skills"),))
+        results = list(change_detector._iter_tree_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "skills/a/b/c/deep.md" in dest_rels
+        assert "skills/top.md" in dest_rels
+
+
+# ── TestIterMemoryFiles ───────────────────────────────────────────────────────
+
+
+class TestIterMemoryFiles:
+    """Tests for _iter_memory_files."""
+
+    def _make_memory_file(
+        self, base: Path, slug: str, filename: str, content: bytes = b"mem"
+    ) -> Path:
+        p = base / "projects" / slug / "memory" / filename
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_bytes(content)
+        return p
+
+    def test_memory_glob_false_yields_nothing(self, tmp_path: Path) -> None:
+        self._make_memory_file(tmp_path, "proj-slug", "MEMORY.md")
+        cfg = _default_cfg(memory_glob=False)
+        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
+
+    def test_missing_projects_dir_yields_nothing(self, tmp_path: Path) -> None:
+        cfg = _default_cfg(memory_glob=True)
+        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
+
+    def test_yields_memory_files_under_projects(self, tmp_path: Path) -> None:
+        self._make_memory_file(tmp_path, "my-proj", "NOTE.md")
+        cfg = _default_cfg(memory_glob=True)
+        results = list(change_detector._iter_memory_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "memory/my-proj/NOTE.md" in dest_rels
+
+    def test_dest_rel_includes_slug_and_filename(self, tmp_path: Path) -> None:
+        self._make_memory_file(tmp_path, "alpha", "a.md")
+        self._make_memory_file(tmp_path, "beta", "b.md")
+        cfg = _default_cfg(memory_glob=True)
+        results = list(change_detector._iter_memory_files(cfg, tmp_path))
+        dest_rels = {d for d, _ in results}
+        assert "memory/alpha/a.md" in dest_rels
+        assert "memory/beta/b.md" in dest_rels
+
+    def test_file_exceeding_max_bytes_skipped(self, tmp_path: Path) -> None:
+        self._make_memory_file(tmp_path, "proj", "big.md", content=b"x" * 200)
+        cfg = _default_cfg(memory_glob=True, max_file_bytes=100)
+        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
+
+    def test_symlink_memory_file_skipped(self, tmp_path: Path) -> None:
+        target = self._make_memory_file(tmp_path, "proj", "real.md")
+        link = tmp_path / "projects" / "proj" / "memory" / "link.md"
+        try:
+            link.symlink_to(target)
+        except (OSError, NotImplementedError):
+            pytest.skip("symlinks not supported on this platform")
+        cfg = _default_cfg(memory_glob=True)
+        results = list(change_detector._iter_memory_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "memory/proj/link.md" not in dest_rels
+        assert "memory/proj/real.md" in dest_rels
+
+    def test_project_file_not_dir_ignored(self, tmp_path: Path) -> None:
+        """A file directly inside projects/ (not a dir) must be skipped."""
+        projects = tmp_path / "projects"
+        projects.mkdir(parents=True)
+        (projects / "stray-file.txt").write_text("x", encoding="utf-8")
+        cfg = _default_cfg(memory_glob=True)
+        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
+
+    def test_slug_without_memory_subdir_skipped(self, tmp_path: Path) -> None:
+        slug_dir = tmp_path / "projects" / "no-memory"
+        slug_dir.mkdir(parents=True)
+        cfg = _default_cfg(memory_glob=True)
+        assert list(change_detector._iter_memory_files(cfg, tmp_path)) == []
+
+    def test_nested_memory_path_dest_rel(self, tmp_path: Path) -> None:
+        nested = tmp_path / "projects" / "proj" / "memory" / "sub" / "deep.md"
+        nested.parent.mkdir(parents=True, exist_ok=True)
+        nested.write_bytes(b"content")
+        cfg = _default_cfg(memory_glob=True)
+        results = list(change_detector._iter_memory_files(cfg, tmp_path))
+        dest_rels = [d for d, _ in results]
+        assert "memory/proj/sub/deep.md" in dest_rels
+
+
+# ── TestLoadSnapshotHashes ────────────────────────────────────────────────────
+
+
+class TestLoadSnapshotHashes:
+    """Tests for the internal _load_snapshot_hashes helper."""
+
+    def test_missing_manifest_returns_empty(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        assert change_detector._load_snapshot_hashes(snap) == {}
+
+    def test_corrupt_json_returns_empty(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text("{NOT JSON", encoding="utf-8")
+        assert change_detector._load_snapshot_hashes(snap) == {}
+
+    def test_valid_manifest_returns_mapping(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            _manifest_json([{"dest": "settings.json", "sha256": "abc123"}]),
+            encoding="utf-8",
+        )
+        result = change_detector._load_snapshot_hashes(snap)
+        assert result == {"settings.json": "abc123"}
+
+    def test_entries_missing_dest_skipped(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            _manifest_json([{"sha256": "abc"}, {"dest": "ok.md", "sha256": "def"}]),
+            encoding="utf-8",
+        )
+        result = change_detector._load_snapshot_hashes(snap)
+        assert "ok.md" in result
+        assert len(result) == 1
+
+    def test_entries_missing_sha256_skipped(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            _manifest_json([{"dest": "x.md"}, {"dest": "y.md", "sha256": "hash"}]),
+            encoding="utf-8",
+        )
+        result = change_detector._load_snapshot_hashes(snap)
+        assert result == {"y.md": "hash"}
+
+    def test_entries_null_values_skipped(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            _manifest_json([{"dest": None, "sha256": "x"}, {"dest": "z.md", "sha256": "y"}]),
+            encoding="utf-8",
+        )
+        result = change_detector._load_snapshot_hashes(snap)
+        assert result == {"z.md": "y"}
+
+    def test_empty_entries_returns_empty(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            json.dumps({"snapshot_id": "s", "entries": []}),
+            encoding="utf-8",
+        )
+        assert change_detector._load_snapshot_hashes(snap) == {}
+
+    def test_manifest_without_entries_key_returns_empty(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            json.dumps({"snapshot_id": "s"}),
+            encoding="utf-8",
+        )
+        assert change_detector._load_snapshot_hashes(snap) == {}
+
+    def test_multiple_entries_all_loaded(self, tmp_path: Path) -> None:
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        entries = [
+            {"dest": "a.md", "sha256": "hash-a"},
+            {"dest": "b.md", "sha256": "hash-b"},
+            {"dest": "c.md", "sha256": "hash-c"},
+        ]
+        (snap / "manifest.json").write_text(
+            _manifest_json(entries), encoding="utf-8"
+        )
+        result = change_detector._load_snapshot_hashes(snap)
+        assert len(result) == 3
+        assert result["b.md"] == "hash-b"
+
+
+# ── TestSnapshotId ────────────────────────────────────────────────────────────
+
+
+class TestSnapshotId:
+    """Tests for the internal _snapshot_id helper."""
+
+    def test_reads_snapshot_id_from_manifest(self, tmp_path: Path) -> None:
+        snap = tmp_path / "20240101T120000Z"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            json.dumps({"snapshot_id": "custom-id-42", "entries": []}),
+            encoding="utf-8",
+        )
+        assert change_detector._snapshot_id(snap) == "custom-id-42"
+
+    def test_falls_back_to_dir_name_on_missing_manifest(self, tmp_path: Path) -> None:
+        snap = tmp_path / "fallback-name"
+        snap.mkdir()
+        assert change_detector._snapshot_id(snap) == "fallback-name"
+
+    def test_falls_back_to_dir_name_on_corrupt_json(self, tmp_path: Path) -> None:
+        snap = tmp_path / "fallback-corrupt"
+        snap.mkdir()
+        (snap / "manifest.json").write_text("{BAD JSON", encoding="utf-8")
+        assert change_detector._snapshot_id(snap) == "fallback-corrupt"
+
+    def test_falls_back_to_dir_name_when_snapshot_id_absent(self, tmp_path: Path) -> None:
+        snap = tmp_path / "dir-name-fallback"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            json.dumps({"entries": []}), encoding="utf-8"
+        )
+        assert change_detector._snapshot_id(snap) == "dir-name-fallback"
+
+    def test_snapshot_id_none_falls_back_to_dir_name(self, tmp_path: Path) -> None:
+        snap = tmp_path / "none-id-fallback"
+        snap.mkdir()
+        (snap / "manifest.json").write_text(
+            json.dumps({"snapshot_id": None, "entries": []}),
+            encoding="utf-8",
+        )
+        # None -> falsy -> falls back to snap.name
+        assert change_detector._snapshot_id(snap) == "none-id-fallback"
+
+
+# ── TestDetectChanges ─────────────────────────────────────────────────────────
+
+
+class TestDetectChanges:
+    """Integration tests for the public detect_changes function."""
+
+    def _write_file(self, path: Path, content: bytes = b"content") -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(content)
+
+    def _write_manifest(
+        self,
+        snap: Path,
+        entries: list[dict[str, Any]],
+        snapshot_id: str = "baseline-snap",
+    ) -> None:
+        snap.mkdir(parents=True, exist_ok=True)
+        (snap / "manifest.json").write_text(
+            _manifest_json(entries, snapshot_id), encoding="utf-8"
+        )
+
+    # -- No baseline --
+
+    def test_no_baseline_all_files_are_new(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        (claude_home / "settings.json").write_text("{}", encoding="utf-8")
+        cfg = _default_cfg(top_files=("settings.json",))
+        report = change_detector.detect_changes(cfg, claude_home, last_snapshot=None)
+        assert "settings.json" in report.new
+        assert report.changed == ()
+        assert report.removed == ()
+        assert report.unchanged == 0
+        assert report.baseline_snapshot is None
+
+    def test_none_snapshot_no_tracked_files(self, tmp_path: Path) -> None:
+        cfg = _default_cfg()
+        report = change_detector.detect_changes(cfg, tmp_path, last_snapshot=None)
+        assert report.new == ()
+        assert report.has_changes is False
+        assert report.baseline_snapshot is None
+
+    def test_nonexistent_snapshot_dir_treated_as_no_baseline(
+        self, tmp_path: Path
+    ) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        (claude_home / "CLAUDE.md").write_text("hi", encoding="utf-8")
+        cfg = _default_cfg(top_files=("CLAUDE.md",))
+        ghost_snap = tmp_path / "nonexistent-snap"
+        report = change_detector.detect_changes(cfg, claude_home, ghost_snap)
+        assert "CLAUDE.md" in report.new
+        assert report.baseline_snapshot is None
+
+    # -- All unchanged --
+
+    def test_all_files_unchanged(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        f = claude_home / "settings.json"
+        f.write_bytes(b"same")
+        digest = hashlib.sha256(b"same").hexdigest()
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [{"dest": "settings.json", "sha256": digest}])
+        cfg = _default_cfg(top_files=("settings.json",))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert report.new == ()
+        assert report.changed == ()
+        assert report.removed == ()
+        assert report.unchanged == 1
+        assert report.has_changes is False
+
+    # -- New files --
+
+    def test_file_absent_from_baseline_is_new(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        (claude_home / "new.json").write_bytes(b"new content")
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [])  # empty baseline
+        cfg = _default_cfg(top_files=("new.json",))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert "new.json" in report.new
+        assert report.changed == ()
+        assert report.removed == ()
+
+    # -- Changed files --
+
+    def test_file_with_different_hash_is_changed(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        f = claude_home / "CLAUDE.md"
+        f.write_bytes(b"new-content")
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [{"dest": "CLAUDE.md", "sha256": "old-stale-hash"}])
+        cfg = _default_cfg(top_files=("CLAUDE.md",))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert "CLAUDE.md" in report.changed
+        assert report.new == ()
+        assert report.removed == ()
+
+    # -- Removed files --
+
+    def test_file_in_baseline_not_on_disk_is_removed(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [{"dest": "gone.json", "sha256": "dead"}])
+        cfg = _default_cfg(top_files=("gone.json",))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert "gone.json" in report.removed
+        assert report.new == ()
+        assert report.changed == ()
+
+    # -- Combined --
+
+    def test_mixed_new_changed_removed_unchanged(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+
+        # new — present now, absent in baseline
+        (claude_home / "new.json").write_bytes(b"fresh")
+        # changed — present now, different hash in baseline
+        (claude_home / "changed.json").write_bytes(b"modified")
+        hashlib.sha256(b"modified").hexdigest()
+        # unchanged — present now, same hash
+        (claude_home / "same.json").write_bytes(b"identical")
+        same_digest = hashlib.sha256(b"identical").hexdigest()
+        # removed — in baseline, not on disk
+
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [
+            {"dest": "changed.json", "sha256": "stale-hash"},
+            {"dest": "same.json",    "sha256": same_digest},
+            {"dest": "removed.json", "sha256": "any-hash"},
+        ])
+        cfg = _default_cfg(top_files=("new.json", "changed.json", "same.json", "removed.json"))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+
+        assert "new.json" in report.new
+        assert "changed.json" in report.changed
+        assert "removed.json" in report.removed
+        assert report.unchanged == 1
+        assert report.has_changes is True
+        assert report.baseline_snapshot == "baseline-snap"
+
+    # -- Snapshot ID propagation --
+
+    def test_baseline_snapshot_id_propagated(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [], snapshot_id="my-snap-xyz")
+        cfg = _default_cfg()
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert report.baseline_snapshot == "my-snap-xyz"
+
+    # -- Trees integration --
+
+    def test_tree_files_compared_against_baseline(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        skill_file = claude_home / "skills" / "py" / "SKILL.md"
+        skill_file.parent.mkdir(parents=True)
+        skill_file.write_bytes(b"skill content")
+        digest = hashlib.sha256(b"skill content").hexdigest()
+
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [{"dest": "skills/py/SKILL.md", "sha256": digest}])
+        cfg = BackupConfig(
+            top_files=(),
+            trees=(BackupTree(src="skills", dest="skills"),),
+            memory_glob=False,
+        )
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert report.unchanged == 1
+        assert report.has_changes is False
+
+    # -- Memory files integration --
+
+    def test_memory_files_detected_as_new(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        mem_file = claude_home / "projects" / "proj-x" / "memory" / "MEMORY.md"
+        mem_file.parent.mkdir(parents=True)
+        mem_file.write_bytes(b"mem data")
+
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [])  # empty baseline
+        cfg = _default_cfg(memory_glob=True)
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert any("memory/proj-x" in d for d in report.new)
+
+    # -- Sorted output --
+
+    def test_new_files_are_sorted(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        for name in ("z.json", "a.json", "m.json"):
+            (claude_home / name).write_bytes(b"x")
+        cfg = _default_cfg(top_files=("z.json", "a.json", "m.json"))
+        report = change_detector.detect_changes(cfg, claude_home, last_snapshot=None)
+        assert list(report.new) == sorted(report.new)
+
+    def test_changed_files_are_sorted(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        files = ["z.json", "a.json", "m.json"]
+        for name in files:
+            (claude_home / name).write_bytes(b"current")
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [{"dest": n, "sha256": "old"} for n in files])
+        cfg = _default_cfg(top_files=tuple(files))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert list(report.changed) == sorted(report.changed)
+
+    # -- Symlink in tracked path --
+
+    def test_symlink_top_file_not_counted(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        target = claude_home / "real.json"
+        target.write_bytes(b"content")
+        link = claude_home / "settings.json"
+        try:
+            link.symlink_to(target)
+        except (OSError, NotImplementedError):
+            pytest.skip("symlinks not supported on this platform")
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [])
+        cfg = _default_cfg(top_files=("settings.json",))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        # _iter_top_files skips the symlink → nothing in current state
+        assert report.new == ()
+
+    # -- Large file skipped by max_file_bytes --
+
+    def test_oversized_tree_file_never_counted_as_new(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        big = claude_home / "agents" / "huge.md"
+        big.parent.mkdir(parents=True)
+        big.write_bytes(b"x" * 1000)
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [])
+        cfg = BackupConfig(
+            top_files=(),
+            trees=(BackupTree(src="agents", dest="agents"),),
+            memory_glob=False,
+            max_file_bytes=500,
+        )
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert report.new == ()
+
+    # -- Parametrized: baseline_snapshot vs no baseline --
+
+    @pytest.mark.parametrize(
+        "last_snapshot_is_none,expected_baseline",
+        [
+            (True, None),
+            (False, "snap-id"),
+        ],
+    )
+    def test_baseline_snapshot_field(
+        self,
+        tmp_path: Path,
+        last_snapshot_is_none: bool,
+        expected_baseline: str | None,
+    ) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        if last_snapshot_is_none:
+            snap = None
+        else:
+            snap = tmp_path / "snap"
+            self._write_manifest(snap, [], snapshot_id="snap-id")
+        cfg = _default_cfg()
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        assert report.baseline_snapshot == expected_baseline
+
+    # -- Parametrized: has_changes conditions --
+
+    @pytest.mark.parametrize(
+        "new,changed,removed,unchanged,expect_changes",
+        [
+            ((), (), (), 0, False),
+            (("a",), (), (), 0, True),
+            ((), ("b",), (), 0, True),
+            ((), (), ("c",), 0, True),
+            ((), (), (), 5, False),
+            (("a",), ("b",), ("c",), 2, True),
+        ],
+    )
+    def test_has_changes_parametrized(
+        self,
+        new: tuple[str, ...],
+        changed: tuple[str, ...],
+        removed: tuple[str, ...],
+        unchanged: int,
+        expect_changes: bool,
+    ) -> None:
+        r = change_detector.ChangeReport(
+            new=new,
+            changed=changed,
+            removed=removed,
+            unchanged=unchanged,
+            baseline_snapshot=None,
+        )
+        assert r.has_changes is expect_changes
+
+    # -- Corrupt manifest in snapshot dir --
+
+    def test_corrupt_manifest_treats_all_current_as_new(self, tmp_path: Path) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        (claude_home / "settings.json").write_bytes(b"data")
+        snap = tmp_path / "snap"
+        snap.mkdir()
+        (snap / "manifest.json").write_text("{INVALID", encoding="utf-8")
+        cfg = _default_cfg(top_files=("settings.json",))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        # Corrupt manifest → empty baseline → settings.json treated as new
+        assert "settings.json" in report.new
+        assert report.removed == ()
+
+    # -- total_current property via detect_changes --
+
+    def test_total_current_counts_new_changed_unchanged_not_removed(
+        self, tmp_path: Path
+    ) -> None:
+        claude_home = tmp_path / "home"
+        claude_home.mkdir()
+        # 2 new files
+        (claude_home / "a.json").write_bytes(b"a")
+        (claude_home / "b.json").write_bytes(b"b")
+        # 1 unchanged
+        (claude_home / "c.json").write_bytes(b"same")
+        same_d = hashlib.sha256(b"same").hexdigest()
+        # 1 changed
+        (claude_home / "d.json").write_bytes(b"new")
+        snap = tmp_path / "snap"
+        self._write_manifest(snap, [
+            {"dest": "c.json", "sha256": same_d},
+            {"dest": "d.json", "sha256": "old-hash"},
+            {"dest": "removed.json", "sha256": "r-hash"},
+        ])
+        cfg = _default_cfg(top_files=("a.json", "b.json", "c.json", "d.json"))
+        report = change_detector.detect_changes(cfg, claude_home, snap)
+        # new=2, changed=1, unchanged=1  → total_current=4
+        assert report.total_current == 4

src/tests/test_config.py

@@ -1,373 +1,373 @@
-"""
-test_config.py -- Tests for the ctx_config.Config system.
-
-Covers:
-  - ctx_config.Config: attribute types, path expansion, reload, deep merge,
-    all_skill_dirs()
-"""
-
-import sys
-import tempfile
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-# ---------------------------------------------------------------------------
-# sys.path is already patched by conftest.py, but guard here too so the module
-# can be run in isolation (e.g. `python -m pytest tests/test_config.py`).
-# ---------------------------------------------------------------------------
-_PROJECT_ROOT = Path(__file__).resolve().parent.parent
-if str(_PROJECT_ROOT) not in sys.path:
-    sys.path.insert(0, str(_PROJECT_ROOT))
-
-import ctx_config  # noqa: E402
-from ctx_config import Config, _deep_merge  # noqa: E402
-
-
-# ===========================================================================
-# Helper
-# ===========================================================================
-
-
-def _minimal_raw(overrides: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Return a minimal raw-config dict sufficient to construct a Config."""
-    raw: dict[str, Any] = {
-        "paths": {
-            "claude_dir": "~/.claude",
-            "wiki_dir": "~/.claude/skill-wiki",
-            "skills_dir": "~/.claude/skills",
-            "agents_dir": "~/.claude/agents",
-            "skill_manifest": "~/.claude/skill-manifest.json",
-            "intent_log": "~/.claude/intent-log.jsonl",
-            "pending_skills": "~/.claude/pending-skills.json",
-            "skill_registry": "~/.claude/skill-registry.json",
-            "stack_profile_tmp": "~/.claude/skill-stack-profile.json",
-            "catalog": "~/.claude/skill-wiki/catalog.md",
-        },
-        "resolver": {},
-        "context_monitor": {},
-        "usage_tracker": {},
-        "skill_transformer": {},
-        "skill_router": {},
-        "extra_skill_dirs": [],
-        "babysitter": {},
-    }
-    if overrides:
-        _deep_merge(raw, overrides)
-    return raw
-
-
-# ===========================================================================
-# Config tests
-# ===========================================================================
-
-
-class TestConfigLoadsDefaults:
-    """test_config_loads_defaults -- expected attributes exist with correct defaults."""
-
-    def test_has_wiki_dir(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert hasattr(cfg, "wiki_dir")
-
-    def test_has_skills_dir(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert hasattr(cfg, "skills_dir")
-
-    def test_line_threshold_default(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.line_threshold == 180
-
-    def test_line_threshold_accepts_user_value(self) -> None:
-        cfg = Config(_minimal_raw({"skill_transformer": {"line_threshold": 240}}))
-        assert cfg.line_threshold == 240
-
-    @pytest.mark.parametrize("value", [0, -1, "not-an-int", "240", True, False, 1.5])
-    def test_line_threshold_rejects_invalid_values(self, value: object) -> None:
-        with pytest.raises(ValueError, match="skill_transformer.line_threshold"):
-            Config(_minimal_raw({"skill_transformer": {"line_threshold": value}}))
-
-    def test_max_stage_lines_default(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.max_stage_lines == 40
-
-    def test_max_skills_default(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.max_skills == 15
-
-    def test_stage_count_default(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.stage_count == 5
-
-
-class TestConfigPathsArePathlib:
-    """test_config_paths_are_pathlib -- all path attributes are Path objects."""
-
-    PATH_ATTRS = [
-        "claude_dir",
-        "wiki_dir",
-        "skills_dir",
-        "agents_dir",
-        "skill_manifest",
-        "intent_log",
-        "pending_skills",
-        "skill_registry",
-        "stack_profile_tmp",
-        "catalog",
-    ]
-
-    @pytest.mark.parametrize("attr", PATH_ATTRS)
-    def test_attr_is_path(
-        self,
-        attr: str,
-        tmp_path: Path,
-        monkeypatch: pytest.MonkeyPatch,
-    ) -> None:
-        cfg = Config(_minimal_raw())
-        assert isinstance(getattr(cfg, attr), Path), (
-            f"cfg.{attr} should be a Path, got {type(getattr(cfg, attr))}"
-        )
-
-        if attr == "stack_profile_tmp":
-            raw = _minimal_raw()
-            del raw["paths"]["stack_profile_tmp"]
-            monkeypatch.setattr(tempfile, "gettempdir", lambda: str(tmp_path))
-
-            cfg = Config(raw)
-
-            assert cfg.stack_profile_tmp == tmp_path / "skill-stack-profile.json"
-
-
-class TestConfigExpandTilde:
-    """test_config_expand_tilde -- paths with ~ are expanded to absolute paths."""
-
-    def test_wiki_dir_is_absolute(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.wiki_dir.is_absolute(), (
-            f"wiki_dir should be absolute after ~ expansion, got: {cfg.wiki_dir}"
-        )
-
-    def test_skills_dir_is_absolute(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.skills_dir.is_absolute()
-
-    def test_claude_dir_is_absolute(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.claude_dir.is_absolute()
-
-    def test_custom_tilde_path_expanded(self) -> None:
-        raw = _minimal_raw({"paths": {"wiki_dir": "~/custom-wiki"}})
-        cfg = Config(raw)
-        assert "~" not in str(cfg.wiki_dir)
-        assert cfg.wiki_dir.is_absolute()
-
-
-def test_claude_adapter_modules_use_cfg_paths() -> None:
-    from ctx.adapters.claude_code import skill_health, skill_loader
-    from ctx.adapters.claude_code.install import install_utils, skill_unload
-
-    assert install_utils.MANIFEST_PATH == ctx_config.cfg.skill_manifest
-    assert skill_loader.SKILLS_DIR == ctx_config.cfg.skills_dir
-    assert skill_loader.AGENTS_DIR == ctx_config.cfg.agents_dir
-    assert skill_loader.WIKI_DIR == ctx_config.cfg.wiki_dir
-    assert skill_loader.PENDING_SKILLS == ctx_config.cfg.pending_skills
-    assert skill_loader.MANIFEST_PATH == ctx_config.cfg.skill_manifest
-    assert skill_unload.CLAUDE_DIR == ctx_config.cfg.claude_dir
-    assert skill_unload.WIKI_DIR == ctx_config.cfg.wiki_dir
-    assert skill_unload.MANIFEST_PATH == ctx_config.cfg.skill_manifest
-    assert skill_health.SKILLS_DIR == ctx_config.cfg.skills_dir
-    assert skill_health.AGENTS_DIR == ctx_config.cfg.agents_dir
-    assert skill_health.PENDING_PATH == ctx_config.cfg.pending_skills
-    assert skill_health.MANIFEST_PATH == ctx_config.cfg.skill_manifest
-
-
-class TestConfigReload:
-    """test_config_reload -- reload() picks up changes to the raw config."""
-
-    def test_reload_updates_singleton(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-        # Write a temporary default config with a custom line_threshold
-        custom_config = tmp_path / "config.json"
-        import json
-
-        custom_config.write_text(
-            json.dumps({"skill_transformer": {"line_threshold": 999}}),
-            encoding="utf-8",
-        )
-
-        # Patch the module-level constants so _load_raw reads our file
-        monkeypatch.setattr(ctx_config, "_DEFAULT_CONFIG", custom_config)
-        # Also suppress user config so it doesn't bleed in
-        monkeypatch.setattr(ctx_config, "_USER_CONFIG", tmp_path / "nonexistent.json")
-
-        ctx_config.reload()
-        assert ctx_config.cfg.line_threshold == 999
-
-    def test_reload_restores_after_monkeypatch(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """After reload with empty config the attribute still exists (defaults apply)."""
-        empty_config = tmp_path / "empty.json"
-        empty_config.write_text("{}", encoding="utf-8")
-
-        monkeypatch.setattr(ctx_config, "_DEFAULT_CONFIG", empty_config)
-        monkeypatch.setattr(ctx_config, "_USER_CONFIG", tmp_path / "nonexistent.json")
-
-        ctx_config.reload()
-        # line_threshold should fall back to the packaged default 180
-        assert ctx_config.cfg.line_threshold == 180
-
-
-class TestConfigAllSkillDirs:
-    """test_config_all_skill_dirs -- all_skill_dirs() returns a list of existing dirs."""
-
-    def test_returns_list(self) -> None:
-        cfg = Config(_minimal_raw())
-        result = cfg.all_skill_dirs()
-        assert isinstance(result, list)
-
-    def test_contains_only_existing_dirs(self) -> None:
-        cfg = Config(_minimal_raw())
-        for d in cfg.all_skill_dirs():
-            assert d.exists() and d.is_dir(), f"{d} does not exist or is not a directory"
-
-    def test_extra_dirs_included_when_they_exist(self, tmp_path: Path) -> None:
-        extra = tmp_path / "extra-skills"
-        extra.mkdir()
-        raw = _minimal_raw({"extra_skill_dirs": [str(extra)]})
-        cfg = Config(raw)
-        assert extra in cfg.all_skill_dirs()
-
-    def test_nonexistent_extra_dirs_excluded(self, tmp_path: Path) -> None:
-        ghost = tmp_path / "ghost-skills"
-        # intentionally do NOT create it
-        raw = _minimal_raw({"extra_skill_dirs": [str(ghost)]})
-        cfg = Config(raw)
-        assert ghost not in cfg.all_skill_dirs()
-
-
-class TestConfigDeepMerge:
-    """test_config_deep_merge -- nested dicts merge correctly and override wins."""
-
-    def test_override_scalar_wins(self) -> None:
-        base: dict[str, Any] = {"a": 1, "b": 2}
-        override: dict[str, Any] = {"b": 99}
-        _deep_merge(base, override)
-        assert base["b"] == 99
-        assert base["a"] == 1  # untouched
-
-    def test_nested_dict_merged_not_replaced(self) -> None:
-        base: dict[str, Any] = {"paths": {"wiki_dir": "~/wiki", "skills_dir": "~/skills"}}
-        override: dict[str, Any] = {"paths": {"wiki_dir": "~/custom-wiki"}}
-        _deep_merge(base, override)
-        # wiki_dir is overridden
-        assert base["paths"]["wiki_dir"] == "~/custom-wiki"
-        # skills_dir is preserved from base
-        assert base["paths"]["skills_dir"] == "~/skills"
-
-    def test_new_key_added(self) -> None:
-        base: dict[str, Any] = {"x": 1}
-        override: dict[str, Any] = {"y": 2}
-        _deep_merge(base, override)
-        assert base["y"] == 2
-
-    def test_deeply_nested_override(self) -> None:
-        base: dict[str, Any] = {"a": {"b": {"c": 10, "d": 20}}}
-        override: dict[str, Any] = {"a": {"b": {"c": 99}}}
-        _deep_merge(base, override)
-        assert base["a"]["b"]["c"] == 99
-        assert base["a"]["b"]["d"] == 20
-
-    def test_override_replaces_non_dict_with_scalar(self) -> None:
-        base: dict[str, Any] = {"a": {"nested": True}}
-        override: dict[str, Any] = {"a": "flat"}
-        _deep_merge(base, override)
-        assert base["a"] == "flat"
-
-
-class TestConfigIntake:
-    """test_config_intake -- intake gate section is exposed with defaults."""
-
-    def test_intake_defaults(self) -> None:
-        cfg = Config(_minimal_raw())
-        assert cfg.intake_enabled is True
-        assert cfg.intake_dup_threshold == pytest.approx(0.93)
-        assert cfg.intake_near_dup_threshold == pytest.approx(0.80)
-        assert cfg.intake_min_neighbors == 0
-        assert cfg.intake_min_neighbor_score == pytest.approx(0.30)
-        assert cfg.intake_min_body_chars == 120
-        assert cfg.intake_backend == "sentence-transformers"
-        assert cfg.intake_model is None
-        assert cfg.intake_base_url is None
-        assert cfg.intake_allow_remote is False
-        assert isinstance(cfg.intake_cache_root, Path)
-        assert cfg.intake_cache_root.is_absolute()
-
-    def test_intake_overrides_applied(self) -> None:
-        raw = _minimal_raw({
-            "intake": {
-                "enabled": False,
-                "dup_threshold": 0.95,
-                "near_dup_threshold": 0.80,
-                "min_neighbors": 2,
-                "min_neighbor_score": 0.50,
-                "min_body_chars": 200,
-                "embedding": {
-                    "backend": "ollama",
-                    "model": "nomic-embed-text",
-                    "allow_remote": True,
-                },
-            },
-        })
-        cfg = Config(raw)
-        assert cfg.intake_enabled is False
-        assert cfg.intake_dup_threshold == pytest.approx(0.95)
-        assert cfg.intake_near_dup_threshold == pytest.approx(0.80)
-        assert cfg.intake_min_neighbors == 2
-        assert cfg.intake_min_neighbor_score == pytest.approx(0.50)
-        assert cfg.intake_min_body_chars == 200
-        assert cfg.intake_backend == "ollama"
-        assert cfg.intake_model == "nomic-embed-text"
-        assert cfg.intake_allow_remote is True
-
-    def test_build_intake_config_returns_dataclass(self) -> None:
-        from intake_gate import IntakeConfig
-
-        cfg = Config(_minimal_raw())
-        ic = cfg.build_intake_config()
-        assert isinstance(ic, IntakeConfig)
-        assert ic.dup_threshold == pytest.approx(0.93)
-        assert ic.near_dup_threshold == pytest.approx(0.80)
-        assert ic.min_body_chars == 120
-
-    def test_build_intake_config_honours_overrides(self) -> None:
-        raw = _minimal_raw({
-            "intake": {"dup_threshold": 0.91, "near_dup_threshold": 0.75},
-        })
-        cfg = Config(raw)
-        ic = cfg.build_intake_config()
-        assert ic.dup_threshold == pytest.approx(0.91)
-        assert ic.near_dup_threshold == pytest.approx(0.75)
-
-    def test_build_intake_embedder_returns_sentence_transformer(self) -> None:
-        from embedding_backend import SentenceTransformerEmbedder
-
-        cfg = Config(_minimal_raw())
-        emb = cfg.build_intake_embedder()
-        assert isinstance(emb, SentenceTransformerEmbedder)
-
-    def test_build_intake_embedder_ollama_selection(self) -> None:
-        from embedding_backend import OllamaEmbedder
-
-        raw = _minimal_raw({
-            "intake": {"embedding": {"backend": "ollama"}},
-        })
-        cfg = Config(raw)
-        emb = cfg.build_intake_embedder()
-        assert isinstance(emb, OllamaEmbedder)
-
-    def test_non_string_model_falls_back_to_none(self) -> None:
-        raw = _minimal_raw({
-            "intake": {"embedding": {"model": 42}},  # wrong type
-        })
-        cfg = Config(raw)
-        assert cfg.intake_model is None
+"""
+test_config.py -- Tests for the ctx_config.Config system.
+
+Covers:
+  - ctx_config.Config: attribute types, path expansion, reload, deep merge,
+    all_skill_dirs()
+"""
+
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# sys.path is already patched by conftest.py, but guard here too so the module
+# can be run in isolation (e.g. `python -m pytest tests/test_config.py`).
+# ---------------------------------------------------------------------------
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+import ctx_config  # noqa: E402
+from ctx_config import Config, _deep_merge  # noqa: E402
+
+
+# ===========================================================================
+# Helper
+# ===========================================================================
+
+
+def _minimal_raw(overrides: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Return a minimal raw-config dict sufficient to construct a Config."""
+    raw: dict[str, Any] = {
+        "paths": {
+            "claude_dir": "~/.claude",
+            "wiki_dir": "~/.claude/skill-wiki",
+            "skills_dir": "~/.claude/skills",
+            "agents_dir": "~/.claude/agents",
+            "skill_manifest": "~/.claude/skill-manifest.json",
+            "intent_log": "~/.claude/intent-log.jsonl",
+            "pending_skills": "~/.claude/pending-skills.json",
+            "skill_registry": "~/.claude/skill-registry.json",
+            "stack_profile_tmp": "~/.claude/skill-stack-profile.json",
+            "catalog": "~/.claude/skill-wiki/catalog.md",
+        },
+        "resolver": {},
+        "context_monitor": {},
+        "usage_tracker": {},
+        "skill_transformer": {},
+        "skill_router": {},
+        "extra_skill_dirs": [],
+        "babysitter": {},
+    }
+    if overrides:
+        _deep_merge(raw, overrides)
+    return raw
+
+
+# ===========================================================================
+# Config tests
+# ===========================================================================
+
+
+class TestConfigLoadsDefaults:
+    """test_config_loads_defaults -- expected attributes exist with correct defaults."""
+
+    def test_has_wiki_dir(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert hasattr(cfg, "wiki_dir")
+
+    def test_has_skills_dir(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert hasattr(cfg, "skills_dir")
+
+    def test_line_threshold_default(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.line_threshold == 180
+
+    def test_line_threshold_accepts_user_value(self) -> None:
+        cfg = Config(_minimal_raw({"skill_transformer": {"line_threshold": 240}}))
+        assert cfg.line_threshold == 240
+
+    @pytest.mark.parametrize("value", [0, -1, "not-an-int", "240", True, False, 1.5])
+    def test_line_threshold_rejects_invalid_values(self, value: object) -> None:
+        with pytest.raises(ValueError, match="skill_transformer.line_threshold"):
+            Config(_minimal_raw({"skill_transformer": {"line_threshold": value}}))
+
+    def test_max_stage_lines_default(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.max_stage_lines == 40
+
+    def test_max_skills_default(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.max_skills == 15
+
+    def test_stage_count_default(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.stage_count == 5
+
+
+class TestConfigPathsArePathlib:
+    """test_config_paths_are_pathlib -- all path attributes are Path objects."""
+
+    PATH_ATTRS = [
+        "claude_dir",
+        "wiki_dir",
+        "skills_dir",
+        "agents_dir",
+        "skill_manifest",
+        "intent_log",
+        "pending_skills",
+        "skill_registry",
+        "stack_profile_tmp",
+        "catalog",
+    ]
+
+    @pytest.mark.parametrize("attr", PATH_ATTRS)
+    def test_attr_is_path(
+        self,
+        attr: str,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        cfg = Config(_minimal_raw())
+        assert isinstance(getattr(cfg, attr), Path), (
+            f"cfg.{attr} should be a Path, got {type(getattr(cfg, attr))}"
+        )
+
+        if attr == "stack_profile_tmp":
+            raw = _minimal_raw()
+            del raw["paths"]["stack_profile_tmp"]
+            monkeypatch.setattr(tempfile, "gettempdir", lambda: str(tmp_path))
+
+            cfg = Config(raw)
+
+            assert cfg.stack_profile_tmp == tmp_path / "skill-stack-profile.json"
+
+
+class TestConfigExpandTilde:
+    """test_config_expand_tilde -- paths with ~ are expanded to absolute paths."""
+
+    def test_wiki_dir_is_absolute(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.wiki_dir.is_absolute(), (
+            f"wiki_dir should be absolute after ~ expansion, got: {cfg.wiki_dir}"
+        )
+
+    def test_skills_dir_is_absolute(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.skills_dir.is_absolute()
+
+    def test_claude_dir_is_absolute(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.claude_dir.is_absolute()
+
+    def test_custom_tilde_path_expanded(self) -> None:
+        raw = _minimal_raw({"paths": {"wiki_dir": "~/custom-wiki"}})
+        cfg = Config(raw)
+        assert "~" not in str(cfg.wiki_dir)
+        assert cfg.wiki_dir.is_absolute()
+
+
+def test_claude_adapter_modules_use_cfg_paths() -> None:
+    from ctx.adapters.claude_code import skill_health, skill_loader
+    from ctx.adapters.claude_code.install import install_utils, skill_unload
+
+    assert install_utils.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+    assert skill_loader.SKILLS_DIR == ctx_config.cfg.skills_dir
+    assert skill_loader.AGENTS_DIR == ctx_config.cfg.agents_dir
+    assert skill_loader.WIKI_DIR == ctx_config.cfg.wiki_dir
+    assert skill_loader.PENDING_SKILLS == ctx_config.cfg.pending_skills
+    assert skill_loader.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+    assert skill_unload.CLAUDE_DIR == ctx_config.cfg.claude_dir
+    assert skill_unload.WIKI_DIR == ctx_config.cfg.wiki_dir
+    assert skill_unload.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+    assert skill_health.SKILLS_DIR == ctx_config.cfg.skills_dir
+    assert skill_health.AGENTS_DIR == ctx_config.cfg.agents_dir
+    assert skill_health.PENDING_PATH == ctx_config.cfg.pending_skills
+    assert skill_health.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+
+
+class TestConfigReload:
+    """test_config_reload -- reload() picks up changes to the raw config."""
+
+    def test_reload_updates_singleton(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        # Write a temporary default config with a custom line_threshold
+        custom_config = tmp_path / "config.json"
+        import json
+
+        custom_config.write_text(
+            json.dumps({"skill_transformer": {"line_threshold": 999}}),
+            encoding="utf-8",
+        )
+
+        # Patch the module-level constants so _load_raw reads our file
+        monkeypatch.setattr(ctx_config, "_DEFAULT_CONFIG", custom_config)
+        # Also suppress user config so it doesn't bleed in
+        monkeypatch.setattr(ctx_config, "_USER_CONFIG", tmp_path / "nonexistent.json")
+
+        ctx_config.reload()
+        assert ctx_config.cfg.line_threshold == 999
+
+    def test_reload_restores_after_monkeypatch(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """After reload with empty config the attribute still exists (defaults apply)."""
+        empty_config = tmp_path / "empty.json"
+        empty_config.write_text("{}", encoding="utf-8")
+
+        monkeypatch.setattr(ctx_config, "_DEFAULT_CONFIG", empty_config)
+        monkeypatch.setattr(ctx_config, "_USER_CONFIG", tmp_path / "nonexistent.json")
+
+        ctx_config.reload()
+        # line_threshold should fall back to the packaged default 180
+        assert ctx_config.cfg.line_threshold == 180
+
+
+class TestConfigAllSkillDirs:
+    """test_config_all_skill_dirs -- all_skill_dirs() returns a list of existing dirs."""
+
+    def test_returns_list(self) -> None:
+        cfg = Config(_minimal_raw())
+        result = cfg.all_skill_dirs()
+        assert isinstance(result, list)
+
+    def test_contains_only_existing_dirs(self) -> None:
+        cfg = Config(_minimal_raw())
+        for d in cfg.all_skill_dirs():
+            assert d.exists() and d.is_dir(), f"{d} does not exist or is not a directory"
+
+    def test_extra_dirs_included_when_they_exist(self, tmp_path: Path) -> None:
+        extra = tmp_path / "extra-skills"
+        extra.mkdir()
+        raw = _minimal_raw({"extra_skill_dirs": [str(extra)]})
+        cfg = Config(raw)
+        assert extra in cfg.all_skill_dirs()
+
+    def test_nonexistent_extra_dirs_excluded(self, tmp_path: Path) -> None:
+        ghost = tmp_path / "ghost-skills"
+        # intentionally do NOT create it
+        raw = _minimal_raw({"extra_skill_dirs": [str(ghost)]})
+        cfg = Config(raw)
+        assert ghost not in cfg.all_skill_dirs()
+
+
+class TestConfigDeepMerge:
+    """test_config_deep_merge -- nested dicts merge correctly and override wins."""
+
+    def test_override_scalar_wins(self) -> None:
+        base: dict[str, Any] = {"a": 1, "b": 2}
+        override: dict[str, Any] = {"b": 99}
+        _deep_merge(base, override)
+        assert base["b"] == 99
+        assert base["a"] == 1  # untouched
+
+    def test_nested_dict_merged_not_replaced(self) -> None:
+        base: dict[str, Any] = {"paths": {"wiki_dir": "~/wiki", "skills_dir": "~/skills"}}
+        override: dict[str, Any] = {"paths": {"wiki_dir": "~/custom-wiki"}}
+        _deep_merge(base, override)
+        # wiki_dir is overridden
+        assert base["paths"]["wiki_dir"] == "~/custom-wiki"
+        # skills_dir is preserved from base
+        assert base["paths"]["skills_dir"] == "~/skills"
+
+    def test_new_key_added(self) -> None:
+        base: dict[str, Any] = {"x": 1}
+        override: dict[str, Any] = {"y": 2}
+        _deep_merge(base, override)
+        assert base["y"] == 2
+
+    def test_deeply_nested_override(self) -> None:
+        base: dict[str, Any] = {"a": {"b": {"c": 10, "d": 20}}}
+        override: dict[str, Any] = {"a": {"b": {"c": 99}}}
+        _deep_merge(base, override)
+        assert base["a"]["b"]["c"] == 99
+        assert base["a"]["b"]["d"] == 20
+
+    def test_override_replaces_non_dict_with_scalar(self) -> None:
+        base: dict[str, Any] = {"a": {"nested": True}}
+        override: dict[str, Any] = {"a": "flat"}
+        _deep_merge(base, override)
+        assert base["a"] == "flat"
+
+
+class TestConfigIntake:
+    """test_config_intake -- intake gate section is exposed with defaults."""
+
+    def test_intake_defaults(self) -> None:
+        cfg = Config(_minimal_raw())
+        assert cfg.intake_enabled is True
+        assert cfg.intake_dup_threshold == pytest.approx(0.93)
+        assert cfg.intake_near_dup_threshold == pytest.approx(0.80)
+        assert cfg.intake_min_neighbors == 0
+        assert cfg.intake_min_neighbor_score == pytest.approx(0.30)
+        assert cfg.intake_min_body_chars == 120
+        assert cfg.intake_backend == "sentence-transformers"
+        assert cfg.intake_model is None
+        assert cfg.intake_base_url is None
+        assert cfg.intake_allow_remote is False
+        assert isinstance(cfg.intake_cache_root, Path)
+        assert cfg.intake_cache_root.is_absolute()
+
+    def test_intake_overrides_applied(self) -> None:
+        raw = _minimal_raw({
+            "intake": {
+                "enabled": False,
+                "dup_threshold": 0.95,
+                "near_dup_threshold": 0.80,
+                "min_neighbors": 2,
+                "min_neighbor_score": 0.50,
+                "min_body_chars": 200,
+                "embedding": {
+                    "backend": "ollama",
+                    "model": "nomic-embed-text",
+                    "allow_remote": True,
+                },
+            },
+        })
+        cfg = Config(raw)
+        assert cfg.intake_enabled is False
+        assert cfg.intake_dup_threshold == pytest.approx(0.95)
+        assert cfg.intake_near_dup_threshold == pytest.approx(0.80)
+        assert cfg.intake_min_neighbors == 2
+        assert cfg.intake_min_neighbor_score == pytest.approx(0.50)
+        assert cfg.intake_min_body_chars == 200
+        assert cfg.intake_backend == "ollama"
+        assert cfg.intake_model == "nomic-embed-text"
+        assert cfg.intake_allow_remote is True
+
+    def test_build_intake_config_returns_dataclass(self) -> None:
+        from intake_gate import IntakeConfig
+
+        cfg = Config(_minimal_raw())
+        ic = cfg.build_intake_config()
+        assert isinstance(ic, IntakeConfig)
+        assert ic.dup_threshold == pytest.approx(0.93)
+        assert ic.near_dup_threshold == pytest.approx(0.80)
+        assert ic.min_body_chars == 120
+
+    def test_build_intake_config_honours_overrides(self) -> None:
+        raw = _minimal_raw({
+            "intake": {"dup_threshold": 0.91, "near_dup_threshold": 0.75},
+        })
+        cfg = Config(raw)
+        ic = cfg.build_intake_config()
+        assert ic.dup_threshold == pytest.approx(0.91)
+        assert ic.near_dup_threshold == pytest.approx(0.75)
+
+    def test_build_intake_embedder_returns_sentence_transformer(self) -> None:
+        from embedding_backend import SentenceTransformerEmbedder
+
+        cfg = Config(_minimal_raw())
+        emb = cfg.build_intake_embedder()
+        assert isinstance(emb, SentenceTransformerEmbedder)
+
+    def test_build_intake_embedder_ollama_selection(self) -> None:
+        from embedding_backend import OllamaEmbedder
+
+        raw = _minimal_raw({
+            "intake": {"embedding": {"backend": "ollama"}},
+        })
+        cfg = Config(raw)
+        emb = cfg.build_intake_embedder()
+        assert isinstance(emb, OllamaEmbedder)
+
+    def test_non_string_model_falls_back_to_none(self) -> None:
+        raw = _minimal_raw({
+            "intake": {"embedding": {"model": 42}},  # wrong type
+        })
+        cfg = Config(raw)
+        assert cfg.intake_model is None

src/tests/test_context_monitor.py

@@ -1,529 +1,529 @@
-"""
-tests/test_context_monitor.py -- pytest suite for context_monitor module.
-
-Covers:
-  - extract_signals             (keyword match, extension match, Bash tool signals, empty input)
-  - load_manifest_skills        (happy, missing file, bad json)
-  - append_intent_log           (creates file, appends)
-  - count_recent_unmatched      (matched vs unmatched)
-  - write_pending_skills        (creates file, content)
-  - load_recent_unmatched_count (happy path, missing file, skips bad lines)
-  - _parse_stdin_payload        (valid JSON, empty stdin, non-dict, bad JSON)
-  - main()                      (--tool/--input flags, --from-stdin flag, no signals exit-0)
-"""
-
-import io
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).parents[1]))
-
-from ctx.adapters.claude_code.hooks import context_monitor as _cm
-from ctx.adapters.claude_code.hooks.context_monitor import (
-    _parse_stdin_payload,
-    append_intent_log,
-    count_recent_unmatched,
-    extract_signals,
-    load_manifest_skills,
-    load_recent_unmatched_count,
-    write_pending_skills,
-)
-
-TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-
-
-# ---------------------------------------------------------------------------
-# extract_signals
-# ---------------------------------------------------------------------------
-
-class TestExtractSignals:
-    def test_keyword_match_react(self):
-        signals = extract_signals("Read", {"file_path": "src/App.tsx"})
-        assert "react" in signals
-
-    def test_keyword_match_docker(self):
-        signals = extract_signals("Read", {"file_path": "Dockerfile"})
-        assert "docker" in signals
-
-    def test_extension_tsx_triggers_react(self):
-        signals = extract_signals("Read", {"file_path": "component.tsx"})
-        assert "react" in signals
-
-    def test_extension_tf_triggers_terraform(self):
-        signals = extract_signals("Write", {"file_path": "main.tf"})
-        assert "terraform" in signals
-
-    def test_bash_pip_install_triggers_python(self):
-        signals = extract_signals("Bash", {"command": "pip install fastapi"})
-        assert "python" in signals
-
-    def test_bash_npm_install_triggers_javascript(self):
-        signals = extract_signals("Bash", {"command": "npm install react"})
-        assert "javascript" in signals
-
-    def test_empty_input_returns_empty(self):
-        signals = extract_signals("Read", {})
-        assert signals == []
-
-    def test_no_match_returns_empty(self):
-        signals = extract_signals("Read", {"file_path": "README.md"})
-        assert signals == []
-
-    def test_multiple_signals_deduped(self):
-        signals = extract_signals("Read", {"content": "react jsx tsx"})
-        # react should appear only once despite 3 matching keywords
-        assert signals.count("react") == 1
-
-    def test_signals_sorted(self):
-        signals = extract_signals("Bash", {"command": "docker-compose up"})
-        assert signals == sorted(signals)
-
-    def test_anthropic_keyword_maps_to_sdk(self):
-        signals = extract_signals("Read", {"content": "from anthropic import Anthropic"})
-        assert "anthropic-sdk" in signals
-
-    def test_kubernetes_keyword_match(self):
-        signals = extract_signals("Bash", {"command": "kubectl apply -f deployment.yaml"})
-        assert "kubernetes" in signals
-
-    def test_case_insensitive_match(self):
-        signals = extract_signals("Read", {"content": "FASTAPI app = FastAPI()"})
-        assert "fastapi" in signals
-
-
-# ---------------------------------------------------------------------------
-# load_manifest_skills
-# ---------------------------------------------------------------------------
-
-class TestLoadManifestSkills:
-    def test_happy_path(self, tmp_path, monkeypatch):
-        manifest = {"load": [{"skill": "react"}, {"skill": "docker"}]}
-        mpath = tmp_path / "manifest.json"
-        mpath.write_text(json.dumps(manifest))
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", mpath)
-        result = load_manifest_skills()
-        assert result == {"react", "docker"}
-
-    def test_missing_file_returns_empty_set(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "no-such.json")
-        assert load_manifest_skills() == set()
-
-    def test_bad_json_returns_empty_set(self, tmp_path, monkeypatch):
-        mpath = tmp_path / "manifest.json"
-        mpath.write_text("not-json")
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", mpath)
-        assert load_manifest_skills() == set()
-
-    def test_empty_load_list(self, tmp_path, monkeypatch):
-        mpath = tmp_path / "manifest.json"
-        mpath.write_text(json.dumps({"load": []}))
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", mpath)
-        assert load_manifest_skills() == set()
-
-
-# ---------------------------------------------------------------------------
-# append_intent_log
-# ---------------------------------------------------------------------------
-
-class TestAppendIntentLog:
-    def test_creates_file_and_appends(self, tmp_path, monkeypatch):
-        log = tmp_path / "intent.jsonl"
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        entry = {"date": TODAY, "signals": ["react"]}
-        append_intent_log(entry)
-        lines = [line for line in log.read_text().strip().split("\n") if line]
-        assert len(lines) == 1
-        assert json.loads(lines[0])["signals"] == ["react"]
-
-    def test_appends_multiple_entries(self, tmp_path, monkeypatch):
-        log = tmp_path / "intent.jsonl"
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        append_intent_log({"date": TODAY, "signals": ["react"]})
-        append_intent_log({"date": TODAY, "signals": ["docker"]})
-        lines = [line for line in log.read_text().strip().split("\n") if line]
-        assert len(lines) == 2
-
-
-# ---------------------------------------------------------------------------
-# count_recent_unmatched
-# ---------------------------------------------------------------------------
-
-class TestCountRecentUnmatched:
-    def test_all_matched(self):
-        unmatched = count_recent_unmatched(["react", "docker"], {"react", "docker"})
-        assert unmatched == []
-
-    def test_none_matched(self):
-        unmatched = count_recent_unmatched(["react", "docker"], set())
-        assert set(unmatched) == {"react", "docker"}
-
-    def test_partial_match(self):
-        unmatched = count_recent_unmatched(["react", "docker"], {"react"})
-        assert unmatched == ["docker"]
-
-    def test_empty_signals(self):
-        assert count_recent_unmatched([], {"react"}) == []
-
-
-# ---------------------------------------------------------------------------
-# write_pending_skills
-# ---------------------------------------------------------------------------
-
-class TestWritePendingSkills:
-    def test_writes_pending_skills_file(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(_cm, "graph_suggest", lambda unmatched: [])
-        write_pending_skills(["react", "docker"])
-        pending = json.loads((tmp_path / "pending.json").read_text())
-        assert pending["unmatched_signals"] == ["react", "docker"]
-        assert "suggestion" in pending
-
-    def test_suggestion_mentions_signals(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(_cm, "graph_suggest", lambda unmatched: [])
-        write_pending_skills(["fastapi"])
-        pending = json.loads((tmp_path / "pending.json").read_text())
-        assert "fastapi" in pending["suggestion"]
-
-    def test_empty_unmatched(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(_cm, "graph_suggest", lambda unmatched: [])
-        write_pending_skills([])
-        pending = json.loads((tmp_path / "pending.json").read_text())
-        assert pending["unmatched_signals"] == []
-
-    def test_graph_suggestions_list_present(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(
-            _cm,
-            "graph_suggest",
-            lambda unmatched: [{"name": "fastapi-pro", "type": "skill"}],
-        )
-        write_pending_skills(["unknown-signal"])
-        pending = json.loads((tmp_path / "pending.json").read_text())
-        assert pending["graph_suggestions"] == [{"name": "fastapi-pro", "type": "skill"}]
-
-    def test_graph_suggest_filters_to_execution_bundle_types(self, tmp_path, monkeypatch):
-        graph_path = tmp_path / "skill-wiki" / "graphify-out" / "graph.json"
-        graph_path.parent.mkdir(parents=True)
-        graph_path.write_text("{}", encoding="utf-8")
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        calls = {}
-
-        class FakeGraph:
-            def number_of_nodes(self):
-                return 1
-
-        fake_graph_module = type(
-            "FakeGraphModule",
-            (),
-            {"load_graph": staticmethod(lambda _path=None: FakeGraph())},
-        )
-
-        def fake_recommend_by_tags(graph, tags, **kwargs):
-            calls["entity_types"] = kwargs.get("entity_types")
-            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.graph.resolve_graph", fake_graph_module)
-        monkeypatch.setitem(
-            sys.modules,
-            "ctx.core.resolve.recommendations",
-            fake_recommend_module,
-        )
-
-        assert _cm.graph_suggest(["fastapi"]) == [{"name": "fastapi-pro", "type": "skill"}]
-        assert calls["entity_types"] == ("skill", "agent", "mcp-server")
-
-
-# ---------------------------------------------------------------------------
-# load_recent_unmatched_count
-# ---------------------------------------------------------------------------
-
-class TestLoadRecentUnmatchedCount:
-    def _write_log(self, path: Path, entries: list[dict]) -> None:
-        path.write_text("\n".join(json.dumps(e) for e in entries) + "\n")
-
-    def test_happy_path_counts_distinct(self, tmp_path, monkeypatch):
-        log = tmp_path / "intent.jsonl"
-        self._write_log(log, [
-            {"date": TODAY, "unmatched": ["react", "docker"]},
-            {"date": TODAY, "unmatched": ["react"]},  # react already counted
-        ])
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        count = load_recent_unmatched_count()
-        assert count == 2  # react + docker distinct
-
-    def test_missing_file_returns_0(self, tmp_path, monkeypatch):
-        monkeypatch.setattr(_cm, "INTENT_LOG", tmp_path / "nope.jsonl")
-        assert load_recent_unmatched_count() == 0
-
-    def test_skips_bad_lines(self, tmp_path, monkeypatch):
-        log = tmp_path / "intent.jsonl"
-        log.write_text(f'not-json\n{json.dumps({"date": TODAY, "unmatched": ["react"]})}\n')
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        assert load_recent_unmatched_count() == 1
-
-    def test_other_dates_not_counted(self, tmp_path, monkeypatch):
-        log = tmp_path / "intent.jsonl"
-        self._write_log(log, [{"date": "2000-01-01", "unmatched": ["react"]}])
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        assert load_recent_unmatched_count() == 0
-
-
-# ---------------------------------------------------------------------------
-# _parse_stdin_payload
-# ---------------------------------------------------------------------------
-
-class TestParseStdinPayload:
-    def test_valid_payload(self, monkeypatch):
-        payload = json.dumps({"tool_name": "Read", "tool_input": {"file_path": "foo.py"}})
-        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
-        tool_name, tool_input = _parse_stdin_payload()
-        assert tool_name == "Read"
-        assert tool_input == {"file_path": "foo.py"}
-
-    def test_empty_stdin(self, monkeypatch):
-        monkeypatch.setattr(sys, "stdin", io.StringIO(""))
-        tool_name, tool_input = _parse_stdin_payload()
-        assert tool_name == "unknown"
-        assert tool_input == {}
-
-    def test_non_dict_json(self, monkeypatch):
-        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps([1, 2, 3])))
-        tool_name, tool_input = _parse_stdin_payload()
-        assert tool_name == "unknown"
-
-    def test_bad_json(self, monkeypatch):
-        monkeypatch.setattr(sys, "stdin", io.StringIO("not-json"))
-        tool_name, tool_input = _parse_stdin_payload()
-        assert tool_name == "unknown"
-        assert tool_input == {}
-
-    def test_missing_tool_input_defaults_to_empty(self, monkeypatch):
-        payload = json.dumps({"tool_name": "Bash"})
-        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
-        _, tool_input = _parse_stdin_payload()
-        assert tool_input == {}
-
-    def test_non_dict_tool_input_defaults_to_empty(self, monkeypatch):
-        payload = json.dumps({"tool_name": "Bash", "tool_input": "not-a-dict"})
-        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
-        _, tool_input = _parse_stdin_payload()
-        assert tool_input == {}
-
-
-# ---------------------------------------------------------------------------
-# main()
-# ---------------------------------------------------------------------------
-
-class TestMain:
-    def test_no_signals_exits_0(self, tmp_path, monkeypatch):
-        """When tool input produces no signals, main exits 0."""
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        monkeypatch.setattr(_cm, "INTENT_LOG", tmp_path / "intent.jsonl")
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", "{}"])
-        with pytest.raises(SystemExit) as exc:
-            _cm.main()
-        assert exc.value.code == 0
-
-    def test_signals_appended_to_log(self, tmp_path, monkeypatch):
-        """Signals from --input are written to the intent log."""
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        log = tmp_path / "intent.jsonl"
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(_cm, "_THRESHOLD", 999)  # prevent pending write
-        tool_input = json.dumps({"file_path": "Dockerfile"})
-        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", tool_input])
-        _cm.main()
-        lines = [line for line in log.read_text().strip().split("\n") if line]
-        assert len(lines) == 1
-        entry = json.loads(lines[0])
-        assert "docker" in entry["signals"]
-
-    def test_from_stdin_flag(self, tmp_path, monkeypatch):
-        """--from-stdin reads tool payload from stdin."""
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        log = tmp_path / "intent.jsonl"
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(_cm, "_THRESHOLD", 999)
-        payload = json.dumps({"tool_name": "Read", "tool_input": {"file_path": "Dockerfile"}})
-        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
-        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--from-stdin"])
-        _cm.main()
-        lines = [line for line in log.read_text().strip().split("\n") if line]
-        assert len(lines) == 1
-        entry = json.loads(lines[0])
-        assert "docker" in entry["signals"]
-
-    def test_bad_json_input_falls_back_to_raw(self, tmp_path, monkeypatch):
-        """Malformed --input falls back to {'raw': value} and may produce no signals."""
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        log = tmp_path / "intent.jsonl"
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
-        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", "not-json"])
-        # Should not crash
-        try:
-            _cm.main()
-        except SystemExit as e:
-            assert e.code == 0  # exits 0 when no signals
-
-    def test_threshold_triggers_pending_write(self, tmp_path, monkeypatch):
-        """When unmatched count >= threshold, pending-skills.json is written."""
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        log = tmp_path / "intent.jsonl"
-        pending = tmp_path / "pending.json"
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", pending)
-        monkeypatch.setattr(_cm, "_THRESHOLD", 1)  # trigger on 1 unmatched
-        tool_input = json.dumps({"file_path": "Dockerfile"})
-        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", tool_input])
-        _cm.main()
-        assert pending.exists()
-
-
-# ---------------------------------------------------------------------------
-# Cumulative-threshold regression (code-reviewer finding BLOCKER)
-# ---------------------------------------------------------------------------
-#
-# Prior impl used ``len(unmatched) >= THRESHOLD`` where ``unmatched`` is the
-# per-invocation list. A single tool call almost never surfaces 3 unmatched
-# signals alone, so the default threshold=3 meant pending-skills.json was
-# essentially never written — silently killing the suggestion arm of the
-# alive loop. The fix walks the intent log and checks the cumulative
-# (per-day, across all invocations) unmatched count against the threshold.
-
-class TestCumulativeThreshold:
-    """The threshold must fire on cumulative unmatched across today's log,
-    not just on a single invocation's count.
-    """
-
-    def _setup_paths(self, tmp_path, monkeypatch):
-        log = tmp_path / "intent.jsonl"
-        pending = tmp_path / "pending.json"
-        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
-        monkeypatch.setattr(_cm, "INTENT_LOG", log)
-        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
-        monkeypatch.setattr(_cm, "PENDING_SKILLS", pending)
-        return log, pending
-
-    def _run_main(self, monkeypatch, tool_name: str, tool_input: dict):
-        monkeypatch.setattr(
-            sys, "argv",
-            ["context_monitor.py", "--tool", tool_name, "--input", json.dumps(tool_input)],
-        )
-        _cm.main()
-
-    def test_fires_on_cumulative_across_three_invocations(
-        self, tmp_path, monkeypatch,
-    ):
-        """Three invocations each surfacing ONE unmatched signal should
-        trigger pending-skills write when THRESHOLD=3.
-
-        This is the case the old len(unmatched)>=THRESHOLD check missed.
-        The user types a react file, then opens a Dockerfile, then edits
-        terraform — three separate tool calls, three different unmatched
-        signals, cumulatively at threshold.
-        """
-        _, pending = self._setup_paths(tmp_path, monkeypatch)
-        monkeypatch.setattr(_cm, "_THRESHOLD", 3)
-
-        # Three invocations, one unique unmatched signal each.
-        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})       # react
-        assert not pending.exists(), "fired after 1 cumulative unmatched"
-
-        self._run_main(monkeypatch, "Read", {"file_path": "Dockerfile"})    # docker
-        assert not pending.exists(), "fired after 2 cumulative unmatched"
-
-        self._run_main(monkeypatch, "Read", {"file_path": "main.tf"})       # terraform
-        assert pending.exists(), (
-            "did NOT fire after 3 cumulative unmatched — "
-            "the per-invocation threshold bug regressed"
-        )
-
-    def test_does_not_fire_below_cumulative_threshold(
-        self, tmp_path, monkeypatch,
-    ):
-        """Below-threshold cumulative count must NOT trigger.
-
-        Otherwise every first-keystroke would spam pending-skills.json.
-        """
-        _, pending = self._setup_paths(tmp_path, monkeypatch)
-        monkeypatch.setattr(_cm, "_THRESHOLD", 3)
-
-        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})
-        self._run_main(monkeypatch, "Read", {"file_path": "Dockerfile"})
-        # Only 2 unique signals accumulated; THRESHOLD=3 => no write.
-        assert not pending.exists()
-
-    def test_fires_when_single_invocation_surfaces_multiple(
-        self, tmp_path, monkeypatch,
-    ):
-        """Backward-compat: a single invocation carrying threshold-worth of
-        new signals on its own still fires (the old happy path)."""
-        _, pending = self._setup_paths(tmp_path, monkeypatch)
-        monkeypatch.setattr(_cm, "_THRESHOLD", 2)
-
-        # A Bash pip install surfaces multiple signals in one invocation.
-        self._run_main(
-            monkeypatch, "Bash",
-            {"command": "pip install fastapi django"},
-        )
-        assert pending.exists()
-
-    def test_pending_contains_cumulative_union(
-        self, tmp_path, monkeypatch,
-    ):
-        """When the threshold fires, pending-skills.json lists ALL of today's
-        unmatched signals, not just the current invocation's."""
-        _, pending = self._setup_paths(tmp_path, monkeypatch)
-        monkeypatch.setattr(_cm, "_THRESHOLD", 2)
-
-        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})
-        self._run_main(monkeypatch, "Read", {"file_path": "Dockerfile"})
-
-        assert pending.exists()
-        payload = json.loads(pending.read_text())
-        unmatched = set(payload.get("unmatched_signals", []))
-        # Both react (from App.tsx) and docker (from Dockerfile) must be
-        # present — a fix that only reports the current invocation's
-        # signals would miss react.
-        assert {"react", "docker"}.issubset(unmatched), (
-            f"pending does not include cumulative signals: {unmatched}"
-        )
-
-    def test_duplicate_signals_across_invocations_count_once(
-        self, tmp_path, monkeypatch,
-    ):
-        """Unique-set cumulative count — repeated signals don't inflate.
-
-        The same file edited twice should not double-count toward the
-        threshold; otherwise a tight edit-save-edit-save loop would
-        auto-trigger suggestions on a single concept.
-        """
-        _, pending = self._setup_paths(tmp_path, monkeypatch)
-        monkeypatch.setattr(_cm, "_THRESHOLD", 2)
-
-        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})       # react
-        self._run_main(monkeypatch, "Read", {"file_path": "index.tsx"})     # react (dup)
-        # Only 1 unique unmatched concept; THRESHOLD=2 => no write.
-        assert not pending.exists()
+"""
+tests/test_context_monitor.py -- pytest suite for context_monitor module.
+
+Covers:
+  - extract_signals             (keyword match, extension match, Bash tool signals, empty input)
+  - load_manifest_skills        (happy, missing file, bad json)
+  - append_intent_log           (creates file, appends)
+  - count_recent_unmatched      (matched vs unmatched)
+  - write_pending_skills        (creates file, content)
+  - load_recent_unmatched_count (happy path, missing file, skips bad lines)
+  - _parse_stdin_payload        (valid JSON, empty stdin, non-dict, bad JSON)
+  - main()                      (--tool/--input flags, --from-stdin flag, no signals exit-0)
+"""
+
+import io
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parents[1]))
+
+from ctx.adapters.claude_code.hooks import context_monitor as _cm
+from ctx.adapters.claude_code.hooks.context_monitor import (
+    _parse_stdin_payload,
+    append_intent_log,
+    count_recent_unmatched,
+    extract_signals,
+    load_manifest_skills,
+    load_recent_unmatched_count,
+    write_pending_skills,
+)
+
+TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+
+# ---------------------------------------------------------------------------
+# extract_signals
+# ---------------------------------------------------------------------------
+
+class TestExtractSignals:
+    def test_keyword_match_react(self):
+        signals = extract_signals("Read", {"file_path": "src/App.tsx"})
+        assert "react" in signals
+
+    def test_keyword_match_docker(self):
+        signals = extract_signals("Read", {"file_path": "Dockerfile"})
+        assert "docker" in signals
+
+    def test_extension_tsx_triggers_react(self):
+        signals = extract_signals("Read", {"file_path": "component.tsx"})
+        assert "react" in signals
+
+    def test_extension_tf_triggers_terraform(self):
+        signals = extract_signals("Write", {"file_path": "main.tf"})
+        assert "terraform" in signals
+
+    def test_bash_pip_install_triggers_python(self):
+        signals = extract_signals("Bash", {"command": "pip install fastapi"})
+        assert "python" in signals
+
+    def test_bash_npm_install_triggers_javascript(self):
+        signals = extract_signals("Bash", {"command": "npm install react"})
+        assert "javascript" in signals
+
+    def test_empty_input_returns_empty(self):
+        signals = extract_signals("Read", {})
+        assert signals == []
+
+    def test_no_match_returns_empty(self):
+        signals = extract_signals("Read", {"file_path": "README.md"})
+        assert signals == []
+
+    def test_multiple_signals_deduped(self):
+        signals = extract_signals("Read", {"content": "react jsx tsx"})
+        # react should appear only once despite 3 matching keywords
+        assert signals.count("react") == 1
+
+    def test_signals_sorted(self):
+        signals = extract_signals("Bash", {"command": "docker-compose up"})
+        assert signals == sorted(signals)
+
+    def test_anthropic_keyword_maps_to_sdk(self):
+        signals = extract_signals("Read", {"content": "from anthropic import Anthropic"})
+        assert "anthropic-sdk" in signals
+
+    def test_kubernetes_keyword_match(self):
+        signals = extract_signals("Bash", {"command": "kubectl apply -f deployment.yaml"})
+        assert "kubernetes" in signals
+
+    def test_case_insensitive_match(self):
+        signals = extract_signals("Read", {"content": "FASTAPI app = FastAPI()"})
+        assert "fastapi" in signals
+
+
+# ---------------------------------------------------------------------------
+# load_manifest_skills
+# ---------------------------------------------------------------------------
+
+class TestLoadManifestSkills:
+    def test_happy_path(self, tmp_path, monkeypatch):
+        manifest = {"load": [{"skill": "react"}, {"skill": "docker"}]}
+        mpath = tmp_path / "manifest.json"
+        mpath.write_text(json.dumps(manifest))
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", mpath)
+        result = load_manifest_skills()
+        assert result == {"react", "docker"}
+
+    def test_missing_file_returns_empty_set(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "no-such.json")
+        assert load_manifest_skills() == set()
+
+    def test_bad_json_returns_empty_set(self, tmp_path, monkeypatch):
+        mpath = tmp_path / "manifest.json"
+        mpath.write_text("not-json")
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", mpath)
+        assert load_manifest_skills() == set()
+
+    def test_empty_load_list(self, tmp_path, monkeypatch):
+        mpath = tmp_path / "manifest.json"
+        mpath.write_text(json.dumps({"load": []}))
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", mpath)
+        assert load_manifest_skills() == set()
+
+
+# ---------------------------------------------------------------------------
+# append_intent_log
+# ---------------------------------------------------------------------------
+
+class TestAppendIntentLog:
+    def test_creates_file_and_appends(self, tmp_path, monkeypatch):
+        log = tmp_path / "intent.jsonl"
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        entry = {"date": TODAY, "signals": ["react"]}
+        append_intent_log(entry)
+        lines = [line for line in log.read_text().strip().split("\n") if line]
+        assert len(lines) == 1
+        assert json.loads(lines[0])["signals"] == ["react"]
+
+    def test_appends_multiple_entries(self, tmp_path, monkeypatch):
+        log = tmp_path / "intent.jsonl"
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        append_intent_log({"date": TODAY, "signals": ["react"]})
+        append_intent_log({"date": TODAY, "signals": ["docker"]})
+        lines = [line for line in log.read_text().strip().split("\n") if line]
+        assert len(lines) == 2
+
+
+# ---------------------------------------------------------------------------
+# count_recent_unmatched
+# ---------------------------------------------------------------------------
+
+class TestCountRecentUnmatched:
+    def test_all_matched(self):
+        unmatched = count_recent_unmatched(["react", "docker"], {"react", "docker"})
+        assert unmatched == []
+
+    def test_none_matched(self):
+        unmatched = count_recent_unmatched(["react", "docker"], set())
+        assert set(unmatched) == {"react", "docker"}
+
+    def test_partial_match(self):
+        unmatched = count_recent_unmatched(["react", "docker"], {"react"})
+        assert unmatched == ["docker"]
+
+    def test_empty_signals(self):
+        assert count_recent_unmatched([], {"react"}) == []
+
+
+# ---------------------------------------------------------------------------
+# write_pending_skills
+# ---------------------------------------------------------------------------
+
+class TestWritePendingSkills:
+    def test_writes_pending_skills_file(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(_cm, "graph_suggest", lambda unmatched: [])
+        write_pending_skills(["react", "docker"])
+        pending = json.loads((tmp_path / "pending.json").read_text())
+        assert pending["unmatched_signals"] == ["react", "docker"]
+        assert "suggestion" in pending
+
+    def test_suggestion_mentions_signals(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(_cm, "graph_suggest", lambda unmatched: [])
+        write_pending_skills(["fastapi"])
+        pending = json.loads((tmp_path / "pending.json").read_text())
+        assert "fastapi" in pending["suggestion"]
+
+    def test_empty_unmatched(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(_cm, "graph_suggest", lambda unmatched: [])
+        write_pending_skills([])
+        pending = json.loads((tmp_path / "pending.json").read_text())
+        assert pending["unmatched_signals"] == []
+
+    def test_graph_suggestions_list_present(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(
+            _cm,
+            "graph_suggest",
+            lambda unmatched: [{"name": "fastapi-pro", "type": "skill"}],
+        )
+        write_pending_skills(["unknown-signal"])
+        pending = json.loads((tmp_path / "pending.json").read_text())
+        assert pending["graph_suggestions"] == [{"name": "fastapi-pro", "type": "skill"}]
+
+    def test_graph_suggest_filters_to_execution_bundle_types(self, tmp_path, monkeypatch):
+        graph_path = tmp_path / "skill-wiki" / "graphify-out" / "graph.json"
+        graph_path.parent.mkdir(parents=True)
+        graph_path.write_text("{}", encoding="utf-8")
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        calls = {}
+
+        class FakeGraph:
+            def number_of_nodes(self):
+                return 1
+
+        fake_graph_module = type(
+            "FakeGraphModule",
+            (),
+            {"load_graph": staticmethod(lambda _path=None: FakeGraph())},
+        )
+
+        def fake_recommend_by_tags(graph, tags, **kwargs):
+            calls["entity_types"] = kwargs.get("entity_types")
+            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.graph.resolve_graph", fake_graph_module)
+        monkeypatch.setitem(
+            sys.modules,
+            "ctx.core.resolve.recommendations",
+            fake_recommend_module,
+        )
+
+        assert _cm.graph_suggest(["fastapi"]) == [{"name": "fastapi-pro", "type": "skill"}]
+        assert calls["entity_types"] == ("skill", "agent", "mcp-server")
+
+
+# ---------------------------------------------------------------------------
+# load_recent_unmatched_count
+# ---------------------------------------------------------------------------
+
+class TestLoadRecentUnmatchedCount:
+    def _write_log(self, path: Path, entries: list[dict]) -> None:
+        path.write_text("\n".join(json.dumps(e) for e in entries) + "\n")
+
+    def test_happy_path_counts_distinct(self, tmp_path, monkeypatch):
+        log = tmp_path / "intent.jsonl"
+        self._write_log(log, [
+            {"date": TODAY, "unmatched": ["react", "docker"]},
+            {"date": TODAY, "unmatched": ["react"]},  # react already counted
+        ])
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        count = load_recent_unmatched_count()
+        assert count == 2  # react + docker distinct
+
+    def test_missing_file_returns_0(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_cm, "INTENT_LOG", tmp_path / "nope.jsonl")
+        assert load_recent_unmatched_count() == 0
+
+    def test_skips_bad_lines(self, tmp_path, monkeypatch):
+        log = tmp_path / "intent.jsonl"
+        log.write_text(f'not-json\n{json.dumps({"date": TODAY, "unmatched": ["react"]})}\n')
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        assert load_recent_unmatched_count() == 1
+
+    def test_other_dates_not_counted(self, tmp_path, monkeypatch):
+        log = tmp_path / "intent.jsonl"
+        self._write_log(log, [{"date": "2000-01-01", "unmatched": ["react"]}])
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        assert load_recent_unmatched_count() == 0
+
+
+# ---------------------------------------------------------------------------
+# _parse_stdin_payload
+# ---------------------------------------------------------------------------
+
+class TestParseStdinPayload:
+    def test_valid_payload(self, monkeypatch):
+        payload = json.dumps({"tool_name": "Read", "tool_input": {"file_path": "foo.py"}})
+        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
+        tool_name, tool_input = _parse_stdin_payload()
+        assert tool_name == "Read"
+        assert tool_input == {"file_path": "foo.py"}
+
+    def test_empty_stdin(self, monkeypatch):
+        monkeypatch.setattr(sys, "stdin", io.StringIO(""))
+        tool_name, tool_input = _parse_stdin_payload()
+        assert tool_name == "unknown"
+        assert tool_input == {}
+
+    def test_non_dict_json(self, monkeypatch):
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps([1, 2, 3])))
+        tool_name, tool_input = _parse_stdin_payload()
+        assert tool_name == "unknown"
+
+    def test_bad_json(self, monkeypatch):
+        monkeypatch.setattr(sys, "stdin", io.StringIO("not-json"))
+        tool_name, tool_input = _parse_stdin_payload()
+        assert tool_name == "unknown"
+        assert tool_input == {}
+
+    def test_missing_tool_input_defaults_to_empty(self, monkeypatch):
+        payload = json.dumps({"tool_name": "Bash"})
+        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
+        _, tool_input = _parse_stdin_payload()
+        assert tool_input == {}
+
+    def test_non_dict_tool_input_defaults_to_empty(self, monkeypatch):
+        payload = json.dumps({"tool_name": "Bash", "tool_input": "not-a-dict"})
+        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
+        _, tool_input = _parse_stdin_payload()
+        assert tool_input == {}
+
+
+# ---------------------------------------------------------------------------
+# main()
+# ---------------------------------------------------------------------------
+
+class TestMain:
+    def test_no_signals_exits_0(self, tmp_path, monkeypatch):
+        """When tool input produces no signals, main exits 0."""
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        monkeypatch.setattr(_cm, "INTENT_LOG", tmp_path / "intent.jsonl")
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", "{}"])
+        with pytest.raises(SystemExit) as exc:
+            _cm.main()
+        assert exc.value.code == 0
+
+    def test_signals_appended_to_log(self, tmp_path, monkeypatch):
+        """Signals from --input are written to the intent log."""
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        log = tmp_path / "intent.jsonl"
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(_cm, "_THRESHOLD", 999)  # prevent pending write
+        tool_input = json.dumps({"file_path": "Dockerfile"})
+        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", tool_input])
+        _cm.main()
+        lines = [line for line in log.read_text().strip().split("\n") if line]
+        assert len(lines) == 1
+        entry = json.loads(lines[0])
+        assert "docker" in entry["signals"]
+
+    def test_from_stdin_flag(self, tmp_path, monkeypatch):
+        """--from-stdin reads tool payload from stdin."""
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        log = tmp_path / "intent.jsonl"
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(_cm, "_THRESHOLD", 999)
+        payload = json.dumps({"tool_name": "Read", "tool_input": {"file_path": "Dockerfile"}})
+        monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
+        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--from-stdin"])
+        _cm.main()
+        lines = [line for line in log.read_text().strip().split("\n") if line]
+        assert len(lines) == 1
+        entry = json.loads(lines[0])
+        assert "docker" in entry["signals"]
+
+    def test_bad_json_input_falls_back_to_raw(self, tmp_path, monkeypatch):
+        """Malformed --input falls back to {'raw': value} and may produce no signals."""
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        log = tmp_path / "intent.jsonl"
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", tmp_path / "pending.json")
+        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", "not-json"])
+        # Should not crash
+        try:
+            _cm.main()
+        except SystemExit as e:
+            assert e.code == 0  # exits 0 when no signals
+
+    def test_threshold_triggers_pending_write(self, tmp_path, monkeypatch):
+        """When unmatched count >= threshold, pending-skills.json is written."""
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        log = tmp_path / "intent.jsonl"
+        pending = tmp_path / "pending.json"
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", pending)
+        monkeypatch.setattr(_cm, "_THRESHOLD", 1)  # trigger on 1 unmatched
+        tool_input = json.dumps({"file_path": "Dockerfile"})
+        monkeypatch.setattr(sys, "argv", ["context_monitor.py", "--tool", "Read", "--input", tool_input])
+        _cm.main()
+        assert pending.exists()
+
+
+# ---------------------------------------------------------------------------
+# Cumulative-threshold regression (code-reviewer finding BLOCKER)
+# ---------------------------------------------------------------------------
+#
+# Prior impl used ``len(unmatched) >= THRESHOLD`` where ``unmatched`` is the
+# per-invocation list. A single tool call almost never surfaces 3 unmatched
+# signals alone, so the default threshold=3 meant pending-skills.json was
+# essentially never written — silently killing the suggestion arm of the
+# alive loop. The fix walks the intent log and checks the cumulative
+# (per-day, across all invocations) unmatched count against the threshold.
+
+class TestCumulativeThreshold:
+    """The threshold must fire on cumulative unmatched across today's log,
+    not just on a single invocation's count.
+    """
+
+    def _setup_paths(self, tmp_path, monkeypatch):
+        log = tmp_path / "intent.jsonl"
+        pending = tmp_path / "pending.json"
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        monkeypatch.setattr(_cm, "INTENT_LOG", log)
+        monkeypatch.setattr(_cm, "MANIFEST_PATH", tmp_path / "manifest.json")
+        monkeypatch.setattr(_cm, "PENDING_SKILLS", pending)
+        return log, pending
+
+    def _run_main(self, monkeypatch, tool_name: str, tool_input: dict):
+        monkeypatch.setattr(
+            sys, "argv",
+            ["context_monitor.py", "--tool", tool_name, "--input", json.dumps(tool_input)],
+        )
+        _cm.main()
+
+    def test_fires_on_cumulative_across_three_invocations(
+        self, tmp_path, monkeypatch,
+    ):
+        """Three invocations each surfacing ONE unmatched signal should
+        trigger pending-skills write when THRESHOLD=3.
+
+        This is the case the old len(unmatched)>=THRESHOLD check missed.
+        The user types a react file, then opens a Dockerfile, then edits
+        terraform — three separate tool calls, three different unmatched
+        signals, cumulatively at threshold.
+        """
+        _, pending = self._setup_paths(tmp_path, monkeypatch)
+        monkeypatch.setattr(_cm, "_THRESHOLD", 3)
+
+        # Three invocations, one unique unmatched signal each.
+        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})       # react
+        assert not pending.exists(), "fired after 1 cumulative unmatched"
+
+        self._run_main(monkeypatch, "Read", {"file_path": "Dockerfile"})    # docker
+        assert not pending.exists(), "fired after 2 cumulative unmatched"
+
+        self._run_main(monkeypatch, "Read", {"file_path": "main.tf"})       # terraform
+        assert pending.exists(), (
+            "did NOT fire after 3 cumulative unmatched — "
+            "the per-invocation threshold bug regressed"
+        )
+
+    def test_does_not_fire_below_cumulative_threshold(
+        self, tmp_path, monkeypatch,
+    ):
+        """Below-threshold cumulative count must NOT trigger.
+
+        Otherwise every first-keystroke would spam pending-skills.json.
+        """
+        _, pending = self._setup_paths(tmp_path, monkeypatch)
+        monkeypatch.setattr(_cm, "_THRESHOLD", 3)
+
+        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})
+        self._run_main(monkeypatch, "Read", {"file_path": "Dockerfile"})
+        # Only 2 unique signals accumulated; THRESHOLD=3 => no write.
+        assert not pending.exists()
+
+    def test_fires_when_single_invocation_surfaces_multiple(
+        self, tmp_path, monkeypatch,
+    ):
+        """Backward-compat: a single invocation carrying threshold-worth of
+        new signals on its own still fires (the old happy path)."""
+        _, pending = self._setup_paths(tmp_path, monkeypatch)
+        monkeypatch.setattr(_cm, "_THRESHOLD", 2)
+
+        # A Bash pip install surfaces multiple signals in one invocation.
+        self._run_main(
+            monkeypatch, "Bash",
+            {"command": "pip install fastapi django"},
+        )
+        assert pending.exists()
+
+    def test_pending_contains_cumulative_union(
+        self, tmp_path, monkeypatch,
+    ):
+        """When the threshold fires, pending-skills.json lists ALL of today's
+        unmatched signals, not just the current invocation's."""
+        _, pending = self._setup_paths(tmp_path, monkeypatch)
+        monkeypatch.setattr(_cm, "_THRESHOLD", 2)
+
+        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})
+        self._run_main(monkeypatch, "Read", {"file_path": "Dockerfile"})
+
+        assert pending.exists()
+        payload = json.loads(pending.read_text())
+        unmatched = set(payload.get("unmatched_signals", []))
+        # Both react (from App.tsx) and docker (from Dockerfile) must be
+        # present — a fix that only reports the current invocation's
+        # signals would miss react.
+        assert {"react", "docker"}.issubset(unmatched), (
+            f"pending does not include cumulative signals: {unmatched}"
+        )
+
+    def test_duplicate_signals_across_invocations_count_once(
+        self, tmp_path, monkeypatch,
+    ):
+        """Unique-set cumulative count — repeated signals don't inflate.
+
+        The same file edited twice should not double-count toward the
+        threshold; otherwise a tight edit-save-edit-save loop would
+        auto-trigger suggestions on a single concept.
+        """
+        _, pending = self._setup_paths(tmp_path, monkeypatch)
+        monkeypatch.setattr(_cm, "_THRESHOLD", 2)
+
+        self._run_main(monkeypatch, "Read", {"file_path": "App.tsx"})       # react
+        self._run_main(monkeypatch, "Read", {"file_path": "index.tsx"})     # react (dup)
+        # Only 1 unique unmatched concept; THRESHOLD=2 => no write.
+        assert not pending.exists()

src/tests/test_ctx_init.py

@@ -1,1348 +1,1368 @@
-"""Tests for ctx_init — bootstrap ~/.claude/ scaffolding."""
-
-from __future__ import annotations
-
-import builtins
-import hashlib
-import io
-import json
-import sqlite3
-import sys
-import tarfile
-import zlib
-from pathlib import Path
-from types import SimpleNamespace
-
-import networkx as nx
-import pytest
-import ctx_init as ci
-
-
-def _write_dashboard_index(path: Path, *, export_id: str = "test-export") -> None:
-    conn = sqlite3.connect(path)
-    try:
-        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
-        conn.execute(
-            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
-            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
-        )
-        conn.execute(
-            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
-            "PRIMARY KEY(slug,type,node_id))"
-        )
-        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
-        conn.executemany(
-            "INSERT INTO meta VALUES(?,?)",
-            [
-                ("export_id", json.dumps(export_id)),
-                ("nodes_count", "1"),
-                ("edges_count", "0"),
-                ("max_degree", "1"),
-                ("top_k", "40"),
-            ],
-        )
-        conn.execute(
-            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
-            ("skill:current", "current", "skill", "[]", "", None, None, 0),
-        )
-        conn.execute("INSERT INTO slug_index VALUES(?,?,?)", ("current", "skill", "skill:current"))
-        conn.execute("INSERT INTO neighbors VALUES(?,?)", ("skill:current", zlib.compress(b"[]")))
-        conn.commit()
-    finally:
-        conn.close()
-
-
-def _artifact_sha256_or_lfs_oid(path: Path, *, normalize_text: bool = False) -> str:
-    data = path.read_bytes()
-    if data.startswith(b"version https://git-lfs.github.com/spec/v1\n"):
-        for line in data.decode("utf-8").splitlines():
-            if line.startswith("oid sha256:"):
-                return line.removeprefix("oid sha256:")
-    if normalize_text:
-        data = data.replace(b"\r\n", b"\n")
-    return hashlib.sha256(data).hexdigest()
-
-
-def test_ensure_directories_creates_standard_tree(tmp_path: Path) -> None:
-    created = ci.ensure_directories(tmp_path)
-    # First call should create every standard subdir.
-    assert len(created) == len(ci._STANDARD_SUBDIRS)
-    for sub in ci._STANDARD_SUBDIRS:
-        assert (tmp_path / sub).is_dir(), f"missing {sub}"
-
-
-def test_ensure_directories_is_idempotent(tmp_path: Path) -> None:
-    first = ci.ensure_directories(tmp_path)
-    assert len(first) > 0
-    second = ci.ensure_directories(tmp_path)
-    assert second == [], "second call should not recreate anything"
-
-
-def test_seed_user_config_writes_once(tmp_path: Path) -> None:
-    tmp_path.mkdir(exist_ok=True)
-    first = ci.seed_user_config(tmp_path)
-    assert first is not None
-    assert first.exists()
-    body = first.read_text(encoding="utf-8")
-    assert "skill-system-config.json" in body
-
-    # Second call returns None (file already exists, force=False).
-    second = ci.seed_user_config(tmp_path)
-    assert second is None
-
-
-def test_seed_user_config_respects_force(tmp_path: Path) -> None:
-    target = tmp_path / "skill-system-config.json"
-    target.write_text("user-custom-content", encoding="utf-8")
-    # Without force → don't touch.
-    assert ci.seed_user_config(tmp_path, force=False) is None
-    assert target.read_text() == "user-custom-content"
-    # With force → overwrite.
-    result = ci.seed_user_config(tmp_path, force=True)
-    assert result == target
-    assert "skill-system-config.json" in target.read_text()
-
-
-def test_main_creates_everything_in_dry_mode(tmp_path: Path, monkeypatch,
-                                              capsys) -> None:
-    """End-to-end: ``ctx-init`` (no flags) creates dirs + config + toolboxes
-    without touching hooks or graph."""
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-
-    # Short-circuit subprocess.run to avoid spawning a real toolbox/graph CLI
-    # in tests. Verify that main() doesn't call install_hooks or build_graph
-    # when those flags are absent.
-    calls: list[list[str]] = []
-
-    class _FakeResult:
-        returncode = 0
-        stdout = ""
-        stderr = ""
-
-    def fake_run(cmd, **kwargs):
-        calls.append(list(cmd))
-        return _FakeResult()
-
-    monkeypatch.setattr(ci.subprocess, "run", fake_run)
-
-    rc = ci.main([])
-    assert rc == 0
-    # toolbox init should have been invoked
-    toolbox_calls = [c for c in calls if "toolbox" in " ".join(c)]
-    assert toolbox_calls, "toolbox init not invoked"
-    # inject_hooks / wiki_graphify must NOT be invoked without flags
-    for c in calls:
-        assert "inject_hooks" not in " ".join(c)
-        assert "wiki_graphify" not in " ".join(c)
-
-    out = capsys.readouterr().out
-    assert "[ok]" in out
-    assert "[skip] hook injection" in out
-    assert "[skip] graph install" in out
-
-
-def test_main_treats_existing_toolboxes_as_idempotent_skip(
-    tmp_path: Path,
-    monkeypatch,
-    capsys,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-
-    class _FakeResult:
-        returncode = 1
-        stdout = ""
-        stderr = (
-            "Global config already has 5 toolbox(es). "
-            "Use --force to overwrite."
-        )
-
-    monkeypatch.setattr(ci.subprocess, "run", lambda *_args, **_kwargs: _FakeResult())
-
-    rc = ci.main(["--model-mode", "skip"])
-    captured = capsys.readouterr()
-
-    assert rc == 0
-    assert "starter toolboxes already present" in captured.out
-    assert "toolbox init returned" not in captured.err
-    assert "Global config already has" not in captured.err
-
-
-def test_main_auto_wizard_in_terminal_configures_custom_model(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "_stdio_is_interactive", lambda: True)
-    monkeypatch.setattr(
-        ci,
-        "recommend_harnesses",
-        lambda goal, top_k=5, model_provider=None, model=None: [],
-    )
-
-    answers = iter([
-        "y",                  # hooks
-        "enriched",           # knowledge mode
-        "n",                  # graph
-        "custom",             # model mode
-        "openai/gpt-5.5",     # model
-        "",                   # provider default: openai
-        "",                   # api key env default: OPENAI_API_KEY
-        "",                   # base URL
-        "build CAD artifacts",
-        "windows python",      # runtime / OS
-        "supervised",          # autonomy
-        "filesystem shell",    # allowed tools
-        "pytest ruff",         # verification
-        "private repo",        # privacy / network
-        "mcp",                 # attach mode
-        "n",                  # validate model
-    ])
-    monkeypatch.setattr(builtins, "input", lambda _prompt: next(answers))
-    calls: list[list[str]] = []
-
-    class _FakeResult:
-        returncode = 0
-        stdout = ""
-        stderr = ""
-
-    def _fake_run(cmd: list[str], **_kwargs: object) -> _FakeResult:
-        calls.append(list(cmd))
-        return _FakeResult()
-
-    monkeypatch.setattr(ci.subprocess, "run", _fake_run)
-
-    rc = ci.main([])
-
-    assert rc == 0
-    assert any("ctx.adapters.claude_code.inject_hooks" in c for c in calls)
-    assert not any("ctx.core.wiki.wiki_graphify" in c for c in calls)
-    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
-    assert profile["mode"] == "custom"
-    assert profile["provider"] == "openai"
-    assert profile["model"] == "openai/gpt-5.5"
-    assert profile["api_key_env"] == "OPENAI_API_KEY"
-    assert profile["goal"] == "build CAD artifacts"
-    assert profile["knowledge_mode"] == "enriched"
-    assert profile["harness_requirements"] == {
-        "runtime": "windows python",
-        "autonomy": "supervised",
-        "tools": "filesystem shell",
-        "verification": "pytest ruff",
-        "privacy": "private repo",
-        "attach_mode": "mcp",
-    }
-    user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
-    assert user_config["knowledge"]["mode"] == "enriched"
-
-
-def test_wizard_flag_prompts_without_tty(tmp_path: Path, monkeypatch) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "_stdio_is_interactive", lambda: False)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(
-        ci,
-        "recommend_harnesses",
-        lambda goal, top_k=5, model_provider=None, model=None: [],
-    )
-
-    answers = iter([
-        "n",                  # hooks
-        "local",              # knowledge mode
-        "claude-code",        # model mode
-        "maintain FastAPI services",
-    ])
-    monkeypatch.setattr(builtins, "input", lambda _prompt: next(answers))
-
-    rc = ci.main(["--wizard"])
-
-    assert rc == 0
-    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
-    assert profile["mode"] == "claude-code"
-    assert profile["goal"] == "maintain FastAPI services"
-    assert profile["knowledge_mode"] == "local"
-    user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
-    assert user_config["knowledge"]["mode"] == "local"
-
-
-def test_explicit_args_do_not_auto_wizard_in_terminal(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "_stdio_is_interactive", lambda: True)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(
-        builtins,
-        "input",
-        lambda _prompt: (_ for _ in ()).throw(AssertionError("unexpected prompt")),
-    )
-
-    assert ci.main(["--model-mode", "skip", "--knowledge-mode", "local"]) == 0
-    user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
-    assert user_config["knowledge"]["mode"] == "local"
-
-
-def test_main_with_hooks_flag_invokes_inject(tmp_path: Path, monkeypatch) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    calls: list[list[str]] = []
-
-    class _FakeResult:
-        returncode = 0
-        stdout = ""
-        stderr = ""
-
-    def _fake_run(cmd: list[str], **_kwargs: object) -> _FakeResult:
-        calls.append(list(cmd))
-        return _FakeResult()
-
-    monkeypatch.setattr(ci.subprocess, "run", _fake_run)
-    rc = ci.main(["--hooks"])
-    assert rc == 0
-    assert any("ctx.adapters.claude_code.inject_hooks" in c for c in calls)
-    assert not any(c == "inject_hooks" for call in calls for c in call)
-
-
-def _write_graph_archive(tmp_path: Path) -> Path:
-    source = tmp_path / "archive-source"
-    graph_out = source / "graphify-out"
-    graph_out.mkdir(parents=True)
-    (graph_out / "graph.json").write_text(
-        json.dumps({"graph": {"export_id": "test-export"}, "nodes": [], "links": []}),
-        encoding="utf-8",
-    )
-    (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 = source / "external-catalogs" / "skills-sh"
-    external.mkdir(parents=True)
-    (external / "catalog.json").write_text("{}", encoding="utf-8")
-    entities = source / "entities" / "skills"
-    entities.mkdir(parents=True)
-    (entities / "current.md").write_text("# Current\n", encoding="utf-8")
-    (source / "index.md").write_text("# Wiki\n", encoding="utf-8")
-    archive = tmp_path / "wiki-graph.tar.gz"
-    with tarfile.open(archive, "w:gz") as tf:
-        for path in sorted(source.rglob("*")):
-            if path.is_file():
-                tf.add(path, arcname=path.relative_to(source).as_posix())
-    return archive
-
-
-def _tar_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 _tar_bytes(tf: tarfile.TarFile, name: str, payload: bytes) -> None:
-    info = tarfile.TarInfo(name)
-    info.size = len(payload)
-    tf.addfile(info, io.BytesIO(payload))
-
-
-def test_download_graph_archive_verifies_sha256(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    payload = b"graph archive bytes"
-
-    class _Response(io.BytesIO):
-        def __enter__(self) -> "_Response":
-            return self
-
-        def __exit__(self, *_args: object) -> None:
-            return None
-
-    monkeypatch.setattr(
-        ci.urllib.request,
-        "urlopen",
-        lambda _url, timeout=120: _Response(payload),
-    )
-
-    destination = tmp_path / "wiki-graph.tar.gz"
-    ci._download_graph_archive(
-        destination,
-        url="https://example.invalid/wiki-graph.tar.gz",
-        expected_sha256=hashlib.sha256(payload).hexdigest(),
-    )
-    assert destination.read_bytes() == payload
-
-    bad_destination = tmp_path / "bad-wiki-graph.tar.gz"
-    with pytest.raises(ValueError, match="checksum mismatch"):
-        ci._download_graph_archive(
-            bad_destination,
-            url="https://example.invalid/wiki-graph.tar.gz",
-            expected_sha256="0" * 64,
-        )
-    assert not bad_destination.exists()
-
-
-def test_graph_download_checksums_match_shipped_artifacts() -> None:
-    root = Path(__file__).resolve().parent.parent.parent
-    for mode, archive_name in ci._GRAPH_ARCHIVE_NAMES.items():
-        path = root / "graph" / archive_name
-        assert ci._GRAPH_ARCHIVE_SHA256[mode] == _artifact_sha256_or_lfs_oid(path)
-
-    overlay_path = root / "graph" / ci._GRAPH_ENTITY_OVERLAY_NAME
-    assert ci._GRAPH_ENTITY_OVERLAY_SHA256 == _artifact_sha256_or_lfs_oid(
-        overlay_path,
-        normalize_text=True,
-    )
-
-
-def test_local_graph_archive_checksum_is_verified(tmp_path: Path) -> None:
-    archive = tmp_path / "wiki-graph-runtime.tar.gz"
-    archive.write_bytes(b"not the shipped runtime archive")
-
-    with pytest.raises(ValueError, match="local graph archive checksum mismatch"):
-        ci._verify_local_graph_archive(archive, requested_install_mode="runtime")
-
-
-def test_custom_graph_url_requires_checksum_or_explicit_opt_out(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    monkeypatch.setattr(ci, "_find_local_graph_archive", lambda _mode: None)
-    monkeypatch.setattr(
-        ci,
-        "_download_graph_archive",
-        lambda *_args, **_kwargs: (_ for _ in ()).throw(
-            AssertionError("download should be blocked before network access")
-        ),
-    )
-
-    rc = ci.build_graph(
-        tmp_path / "home",
-        graph_url="https://example.invalid/wiki-graph.tar.gz",
-    )
-
-    assert rc == 1
-
-
-def test_custom_graph_url_bypasses_local_archive(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    archive = _write_graph_archive(tmp_path)
-    archive_bytes = archive.read_bytes()
-    calls: list[dict[str, object]] = []
-
-    monkeypatch.setattr(
-        ci,
-        "_find_local_graph_archive",
-        lambda _mode: (_ for _ in ()).throw(
-            AssertionError("explicit graph_url must not use local archive")
-        ),
-    )
-
-    def fake_download(destination: Path, **kwargs: object) -> None:
-        calls.append(dict(kwargs))
-        destination.write_bytes(archive_bytes)
-
-    monkeypatch.setattr(ci, "_download_graph_archive", fake_download)
-    monkeypatch.setattr(ci, "_install_graph_entity_overlay", lambda *_a, **_k: None)
-
-    rc = ci.build_graph(
-        tmp_path / "home",
-        graph_url="https://example.invalid/custom-wiki-graph.tar.gz",
-        graph_sha256=hashlib.sha256(archive_bytes).hexdigest(),
-    )
-
-    assert rc == 0
-    assert calls == [
-        {
-            "url": "https://example.invalid/custom-wiki-graph.tar.gz",
-            "expected_sha256": hashlib.sha256(archive_bytes).hexdigest(),
-        }
-    ]
-
-
-def test_main_with_graph_flag_installs_prebuilt_graph(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    claude = tmp_path / "home"
-    archive = _write_graph_archive(tmp_path)
-    monkeypatch.setattr(ci, "_claude_dir", lambda: claude)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(
-        ci,
-        "_find_local_graph_archive",
-        lambda _install_mode="runtime": archive,
-        raising=False,
-    )
-    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
-    monkeypatch.setattr(
-        ci,
-        "_download_graph_archive",
-        lambda _dest, **_kwargs: (_ for _ in ()).throw(
-            AssertionError("unexpected release download")
-        ),
-        raising=False,
-    )
-    calls: list[list[str]] = []
-
-    class _FakeResult:
-        returncode = 0
-        stdout = ""
-        stderr = ""
-
-    def _fake_run(cmd: list[str], **_kwargs: object) -> _FakeResult:
-        calls.append(list(cmd))
-        return _FakeResult()
-
-    monkeypatch.setattr(ci.subprocess, "run", _fake_run)
-    rc = ci.main(["--graph", "--model-mode", "skip"])
-    assert rc == 0
-    graph_json = claude / "skill-wiki" / "graphify-out" / "graph.json"
-    graph_payload = json.loads(graph_json.read_text(encoding="utf-8"))
-    assert graph_payload["graph"]["export_id"] == "test-export"
-    assert not (
-        claude / "skill-wiki" / "entities" / "skills" / "current.md"
-    ).exists()
-    assert not any("ctx.core.wiki.wiki_graphify" in c for c in calls)
-    assert not any(c == "wiki_graphify" for call in calls for c in call)
-
-
-def test_graph_install_copies_local_entity_overlay(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    claude = tmp_path / "home"
-    archive = _write_graph_archive(tmp_path)
-    overlay = tmp_path / "entity-overlays.jsonl"
-    overlay.write_text(
-        json.dumps({
-            "overlay_id": "test-overlay",
-            "nodes": [{"id": "harness:mirage", "type": "harness"}],
-            "edges": [
-                {
-                    "source": "harness:mirage",
-                    "target": "skill:codex-review",
-                    "weight": 0.5,
-                    "similarity_score": 0.5,
-                    "method": "manual_direct_overlay_v1",
-                    "rank": 1,
-                    "provenance": "manual_overlay_v1",
-                }
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(
-        ci,
-        "_find_local_graph_archive",
-        lambda _install_mode="runtime": archive,
-        raising=False,
-    )
-    monkeypatch.setattr(ci, "_find_local_graph_entity_overlay", lambda: overlay)
-    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
-
-    assert ci.build_graph(claude) == 0
-
-    installed = claude / "skill-wiki" / "graphify-out" / "entity-overlays.jsonl"
-    payload = json.loads(installed.read_text(encoding="utf-8"))
-    assert payload["overlay_id"] == "test-overlay"
-    assert payload["edges"][0]["method"] == "manual_direct_overlay_v1"
-
-
-@pytest.mark.parametrize("field", ["semantic_sim", "tag_sim", "token_sim"])
-def test_graph_overlay_validation_rejects_out_of_range_similarity_fields(
-    tmp_path: Path,
-    field: str,
-) -> None:
-    overlay = tmp_path / "entity-overlays.jsonl"
-    overlay.write_text(
-        json.dumps({
-            "nodes": [{"id": "skill:a"}],
-            "edges": [
-                {
-                    "source": "skill:a",
-                    "target": "skill:b",
-                    "weight": 0.5,
-                    "final_weight": 0.5,
-                    field: 2.0,
-                },
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(ValueError, match=f"{field} must be 0..1"):
-        ci._validate_graph_entity_overlay(overlay)
-
-
-def test_graph_overlay_validation_rejects_weight_final_weight_drift(
-    tmp_path: Path,
-) -> None:
-    overlay = tmp_path / "entity-overlays.jsonl"
-    overlay.write_text(
-        json.dumps({
-            "nodes": [{"id": "skill:a"}],
-            "edges": [
-                {
-                    "source": "skill:a",
-                    "target": "skill:b",
-                    "weight": 0.7,
-                    "final_weight": 0.5,
-                },
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(ValueError, match="weight must equal final_weight"):
-        ci._validate_graph_entity_overlay(overlay)
-
-
-def test_runtime_graph_install_extracts_harness_pages_after_required_files(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    archive = tmp_path / "ordered-runtime-wiki-graph.tar.gz"
-    with tarfile.open(archive, "w:gz") as tf:
-        _tar_text(
-            tf,
-            "graphify-out/graph.json",
-            json.dumps({
-                "graph": {"export_id": "test-export"},
-                "nodes": [{"id": "harness:text-to-cad", "type": "harness"}],
-                "links": [],
-            }),
-        )
-        _tar_text(
-            tf,
-            "graphify-out/graph-delta.json",
-            json.dumps({"export_id": "test-export", "nodes": [], "edges": []}),
-        )
-        _tar_text(
-            tf,
-            "graphify-out/communities.json",
-            json.dumps({"export_id": "test-export", "total_communities": 0}),
-        )
-        _tar_text(tf, "graphify-out/graph-report.md", "# Graph Report\n")
-        _tar_text(
-            tf,
-            "graphify-out/graph-export-manifest.json",
-            json.dumps({
-                "version": 1,
-                "export_id": "test-export",
-                "artifacts": {
-                    "graph": "graph.json",
-                    "delta": "graph-delta.json",
-                    "communities": "communities.json",
-                    "report": "graph-report.md",
-                },
-            }),
-        )
-        index_path = tmp_path / "runtime-dashboard-neighborhoods.sqlite3"
-        _write_dashboard_index(index_path)
-        _tar_bytes(
-            tf,
-            "graphify-out/dashboard-neighborhoods.sqlite3",
-            index_path.read_bytes(),
-        )
-        _tar_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
-        _tar_text(tf, "index.md", "# Wiki\n")
-        _tar_text(tf, "entities/harnesses/text-to-cad.md", "# Text to CAD\n")
-        _tar_text(tf, "entities/skills/not-runtime.md", "# Not runtime\n")
-
-    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)
-
-    assert ci.build_graph(claude) == 0
-    assert (
-        claude / "skill-wiki" / "entities" / "harnesses" / "text-to-cad.md"
-    ).is_file()
-    assert not (
-        claude / "skill-wiki" / "entities" / "skills" / "not-runtime.md"
-    ).exists()
-
-
-def test_runtime_graph_install_preserves_existing_non_harness_entities(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    archive = _write_graph_archive(tmp_path)
-    claude = tmp_path / "home"
-    local_skill = claude / "skill-wiki" / "entities" / "skills" / "private.md"
-    local_agent = claude / "skill-wiki" / "entities" / "agents" / "private.md"
-    local_mcp = claude / "skill-wiki" / "entities" / "mcp-servers" / "p" / "private.md"
-    local_harness = claude / "skill-wiki" / "entities" / "harnesses" / "old.md"
-    for path in (local_skill, local_agent, local_mcp, local_harness):
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(f"# {path.stem}\n", encoding="utf-8")
-
-    monkeypatch.setattr(
-        ci,
-        "_find_local_graph_archive",
-        lambda _install_mode="runtime": archive,
-    )
-    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
-    monkeypatch.setattr(ci, "_install_graph_entity_overlay", lambda *_a, **_k: None)
-
-    assert ci.build_graph(claude, force=True, install_mode="runtime") == 0
-
-    assert local_skill.is_file()
-    assert local_agent.is_file()
-    assert local_mcp.is_file()
-    assert not local_harness.exists()
-
-
-def test_graph_install_rejects_incomplete_archive(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    source = tmp_path / "incomplete-source"
-    graph_out = source / "graphify-out"
-    graph_out.mkdir(parents=True)
-    (graph_out / "graph.json").write_text(
-        json.dumps({"graph": {"export_id": "partial"}, "nodes": []}),
-        encoding="utf-8",
-    )
-    archive = tmp_path / "incomplete-wiki-graph.tar.gz"
-    with tarfile.open(archive, "w:gz") as tf:
-        tf.add(graph_out / "graph.json", arcname="graphify-out/graph.json")
-
-    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)
-
-    assert ci.build_graph(claude) == 1
-    assert not (claude / "skill-wiki" / "graphify-out" / "graph.json").exists()
-
-
-def test_graph_install_validation_does_not_parse_full_graph_json(
-    tmp_path: Path,
-    monkeypatch,
-) -> 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_out / "graph.json").write_text(
-        json.dumps({"graph": {"export_id": "test-export"}, "nodes": [], "links": []}),
-        encoding="utf-8",
-    )
-    (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")
-
-    def guarded_read(path: Path) -> object:
-        if path.name == "graph.json":
-            raise AssertionError("install validation must not parse full graph.json")
-        return json.loads(path.read_text(encoding="utf-8"))
-
-    monkeypatch.setattr(ci, "_read_json_file", guarded_read)
-
-    ci._validate_graph_install_tree(wiki)
-
-
-def test_graph_install_force_prunes_stale_generated_files(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    archive = _write_graph_archive(tmp_path)
-    claude = tmp_path / "home"
-    stale = claude / "skill-wiki" / "entities" / "skills" / "stale.md"
-    stale.parent.mkdir(parents=True)
-    stale.write_text("# Stale\n", encoding="utf-8")
-    monkeypatch.setattr(ci, "_claude_dir", lambda: claude)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(
-        ci,
-        "_find_local_graph_archive",
-        lambda _install_mode="runtime": archive,
-    )
-    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
-
-    assert ci.main([
-        "--graph",
-        "--graph-install-mode", "full",
-        "--force",
-        "--model-mode", "skip",
-    ]) == 0
-    assert not stale.exists()
-    assert (claude / "skill-wiki" / "entities" / "skills" / "current.md").is_file()
-
-
-def test_graph_install_rejects_path_traversal_archive(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    archive = tmp_path / "malicious-wiki-graph.tar.gz"
-    payload = b"owned"
-    with tarfile.open(archive, "w:gz") as tf:
-        info = tarfile.TarInfo("../evil.txt")
-        info.size = len(payload)
-        tf.addfile(info, io.BytesIO(payload))
-
-    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)
-
-    assert ci.build_graph(claude) == 1
-    assert not (tmp_path / "evil.txt").exists()
-    assert not (claude / "evil.txt").exists()
-
-
-def test_main_with_requested_hook_failure_exits_nonzero(
-    tmp_path: Path, monkeypatch
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-
-    class _FakeResult:
-        def __init__(self, returncode: int) -> None:
-            self.returncode = returncode
-            self.stdout = ""
-            self.stderr = ""
-
-    def fake_run(cmd, **kwargs):
-        if "ctx.adapters.claude_code.inject_hooks" in cmd:
-            return _FakeResult(7)
-        return _FakeResult(0)
-
-    monkeypatch.setattr(ci.subprocess, "run", fake_run)
-
-    assert ci.main(["--hooks"]) == 7
-
-
-def test_main_custom_model_writes_profile_and_recommends_harness(
-    tmp_path: Path,
-    monkeypatch,
-    capsys,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-
-    recommendation_calls: list[dict[str, object]] = []
-
-    def fake_recommend(
-        goal: str,
-        top_k: int = 5,
-        model_provider: str | None = None,
-        model: str | None = None,
-    ) -> list[dict[str, object]]:
-        recommendation_calls.append({
-            "goal": goal,
-            "top_k": top_k,
-            "model_provider": model_provider,
-            "model": model,
-        })
-        return [{"name": "text-to-cad", "type": "harness", "score": 0.8}]
-
-    monkeypatch.setattr(
-        ci,
-        "recommend_harnesses",
-        fake_recommend,
-    )
-
-    rc = ci.main([
-        "--model-mode", "custom",
-        "--model", "openai/gpt-5.5",
-        "--goal", "turn text prompts into CAD",
-    ])
-
-    assert rc == 0
-    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
-    assert profile["mode"] == "custom"
-    assert profile["provider"] == "openai"
-    assert profile["model"] == "openai/gpt-5.5"
-    assert profile["api_key_env"] == "OPENAI_API_KEY"
-    assert recommendation_calls[0]["model_provider"] == "openai"
-    assert recommendation_calls[0]["model"] == "openai/gpt-5.5"
-    assert "text-to-cad" in capsys.readouterr().out
-
-
-def test_main_custom_model_records_structured_harness_requirements(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    recommendation_calls: list[dict[str, object]] = []
-
-    def fake_recommend(
-        goal: str,
-        top_k: int = 5,
-        model_provider: str | None = None,
-        model: str | None = None,
-    ) -> list[dict[str, object]]:
-        recommendation_calls.append({
-            "goal": goal,
-            "top_k": top_k,
-            "model_provider": model_provider,
-            "model": model,
-        })
-        return []
-
-    monkeypatch.setattr(ci, "recommend_harnesses", fake_recommend)
-
-    rc = ci.main([
-        "--model-mode", "custom",
-        "--model", "openai/gpt-5.5",
-        "--goal", "build a code agent",
-        "--harness-runtime", "windows python",
-        "--harness-autonomy", "supervised",
-        "--harness-tools", "filesystem shell browser",
-        "--harness-verify", "pytest ruff",
-        "--harness-privacy", "private repo no secrets",
-        "--harness-attach-mode", "mcp",
-    ])
-
-    assert rc == 0
-    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
-    assert profile["harness_requirements"] == {
-        "runtime": "windows python",
-        "autonomy": "supervised",
-        "tools": "filesystem shell browser",
-        "verification": "pytest ruff",
-        "privacy": "private repo no secrets",
-        "attach_mode": "mcp",
-    }
-    query = str(recommendation_calls[0]["goal"])
-    assert "windows python" in query
-    assert "filesystem shell browser" in query
-    assert "pytest ruff" in query
-    assert "private repo no secrets" in query
-    assert "mcp" in query
-
-
-def test_main_custom_model_no_fit_points_to_harness_plan(
-    tmp_path: Path,
-    monkeypatch,
-    capsys,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(ci, "recommend_harnesses", lambda *args, **kwargs: [])
-
-    rc = ci.main([
-        "--model-mode", "custom",
-        "--model", "ollama/llama3.1",
-        "--model-provider", "ollama",
-        "--goal", "private local CAD workflow",
-        "--harness-runtime", "linux server",
-        "--harness-tools", "filesystem shell",
-        "--harness-verify", "pytest",
-        "--harness-privacy", "offline source code",
-        "--harness-attach-mode", "mcp",
-    ])
-
-    assert rc == 0
-    output = capsys.readouterr().out
-    assert "no harness recommendations matched yet" in output
-    assert "ctx-harness-install --recommend" in output
-    assert "--model-provider \"ollama\"" in output
-    assert "--harness-runtime \"linux server\"" in output
-    assert "--harness-tools \"filesystem shell\"" in output
-    assert "--harness-verify \"pytest\"" in output
-    assert "--harness-privacy \"offline source code\"" in output
-    assert "--harness-attach-mode \"mcp\"" in output
-    assert "--plan-on-no-fit" in output
-
-
-def test_recommend_harnesses_uses_wiki_frontmatter_for_fit(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    wiki = tmp_path / "wiki"
-    page = wiki / "entities" / "harnesses" / "text-to-cad.md"
-    page.parent.mkdir(parents=True)
-    page.write_text(
-        """---
-title: Text to CAD
-type: harness
-tags:
-  - cad
-runtimes:
-  - python
-model_providers:
-  - openai
-capabilities:
-  - Generate CAD artifacts from natural language prompts
-    with OpenSCAD and mesh validation
-repo_url: https://github.com/earthtojake/text-to-cad
----
-# Text to CAD
-""",
-        encoding="utf-8",
-    )
-    graph = nx.Graph()
-    graph.add_node(
-        "harness:text-to-cad",
-        label="text-to-cad",
-        type="harness",
-        tags=["cad"],
-    )
-    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
-    import ctx_config
-
-    monkeypatch.setattr(
-        ctx_config,
-        "cfg",
-        SimpleNamespace(
-            wiki_dir=wiki,
-            claude_dir=tmp_path / ".claude",
-            recommendation_top_k=5,
-            harness_recommendation_min_fit_score=0.85,
-        ),
-    )
-
-    results = ci.recommend_harnesses(
-        "turn text prompts into CAD openscad openai gpt-5 harness",
-        model_provider="openai",
-        model="openai/gpt-5.5",
-    )
-
-    assert results
-    assert results[0]["name"] == "text-to-cad"
-    assert results[0]["fit_score"] >= 0.85
-    assert "openai" in results[0]["fit_signals"]
-    assert "gpt-5" not in results[0]["fit_signals"]
-    assert "gpt-5" not in results[0]["missing_signals"]
-    assert "openscad" in results[0]["fit_signals"]
-
-
-def test_load_recommendation_graph_uses_configured_wiki_dir(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    wiki = tmp_path / "custom-wiki"
-    out = wiki / "graphify-out"
-    out.mkdir(parents=True)
-    graph = nx.Graph()
-    graph.add_node("harness:custom", label="custom", type="harness")
-    data = nx.node_link_data(graph)
-    (out / "graph.json").write_text(json.dumps(data), encoding="utf-8")
-
-    import ctx_config
-
-    monkeypatch.setattr(ctx_config, "cfg", SimpleNamespace(wiki_dir=wiki))
-
-    loaded = ci._load_recommendation_graph()
-
-    assert "harness:custom" in loaded
-
-
-def test_recommend_harnesses_surfaces_reliability_rubric(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    wiki = tmp_path / "wiki"
-    harness_dir = wiki / "entities" / "harnesses"
-    harness_dir.mkdir(parents=True)
-    (harness_dir / "reliable-agent.md").write_text(
-        """---
-title: Reliable Agent
-type: harness
-tags:
-  - agents
-model_providers:
-  - openai
-capabilities:
-  - Persistent project context and task state
-  - Permission limits, sandbox rules, and policy checks
-  - Automated tests, evals, retry loops, and validation gates
-verify_commands:
-  - pytest
-repo_url: https://example.test/reliable-agent
----
-# Reliable Agent
-""",
-        encoding="utf-8",
-    )
-    graph = nx.Graph()
-    graph.add_node(
-        "harness:reliable-agent",
-        label="reliable-agent",
-        type="harness",
-        tags=["agents"],
-    )
-    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
-    import ctx_config
-
-    monkeypatch.setattr(
-        ctx_config,
-        "cfg",
-        SimpleNamespace(
-            wiki_dir=wiki,
-            claude_dir=tmp_path / ".claude",
-            recommendation_top_k=5,
-            harness_recommendation_min_fit_score=0.20,
-            harness_reliability_weights={
-                "context": 0.34,
-                "constraints": 0.33,
-                "convergence": 0.33,
-            },
-        ),
-    )
-
-    results = ci.recommend_harnesses(
-        "openai agent workflow with tests and sandbox",
-        model_provider="openai",
-        model="openai/gpt-5.5",
-    )
-
-    assert results
-    recommendation = results[0]
-    assert recommendation["name"] == "reliable-agent"
-    assert recommendation["reliability_score"] >= 0.90
-    assert set(recommendation["reliability_dimensions"]) == {
-        "context",
-        "constraints",
-        "convergence",
-    }
-    assert recommendation["reliability_dimensions"]["context"]["matched_terms"]
-    assert recommendation["reliability_dimensions"]["constraints"]["matched_terms"]
-    assert recommendation["reliability_dimensions"]["convergence"]["matched_terms"]
-    assert "context" in recommendation["reliability_reason"]
-    assert "constraints" in recommendation["reliability_reason"]
-    assert "convergence" in recommendation["reliability_reason"]
-
-
-def test_recommend_harnesses_prefers_reliable_harness_when_fit_ties(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    wiki = tmp_path / "wiki"
-    harness_dir = wiki / "entities" / "harnesses"
-    harness_dir.mkdir(parents=True)
-    (harness_dir / "thin-agent.md").write_text(
-        """---
-title: Thin Agent
-type: harness
-tags:
-  - agents
-model_providers:
-  - openai
-capabilities:
-  - Agent workflow orchestration
-repo_url: https://example.test/thin-agent
----
-# Thin Agent
-""",
-        encoding="utf-8",
-    )
-    (harness_dir / "reliable-agent.md").write_text(
-        """---
-title: Reliable Agent
-type: harness
-tags:
-  - agents
-model_providers:
-  - openai
-capabilities:
-  - Agent workflow orchestration
-  - Persistent context state and durable task documents
-  - Permission limits, sandbox boundaries, and approval policies
-  - Automated tests, evals, validation gates, and retry loops
-verify_commands:
-  - pytest
-repo_url: https://example.test/reliable-agent
----
-# Reliable Agent
-""",
-        encoding="utf-8",
-    )
-    graph = nx.Graph()
-    for slug in ("thin-agent", "reliable-agent"):
-        graph.add_node(
-            f"harness:{slug}",
-            label=slug,
-            type="harness",
-            tags=["agents"],
-        )
-    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
-    import ctx_config
-
-    monkeypatch.setattr(
-        ctx_config,
-        "cfg",
-        SimpleNamespace(
-            wiki_dir=wiki,
-            claude_dir=tmp_path / ".claude",
-            recommendation_top_k=5,
-            harness_recommendation_min_fit_score=0.20,
-            harness_reliability_weights={
-                "context": 0.34,
-                "constraints": 0.33,
-                "convergence": 0.33,
-            },
-        ),
-    )
-
-    results = ci.recommend_harnesses(
-        "openai agent workflow",
-        model_provider="openai",
-        model="openai/gpt-5.5",
-    )
-
-    assert [row["name"] for row in results[:2]] == [
-        "reliable-agent",
-        "thin-agent",
-    ]
-    assert results[0]["fit_score"] == results[1]["fit_score"]
-    assert results[0]["reliability_score"] > results[1]["reliability_score"]
-
-
-def test_recommend_harnesses_avoids_semantic_model_load_by_default(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    graph = nx.Graph()
-    graph.add_node("harness:langgraph", label="langgraph", type="harness")
-    monkeypatch.setattr(ci, "_load_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(
-        ci,
-        "_annotate_harness_fit",
-        lambda *_args, **_kwargs: {"fit_score": 0.99, "fit_signals": ["agent"]},
-    )
-    import ctx_config
-
-    monkeypatch.setattr(
-        ctx_config,
-        "cfg",
-        SimpleNamespace(
-            claude_dir=tmp_path / ".claude",
-            recommendation_top_k=5,
-            harness_recommendation_min_fit_score=0.85,
-        ),
-    )
-    calls: dict[str, object] = {}
-
-    def fake_recommend_by_tags(*_args, **kwargs):
-        calls.update(kwargs)
-        return [{"name": "langgraph", "type": "harness", "score": 1.0}]
-
-    monkeypatch.setitem(
-        sys.modules,
-        "ctx.core.resolve.recommendations",
-        type(
-            "FakeRecommendModule",
-            (),
-            {
-                "query_to_tags": staticmethod(lambda _query: ["agent"]),
-                "recommend_by_tags": staticmethod(fake_recommend_by_tags),
-            },
-        ),
-    )
-
-    results = ci.recommend_harnesses(
-        "build an agent workflow",
-        model_provider="openai",
-        model="openai/gpt-5.5",
-    )
-
-    assert results[0]["name"] == "langgraph"
-    assert calls["query"] == "build an agent workflow"
-    assert calls["entity_types"] == ("harness",)
-    assert calls["use_semantic_query"] is False
-
-
-def test_main_custom_model_requires_model(tmp_path: Path, monkeypatch) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-
-    assert ci.main(["--model-mode", "custom"]) == 1
-
-
-def test_validate_model_flag_invokes_connection_check(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
-    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
-    monkeypatch.setattr(
-        ci,
-        "recommend_harnesses",
-        lambda goal, top_k=5, model_provider=None, model=None: [],
-    )
-    calls: list[dict] = []
-
-    def fake_validate(**kwargs):
-        calls.append(kwargs)
-        return 0
-
-    monkeypatch.setattr(ci, "validate_model_connection", fake_validate)
-
-    rc = ci.main([
-        "--model-mode", "custom",
-        "--model", "ollama/llama3.1",
-        "--validate-model",
-    ])
-
-    assert rc == 0
-    assert calls == [{
-        "model": "ollama/llama3.1",
-        "api_key_env": None,
-        "base_url": None,
-    }]
+"""Tests for ctx_init — bootstrap ~/.claude/ scaffolding."""
+
+from __future__ import annotations
+
+import builtins
+import hashlib
+import io
+import json
+import sqlite3
+import sys
+import tarfile
+import zlib
+from pathlib import Path
+from types import SimpleNamespace
+
+import networkx as nx
+import pytest
+import ctx_init as ci
+
+
+def _write_dashboard_index(path: Path, *, export_id: str = "test-export") -> None:
+    conn = sqlite3.connect(path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("export_id", json.dumps(export_id)),
+                ("nodes_count", "1"),
+                ("edges_count", "0"),
+                ("max_degree", "1"),
+                ("top_k", "40"),
+            ],
+        )
+        conn.execute(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            ("skill:current", "current", "skill", "[]", "", None, None, 0),
+        )
+        conn.execute("INSERT INTO slug_index VALUES(?,?,?)", ("current", "skill", "skill:current"))
+        conn.execute("INSERT INTO neighbors VALUES(?,?)", ("skill:current", zlib.compress(b"[]")))
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def _artifact_sha256_or_lfs_oid(path: Path, *, normalize_text: bool = False) -> str:
+    data = path.read_bytes()
+    if data.startswith(b"version https://git-lfs.github.com/spec/v1\n"):
+        for line in data.decode("utf-8").splitlines():
+            if line.startswith("oid sha256:"):
+                return line.removeprefix("oid sha256:")
+    if normalize_text:
+        data = data.replace(b"\r\n", b"\n")
+    return hashlib.sha256(data).hexdigest()
+
+
+def test_ensure_directories_creates_standard_tree(tmp_path: Path) -> None:
+    created = ci.ensure_directories(tmp_path)
+    # First call should create every standard subdir.
+    assert len(created) == len(ci._STANDARD_SUBDIRS)
+    for sub in ci._STANDARD_SUBDIRS:
+        assert (tmp_path / sub).is_dir(), f"missing {sub}"
+
+
+def test_ensure_directories_is_idempotent(tmp_path: Path) -> None:
+    first = ci.ensure_directories(tmp_path)
+    assert len(first) > 0
+    second = ci.ensure_directories(tmp_path)
+    assert second == [], "second call should not recreate anything"
+
+
+def test_seed_user_config_writes_once(tmp_path: Path) -> None:
+    tmp_path.mkdir(exist_ok=True)
+    first = ci.seed_user_config(tmp_path)
+    assert first is not None
+    assert first.exists()
+    body = first.read_text(encoding="utf-8")
+    assert "skill-system-config.json" in body
+
+    # Second call returns None (file already exists, force=False).
+    second = ci.seed_user_config(tmp_path)
+    assert second is None
+
+
+def test_seed_user_config_respects_force(tmp_path: Path) -> None:
+    target = tmp_path / "skill-system-config.json"
+    target.write_text("user-custom-content", encoding="utf-8")
+    # Without force → don't touch.
+    assert ci.seed_user_config(tmp_path, force=False) is None
+    assert target.read_text() == "user-custom-content"
+    # With force → overwrite.
+    result = ci.seed_user_config(tmp_path, force=True)
+    assert result == target
+    assert "skill-system-config.json" in target.read_text()
+
+
+def test_main_creates_everything_in_dry_mode(tmp_path: Path, monkeypatch,
+                                              capsys) -> None:
+    """End-to-end: ``ctx-init`` (no flags) creates dirs + config + toolboxes
+    without touching hooks or graph."""
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+
+    # Short-circuit subprocess.run to avoid spawning a real toolbox/graph CLI
+    # in tests. Verify that main() doesn't call install_hooks or build_graph
+    # when those flags are absent.
+    calls: list[list[str]] = []
+
+    class _FakeResult:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def fake_run(cmd, **kwargs):
+        calls.append(list(cmd))
+        return _FakeResult()
+
+    monkeypatch.setattr(ci.subprocess, "run", fake_run)
+
+    rc = ci.main([])
+    assert rc == 0
+    # toolbox init should have been invoked
+    toolbox_calls = [c for c in calls if "toolbox" in " ".join(c)]
+    assert toolbox_calls, "toolbox init not invoked"
+    # inject_hooks / wiki_graphify must NOT be invoked without flags
+    for c in calls:
+        assert "inject_hooks" not in " ".join(c)
+        assert "wiki_graphify" not in " ".join(c)
+
+    out = capsys.readouterr().out
+    assert "[ok]" in out
+    assert "[skip] hook injection" in out
+    assert "[skip] graph install" in out
+
+
+def test_main_treats_existing_toolboxes_as_idempotent_skip(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+
+    class _FakeResult:
+        returncode = 1
+        stdout = ""
+        stderr = (
+            "Global config already has 5 toolbox(es). "
+            "Use --force to overwrite."
+        )
+
+    monkeypatch.setattr(ci.subprocess, "run", lambda *_args, **_kwargs: _FakeResult())
+
+    rc = ci.main(["--model-mode", "skip"])
+    captured = capsys.readouterr()
+
+    assert rc == 0
+    assert "starter toolboxes already present" in captured.out
+    assert "toolbox init returned" not in captured.err
+    assert "Global config already has" not in captured.err
+
+
+def test_main_auto_wizard_in_terminal_configures_custom_model(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "_stdio_is_interactive", lambda: True)
+    monkeypatch.setattr(
+        ci,
+        "recommend_harnesses",
+        lambda goal, top_k=5, model_provider=None, model=None: [],
+    )
+
+    answers = iter([
+        "y",                  # hooks
+        "enriched",           # knowledge mode
+        "n",                  # graph
+        "custom",             # model mode
+        "openai/gpt-5.5",     # model
+        "",                   # provider default: openai
+        "",                   # api key env default: OPENAI_API_KEY
+        "",                   # base URL
+        "build CAD artifacts",
+        "windows python",      # runtime / OS
+        "supervised",          # autonomy
+        "filesystem shell",    # allowed tools
+        "pytest ruff",         # verification
+        "private repo",        # privacy / network
+        "mcp",                 # attach mode
+        "n",                  # validate model
+    ])
+    monkeypatch.setattr(builtins, "input", lambda _prompt: next(answers))
+    calls: list[list[str]] = []
+
+    class _FakeResult:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def _fake_run(cmd: list[str], **_kwargs: object) -> _FakeResult:
+        calls.append(list(cmd))
+        return _FakeResult()
+
+    monkeypatch.setattr(ci.subprocess, "run", _fake_run)
+
+    rc = ci.main([])
+
+    assert rc == 0
+    assert any("ctx.adapters.claude_code.inject_hooks" in c for c in calls)
+    assert not any("ctx.core.wiki.wiki_graphify" in c for c in calls)
+    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
+    assert profile["mode"] == "custom"
+    assert profile["provider"] == "openai"
+    assert profile["model"] == "openai/gpt-5.5"
+    assert profile["api_key_env"] == "OPENAI_API_KEY"
+    assert profile["goal"] == "build CAD artifacts"
+    assert profile["knowledge_mode"] == "enriched"
+    assert profile["harness_requirements"] == {
+        "runtime": "windows python",
+        "autonomy": "supervised",
+        "tools": "filesystem shell",
+        "verification": "pytest ruff",
+        "privacy": "private repo",
+        "attach_mode": "mcp",
+    }
+    user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
+    assert user_config["knowledge"]["mode"] == "enriched"
+
+
+def test_wizard_flag_prompts_without_tty(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "_stdio_is_interactive", lambda: False)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(
+        ci,
+        "recommend_harnesses",
+        lambda goal, top_k=5, model_provider=None, model=None: [],
+    )
+
+    answers = iter([
+        "n",                  # hooks
+        "local",              # knowledge mode
+        "claude-code",        # model mode
+        "maintain FastAPI services",
+    ])
+    monkeypatch.setattr(builtins, "input", lambda _prompt: next(answers))
+
+    rc = ci.main(["--wizard"])
+
+    assert rc == 0
+    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
+    assert profile["mode"] == "claude-code"
+    assert profile["goal"] == "maintain FastAPI services"
+    assert profile["knowledge_mode"] == "local"
+    user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
+    assert user_config["knowledge"]["mode"] == "local"
+
+
+def test_explicit_args_do_not_auto_wizard_in_terminal(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "_stdio_is_interactive", lambda: True)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(
+        builtins,
+        "input",
+        lambda _prompt: (_ for _ in ()).throw(AssertionError("unexpected prompt")),
+    )
+
+    assert ci.main(["--model-mode", "skip", "--knowledge-mode", "local"]) == 0
+    user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
+    assert user_config["knowledge"]["mode"] == "local"
+
+
+def test_main_with_hooks_flag_invokes_inject(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    calls: list[list[str]] = []
+
+    class _FakeResult:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def _fake_run(cmd: list[str], **_kwargs: object) -> _FakeResult:
+        calls.append(list(cmd))
+        return _FakeResult()
+
+    monkeypatch.setattr(ci.subprocess, "run", _fake_run)
+    rc = ci.main(["--hooks"])
+    assert rc == 0
+    assert any("ctx.adapters.claude_code.inject_hooks" in c for c in calls)
+    assert not any(c == "inject_hooks" for call in calls for c in call)
+
+
+def _write_graph_archive(tmp_path: Path) -> Path:
+    source = tmp_path / "archive-source"
+    graph_out = source / "graphify-out"
+    graph_out.mkdir(parents=True)
+    (graph_out / "graph.json").write_text(
+        json.dumps({"graph": {"export_id": "test-export"}, "nodes": [], "links": []}),
+        encoding="utf-8",
+    )
+    (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 = source / "external-catalogs" / "skills-sh"
+    external.mkdir(parents=True)
+    (external / "catalog.json").write_text("{}", encoding="utf-8")
+    entities = source / "entities" / "skills"
+    entities.mkdir(parents=True)
+    (entities / "current.md").write_text("# Current\n", encoding="utf-8")
+    (source / "index.md").write_text("# Wiki\n", encoding="utf-8")
+    archive = tmp_path / "wiki-graph.tar.gz"
+    with tarfile.open(archive, "w:gz") as tf:
+        for path in sorted(source.rglob("*")):
+            if path.is_file():
+                tf.add(path, arcname=path.relative_to(source).as_posix())
+    return archive
+
+
+def _tar_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 _tar_bytes(tf: tarfile.TarFile, name: str, payload: bytes) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    tf.addfile(info, io.BytesIO(payload))
+
+
+def test_download_graph_archive_verifies_sha256(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    payload = b"graph archive bytes"
+
+    class _Response(io.BytesIO):
+        def __enter__(self) -> "_Response":
+            return self
+
+        def __exit__(self, *_args: object) -> None:
+            return None
+
+    monkeypatch.setattr(
+        ci.urllib.request,
+        "urlopen",
+        lambda _url, timeout=120: _Response(payload),
+    )
+
+    destination = tmp_path / "wiki-graph.tar.gz"
+    ci._download_graph_archive(
+        destination,
+        url="https://example.invalid/wiki-graph.tar.gz",
+        expected_sha256=hashlib.sha256(payload).hexdigest(),
+    )
+    assert destination.read_bytes() == payload
+
+    bad_destination = tmp_path / "bad-wiki-graph.tar.gz"
+    with pytest.raises(ValueError, match="checksum mismatch"):
+        ci._download_graph_archive(
+            bad_destination,
+            url="https://example.invalid/wiki-graph.tar.gz",
+            expected_sha256="0" * 64,
+        )
+    assert not bad_destination.exists()
+
+
+def test_graph_download_checksums_match_shipped_artifacts() -> None:
+    root = Path(__file__).resolve().parent.parent.parent
+    for mode, archive_name in ci._GRAPH_ARCHIVE_NAMES.items():
+        path = root / "graph" / archive_name
+        assert ci._GRAPH_ARCHIVE_SHA256[mode] == _artifact_sha256_or_lfs_oid(path)
+
+    overlay_path = root / "graph" / ci._GRAPH_ENTITY_OVERLAY_NAME
+    assert ci._GRAPH_ENTITY_OVERLAY_SHA256 == _artifact_sha256_or_lfs_oid(
+        overlay_path,
+        normalize_text=True,
+    )
+
+
+def test_local_graph_archive_checksum_is_verified(tmp_path: Path) -> None:
+    archive = tmp_path / "wiki-graph-runtime.tar.gz"
+    archive.write_bytes(b"not the shipped runtime archive")
+
+    with pytest.raises(ValueError, match="local graph archive checksum mismatch"):
+        ci._verify_local_graph_archive(archive, requested_install_mode="runtime")
+
+
+def test_lfs_pointer_graph_archive_is_ignored(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    graph_dir = tmp_path / "graph"
+    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",
+        encoding="utf-8",
+    )
+    cwd = tmp_path / "cwd"
+    cwd.mkdir()
+    monkeypatch.chdir(cwd)
+    monkeypatch.setattr(ci, "__file__", str(tmp_path / "src" / "ctx_init.py"))
+
+    assert ci._find_local_graph_archive("runtime") is None
+
+
+def test_custom_graph_url_requires_checksum_or_explicit_opt_out(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci, "_find_local_graph_archive", lambda _mode: None)
+    monkeypatch.setattr(
+        ci,
+        "_download_graph_archive",
+        lambda *_args, **_kwargs: (_ for _ in ()).throw(
+            AssertionError("download should be blocked before network access")
+        ),
+    )
+
+    rc = ci.build_graph(
+        tmp_path / "home",
+        graph_url="https://example.invalid/wiki-graph.tar.gz",
+    )
+
+    assert rc == 1
+
+
+def test_custom_graph_url_bypasses_local_archive(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    archive_bytes = archive.read_bytes()
+    calls: list[dict[str, object]] = []
+
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _mode: (_ for _ in ()).throw(
+            AssertionError("explicit graph_url must not use local archive")
+        ),
+    )
+
+    def fake_download(destination: Path, **kwargs: object) -> None:
+        calls.append(dict(kwargs))
+        destination.write_bytes(archive_bytes)
+
+    monkeypatch.setattr(ci, "_download_graph_archive", fake_download)
+    monkeypatch.setattr(ci, "_install_graph_entity_overlay", lambda *_a, **_k: None)
+
+    rc = ci.build_graph(
+        tmp_path / "home",
+        graph_url="https://example.invalid/custom-wiki-graph.tar.gz",
+        graph_sha256=hashlib.sha256(archive_bytes).hexdigest(),
+    )
+
+    assert rc == 0
+    assert calls == [
+        {
+            "url": "https://example.invalid/custom-wiki-graph.tar.gz",
+            "expected_sha256": hashlib.sha256(archive_bytes).hexdigest(),
+        }
+    ]
+
+
+def test_main_with_graph_flag_installs_prebuilt_graph(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    claude = tmp_path / "home"
+    archive = _write_graph_archive(tmp_path)
+    monkeypatch.setattr(ci, "_claude_dir", lambda: claude)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+        raising=False,
+    )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
+    monkeypatch.setattr(
+        ci,
+        "_download_graph_archive",
+        lambda _dest, **_kwargs: (_ for _ in ()).throw(
+            AssertionError("unexpected release download")
+        ),
+        raising=False,
+    )
+    calls: list[list[str]] = []
+
+    class _FakeResult:
+        returncode = 0
+        stdout = ""
+        stderr = ""
+
+    def _fake_run(cmd: list[str], **_kwargs: object) -> _FakeResult:
+        calls.append(list(cmd))
+        return _FakeResult()
+
+    monkeypatch.setattr(ci.subprocess, "run", _fake_run)
+    rc = ci.main(["--graph", "--model-mode", "skip"])
+    assert rc == 0
+    graph_json = claude / "skill-wiki" / "graphify-out" / "graph.json"
+    graph_payload = json.loads(graph_json.read_text(encoding="utf-8"))
+    assert graph_payload["graph"]["export_id"] == "test-export"
+    assert not (
+        claude / "skill-wiki" / "entities" / "skills" / "current.md"
+    ).exists()
+    assert not any("ctx.core.wiki.wiki_graphify" in c for c in calls)
+    assert not any(c == "wiki_graphify" for call in calls for c in call)
+
+
+def test_graph_install_copies_local_entity_overlay(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    claude = tmp_path / "home"
+    archive = _write_graph_archive(tmp_path)
+    overlay = tmp_path / "entity-overlays.jsonl"
+    overlay.write_text(
+        json.dumps({
+            "overlay_id": "test-overlay",
+            "nodes": [{"id": "harness:mirage", "type": "harness"}],
+            "edges": [
+                {
+                    "source": "harness:mirage",
+                    "target": "skill:codex-review",
+                    "weight": 0.5,
+                    "similarity_score": 0.5,
+                    "method": "manual_direct_overlay_v1",
+                    "rank": 1,
+                    "provenance": "manual_overlay_v1",
+                }
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+        raising=False,
+    )
+    monkeypatch.setattr(ci, "_find_local_graph_entity_overlay", lambda: overlay)
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
+
+    assert ci.build_graph(claude) == 0
+
+    installed = claude / "skill-wiki" / "graphify-out" / "entity-overlays.jsonl"
+    payload = json.loads(installed.read_text(encoding="utf-8"))
+    assert payload["overlay_id"] == "test-overlay"
+    assert payload["edges"][0]["method"] == "manual_direct_overlay_v1"
+
+
+@pytest.mark.parametrize("field", ["semantic_sim", "tag_sim", "token_sim"])
+def test_graph_overlay_validation_rejects_out_of_range_similarity_fields(
+    tmp_path: Path,
+    field: str,
+) -> None:
+    overlay = tmp_path / "entity-overlays.jsonl"
+    overlay.write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.5,
+                    "final_weight": 0.5,
+                    field: 2.0,
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(ValueError, match=f"{field} must be 0..1"):
+        ci._validate_graph_entity_overlay(overlay)
+
+
+def test_graph_overlay_validation_rejects_weight_final_weight_drift(
+    tmp_path: Path,
+) -> None:
+    overlay = tmp_path / "entity-overlays.jsonl"
+    overlay.write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.7,
+                    "final_weight": 0.5,
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(ValueError, match="weight must equal final_weight"):
+        ci._validate_graph_entity_overlay(overlay)
+
+
+def test_runtime_graph_install_extracts_harness_pages_after_required_files(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = tmp_path / "ordered-runtime-wiki-graph.tar.gz"
+    with tarfile.open(archive, "w:gz") as tf:
+        _tar_text(
+            tf,
+            "graphify-out/graph.json",
+            json.dumps({
+                "graph": {"export_id": "test-export"},
+                "nodes": [{"id": "harness:text-to-cad", "type": "harness"}],
+                "links": [],
+            }),
+        )
+        _tar_text(
+            tf,
+            "graphify-out/graph-delta.json",
+            json.dumps({"export_id": "test-export", "nodes": [], "edges": []}),
+        )
+        _tar_text(
+            tf,
+            "graphify-out/communities.json",
+            json.dumps({"export_id": "test-export", "total_communities": 0}),
+        )
+        _tar_text(tf, "graphify-out/graph-report.md", "# Graph Report\n")
+        _tar_text(
+            tf,
+            "graphify-out/graph-export-manifest.json",
+            json.dumps({
+                "version": 1,
+                "export_id": "test-export",
+                "artifacts": {
+                    "graph": "graph.json",
+                    "delta": "graph-delta.json",
+                    "communities": "communities.json",
+                    "report": "graph-report.md",
+                },
+            }),
+        )
+        index_path = tmp_path / "runtime-dashboard-neighborhoods.sqlite3"
+        _write_dashboard_index(index_path)
+        _tar_bytes(
+            tf,
+            "graphify-out/dashboard-neighborhoods.sqlite3",
+            index_path.read_bytes(),
+        )
+        _tar_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        _tar_text(tf, "index.md", "# Wiki\n")
+        _tar_text(tf, "entities/harnesses/text-to-cad.md", "# Text to CAD\n")
+        _tar_text(tf, "entities/skills/not-runtime.md", "# Not runtime\n")
+
+    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)
+
+    assert ci.build_graph(claude) == 0
+    assert (
+        claude / "skill-wiki" / "entities" / "harnesses" / "text-to-cad.md"
+    ).is_file()
+    assert not (
+        claude / "skill-wiki" / "entities" / "skills" / "not-runtime.md"
+    ).exists()
+
+
+def test_runtime_graph_install_preserves_existing_non_harness_entities(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    claude = tmp_path / "home"
+    local_skill = claude / "skill-wiki" / "entities" / "skills" / "private.md"
+    local_agent = claude / "skill-wiki" / "entities" / "agents" / "private.md"
+    local_mcp = claude / "skill-wiki" / "entities" / "mcp-servers" / "p" / "private.md"
+    local_harness = claude / "skill-wiki" / "entities" / "harnesses" / "old.md"
+    for path in (local_skill, local_agent, local_mcp, local_harness):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(f"# {path.stem}\n", encoding="utf-8")
+
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+    )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
+    monkeypatch.setattr(ci, "_install_graph_entity_overlay", lambda *_a, **_k: None)
+
+    assert ci.build_graph(claude, force=True, install_mode="runtime") == 0
+
+    assert local_skill.is_file()
+    assert local_agent.is_file()
+    assert local_mcp.is_file()
+    assert not local_harness.exists()
+
+
+def test_graph_install_rejects_incomplete_archive(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    source = tmp_path / "incomplete-source"
+    graph_out = source / "graphify-out"
+    graph_out.mkdir(parents=True)
+    (graph_out / "graph.json").write_text(
+        json.dumps({"graph": {"export_id": "partial"}, "nodes": []}),
+        encoding="utf-8",
+    )
+    archive = tmp_path / "incomplete-wiki-graph.tar.gz"
+    with tarfile.open(archive, "w:gz") as tf:
+        tf.add(graph_out / "graph.json", arcname="graphify-out/graph.json")
+
+    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)
+
+    assert ci.build_graph(claude) == 1
+    assert not (claude / "skill-wiki" / "graphify-out" / "graph.json").exists()
+
+
+def test_graph_install_validation_does_not_parse_full_graph_json(
+    tmp_path: Path,
+    monkeypatch,
+) -> 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_out / "graph.json").write_text(
+        json.dumps({"graph": {"export_id": "test-export"}, "nodes": [], "links": []}),
+        encoding="utf-8",
+    )
+    (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")
+
+    def guarded_read(path: Path) -> object:
+        if path.name == "graph.json":
+            raise AssertionError("install validation must not parse full graph.json")
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    monkeypatch.setattr(ci, "_read_json_file", guarded_read)
+
+    ci._validate_graph_install_tree(wiki)
+
+
+def test_graph_install_force_prunes_stale_generated_files(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    claude = tmp_path / "home"
+    stale = claude / "skill-wiki" / "entities" / "skills" / "stale.md"
+    stale.parent.mkdir(parents=True)
+    stale.write_text("# Stale\n", encoding="utf-8")
+    monkeypatch.setattr(ci, "_claude_dir", lambda: claude)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+    )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
+
+    assert ci.main([
+        "--graph",
+        "--graph-install-mode", "full",
+        "--force",
+        "--model-mode", "skip",
+    ]) == 0
+    assert not stale.exists()
+    assert (claude / "skill-wiki" / "entities" / "skills" / "current.md").is_file()
+
+
+def test_graph_install_rejects_path_traversal_archive(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = tmp_path / "malicious-wiki-graph.tar.gz"
+    payload = b"owned"
+    with tarfile.open(archive, "w:gz") as tf:
+        info = tarfile.TarInfo("../evil.txt")
+        info.size = len(payload)
+        tf.addfile(info, io.BytesIO(payload))
+
+    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)
+
+    assert ci.build_graph(claude) == 1
+    assert not (tmp_path / "evil.txt").exists()
+    assert not (claude / "evil.txt").exists()
+
+
+def test_main_with_requested_hook_failure_exits_nonzero(
+    tmp_path: Path, monkeypatch
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+
+    class _FakeResult:
+        def __init__(self, returncode: int) -> None:
+            self.returncode = returncode
+            self.stdout = ""
+            self.stderr = ""
+
+    def fake_run(cmd, **kwargs):
+        if "ctx.adapters.claude_code.inject_hooks" in cmd:
+            return _FakeResult(7)
+        return _FakeResult(0)
+
+    monkeypatch.setattr(ci.subprocess, "run", fake_run)
+
+    assert ci.main(["--hooks"]) == 7
+
+
+def test_main_custom_model_writes_profile_and_recommends_harness(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+
+    recommendation_calls: list[dict[str, object]] = []
+
+    def fake_recommend(
+        goal: str,
+        top_k: int = 5,
+        model_provider: str | None = None,
+        model: str | None = None,
+    ) -> list[dict[str, object]]:
+        recommendation_calls.append({
+            "goal": goal,
+            "top_k": top_k,
+            "model_provider": model_provider,
+            "model": model,
+        })
+        return [{"name": "text-to-cad", "type": "harness", "score": 0.8}]
+
+    monkeypatch.setattr(
+        ci,
+        "recommend_harnesses",
+        fake_recommend,
+    )
+
+    rc = ci.main([
+        "--model-mode", "custom",
+        "--model", "openai/gpt-5.5",
+        "--goal", "turn text prompts into CAD",
+    ])
+
+    assert rc == 0
+    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
+    assert profile["mode"] == "custom"
+    assert profile["provider"] == "openai"
+    assert profile["model"] == "openai/gpt-5.5"
+    assert profile["api_key_env"] == "OPENAI_API_KEY"
+    assert recommendation_calls[0]["model_provider"] == "openai"
+    assert recommendation_calls[0]["model"] == "openai/gpt-5.5"
+    assert "text-to-cad" in capsys.readouterr().out
+
+
+def test_main_custom_model_records_structured_harness_requirements(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    recommendation_calls: list[dict[str, object]] = []
+
+    def fake_recommend(
+        goal: str,
+        top_k: int = 5,
+        model_provider: str | None = None,
+        model: str | None = None,
+    ) -> list[dict[str, object]]:
+        recommendation_calls.append({
+            "goal": goal,
+            "top_k": top_k,
+            "model_provider": model_provider,
+            "model": model,
+        })
+        return []
+
+    monkeypatch.setattr(ci, "recommend_harnesses", fake_recommend)
+
+    rc = ci.main([
+        "--model-mode", "custom",
+        "--model", "openai/gpt-5.5",
+        "--goal", "build a code agent",
+        "--harness-runtime", "windows python",
+        "--harness-autonomy", "supervised",
+        "--harness-tools", "filesystem shell browser",
+        "--harness-verify", "pytest ruff",
+        "--harness-privacy", "private repo no secrets",
+        "--harness-attach-mode", "mcp",
+    ])
+
+    assert rc == 0
+    profile = json.loads((tmp_path / "ctx-model-profile.json").read_text())
+    assert profile["harness_requirements"] == {
+        "runtime": "windows python",
+        "autonomy": "supervised",
+        "tools": "filesystem shell browser",
+        "verification": "pytest ruff",
+        "privacy": "private repo no secrets",
+        "attach_mode": "mcp",
+    }
+    query = str(recommendation_calls[0]["goal"])
+    assert "windows python" in query
+    assert "filesystem shell browser" in query
+    assert "pytest ruff" in query
+    assert "private repo no secrets" in query
+    assert "mcp" in query
+
+
+def test_main_custom_model_no_fit_points_to_harness_plan(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(ci, "recommend_harnesses", lambda *args, **kwargs: [])
+
+    rc = ci.main([
+        "--model-mode", "custom",
+        "--model", "ollama/llama3.1",
+        "--model-provider", "ollama",
+        "--goal", "private local CAD workflow",
+        "--harness-runtime", "linux server",
+        "--harness-tools", "filesystem shell",
+        "--harness-verify", "pytest",
+        "--harness-privacy", "offline source code",
+        "--harness-attach-mode", "mcp",
+    ])
+
+    assert rc == 0
+    output = capsys.readouterr().out
+    assert "no harness recommendations matched yet" in output
+    assert "ctx-harness-install --recommend" in output
+    assert "--model-provider \"ollama\"" in output
+    assert "--harness-runtime \"linux server\"" in output
+    assert "--harness-tools \"filesystem shell\"" in output
+    assert "--harness-verify \"pytest\"" in output
+    assert "--harness-privacy \"offline source code\"" in output
+    assert "--harness-attach-mode \"mcp\"" in output
+    assert "--plan-on-no-fit" in output
+
+
+def test_recommend_harnesses_uses_wiki_frontmatter_for_fit(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "wiki"
+    page = wiki / "entities" / "harnesses" / "text-to-cad.md"
+    page.parent.mkdir(parents=True)
+    page.write_text(
+        """---
+title: Text to CAD
+type: harness
+tags:
+  - cad
+runtimes:
+  - python
+model_providers:
+  - openai
+capabilities:
+  - Generate CAD artifacts from natural language prompts
+    with OpenSCAD and mesh validation
+repo_url: https://github.com/earthtojake/text-to-cad
+---
+# Text to CAD
+""",
+        encoding="utf-8",
+    )
+    graph = nx.Graph()
+    graph.add_node(
+        "harness:text-to-cad",
+        label="text-to-cad",
+        type="harness",
+        tags=["cad"],
+    )
+    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        SimpleNamespace(
+            wiki_dir=wiki,
+            claude_dir=tmp_path / ".claude",
+            recommendation_top_k=5,
+            harness_recommendation_min_fit_score=0.85,
+        ),
+    )
+
+    results = ci.recommend_harnesses(
+        "turn text prompts into CAD openscad openai gpt-5 harness",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+    )
+
+    assert results
+    assert results[0]["name"] == "text-to-cad"
+    assert results[0]["fit_score"] >= 0.85
+    assert "openai" in results[0]["fit_signals"]
+    assert "gpt-5" not in results[0]["fit_signals"]
+    assert "gpt-5" not in results[0]["missing_signals"]
+    assert "openscad" in results[0]["fit_signals"]
+
+
+def test_load_recommendation_graph_uses_configured_wiki_dir(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "custom-wiki"
+    out = wiki / "graphify-out"
+    out.mkdir(parents=True)
+    graph = nx.Graph()
+    graph.add_node("harness:custom", label="custom", type="harness")
+    data = nx.node_link_data(graph)
+    (out / "graph.json").write_text(json.dumps(data), encoding="utf-8")
+
+    import ctx_config
+
+    monkeypatch.setattr(ctx_config, "cfg", SimpleNamespace(wiki_dir=wiki))
+
+    loaded = ci._load_recommendation_graph()
+
+    assert "harness:custom" in loaded
+
+
+def test_recommend_harnesses_surfaces_reliability_rubric(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "wiki"
+    harness_dir = wiki / "entities" / "harnesses"
+    harness_dir.mkdir(parents=True)
+    (harness_dir / "reliable-agent.md").write_text(
+        """---
+title: Reliable Agent
+type: harness
+tags:
+  - agents
+model_providers:
+  - openai
+capabilities:
+  - Persistent project context and task state
+  - Permission limits, sandbox rules, and policy checks
+  - Automated tests, evals, retry loops, and validation gates
+verify_commands:
+  - pytest
+repo_url: https://example.test/reliable-agent
+---
+# Reliable Agent
+""",
+        encoding="utf-8",
+    )
+    graph = nx.Graph()
+    graph.add_node(
+        "harness:reliable-agent",
+        label="reliable-agent",
+        type="harness",
+        tags=["agents"],
+    )
+    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        SimpleNamespace(
+            wiki_dir=wiki,
+            claude_dir=tmp_path / ".claude",
+            recommendation_top_k=5,
+            harness_recommendation_min_fit_score=0.20,
+            harness_reliability_weights={
+                "context": 0.34,
+                "constraints": 0.33,
+                "convergence": 0.33,
+            },
+        ),
+    )
+
+    results = ci.recommend_harnesses(
+        "openai agent workflow with tests and sandbox",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+    )
+
+    assert results
+    recommendation = results[0]
+    assert recommendation["name"] == "reliable-agent"
+    assert recommendation["reliability_score"] >= 0.90
+    assert set(recommendation["reliability_dimensions"]) == {
+        "context",
+        "constraints",
+        "convergence",
+    }
+    assert recommendation["reliability_dimensions"]["context"]["matched_terms"]
+    assert recommendation["reliability_dimensions"]["constraints"]["matched_terms"]
+    assert recommendation["reliability_dimensions"]["convergence"]["matched_terms"]
+    assert "context" in recommendation["reliability_reason"]
+    assert "constraints" in recommendation["reliability_reason"]
+    assert "convergence" in recommendation["reliability_reason"]
+
+
+def test_recommend_harnesses_prefers_reliable_harness_when_fit_ties(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    wiki = tmp_path / "wiki"
+    harness_dir = wiki / "entities" / "harnesses"
+    harness_dir.mkdir(parents=True)
+    (harness_dir / "thin-agent.md").write_text(
+        """---
+title: Thin Agent
+type: harness
+tags:
+  - agents
+model_providers:
+  - openai
+capabilities:
+  - Agent workflow orchestration
+repo_url: https://example.test/thin-agent
+---
+# Thin Agent
+""",
+        encoding="utf-8",
+    )
+    (harness_dir / "reliable-agent.md").write_text(
+        """---
+title: Reliable Agent
+type: harness
+tags:
+  - agents
+model_providers:
+  - openai
+capabilities:
+  - Agent workflow orchestration
+  - Persistent context state and durable task documents
+  - Permission limits, sandbox boundaries, and approval policies
+  - Automated tests, evals, validation gates, and retry loops
+verify_commands:
+  - pytest
+repo_url: https://example.test/reliable-agent
+---
+# Reliable Agent
+""",
+        encoding="utf-8",
+    )
+    graph = nx.Graph()
+    for slug in ("thin-agent", "reliable-agent"):
+        graph.add_node(
+            f"harness:{slug}",
+            label=slug,
+            type="harness",
+            tags=["agents"],
+        )
+    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        SimpleNamespace(
+            wiki_dir=wiki,
+            claude_dir=tmp_path / ".claude",
+            recommendation_top_k=5,
+            harness_recommendation_min_fit_score=0.20,
+            harness_reliability_weights={
+                "context": 0.34,
+                "constraints": 0.33,
+                "convergence": 0.33,
+            },
+        ),
+    )
+
+    results = ci.recommend_harnesses(
+        "openai agent workflow",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+    )
+
+    assert [row["name"] for row in results[:2]] == [
+        "reliable-agent",
+        "thin-agent",
+    ]
+    assert results[0]["fit_score"] == results[1]["fit_score"]
+    assert results[0]["reliability_score"] > results[1]["reliability_score"]
+
+
+def test_recommend_harnesses_avoids_semantic_model_load_by_default(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    graph = nx.Graph()
+    graph.add_node("harness:langgraph", label="langgraph", type="harness")
+    monkeypatch.setattr(ci, "_load_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(
+        ci,
+        "_annotate_harness_fit",
+        lambda *_args, **_kwargs: {"fit_score": 0.99, "fit_signals": ["agent"]},
+    )
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        SimpleNamespace(
+            claude_dir=tmp_path / ".claude",
+            recommendation_top_k=5,
+            harness_recommendation_min_fit_score=0.85,
+        ),
+    )
+    calls: dict[str, object] = {}
+
+    def fake_recommend_by_tags(*_args, **kwargs):
+        calls.update(kwargs)
+        return [{"name": "langgraph", "type": "harness", "score": 1.0}]
+
+    monkeypatch.setitem(
+        sys.modules,
+        "ctx.core.resolve.recommendations",
+        type(
+            "FakeRecommendModule",
+            (),
+            {
+                "query_to_tags": staticmethod(lambda _query: ["agent"]),
+                "recommend_by_tags": staticmethod(fake_recommend_by_tags),
+            },
+        ),
+    )
+
+    results = ci.recommend_harnesses(
+        "build an agent workflow",
+        model_provider="openai",
+        model="openai/gpt-5.5",
+    )
+
+    assert results[0]["name"] == "langgraph"
+    assert calls["query"] == "build an agent workflow"
+    assert calls["entity_types"] == ("harness",)
+    assert calls["use_semantic_query"] is False
+
+
+def test_main_custom_model_requires_model(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+
+    assert ci.main(["--model-mode", "custom"]) == 1
+
+
+def test_validate_model_flag_invokes_connection_check(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(ci, "_claude_dir", lambda: tmp_path)
+    monkeypatch.setattr(ci, "seed_toolboxes", lambda force=False: 0)
+    monkeypatch.setattr(
+        ci,
+        "recommend_harnesses",
+        lambda goal, top_k=5, model_provider=None, model=None: [],
+    )
+    calls: list[dict] = []
+
+    def fake_validate(**kwargs):
+        calls.append(kwargs)
+        return 0
+
+    monkeypatch.setattr(ci, "validate_model_connection", fake_validate)
+
+    rc = ci.main([
+        "--model-mode", "custom",
+        "--model", "ollama/llama3.1",
+        "--validate-model",
+    ])
+
+    assert rc == 0
+    assert calls == [{
+        "model": "ollama/llama3.1",
+        "api_key_env": None,
+        "base_url": None,
+    }]

src/tests/test_dedup_check.py

@@ -1,286 +1,286 @@
-"""test_dedup_check.py — unit tests for the dedup gate.
-
-Covers:
-  - allowlist parsing (comments, malformed lines, slug ordering)
-  - state load/save (round-trip, version mismatch, threshold mismatch)
-  - find_high_similarity_pairs (chunking, threshold filtering, dedup)
-  - end-to-end orchestration on a synthetic fixture
-  - markdown + JSON report rendering
-  - exit code behavior
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-import numpy as np
-
-SRC_DIR = Path(__file__).resolve().parents[1]
-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
-
-
-# ── Allowlist ──────────────────────────────────────────────────────────
-
-
-def test_allowlist_parses_comments_and_blanks(tmp_path: Path) -> None:
-    p = tmp_path / "allow.txt"
-    p.write_text(
-        "\n".join([
-            "# header comment",
-            "",
-            "alpha beta  # legitimate distinct",
-            "  gamma delta",
-            "# trailing comment",
-        ]),
-        encoding="utf-8",
-    )
-    assert dc.load_allowlist(p) == {("alpha", "beta"), ("delta", "gamma")}
-
-
-def test_allowlist_canonicalises_slug_order(tmp_path: Path) -> None:
-    p = tmp_path / "allow.txt"
-    p.write_text("zebra apple\n", encoding="utf-8")
-    # Stored canonical (low, high) regardless of file order
-    assert dc.load_allowlist(p) == {("apple", "zebra")}
-
-
-def test_allowlist_returns_empty_when_missing(tmp_path: Path) -> None:
-    assert dc.load_allowlist(tmp_path / "does-not-exist.txt") == set()
-
-
-def test_allowlist_skips_malformed_lines(tmp_path: Path) -> None:
-    p = tmp_path / "allow.txt"
-    p.write_text("only-one-token\n", encoding="utf-8")
-    assert dc.load_allowlist(p) == set()
-
-
-# ── State ──────────────────────────────────────────────────────────────
-
-
-def test_state_round_trip(tmp_path: Path) -> None:
-    s = dc.DedupState(
-        version=dc.DEDUP_STATE_VERSION,
-        model_id="m1",
-        threshold=0.85,
-        entity_hashes={"skill:a": "h1"},
-        last_findings=[{"a": "skill:a", "b": "skill:b"}],
-    )
-    dc.save_state(tmp_path, s)
-    loaded = dc.load_state(tmp_path, model_id="m1", threshold=0.85)
-    assert loaded.entity_hashes == {"skill:a": "h1"}
-    assert loaded.threshold == 0.85
-    assert loaded.model_id == "m1"
-
-
-def test_state_invalidates_on_model_change(tmp_path: Path) -> None:
-    s = dc.DedupState(
-        version=dc.DEDUP_STATE_VERSION,
-        model_id="m1", threshold=0.85,
-        entity_hashes={"skill:a": "h1"}, last_findings=[],
-    )
-    dc.save_state(tmp_path, s)
-    loaded = dc.load_state(tmp_path, model_id="m2", threshold=0.85)
-    assert loaded.entity_hashes == {}, "model change must invalidate state"
-
-
-def test_state_invalidates_on_threshold_change(tmp_path: Path) -> None:
-    s = dc.DedupState(
-        version=dc.DEDUP_STATE_VERSION,
-        model_id="m1", threshold=0.85,
-        entity_hashes={"skill:a": "h1"}, last_findings=[],
-    )
-    dc.save_state(tmp_path, s)
-    loaded = dc.load_state(tmp_path, model_id="m1", threshold=0.90)
-    assert loaded.entity_hashes == {}, "threshold change must invalidate state"
-
-
-def test_state_returns_empty_when_missing(tmp_path: Path) -> None:
-    out = dc.load_state(tmp_path, model_id="m1", threshold=0.85)
-    assert out.entity_hashes == {}
-    assert out.threshold == 0.85
-
-
-# ── Pair finding ───────────────────────────────────────────────────────
-
-
-def test_find_high_similarity_pairs_emits_each_pair_once() -> None:
-    """A symmetric similarity matrix must produce N(N-1)/2 pairs at most,
-    not N² (no double-emission).
-    """
-    # Three identical vectors → all three pairs are perfectly similar
-    vecs = np.array([
-        [1.0, 0.0, 0.0],
-        [1.0, 0.0, 0.0],
-        [1.0, 0.0, 0.0],
-    ], dtype="float32")
-    # L2 already normalised
-    entities = [
-        dc.EntityRef(node_id=f"skill:{s}", type="skill", slug=s,
-                     path=Path(f"/{s}.md"), description=s, tags=())
-        for s in ["a", "b", "c"]
-    ]
-    pairs = dc.find_high_similarity_pairs(entities, vecs, threshold=0.99)
-    assert len(pairs) == 3, "expected exactly 3 pairs for 3 entities"
-    seen = {(i, j) for i, j, _ in pairs}
-    assert seen == {(0, 1), (0, 2), (1, 2)}
-
-
-def test_find_high_similarity_pairs_threshold_filters() -> None:
-    """Below-threshold pairs must not appear."""
-    # Two orthogonal vectors → cosine = 0
-    vecs = np.array([[1.0, 0.0], [0.0, 1.0]], dtype="float32")
-    entities = [
-        dc.EntityRef(node_id=f"skill:{s}", type="skill", slug=s,
-                     path=Path(f"/{s}.md"), description=s, tags=())
-        for s in ["a", "b"]
-    ]
-    pairs = dc.find_high_similarity_pairs(entities, vecs, threshold=0.50)
-    assert pairs == [], "orthogonal vectors must not produce a pair at any threshold > 0"
-
-
-def test_find_high_similarity_pairs_chunking_consistent() -> None:
-    """Different chunk sizes must produce the same result."""
-    rng = np.random.default_rng(42)
-    n = 50
-    raw = rng.standard_normal((n, 8)).astype("float32")
-    norms = np.linalg.norm(raw, axis=1, keepdims=True)
-    norms[norms == 0] = 1.0
-    vecs = raw / norms
-    entities = [
-        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
-                     path=Path(f"/e{i}.md"), description="", tags=())
-        for i in range(n)
-    ]
-    a = sorted(dc.find_high_similarity_pairs(entities, vecs, threshold=0.5, chunk_size=8))
-    b = sorted(dc.find_high_similarity_pairs(entities, vecs, threshold=0.5, chunk_size=200))
-    assert [(i, j) for i, j, _ in a] == [(i, j) for i, j, _ in b], (
-        "chunked + unchunked runs must produce identical pair sets"
-    )
-
-
-# ── Markdown rendering ────────────────────────────────────────────────
-
-
-def test_render_markdown_with_no_findings() -> None:
-    rep = dc.DedupReport(
-        threshold=0.85, model_id="m1",
-        total_entities=10, pairs_evaluated=45,
-    )
-    md = dc.render_markdown(rep)
-    assert "No actionable findings" in md
-    assert "0.85" in md
-
-
-def test_render_markdown_caps_at_top_n() -> None:
-    refs = [
-        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
-                     path=Path(f"/e{i}.md"), description=f"desc{i}", tags=())
-        for i in range(150)
-    ]
-    pairs = [
-        dc.DedupPair(a=refs[i], b=refs[i + 1],
-                     similarity=0.99 - i * 0.0001, shared_tags=())
-        for i in range(149)
-    ]
-    rep = dc.DedupReport(
-        threshold=0.85, model_id="m1",
-        total_entities=150, pairs_evaluated=149,
-        findings=pairs,
-    )
-    md = dc.render_markdown(rep, top_n=10)
-    # Header acknowledges the cap
-    assert "Showing" in md and "top 10" in md
-    # Body has at most top_n ### headers
-    headers = [line for line in md.splitlines() if line.startswith("### ")]
-    assert len(headers) == 10, f"expected 10 finding headers, got {len(headers)}"
-
-
-def test_incremental_skips_unchanged_pairs(tmp_path: Path) -> None:
-    """First run: full pass, state saved. Second run with same hashes:
-    every prior finding carries forward without recomputation, and only
-    pairs touching changed/new entities are recomputed.
-    """
-    import numpy as np
-
-    cache_dir = tmp_path / "cache"
-    cache_dir.mkdir()
-    # Build a tiny embeddings.npz + topk-state.json the loader can read.
-    refs = [
-        dc.EntityRef(
-            node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
-            path=tmp_path / f"e{i}.md", description=f"d{i}", tags=("t",),
-        )
-        for i in range(3)
-    ]
-    # Vectors: e0/e1 are nearly identical (cosine ~1.0); e2 is unrelated.
-    vecs = np.array([[1.0, 0.0], [0.999, 0.045], [0.0, 1.0]], dtype="float32")
-
-    # Save first state via run_dedup_check's normal save path: simulate a
-    # prior run by saving state directly with these hashes + finding.
-    hashes = {r.node_id: dc._entity_hash_for_state(r) for r in refs}
-    prior = dc.DedupState(
-        version=dc.DEDUP_STATE_VERSION,
-        model_id="test", threshold=0.85,
-        entity_hashes=hashes,
-        last_findings=[
-            {"a": "skill:e0", "b": "skill:e1", "similarity": 0.999},
-        ],
-    )
-    dc.save_state(cache_dir, prior)
-
-    # All entities unchanged → unchanged_ids covers everyone → carry-forward
-    unchanged = {nid for nid, h in hashes.items() if prior.entity_hashes.get(nid) == h}
-    assert unchanged == {"skill:e0", "skill:e1", "skill:e2"}
-
-    # Verify _find_pairs_for_changed returns nothing when there are no
-    # changed entities (i.e. an incremental run with everything cached
-    # bypasses the expensive pairwise pass entirely).
-    pairs = dc._find_pairs_for_changed(refs, vecs, [], threshold=0.85)
-    assert pairs == []
-
-
-def test_incremental_recomputes_when_entity_changed(tmp_path: Path) -> None:
-    """When one entity's hash changes, pairs touching it must be
-    recomputed even if the prior state had carry-forward findings.
-    """
-    import numpy as np
-
-    refs = [
-        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
-                     path=tmp_path / f"e{i}.md", description=f"d{i}", tags=())
-        for i in range(3)
-    ]
-    vecs = np.array([[1.0, 0.0], [0.999, 0.045], [0.0, 1.0]], dtype="float32")
-
-    # Only e1 is "changed" (index 1); pairs computed only for rows
-    # involving index 1.
-    pairs = dc._find_pairs_for_changed(refs, vecs, [1], threshold=0.85)
-    pair_keys = {(i, j) for i, j, _ in pairs}
-    # e0-e1 pair (0,1) must be present; e1-e2 pair would exist if cosine
-    # were >= 0.85 but the vectors here put it well below.
-    assert (0, 1) in pair_keys
-    # No (0, 2) pair since neither endpoint is changed.
-    assert (0, 2) not in pair_keys
-
-
-def test_render_markdown_includes_distribution_buckets() -> None:
-    refs = [
-        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
-                     path=Path(f"/e{i}.md"), description="", tags=())
-        for i in range(4)
-    ]
-    pairs = [
-        dc.DedupPair(a=refs[0], b=refs[1], similarity=0.995, shared_tags=()),
-        dc.DedupPair(a=refs[0], b=refs[2], similarity=0.93, shared_tags=()),
-        dc.DedupPair(a=refs[0], b=refs[3], similarity=0.86, shared_tags=()),
-    ]
-    rep = dc.DedupReport(
-        threshold=0.85, model_id="m1",
-        total_entities=4, pairs_evaluated=6, findings=pairs,
-    )
-    md = dc.render_markdown(rep)
-    assert "≥0.99" in md and "0.90-0.95" in md and "0.85-0.90" in md
+"""test_dedup_check.py — unit tests for the dedup gate.
+
+Covers:
+  - allowlist parsing (comments, malformed lines, slug ordering)
+  - state load/save (round-trip, version mismatch, threshold mismatch)
+  - find_high_similarity_pairs (chunking, threshold filtering, dedup)
+  - end-to-end orchestration on a synthetic fixture
+  - markdown + JSON report rendering
+  - exit code behavior
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+
+SRC_DIR = Path(__file__).resolve().parents[1]
+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
+
+
+# ── Allowlist ──────────────────────────────────────────────────────────
+
+
+def test_allowlist_parses_comments_and_blanks(tmp_path: Path) -> None:
+    p = tmp_path / "allow.txt"
+    p.write_text(
+        "\n".join([
+            "# header comment",
+            "",
+            "alpha beta  # legitimate distinct",
+            "  gamma delta",
+            "# trailing comment",
+        ]),
+        encoding="utf-8",
+    )
+    assert dc.load_allowlist(p) == {("alpha", "beta"), ("delta", "gamma")}
+
+
+def test_allowlist_canonicalises_slug_order(tmp_path: Path) -> None:
+    p = tmp_path / "allow.txt"
+    p.write_text("zebra apple\n", encoding="utf-8")
+    # Stored canonical (low, high) regardless of file order
+    assert dc.load_allowlist(p) == {("apple", "zebra")}
+
+
+def test_allowlist_returns_empty_when_missing(tmp_path: Path) -> None:
+    assert dc.load_allowlist(tmp_path / "does-not-exist.txt") == set()
+
+
+def test_allowlist_skips_malformed_lines(tmp_path: Path) -> None:
+    p = tmp_path / "allow.txt"
+    p.write_text("only-one-token\n", encoding="utf-8")
+    assert dc.load_allowlist(p) == set()
+
+
+# ── State ──────────────────────────────────────────────────────────────
+
+
+def test_state_round_trip(tmp_path: Path) -> None:
+    s = dc.DedupState(
+        version=dc.DEDUP_STATE_VERSION,
+        model_id="m1",
+        threshold=0.85,
+        entity_hashes={"skill:a": "h1"},
+        last_findings=[{"a": "skill:a", "b": "skill:b"}],
+    )
+    dc.save_state(tmp_path, s)
+    loaded = dc.load_state(tmp_path, model_id="m1", threshold=0.85)
+    assert loaded.entity_hashes == {"skill:a": "h1"}
+    assert loaded.threshold == 0.85
+    assert loaded.model_id == "m1"
+
+
+def test_state_invalidates_on_model_change(tmp_path: Path) -> None:
+    s = dc.DedupState(
+        version=dc.DEDUP_STATE_VERSION,
+        model_id="m1", threshold=0.85,
+        entity_hashes={"skill:a": "h1"}, last_findings=[],
+    )
+    dc.save_state(tmp_path, s)
+    loaded = dc.load_state(tmp_path, model_id="m2", threshold=0.85)
+    assert loaded.entity_hashes == {}, "model change must invalidate state"
+
+
+def test_state_invalidates_on_threshold_change(tmp_path: Path) -> None:
+    s = dc.DedupState(
+        version=dc.DEDUP_STATE_VERSION,
+        model_id="m1", threshold=0.85,
+        entity_hashes={"skill:a": "h1"}, last_findings=[],
+    )
+    dc.save_state(tmp_path, s)
+    loaded = dc.load_state(tmp_path, model_id="m1", threshold=0.90)
+    assert loaded.entity_hashes == {}, "threshold change must invalidate state"
+
+
+def test_state_returns_empty_when_missing(tmp_path: Path) -> None:
+    out = dc.load_state(tmp_path, model_id="m1", threshold=0.85)
+    assert out.entity_hashes == {}
+    assert out.threshold == 0.85
+
+
+# ── Pair finding ───────────────────────────────────────────────────────
+
+
+def test_find_high_similarity_pairs_emits_each_pair_once() -> None:
+    """A symmetric similarity matrix must produce N(N-1)/2 pairs at most,
+    not N² (no double-emission).
+    """
+    # Three identical vectors → all three pairs are perfectly similar
+    vecs = np.array([
+        [1.0, 0.0, 0.0],
+        [1.0, 0.0, 0.0],
+        [1.0, 0.0, 0.0],
+    ], dtype="float32")
+    # L2 already normalised
+    entities = [
+        dc.EntityRef(node_id=f"skill:{s}", type="skill", slug=s,
+                     path=Path(f"/{s}.md"), description=s, tags=())
+        for s in ["a", "b", "c"]
+    ]
+    pairs = dc.find_high_similarity_pairs(entities, vecs, threshold=0.99)
+    assert len(pairs) == 3, "expected exactly 3 pairs for 3 entities"
+    seen = {(i, j) for i, j, _ in pairs}
+    assert seen == {(0, 1), (0, 2), (1, 2)}
+
+
+def test_find_high_similarity_pairs_threshold_filters() -> None:
+    """Below-threshold pairs must not appear."""
+    # Two orthogonal vectors → cosine = 0
+    vecs = np.array([[1.0, 0.0], [0.0, 1.0]], dtype="float32")
+    entities = [
+        dc.EntityRef(node_id=f"skill:{s}", type="skill", slug=s,
+                     path=Path(f"/{s}.md"), description=s, tags=())
+        for s in ["a", "b"]
+    ]
+    pairs = dc.find_high_similarity_pairs(entities, vecs, threshold=0.50)
+    assert pairs == [], "orthogonal vectors must not produce a pair at any threshold > 0"
+
+
+def test_find_high_similarity_pairs_chunking_consistent() -> None:
+    """Different chunk sizes must produce the same result."""
+    rng = np.random.default_rng(42)
+    n = 50
+    raw = rng.standard_normal((n, 8)).astype("float32")
+    norms = np.linalg.norm(raw, axis=1, keepdims=True)
+    norms[norms == 0] = 1.0
+    vecs = raw / norms
+    entities = [
+        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
+                     path=Path(f"/e{i}.md"), description="", tags=())
+        for i in range(n)
+    ]
+    a = sorted(dc.find_high_similarity_pairs(entities, vecs, threshold=0.5, chunk_size=8))
+    b = sorted(dc.find_high_similarity_pairs(entities, vecs, threshold=0.5, chunk_size=200))
+    assert [(i, j) for i, j, _ in a] == [(i, j) for i, j, _ in b], (
+        "chunked + unchunked runs must produce identical pair sets"
+    )
+
+
+# ── Markdown rendering ────────────────────────────────────────────────
+
+
+def test_render_markdown_with_no_findings() -> None:
+    rep = dc.DedupReport(
+        threshold=0.85, model_id="m1",
+        total_entities=10, pairs_evaluated=45,
+    )
+    md = dc.render_markdown(rep)
+    assert "No actionable findings" in md
+    assert "0.85" in md
+
+
+def test_render_markdown_caps_at_top_n() -> None:
+    refs = [
+        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
+                     path=Path(f"/e{i}.md"), description=f"desc{i}", tags=())
+        for i in range(150)
+    ]
+    pairs = [
+        dc.DedupPair(a=refs[i], b=refs[i + 1],
+                     similarity=0.99 - i * 0.0001, shared_tags=())
+        for i in range(149)
+    ]
+    rep = dc.DedupReport(
+        threshold=0.85, model_id="m1",
+        total_entities=150, pairs_evaluated=149,
+        findings=pairs,
+    )
+    md = dc.render_markdown(rep, top_n=10)
+    # Header acknowledges the cap
+    assert "Showing" in md and "top 10" in md
+    # Body has at most top_n ### headers
+    headers = [line for line in md.splitlines() if line.startswith("### ")]
+    assert len(headers) == 10, f"expected 10 finding headers, got {len(headers)}"
+
+
+def test_incremental_skips_unchanged_pairs(tmp_path: Path) -> None:
+    """First run: full pass, state saved. Second run with same hashes:
+    every prior finding carries forward without recomputation, and only
+    pairs touching changed/new entities are recomputed.
+    """
+    import numpy as np
+
+    cache_dir = tmp_path / "cache"
+    cache_dir.mkdir()
+    # Build a tiny embeddings.npz + topk-state.json the loader can read.
+    refs = [
+        dc.EntityRef(
+            node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
+            path=tmp_path / f"e{i}.md", description=f"d{i}", tags=("t",),
+        )
+        for i in range(3)
+    ]
+    # Vectors: e0/e1 are nearly identical (cosine ~1.0); e2 is unrelated.
+    vecs = np.array([[1.0, 0.0], [0.999, 0.045], [0.0, 1.0]], dtype="float32")
+
+    # Save first state via run_dedup_check's normal save path: simulate a
+    # prior run by saving state directly with these hashes + finding.
+    hashes = {r.node_id: dc._entity_hash_for_state(r) for r in refs}
+    prior = dc.DedupState(
+        version=dc.DEDUP_STATE_VERSION,
+        model_id="test", threshold=0.85,
+        entity_hashes=hashes,
+        last_findings=[
+            {"a": "skill:e0", "b": "skill:e1", "similarity": 0.999},
+        ],
+    )
+    dc.save_state(cache_dir, prior)
+
+    # All entities unchanged → unchanged_ids covers everyone → carry-forward
+    unchanged = {nid for nid, h in hashes.items() if prior.entity_hashes.get(nid) == h}
+    assert unchanged == {"skill:e0", "skill:e1", "skill:e2"}
+
+    # Verify _find_pairs_for_changed returns nothing when there are no
+    # changed entities (i.e. an incremental run with everything cached
+    # bypasses the expensive pairwise pass entirely).
+    pairs = dc._find_pairs_for_changed(refs, vecs, [], threshold=0.85)
+    assert pairs == []
+
+
+def test_incremental_recomputes_when_entity_changed(tmp_path: Path) -> None:
+    """When one entity's hash changes, pairs touching it must be
+    recomputed even if the prior state had carry-forward findings.
+    """
+    import numpy as np
+
+    refs = [
+        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
+                     path=tmp_path / f"e{i}.md", description=f"d{i}", tags=())
+        for i in range(3)
+    ]
+    vecs = np.array([[1.0, 0.0], [0.999, 0.045], [0.0, 1.0]], dtype="float32")
+
+    # Only e1 is "changed" (index 1); pairs computed only for rows
+    # involving index 1.
+    pairs = dc._find_pairs_for_changed(refs, vecs, [1], threshold=0.85)
+    pair_keys = {(i, j) for i, j, _ in pairs}
+    # e0-e1 pair (0,1) must be present; e1-e2 pair would exist if cosine
+    # were >= 0.85 but the vectors here put it well below.
+    assert (0, 1) in pair_keys
+    # No (0, 2) pair since neither endpoint is changed.
+    assert (0, 2) not in pair_keys
+
+
+def test_render_markdown_includes_distribution_buckets() -> None:
+    refs = [
+        dc.EntityRef(node_id=f"skill:e{i}", type="skill", slug=f"e{i}",
+                     path=Path(f"/e{i}.md"), description="", tags=())
+        for i in range(4)
+    ]
+    pairs = [
+        dc.DedupPair(a=refs[0], b=refs[1], similarity=0.995, shared_tags=()),
+        dc.DedupPair(a=refs[0], b=refs[2], similarity=0.93, shared_tags=()),
+        dc.DedupPair(a=refs[0], b=refs[3], similarity=0.86, shared_tags=()),
+    ]
+    rep = dc.DedupReport(
+        threshold=0.85, model_id="m1",
+        total_entities=4, pairs_evaluated=6, findings=pairs,
+    )
+    md = dc.render_markdown(rep)
+    assert "≥0.99" in md and "0.90-0.95" in md and "0.85-0.90" in md

src/tests/test_fs_utils.py

@@ -1,207 +1,207 @@
-"""
-test_fs_utils.py -- Tests for the shared atomic file-write helpers.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-import threading
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-# Ensure src/ is on sys.path
-_SRC = Path(__file__).resolve().parent.parent
-if str(_SRC) not in sys.path:
-    sys.path.insert(0, str(_SRC))
-
-from ctx.utils import _fs_utils as fs_utils  # noqa: E402
-from ctx.utils._fs_utils import atomic_write_bytes, atomic_write_json, atomic_write_text  # noqa: E402
-
-
-# ── atomic_write_text ─────────────────────────────────────────────────────────
-
-
-def test_write_text_happy_path(tmp_path: Path) -> None:
-    target = tmp_path / "out.txt"
-    atomic_write_text(target, "hello world")
-    assert target.read_text(encoding="utf-8") == "hello world"
-
-
-def test_write_text_creates_parent_dirs(tmp_path: Path) -> None:
-    target = tmp_path / "a" / "b" / "c" / "out.txt"
-    atomic_write_text(target, "nested")
-    assert target.read_text(encoding="utf-8") == "nested"
-
-
-def test_write_text_overwrites_existing(tmp_path: Path) -> None:
-    target = tmp_path / "out.txt"
-    target.write_text("old", encoding="utf-8")
-    atomic_write_text(target, "new")
-    assert target.read_text(encoding="utf-8") == "new"
-
-
-def test_write_text_custom_encoding(tmp_path: Path) -> None:
-    target = tmp_path / "out.txt"
-    text = "caf\u00e9"  # contains non-ASCII
-    atomic_write_text(target, text, encoding="utf-8")
-    assert target.read_text(encoding="utf-8") == text
-
-
-def test_write_text_no_temp_file_left_on_success(tmp_path: Path) -> None:
-    target = tmp_path / "out.txt"
-    atomic_write_text(target, "data")
-    leftover = list(tmp_path.glob("out.txt.*"))
-    assert leftover == [], f"Unexpected temp files: {leftover}"
-
-
-def test_write_text_no_temp_file_left_on_error(tmp_path: Path) -> None:
-    """Temp file must be cleaned up even when os.replace raises."""
-    target = tmp_path / "out.txt"
-    with patch("ctx.utils._fs_utils._replace_with_retry", side_effect=OSError("boom")):
-        with pytest.raises(OSError, match="boom"):
-            atomic_write_text(target, "data")
-    leftover = list(tmp_path.glob("out.txt.*"))
-    assert leftover == [], f"Temp file leaked: {leftover}"
-
-
-def test_write_text_fsyncs_temp_before_replace_and_parent_after(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    target = tmp_path / "out.txt"
-    events: list[str] = []
-
-    def record_fsync(_fd: int) -> None:
-        events.append("fsync")
-
-    def record_replace(
-        src: str,
-        dst: Path,
-        *,
-        attempts: int = 10,
-        delay: float = 0.05,
-    ) -> None:
-        del attempts, delay
-        events.append("replace")
-        os.replace(src, dst)
-
-    def record_parent_fsync(path: Path) -> None:
-        assert path == target.parent
-        events.append("parent-fsync")
-
-    monkeypatch.setattr(fs_utils.os, "fsync", record_fsync)
-    monkeypatch.setattr(fs_utils, "_replace_with_retry", record_replace)
-    monkeypatch.setattr(fs_utils, "_fsync_parent_dir", record_parent_fsync, raising=False)
-
-    atomic_write_text(target, "durable")
-
-    assert events == ["fsync", "replace", "parent-fsync"]
-
-
-# ── atomic_write_bytes ────────────────────────────────────────────────────────
-
-
-def test_write_bytes_happy_path(tmp_path: Path) -> None:
-    target = tmp_path / "out.bin"
-    atomic_write_bytes(target, b"\x00\x01\x02\x03")
-    assert target.read_bytes() == b"\x00\x01\x02\x03"
-
-
-def test_write_bytes_creates_parent_dirs(tmp_path: Path) -> None:
-    target = tmp_path / "deep" / "out.bin"
-    atomic_write_bytes(target, b"bytes")
-    assert target.read_bytes() == b"bytes"
-
-
-# ── atomic_write_json ─────────────────────────────────────────────────────────
-
-
-def test_write_json_happy_path(tmp_path: Path) -> None:
-    target = tmp_path / "data.json"
-    obj = {"key": "value", "num": 42}
-    atomic_write_json(target, obj)
-    loaded = json.loads(target.read_text(encoding="utf-8"))
-    assert loaded == obj
-
-
-def test_write_json_trailing_newline(tmp_path: Path) -> None:
-    target = tmp_path / "data.json"
-    atomic_write_json(target, {"x": 1})
-    assert target.read_text(encoding="utf-8").endswith("\n")
-
-
-def test_write_json_custom_indent(tmp_path: Path) -> None:
-    target = tmp_path / "data.json"
-    atomic_write_json(target, {"a": 1}, indent=4)
-    raw = target.read_text(encoding="utf-8")
-    assert '    "a"' in raw  # 4-space indent present
-
-
-def test_write_json_none_indent(tmp_path: Path) -> None:
-    target = tmp_path / "data.json"
-    atomic_write_json(target, {"a": 1}, indent=None)
-    raw = target.read_text(encoding="utf-8").strip()
-    assert raw == '{"a": 1}'
-
-
-# ── Windows retry ─────────────────────────────────────────────────────────────
-
-
-def test_replace_retries_on_permission_error(tmp_path: Path) -> None:
-    """_replace_with_retry should succeed on the second attempt."""
-    target = tmp_path / "out.txt"
-    call_count = 0
-    real_replace = os.replace
-
-    def flaky_replace(src: str, dst: Path) -> None:
-        nonlocal call_count
-        call_count += 1
-        if call_count == 1:
-            raise PermissionError("locked")
-        real_replace(src, dst)
-
-    with patch("ctx.utils._fs_utils.os.replace", side_effect=flaky_replace):
-        with patch("ctx.utils._fs_utils.time.sleep"):  # don't actually sleep
-            atomic_write_text(target, "retry-test")
-
-    assert call_count == 2
-    assert target.read_text(encoding="utf-8") == "retry-test"
-
-
-def test_replace_raises_after_max_attempts(tmp_path: Path) -> None:
-    """After exhausting retries, the PermissionError must propagate."""
-    target = tmp_path / "out.txt"
-
-    with patch("ctx.utils._fs_utils.os.replace", side_effect=PermissionError("always locked")):
-        with patch("ctx.utils._fs_utils.time.sleep"):
-            with pytest.raises(PermissionError, match="always locked"):
-                atomic_write_text(target, "data")
-
-
-# ── Concurrency smoke test ────────────────────────────────────────────────────
-
-
-def test_concurrent_writes_last_write_wins(tmp_path: Path) -> None:
-    """Multiple threads writing to the same path must not leave corruption."""
-    target = tmp_path / "shared.txt"
-    errors: list[Exception] = []
-
-    def writer(content: str) -> None:
-        try:
-            atomic_write_text(target, content)
-        except Exception as exc:
-            errors.append(exc)
-
-    threads = [threading.Thread(target=writer, args=(f"thread-{i}",)) for i in range(8)]
-    for t in threads:
-        t.start()
-    for t in threads:
-        t.join()
-
-    assert errors == [], f"Writer threads raised: {errors}"
-    content = target.read_text(encoding="utf-8")
-    assert content.startswith("thread-")
+"""
+test_fs_utils.py -- Tests for the shared atomic file-write helpers.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+# Ensure src/ is on sys.path
+_SRC = Path(__file__).resolve().parent.parent
+if str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+
+from ctx.utils import _fs_utils as fs_utils  # noqa: E402
+from ctx.utils._fs_utils import atomic_write_bytes, atomic_write_json, atomic_write_text  # noqa: E402
+
+
+# ── atomic_write_text ─────────────────────────────────────────────────────────
+
+
+def test_write_text_happy_path(tmp_path: Path) -> None:
+    target = tmp_path / "out.txt"
+    atomic_write_text(target, "hello world")
+    assert target.read_text(encoding="utf-8") == "hello world"
+
+
+def test_write_text_creates_parent_dirs(tmp_path: Path) -> None:
+    target = tmp_path / "a" / "b" / "c" / "out.txt"
+    atomic_write_text(target, "nested")
+    assert target.read_text(encoding="utf-8") == "nested"
+
+
+def test_write_text_overwrites_existing(tmp_path: Path) -> None:
+    target = tmp_path / "out.txt"
+    target.write_text("old", encoding="utf-8")
+    atomic_write_text(target, "new")
+    assert target.read_text(encoding="utf-8") == "new"
+
+
+def test_write_text_custom_encoding(tmp_path: Path) -> None:
+    target = tmp_path / "out.txt"
+    text = "caf\u00e9"  # contains non-ASCII
+    atomic_write_text(target, text, encoding="utf-8")
+    assert target.read_text(encoding="utf-8") == text
+
+
+def test_write_text_no_temp_file_left_on_success(tmp_path: Path) -> None:
+    target = tmp_path / "out.txt"
+    atomic_write_text(target, "data")
+    leftover = list(tmp_path.glob("out.txt.*"))
+    assert leftover == [], f"Unexpected temp files: {leftover}"
+
+
+def test_write_text_no_temp_file_left_on_error(tmp_path: Path) -> None:
+    """Temp file must be cleaned up even when os.replace raises."""
+    target = tmp_path / "out.txt"
+    with patch("ctx.utils._fs_utils._replace_with_retry", side_effect=OSError("boom")):
+        with pytest.raises(OSError, match="boom"):
+            atomic_write_text(target, "data")
+    leftover = list(tmp_path.glob("out.txt.*"))
+    assert leftover == [], f"Temp file leaked: {leftover}"
+
+
+def test_write_text_fsyncs_temp_before_replace_and_parent_after(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    target = tmp_path / "out.txt"
+    events: list[str] = []
+
+    def record_fsync(_fd: int) -> None:
+        events.append("fsync")
+
+    def record_replace(
+        src: str,
+        dst: Path,
+        *,
+        attempts: int = 10,
+        delay: float = 0.05,
+    ) -> None:
+        del attempts, delay
+        events.append("replace")
+        os.replace(src, dst)
+
+    def record_parent_fsync(path: Path) -> None:
+        assert path == target.parent
+        events.append("parent-fsync")
+
+    monkeypatch.setattr(fs_utils.os, "fsync", record_fsync)
+    monkeypatch.setattr(fs_utils, "_replace_with_retry", record_replace)
+    monkeypatch.setattr(fs_utils, "_fsync_parent_dir", record_parent_fsync, raising=False)
+
+    atomic_write_text(target, "durable")
+
+    assert events == ["fsync", "replace", "parent-fsync"]
+
+
+# ── atomic_write_bytes ────────────────────────────────────────────────────────
+
+
+def test_write_bytes_happy_path(tmp_path: Path) -> None:
+    target = tmp_path / "out.bin"
+    atomic_write_bytes(target, b"\x00\x01\x02\x03")
+    assert target.read_bytes() == b"\x00\x01\x02\x03"
+
+
+def test_write_bytes_creates_parent_dirs(tmp_path: Path) -> None:
+    target = tmp_path / "deep" / "out.bin"
+    atomic_write_bytes(target, b"bytes")
+    assert target.read_bytes() == b"bytes"
+
+
+# ── atomic_write_json ─────────────────────────────────────────────────────────
+
+
+def test_write_json_happy_path(tmp_path: Path) -> None:
+    target = tmp_path / "data.json"
+    obj = {"key": "value", "num": 42}
+    atomic_write_json(target, obj)
+    loaded = json.loads(target.read_text(encoding="utf-8"))
+    assert loaded == obj
+
+
+def test_write_json_trailing_newline(tmp_path: Path) -> None:
+    target = tmp_path / "data.json"
+    atomic_write_json(target, {"x": 1})
+    assert target.read_text(encoding="utf-8").endswith("\n")
+
+
+def test_write_json_custom_indent(tmp_path: Path) -> None:
+    target = tmp_path / "data.json"
+    atomic_write_json(target, {"a": 1}, indent=4)
+    raw = target.read_text(encoding="utf-8")
+    assert '    "a"' in raw  # 4-space indent present
+
+
+def test_write_json_none_indent(tmp_path: Path) -> None:
+    target = tmp_path / "data.json"
+    atomic_write_json(target, {"a": 1}, indent=None)
+    raw = target.read_text(encoding="utf-8").strip()
+    assert raw == '{"a": 1}'
+
+
+# ── Windows retry ─────────────────────────────────────────────────────────────
+
+
+def test_replace_retries_on_permission_error(tmp_path: Path) -> None:
+    """_replace_with_retry should succeed on the second attempt."""
+    target = tmp_path / "out.txt"
+    call_count = 0
+    real_replace = os.replace
+
+    def flaky_replace(src: str, dst: Path) -> None:
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            raise PermissionError("locked")
+        real_replace(src, dst)
+
+    with patch("ctx.utils._fs_utils.os.replace", side_effect=flaky_replace):
+        with patch("ctx.utils._fs_utils.time.sleep"):  # don't actually sleep
+            atomic_write_text(target, "retry-test")
+
+    assert call_count == 2
+    assert target.read_text(encoding="utf-8") == "retry-test"
+
+
+def test_replace_raises_after_max_attempts(tmp_path: Path) -> None:
+    """After exhausting retries, the PermissionError must propagate."""
+    target = tmp_path / "out.txt"
+
+    with patch("ctx.utils._fs_utils.os.replace", side_effect=PermissionError("always locked")):
+        with patch("ctx.utils._fs_utils.time.sleep"):
+            with pytest.raises(PermissionError, match="always locked"):
+                atomic_write_text(target, "data")
+
+
+# ── Concurrency smoke test ────────────────────────────────────────────────────
+
+
+def test_concurrent_writes_last_write_wins(tmp_path: Path) -> None:
+    """Multiple threads writing to the same path must not leave corruption."""
+    target = tmp_path / "shared.txt"
+    errors: list[Exception] = []
+
+    def writer(content: str) -> None:
+        try:
+            atomic_write_text(target, content)
+        except Exception as exc:
+            errors.append(exc)
+
+    threads = [threading.Thread(target=writer, args=(f"thread-{i}",)) for i in range(8)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+
+    assert errors == [], f"Writer threads raised: {errors}"
+    content = target.read_text(encoding="utf-8")
+    assert content.startswith("thread-")

src/tests/test_harness_contract.py

@@ -1,744 +1,744 @@
-"""
-test_harness_contract.py -- Contract + ContractBuilder + P/C/G/E flow.
-
-Pins:
-  * ContractCriterion + Contract shapes, frozen, to_dict, to_markdown
-  * ContractCriterion.as_evaluator_criterion rendering with/without
-    metric + threshold
-  * ContractBuilder.build happy path, unstructured fallback, planner
-    injection into user turn, default temperature
-  * _parse_criteria_list: synth name fallback, drops non-dict items
-  * _safe_str_tuple: list / string-fallback / non-list
-  * run_with_evaluation with contract_builder: evaluator gets
-    refined criteria, system prompt uses contract markdown,
-    total_usage sums all four agents
-  * CLI: --contract requires --planner; --contract persists contract
-    event into JSONL; JSON output does NOT re-duplicate contract
-    (it's in the session file)
-  * augmented_system_prompt_with_contract formatting
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-import types
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-from ctx.adapters.generic.contract import (
-    Contract,
-    ContractBuilder,
-    ContractCriterion,
-    _parse_criteria_list,
-    _safe_str_tuple,
-    augmented_system_prompt_with_contract,
-)
-from ctx.adapters.generic.evaluator import (
-    Evaluator,
-    run_with_evaluation,
-)
-from ctx.adapters.generic.planner import PlanArtifact, Planner
-from ctx.adapters.generic.providers import (
-    CompletionResponse,
-    Message,
-    ModelProvider,
-    ToolDefinition,
-    Usage,
-)
-
-
-# ── Scripted provider ──────────────────────────────────────────────────────
-
-
-@dataclass
-class _Scripted(ModelProvider):
-    responses: list[CompletionResponse]
-    name: str = "scripted"
-    calls: list[dict[str, Any]] = field(default_factory=list)
-
-    def complete(
-        self,
-        messages: list[Message],
-        tools: list[ToolDefinition] | None = None,
-        *,
-        model: str | None = None,
-        temperature: float = 0.7,
-        max_tokens: int | None = None,
-    ) -> CompletionResponse:
-        self.calls.append(
-            {
-                "messages": list(messages),
-                "model": model,
-                "temperature": temperature,
-                "max_tokens": max_tokens,
-            }
-        )
-        if not self.responses:
-            raise RuntimeError("scripted: ran out of responses")
-        return self.responses.pop(0)
-
-
-def _resp(content: str) -> CompletionResponse:
-    return CompletionResponse(
-        content=content,
-        tool_calls=(),
-        finish_reason="stop",
-        usage=Usage(input_tokens=10, output_tokens=20),
-        provider="scripted",
-        model="x",
-    )
-
-
-_VALID_CONTRACT_JSON = json.dumps({
-    "summary": "Ensure input validation on the submit endpoint.",
-    "criteria": [
-        {
-            "name": "empty-input-returns-422",
-            "description": "Empty input must not silently succeed.",
-            "pass_condition": "POST with empty body returns HTTP 422.",
-            "fail_condition": "POST with empty body returns anything other than 422.",
-        },
-        {
-            "name": "latency-under-200ms",
-            "description": "Happy path must stay under 200ms p95.",
-            "pass_condition": "p95 latency is under 200ms over 100 requests.",
-            "fail_condition": "p95 latency exceeds 200ms.",
-            "metric": "p95_latency_ms",
-            "threshold": "< 200",
-        },
-    ],
-    "scope_in": ["POST /submit handler", "input validation layer"],
-    "scope_out": ["frontend forms", "unrelated endpoints"],
-    "approach": "Add a Pydantic validator at the entrypoint.",
-})
-
-
-_VALID_PLAN_JSON = json.dumps({
-    "summary": "Add validation to /submit",
-    "success_criteria": [
-        "Empty input should be rejected",
-        "Latency should stay reasonable",
-    ],
-    "approach": "Add a validator",
-    "out_of_scope": [],
-    "risks": [],
-})
-
-
-# ── ContractCriterion ──────────────────────────────────────────────────────
-
-
-class TestContractCriterion:
-    def test_frozen(self) -> None:
-        c = ContractCriterion(
-            name="n", description="d", pass_condition="p",
-        )
-        with pytest.raises(Exception):
-            c.name = "m"  # type: ignore[misc]
-
-    def test_defaults(self) -> None:
-        c = ContractCriterion(
-            name="n", description="d", pass_condition="p",
-        )
-        assert c.fail_condition == ""
-        assert c.metric == ""
-        assert c.threshold == ""
-
-    def test_as_evaluator_criterion_basic(self) -> None:
-        c = ContractCriterion(
-            name="x", description="d", pass_condition="returns 422",
-        )
-        assert c.as_evaluator_criterion() == "returns 422"
-
-    def test_as_evaluator_criterion_with_metric(self) -> None:
-        c = ContractCriterion(
-            name="x", description="d",
-            pass_condition="p95 fast enough",
-            metric="p95_latency_ms",
-        )
-        out = c.as_evaluator_criterion()
-        assert "p95 fast enough" in out
-        assert "p95_latency_ms" in out
-
-    def test_as_evaluator_criterion_with_threshold(self) -> None:
-        c = ContractCriterion(
-            name="x", description="d",
-            pass_condition="fast",
-            metric="latency",
-            threshold="< 200",
-        )
-        out = c.as_evaluator_criterion()
-        assert "latency" in out
-        assert "< 200" in out
-
-    def test_as_evaluator_criterion_falls_back_to_description(self) -> None:
-        # Empty pass_condition → use description.
-        c = ContractCriterion(
-            name="x", description="desc-text", pass_condition="",
-        )
-        assert c.as_evaluator_criterion() == "desc-text"
-
-    def test_as_evaluator_criterion_falls_back_to_name(self) -> None:
-        c = ContractCriterion(name="the-name", description="", pass_condition="")
-        assert c.as_evaluator_criterion() == "the-name"
-
-
-# ── Contract ───────────────────────────────────────────────────────────────
-
-
-class TestContract:
-    def _mk(self) -> Contract:
-        return Contract(
-            task="t",
-            summary="s",
-            criteria=(
-                ContractCriterion(
-                    name="a", description="d1", pass_condition="p1",
-                    fail_condition="f1",
-                ),
-                ContractCriterion(
-                    name="b", description="d2", pass_condition="p2",
-                    metric="m", threshold=">=0.8",
-                ),
-            ),
-            scope_in=("in1",),
-            scope_out=("out1",),
-            approach="do X",
-            usage=Usage(input_tokens=5, output_tokens=10),
-            raw_json="",
-        )
-
-    def test_frozen(self) -> None:
-        c = self._mk()
-        with pytest.raises(Exception):
-            c.summary = "other"  # type: ignore[misc]
-
-    def test_as_evaluator_criteria(self) -> None:
-        crits = self._mk().as_evaluator_criteria()
-        assert crits[0] == "p1"
-        assert "p2" in crits[1]
-        assert "m" in crits[1]
-        assert ">=0.8" in crits[1]
-
-    def test_to_dict_shape(self) -> None:
-        d = self._mk().to_dict()
-        assert d["task"] == "t"
-        assert d["summary"] == "s"
-        assert len(d["criteria"]) == 2
-        assert d["criteria"][0]["name"] == "a"
-        assert d["scope_in"] == ["in1"]
-        assert d["scope_out"] == ["out1"]
-        assert d["parsed_ok"] is True
-
-    def test_to_markdown_shape(self) -> None:
-        md = self._mk().to_markdown()
-        assert "# Sprint Contract" in md
-        assert "**Task:** t" in md
-        assert "## Summary" in md
-        assert "### 1. a" in md
-        assert "### 2. b" in md
-        assert "**Pass:** p1" in md
-        assert "**Fail:** f1" in md
-        assert "**Metric:** m" in md
-        assert "threshold: >=0.8" in md
-        assert "## In scope" in md
-        assert "- in1" in md
-        assert "## Out of scope" in md
-        assert "- out1" in md
-        assert "## Approach" in md
-
-    def test_to_markdown_empty_sections(self) -> None:
-        c = Contract(
-            task="t", summary="", criteria=(),
-            scope_in=(), scope_out=(), approach="",
-            usage=Usage(), raw_json="",
-        )
-        md = c.to_markdown()
-        assert "_(no summary)_" in md
-        # Empty sections should not appear.
-        assert "## Criteria" not in md
-        assert "## In scope" not in md
-        assert "## Approach" not in md
-
-
-# ── ContractBuilder ────────────────────────────────────────────────────────
-
-
-class TestContractBuilder:
-    def test_happy_path_from_plan(self) -> None:
-        plan = PlanArtifact(
-            task="t",
-            summary="plan summary",
-            success_criteria=("empty input", "good perf"),
-            approach="approach",
-            out_of_scope=(),
-            risks=(),
-            usage=Usage(),
-            raw_json="",
-        )
-        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
-        contract = ContractBuilder(provider).build("t", plan=plan)
-        assert contract.parsed_ok is True
-        assert len(contract.criteria) == 2
-        assert contract.criteria[0].name == "empty-input-returns-422"
-        assert contract.criteria[1].metric == "p95_latency_ms"
-
-    def test_happy_path_without_plan(self) -> None:
-        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
-        contract = ContractBuilder(provider).build("task")
-        assert contract.parsed_ok is True
-        assert len(contract.criteria) == 2
-
-    def test_plan_markdown_embedded_in_user_turn(self) -> None:
-        plan = PlanArtifact(
-            task="t",
-            summary="plan-summary-marker",
-            success_criteria=(),
-            approach="",
-            out_of_scope=(),
-            risks=(),
-            usage=Usage(),
-            raw_json="",
-        )
-        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
-        ContractBuilder(provider).build("task", plan=plan)
-        user_msg = next(
-            m for m in provider.calls[0]["messages"] if m.role == "user"
-        )
-        assert "plan-summary-marker" in user_msg.content
-
-    def test_unstructured_fallback(self) -> None:
-        provider = _Scripted([_resp("not JSON, just prose")])
-        contract = ContractBuilder(provider).build("t")
-        assert contract.parsed_ok is False
-        assert contract.criteria == ()
-        assert contract.summary == "not JSON, just prose"
-
-    def test_default_temperature_is_strict(self) -> None:
-        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
-        ContractBuilder(provider).build("t")
-        # Default 0.2 — stricter than the planner (0.4) and generator (0.7).
-        assert provider.calls[0]["temperature"] == 0.2
-
-    def test_model_override(self) -> None:
-        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
-        ContractBuilder(provider, model="contract-model").build("t")
-        assert provider.calls[0]["model"] == "contract-model"
-
-    def test_empty_response_produces_stub(self) -> None:
-        provider = _Scripted([_resp("")])
-        contract = ContractBuilder(provider).build("t")
-        assert contract.parsed_ok is False
-        # Empty response → summary carries the placeholder text
-        assert "empty" in contract.summary.lower()
-
-
-# ── Parsers ────────────────────────────────────────────────────────────────
-
-
-class TestParseCriteriaList:
-    def test_empty(self) -> None:
-        assert _parse_criteria_list([]) == ()
-
-    def test_non_list(self) -> None:
-        assert _parse_criteria_list({"a": 1}) == ()
-        assert _parse_criteria_list(None) == ()
-
-    def test_skips_non_dict_items(self) -> None:
-        out = _parse_criteria_list([
-            {"name": "a", "description": "d", "pass_condition": "p"},
-            "garbage",
-            42,
-        ])
-        assert len(out) == 1
-        assert out[0].name == "a"
-
-    def test_synthesises_missing_name(self) -> None:
-        out = _parse_criteria_list([
-            {"description": "d", "pass_condition": "p"},
-            {"description": "d", "pass_condition": "p"},
-        ])
-        assert out[0].name == "criterion-1"
-        assert out[1].name == "criterion-2"
-
-    def test_all_fields_preserved(self) -> None:
-        out = _parse_criteria_list([
-            {
-                "name": "n", "description": "d",
-                "pass_condition": "p", "fail_condition": "f",
-                "metric": "m", "threshold": "< 100",
-            }
-        ])
-        c = out[0]
-        assert c.name == "n"
-        assert c.pass_condition == "p"
-        assert c.fail_condition == "f"
-        assert c.metric == "m"
-        assert c.threshold == "< 100"
-
-
-class TestSafeStrTuple:
-    def test_none(self) -> None:
-        assert _safe_str_tuple(None) == ()
-
-    def test_list(self) -> None:
-        assert _safe_str_tuple(["a", "b"]) == ("a", "b")
-
-    def test_drops_empty(self) -> None:
-        assert _safe_str_tuple(["a", "", None, "b"]) == ("a", "b")
-
-    def test_string_fallback(self) -> None:
-        out = _safe_str_tuple("- first\n* second\nthird")
-        assert out == ("first", "second", "third")
-
-    def test_non_list_non_string(self) -> None:
-        assert _safe_str_tuple(42) == ()
-
-
-# ── augmented_system_prompt_with_contract ────────────────────────────────
-
-
-class TestAugmentedSystemPromptWithContract:
-    def test_contract_embedded(self) -> None:
-        contract = Contract(
-            task="t", summary="the contract summary",
-            criteria=(
-                ContractCriterion(
-                    name="n", description="d",
-                    pass_condition="MUST return 422",
-                ),
-            ),
-            scope_in=(), scope_out=(), approach="",
-            usage=Usage(), raw_json="",
-        )
-        out = augmented_system_prompt_with_contract("base", contract)
-        assert "base" in out
-        assert "# Sprint Contract" in out
-        assert "MUST return 422" in out
-        assert "the contract summary" in out
-        assert "non-negotiable" in out
-
-
-# ── run_with_evaluation with contract_builder ─────────────────────────────
-
-
-class TestRunWithContract:
-    def test_contract_criteria_used_by_evaluator(self) -> None:
-        # Response order: planner, contract, generator, evaluator
-        provider = _Scripted([
-            _resp(_VALID_PLAN_JSON),
-            _resp(_VALID_CONTRACT_JSON),
-            _resp("generator answer"),
-            _resp(json.dumps({
-                "verdict": "pass",
-                "overall_score": 1.0,
-                "criteria": [],
-                "summary_feedback": "good",
-                "revision_directive": "",
-            })),
-        ])
-        outcome = run_with_evaluation(
-            provider=provider,
-            system_prompt="sys",
-            task="t",
-            evaluator=Evaluator(provider),
-            planner=Planner(provider),
-            contract_builder=ContractBuilder(provider),
-            max_rounds=1,
-        )
-        # Outcome carries plan + contract.
-        assert outcome.plan is not None
-        assert outcome.contract is not None
-        assert outcome.contract.summary.startswith("Ensure")
-        # Evaluator call (4th) should see contract-derived criteria.
-        evaluator_call = provider.calls[3]
-        user_content = next(
-            m.content for m in evaluator_call["messages"] if m.role == "user"
-        )
-        assert "POST with empty body returns HTTP 422" in user_content
-
-    def test_contract_prompt_injected_into_generator(self) -> None:
-        provider = _Scripted([
-            _resp(_VALID_PLAN_JSON),
-            _resp(_VALID_CONTRACT_JSON),
-            _resp("gen answer"),
-            _resp(json.dumps({
-                "verdict": "pass", "overall_score": 1.0, "criteria": [],
-                "summary_feedback": "", "revision_directive": "",
-            })),
-        ])
-        run_with_evaluation(
-            provider=provider,
-            system_prompt="base-prompt",
-            task="t",
-            evaluator=Evaluator(provider),
-            planner=Planner(provider),
-            contract_builder=ContractBuilder(provider),
-            max_rounds=1,
-        )
-        # Generator call (3rd) should see contract markdown in system prompt.
-        generator_call = provider.calls[2]
-        sys_content = next(
-            m.content for m in generator_call["messages"] if m.role == "system"
-        )
-        assert "# Sprint Contract" in sys_content
-        assert "non-negotiable" in sys_content
-        # Plan's narrative still present too (base + contract embeds).
-        assert "base-prompt" in sys_content
-
-    def test_total_usage_includes_contract_cost(self) -> None:
-        # Each response reports 10 input + 20 output → 40 total input.
-        provider = _Scripted([
-            _resp(_VALID_PLAN_JSON),        # planner
-            _resp(_VALID_CONTRACT_JSON),    # contract
-            _resp("g"),                     # generator
-            _resp(json.dumps({
-                "verdict": "pass", "overall_score": 1.0, "criteria": [],
-                "summary_feedback": "", "revision_directive": "",
-            })),                             # evaluator
-        ])
-        outcome = run_with_evaluation(
-            provider=provider,
-            system_prompt="s",
-            task="t",
-            evaluator=Evaluator(provider),
-            planner=Planner(provider),
-            contract_builder=ContractBuilder(provider),
-            max_rounds=1,
-        )
-        assert outcome.total_usage.input_tokens == 40
-        assert outcome.total_usage.output_tokens == 80
-
-    def test_contract_without_planner_also_works(self) -> None:
-        """Contract can run without a plan — library escape hatch."""
-        provider = _Scripted([
-            _resp(_VALID_CONTRACT_JSON),
-            _resp("g"),
-            _resp(json.dumps({
-                "verdict": "pass", "overall_score": 1.0, "criteria": [],
-                "summary_feedback": "", "revision_directive": "",
-            })),
-        ])
-        outcome = run_with_evaluation(
-            provider=provider,
-            system_prompt="s",
-            task="t",
-            evaluator=Evaluator(provider),
-            planner=None,
-            contract_builder=ContractBuilder(provider),
-            max_rounds=1,
-        )
-        assert outcome.plan is None
-        assert outcome.contract is not None
-
-    def test_empty_contract_criteria_falls_back_to_evaluator_defaults(
-        self,
-    ) -> None:
-        """When the contract builder produces no criteria (bad JSON),
-        the evaluator still runs with its default criteria set."""
-        empty_contract_json = json.dumps({
-            "summary": "stub", "criteria": [],
-            "scope_in": [], "scope_out": [], "approach": "",
-        })
-        provider = _Scripted([
-            _resp(_VALID_PLAN_JSON),
-            _resp(empty_contract_json),
-            _resp("g"),
-            _resp(json.dumps({
-                "verdict": "pass", "overall_score": 1.0, "criteria": [],
-                "summary_feedback": "", "revision_directive": "",
-            })),
-        ])
-        outcome = run_with_evaluation(
-            provider=provider,
-            system_prompt="s",
-            task="t",
-            evaluator=Evaluator(provider),
-            planner=Planner(provider),
-            contract_builder=ContractBuilder(provider),
-            max_rounds=1,
-        )
-        # Contract captured but empty.
-        assert outcome.contract is not None
-        assert outcome.contract.criteria == ()
-        # Evaluator call saw the planner's success_criteria (since
-        # the contract had nothing to replace them with).
-        evaluator_call = provider.calls[3]
-        user_content = next(
-            m.content for m in evaluator_call["messages"] if m.role == "user"
-        )
-        # Planner criteria survive.
-        assert "Empty input should be rejected" in user_content
-
-
-# ── CLI integration ───────────────────────────────────────────────────────
-
-
-@pytest.fixture()
-def fake_litellm_contract(monkeypatch: pytest.MonkeyPatch):
-    fake = types.ModuleType("litellm")
-    calls: list[dict[str, Any]] = []
-
-    def _mk(content: str) -> dict[str, Any]:
-        return {
-            "choices": [
-                {"message": {"content": content}, "finish_reason": "stop"}
-            ],
-            "usage": {"prompt_tokens": 5, "completion_tokens": 10},
-        }
-
-    # Default queue: planner → contract → generator → evaluator(pass).
-    fake._responses = [  # type: ignore[attr-defined]
-        _mk(_VALID_PLAN_JSON),
-        _mk(_VALID_CONTRACT_JSON),
-        _mk("done"),
-        _mk(json.dumps({
-            "verdict": "pass", "overall_score": 1.0, "criteria": [],
-            "summary_feedback": "fine", "revision_directive": "",
-        })),
-    ]
-
-    def completion(**kwargs):
-        calls.append(kwargs)
-        if not fake._responses:  # type: ignore[attr-defined]
-            raise RuntimeError("fake: no more responses")
-        return fake._responses.pop(0)  # type: ignore[attr-defined]
-
-    fake.completion = completion  # type: ignore[attr-defined]
-    fake._calls = calls           # type: ignore[attr-defined]
-    fake._mk = _mk                 # type: ignore[attr-defined]
-    monkeypatch.setitem(sys.modules, "litellm", fake)
-    return fake
-
-
-class TestCliContract:
-    def test_contract_without_planner_rejected(self, tmp_path: Path) -> None:
-        from ctx.cli.run import main
-
-        with pytest.raises(SystemExit, match="--contract requires --planner"):
-            main(
-                [
-                    "run",
-                    "--model", "ollama/x",
-                    "--task", "t",
-                    "--sessions-dir", str(tmp_path),
-                    "--evaluator",
-                    "--contract",
-                    "--no-ctx-tools",
-                    "--quiet",
-                ]
-            )
-
-    def test_contract_without_evaluator_rejected(
-        self, tmp_path: Path,
-    ) -> None:
-        """--contract is only meaningful with --evaluator + --planner."""
-        # Without --evaluator the contract flag is silently ignored
-        # (the solo path ignores it since run_with_evaluation isn't
-        # entered); that's acceptable behaviour — document but don't
-        # error. This test pins the current behaviour so a future
-        # change is explicit.
-        from ctx.cli.run import main
-
-        # Should not raise — --contract is silently ignored in the
-        # solo path (run_with_evaluation isn't entered). The solo
-        # path with --planner makes TWO provider calls: the planner
-        # call and the Generator's single iteration.
-        fake = types.ModuleType("litellm")
-
-        def _mk(content: str) -> dict[str, Any]:
-            return {
-                "choices": [
-                    {"message": {"content": content}, "finish_reason": "stop"}
-                ],
-                "usage": {"prompt_tokens": 1, "completion_tokens": 1},
-            }
-
-        fake._responses = [  # type: ignore[attr-defined]
-            _mk(_VALID_PLAN_JSON),  # planner call
-            _mk("generator answer"),  # generator
-        ]
-
-        def completion(**kwargs):
-            return fake._responses.pop(0)  # type: ignore[attr-defined]
-
-        fake.completion = completion  # type: ignore[attr-defined]
-        import sys as _sys
-        _sys.modules["litellm"] = fake
-        exit_code = main(
-            [
-                "run",
-                "--model", "ollama/x",
-                "--task", "t",
-                "--sessions-dir", str(tmp_path),
-                "--planner",       # planner enabled but evaluator isn't
-                "--contract",       # contract solo path doesn't reach run_with_eval
-                "--no-ctx-tools",
-                "--quiet",
-            ]
-        )
-        assert exit_code == 0
-
-    def test_contract_persisted_in_jsonl(
-        self, fake_litellm_contract: Any, tmp_path: Path,
-    ) -> None:
-        from ctx.cli.run import main
-
-        main(
-            [
-                "run",
-                "--model", "ollama/x",
-                "--task", "add validation",
-                "--sessions-dir", str(tmp_path),
-                "--session-id", "cn-run",
-                "--planner",
-                "--evaluator",
-                "--contract",
-                "--no-ctx-tools",
-                "--quiet",
-            ]
-        )
-        # JSONL should carry a 'contract' event with the refined criteria.
-        events = [
-            json.loads(line)
-            for line in (tmp_path / "cn-run.jsonl").read_text(encoding="utf-8").splitlines()
-            if line
-        ]
-        contract_events = [e for e in events if e.get("type") == "contract"]
-        assert len(contract_events) == 1
-        ce = contract_events[0]
-        assert ce["summary"].startswith("Ensure")
-        assert len(ce["criteria"]) == 2
-        # session_start metadata contract_used True.
-        first = events[0]
-        assert first["type"] == "session_start"
-        assert first["contract_used"] is True
-
-    def test_contract_model_override(
-        self, fake_litellm_contract: Any, tmp_path: Path,
-    ) -> None:
-        from ctx.cli.run import main
-
-        main(
-            [
-                "run",
-                "--model", "ollama/main",
-                "--contract-model", "ollama/contract",
-                "--task", "t",
-                "--sessions-dir", str(tmp_path),
-                "--session-id", "cn-override",
-                "--planner",
-                "--evaluator",
-                "--contract",
-                "--no-ctx-tools",
-                "--quiet",
-            ]
-        )
-        calls = fake_litellm_contract._calls
-        # Order: planner → contract → generator → evaluator
-        contract_call = calls[1]
-        assert contract_call["model"] == "ollama/contract"
+"""
+test_harness_contract.py -- Contract + ContractBuilder + P/C/G/E flow.
+
+Pins:
+  * ContractCriterion + Contract shapes, frozen, to_dict, to_markdown
+  * ContractCriterion.as_evaluator_criterion rendering with/without
+    metric + threshold
+  * ContractBuilder.build happy path, unstructured fallback, planner
+    injection into user turn, default temperature
+  * _parse_criteria_list: synth name fallback, drops non-dict items
+  * _safe_str_tuple: list / string-fallback / non-list
+  * run_with_evaluation with contract_builder: evaluator gets
+    refined criteria, system prompt uses contract markdown,
+    total_usage sums all four agents
+  * CLI: --contract requires --planner; --contract persists contract
+    event into JSONL; JSON output does NOT re-duplicate contract
+    (it's in the session file)
+  * augmented_system_prompt_with_contract formatting
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import types
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from ctx.adapters.generic.contract import (
+    Contract,
+    ContractBuilder,
+    ContractCriterion,
+    _parse_criteria_list,
+    _safe_str_tuple,
+    augmented_system_prompt_with_contract,
+)
+from ctx.adapters.generic.evaluator import (
+    Evaluator,
+    run_with_evaluation,
+)
+from ctx.adapters.generic.planner import PlanArtifact, Planner
+from ctx.adapters.generic.providers import (
+    CompletionResponse,
+    Message,
+    ModelProvider,
+    ToolDefinition,
+    Usage,
+)
+
+
+# ── Scripted provider ──────────────────────────────────────────────────────
+
+
+@dataclass
+class _Scripted(ModelProvider):
+    responses: list[CompletionResponse]
+    name: str = "scripted"
+    calls: list[dict[str, Any]] = field(default_factory=list)
+
+    def complete(
+        self,
+        messages: list[Message],
+        tools: list[ToolDefinition] | None = None,
+        *,
+        model: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+    ) -> CompletionResponse:
+        self.calls.append(
+            {
+                "messages": list(messages),
+                "model": model,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+            }
+        )
+        if not self.responses:
+            raise RuntimeError("scripted: ran out of responses")
+        return self.responses.pop(0)
+
+
+def _resp(content: str) -> CompletionResponse:
+    return CompletionResponse(
+        content=content,
+        tool_calls=(),
+        finish_reason="stop",
+        usage=Usage(input_tokens=10, output_tokens=20),
+        provider="scripted",
+        model="x",
+    )
+
+
+_VALID_CONTRACT_JSON = json.dumps({
+    "summary": "Ensure input validation on the submit endpoint.",
+    "criteria": [
+        {
+            "name": "empty-input-returns-422",
+            "description": "Empty input must not silently succeed.",
+            "pass_condition": "POST with empty body returns HTTP 422.",
+            "fail_condition": "POST with empty body returns anything other than 422.",
+        },
+        {
+            "name": "latency-under-200ms",
+            "description": "Happy path must stay under 200ms p95.",
+            "pass_condition": "p95 latency is under 200ms over 100 requests.",
+            "fail_condition": "p95 latency exceeds 200ms.",
+            "metric": "p95_latency_ms",
+            "threshold": "< 200",
+        },
+    ],
+    "scope_in": ["POST /submit handler", "input validation layer"],
+    "scope_out": ["frontend forms", "unrelated endpoints"],
+    "approach": "Add a Pydantic validator at the entrypoint.",
+})
+
+
+_VALID_PLAN_JSON = json.dumps({
+    "summary": "Add validation to /submit",
+    "success_criteria": [
+        "Empty input should be rejected",
+        "Latency should stay reasonable",
+    ],
+    "approach": "Add a validator",
+    "out_of_scope": [],
+    "risks": [],
+})
+
+
+# ── ContractCriterion ──────────────────────────────────────────────────────
+
+
+class TestContractCriterion:
+    def test_frozen(self) -> None:
+        c = ContractCriterion(
+            name="n", description="d", pass_condition="p",
+        )
+        with pytest.raises(Exception):
+            c.name = "m"  # type: ignore[misc]
+
+    def test_defaults(self) -> None:
+        c = ContractCriterion(
+            name="n", description="d", pass_condition="p",
+        )
+        assert c.fail_condition == ""
+        assert c.metric == ""
+        assert c.threshold == ""
+
+    def test_as_evaluator_criterion_basic(self) -> None:
+        c = ContractCriterion(
+            name="x", description="d", pass_condition="returns 422",
+        )
+        assert c.as_evaluator_criterion() == "returns 422"
+
+    def test_as_evaluator_criterion_with_metric(self) -> None:
+        c = ContractCriterion(
+            name="x", description="d",
+            pass_condition="p95 fast enough",
+            metric="p95_latency_ms",
+        )
+        out = c.as_evaluator_criterion()
+        assert "p95 fast enough" in out
+        assert "p95_latency_ms" in out
+
+    def test_as_evaluator_criterion_with_threshold(self) -> None:
+        c = ContractCriterion(
+            name="x", description="d",
+            pass_condition="fast",
+            metric="latency",
+            threshold="< 200",
+        )
+        out = c.as_evaluator_criterion()
+        assert "latency" in out
+        assert "< 200" in out
+
+    def test_as_evaluator_criterion_falls_back_to_description(self) -> None:
+        # Empty pass_condition → use description.
+        c = ContractCriterion(
+            name="x", description="desc-text", pass_condition="",
+        )
+        assert c.as_evaluator_criterion() == "desc-text"
+
+    def test_as_evaluator_criterion_falls_back_to_name(self) -> None:
+        c = ContractCriterion(name="the-name", description="", pass_condition="")
+        assert c.as_evaluator_criterion() == "the-name"
+
+
+# ── Contract ───────────────────────────────────────────────────────────────
+
+
+class TestContract:
+    def _mk(self) -> Contract:
+        return Contract(
+            task="t",
+            summary="s",
+            criteria=(
+                ContractCriterion(
+                    name="a", description="d1", pass_condition="p1",
+                    fail_condition="f1",
+                ),
+                ContractCriterion(
+                    name="b", description="d2", pass_condition="p2",
+                    metric="m", threshold=">=0.8",
+                ),
+            ),
+            scope_in=("in1",),
+            scope_out=("out1",),
+            approach="do X",
+            usage=Usage(input_tokens=5, output_tokens=10),
+            raw_json="",
+        )
+
+    def test_frozen(self) -> None:
+        c = self._mk()
+        with pytest.raises(Exception):
+            c.summary = "other"  # type: ignore[misc]
+
+    def test_as_evaluator_criteria(self) -> None:
+        crits = self._mk().as_evaluator_criteria()
+        assert crits[0] == "p1"
+        assert "p2" in crits[1]
+        assert "m" in crits[1]
+        assert ">=0.8" in crits[1]
+
+    def test_to_dict_shape(self) -> None:
+        d = self._mk().to_dict()
+        assert d["task"] == "t"
+        assert d["summary"] == "s"
+        assert len(d["criteria"]) == 2
+        assert d["criteria"][0]["name"] == "a"
+        assert d["scope_in"] == ["in1"]
+        assert d["scope_out"] == ["out1"]
+        assert d["parsed_ok"] is True
+
+    def test_to_markdown_shape(self) -> None:
+        md = self._mk().to_markdown()
+        assert "# Sprint Contract" in md
+        assert "**Task:** t" in md
+        assert "## Summary" in md
+        assert "### 1. a" in md
+        assert "### 2. b" in md
+        assert "**Pass:** p1" in md
+        assert "**Fail:** f1" in md
+        assert "**Metric:** m" in md
+        assert "threshold: >=0.8" in md
+        assert "## In scope" in md
+        assert "- in1" in md
+        assert "## Out of scope" in md
+        assert "- out1" in md
+        assert "## Approach" in md
+
+    def test_to_markdown_empty_sections(self) -> None:
+        c = Contract(
+            task="t", summary="", criteria=(),
+            scope_in=(), scope_out=(), approach="",
+            usage=Usage(), raw_json="",
+        )
+        md = c.to_markdown()
+        assert "_(no summary)_" in md
+        # Empty sections should not appear.
+        assert "## Criteria" not in md
+        assert "## In scope" not in md
+        assert "## Approach" not in md
+
+
+# ── ContractBuilder ────────────────────────────────────────────────────────
+
+
+class TestContractBuilder:
+    def test_happy_path_from_plan(self) -> None:
+        plan = PlanArtifact(
+            task="t",
+            summary="plan summary",
+            success_criteria=("empty input", "good perf"),
+            approach="approach",
+            out_of_scope=(),
+            risks=(),
+            usage=Usage(),
+            raw_json="",
+        )
+        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
+        contract = ContractBuilder(provider).build("t", plan=plan)
+        assert contract.parsed_ok is True
+        assert len(contract.criteria) == 2
+        assert contract.criteria[0].name == "empty-input-returns-422"
+        assert contract.criteria[1].metric == "p95_latency_ms"
+
+    def test_happy_path_without_plan(self) -> None:
+        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
+        contract = ContractBuilder(provider).build("task")
+        assert contract.parsed_ok is True
+        assert len(contract.criteria) == 2
+
+    def test_plan_markdown_embedded_in_user_turn(self) -> None:
+        plan = PlanArtifact(
+            task="t",
+            summary="plan-summary-marker",
+            success_criteria=(),
+            approach="",
+            out_of_scope=(),
+            risks=(),
+            usage=Usage(),
+            raw_json="",
+        )
+        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
+        ContractBuilder(provider).build("task", plan=plan)
+        user_msg = next(
+            m for m in provider.calls[0]["messages"] if m.role == "user"
+        )
+        assert "plan-summary-marker" in user_msg.content
+
+    def test_unstructured_fallback(self) -> None:
+        provider = _Scripted([_resp("not JSON, just prose")])
+        contract = ContractBuilder(provider).build("t")
+        assert contract.parsed_ok is False
+        assert contract.criteria == ()
+        assert contract.summary == "not JSON, just prose"
+
+    def test_default_temperature_is_strict(self) -> None:
+        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
+        ContractBuilder(provider).build("t")
+        # Default 0.2 — stricter than the planner (0.4) and generator (0.7).
+        assert provider.calls[0]["temperature"] == 0.2
+
+    def test_model_override(self) -> None:
+        provider = _Scripted([_resp(_VALID_CONTRACT_JSON)])
+        ContractBuilder(provider, model="contract-model").build("t")
+        assert provider.calls[0]["model"] == "contract-model"
+
+    def test_empty_response_produces_stub(self) -> None:
+        provider = _Scripted([_resp("")])
+        contract = ContractBuilder(provider).build("t")
+        assert contract.parsed_ok is False
+        # Empty response → summary carries the placeholder text
+        assert "empty" in contract.summary.lower()
+
+
+# ── Parsers ────────────────────────────────────────────────────────────────
+
+
+class TestParseCriteriaList:
+    def test_empty(self) -> None:
+        assert _parse_criteria_list([]) == ()
+
+    def test_non_list(self) -> None:
+        assert _parse_criteria_list({"a": 1}) == ()
+        assert _parse_criteria_list(None) == ()
+
+    def test_skips_non_dict_items(self) -> None:
+        out = _parse_criteria_list([
+            {"name": "a", "description": "d", "pass_condition": "p"},
+            "garbage",
+            42,
+        ])
+        assert len(out) == 1
+        assert out[0].name == "a"
+
+    def test_synthesises_missing_name(self) -> None:
+        out = _parse_criteria_list([
+            {"description": "d", "pass_condition": "p"},
+            {"description": "d", "pass_condition": "p"},
+        ])
+        assert out[0].name == "criterion-1"
+        assert out[1].name == "criterion-2"
+
+    def test_all_fields_preserved(self) -> None:
+        out = _parse_criteria_list([
+            {
+                "name": "n", "description": "d",
+                "pass_condition": "p", "fail_condition": "f",
+                "metric": "m", "threshold": "< 100",
+            }
+        ])
+        c = out[0]
+        assert c.name == "n"
+        assert c.pass_condition == "p"
+        assert c.fail_condition == "f"
+        assert c.metric == "m"
+        assert c.threshold == "< 100"
+
+
+class TestSafeStrTuple:
+    def test_none(self) -> None:
+        assert _safe_str_tuple(None) == ()
+
+    def test_list(self) -> None:
+        assert _safe_str_tuple(["a", "b"]) == ("a", "b")
+
+    def test_drops_empty(self) -> None:
+        assert _safe_str_tuple(["a", "", None, "b"]) == ("a", "b")
+
+    def test_string_fallback(self) -> None:
+        out = _safe_str_tuple("- first\n* second\nthird")
+        assert out == ("first", "second", "third")
+
+    def test_non_list_non_string(self) -> None:
+        assert _safe_str_tuple(42) == ()
+
+
+# ── augmented_system_prompt_with_contract ────────────────────────────────
+
+
+class TestAugmentedSystemPromptWithContract:
+    def test_contract_embedded(self) -> None:
+        contract = Contract(
+            task="t", summary="the contract summary",
+            criteria=(
+                ContractCriterion(
+                    name="n", description="d",
+                    pass_condition="MUST return 422",
+                ),
+            ),
+            scope_in=(), scope_out=(), approach="",
+            usage=Usage(), raw_json="",
+        )
+        out = augmented_system_prompt_with_contract("base", contract)
+        assert "base" in out
+        assert "# Sprint Contract" in out
+        assert "MUST return 422" in out
+        assert "the contract summary" in out
+        assert "non-negotiable" in out
+
+
+# ── run_with_evaluation with contract_builder ─────────────────────────────
+
+
+class TestRunWithContract:
+    def test_contract_criteria_used_by_evaluator(self) -> None:
+        # Response order: planner, contract, generator, evaluator
+        provider = _Scripted([
+            _resp(_VALID_PLAN_JSON),
+            _resp(_VALID_CONTRACT_JSON),
+            _resp("generator answer"),
+            _resp(json.dumps({
+                "verdict": "pass",
+                "overall_score": 1.0,
+                "criteria": [],
+                "summary_feedback": "good",
+                "revision_directive": "",
+            })),
+        ])
+        outcome = run_with_evaluation(
+            provider=provider,
+            system_prompt="sys",
+            task="t",
+            evaluator=Evaluator(provider),
+            planner=Planner(provider),
+            contract_builder=ContractBuilder(provider),
+            max_rounds=1,
+        )
+        # Outcome carries plan + contract.
+        assert outcome.plan is not None
+        assert outcome.contract is not None
+        assert outcome.contract.summary.startswith("Ensure")
+        # Evaluator call (4th) should see contract-derived criteria.
+        evaluator_call = provider.calls[3]
+        user_content = next(
+            m.content for m in evaluator_call["messages"] if m.role == "user"
+        )
+        assert "POST with empty body returns HTTP 422" in user_content
+
+    def test_contract_prompt_injected_into_generator(self) -> None:
+        provider = _Scripted([
+            _resp(_VALID_PLAN_JSON),
+            _resp(_VALID_CONTRACT_JSON),
+            _resp("gen answer"),
+            _resp(json.dumps({
+                "verdict": "pass", "overall_score": 1.0, "criteria": [],
+                "summary_feedback": "", "revision_directive": "",
+            })),
+        ])
+        run_with_evaluation(
+            provider=provider,
+            system_prompt="base-prompt",
+            task="t",
+            evaluator=Evaluator(provider),
+            planner=Planner(provider),
+            contract_builder=ContractBuilder(provider),
+            max_rounds=1,
+        )
+        # Generator call (3rd) should see contract markdown in system prompt.
+        generator_call = provider.calls[2]
+        sys_content = next(
+            m.content for m in generator_call["messages"] if m.role == "system"
+        )
+        assert "# Sprint Contract" in sys_content
+        assert "non-negotiable" in sys_content
+        # Plan's narrative still present too (base + contract embeds).
+        assert "base-prompt" in sys_content
+
+    def test_total_usage_includes_contract_cost(self) -> None:
+        # Each response reports 10 input + 20 output → 40 total input.
+        provider = _Scripted([
+            _resp(_VALID_PLAN_JSON),        # planner
+            _resp(_VALID_CONTRACT_JSON),    # contract
+            _resp("g"),                     # generator
+            _resp(json.dumps({
+                "verdict": "pass", "overall_score": 1.0, "criteria": [],
+                "summary_feedback": "", "revision_directive": "",
+            })),                             # evaluator
+        ])
+        outcome = run_with_evaluation(
+            provider=provider,
+            system_prompt="s",
+            task="t",
+            evaluator=Evaluator(provider),
+            planner=Planner(provider),
+            contract_builder=ContractBuilder(provider),
+            max_rounds=1,
+        )
+        assert outcome.total_usage.input_tokens == 40
+        assert outcome.total_usage.output_tokens == 80
+
+    def test_contract_without_planner_also_works(self) -> None:
+        """Contract can run without a plan — library escape hatch."""
+        provider = _Scripted([
+            _resp(_VALID_CONTRACT_JSON),
+            _resp("g"),
+            _resp(json.dumps({
+                "verdict": "pass", "overall_score": 1.0, "criteria": [],
+                "summary_feedback": "", "revision_directive": "",
+            })),
+        ])
+        outcome = run_with_evaluation(
+            provider=provider,
+            system_prompt="s",
+            task="t",
+            evaluator=Evaluator(provider),
+            planner=None,
+            contract_builder=ContractBuilder(provider),
+            max_rounds=1,
+        )
+        assert outcome.plan is None
+        assert outcome.contract is not None
+
+    def test_empty_contract_criteria_falls_back_to_evaluator_defaults(
+        self,
+    ) -> None:
+        """When the contract builder produces no criteria (bad JSON),
+        the evaluator still runs with its default criteria set."""
+        empty_contract_json = json.dumps({
+            "summary": "stub", "criteria": [],
+            "scope_in": [], "scope_out": [], "approach": "",
+        })
+        provider = _Scripted([
+            _resp(_VALID_PLAN_JSON),
+            _resp(empty_contract_json),
+            _resp("g"),
+            _resp(json.dumps({
+                "verdict": "pass", "overall_score": 1.0, "criteria": [],
+                "summary_feedback": "", "revision_directive": "",
+            })),
+        ])
+        outcome = run_with_evaluation(
+            provider=provider,
+            system_prompt="s",
+            task="t",
+            evaluator=Evaluator(provider),
+            planner=Planner(provider),
+            contract_builder=ContractBuilder(provider),
+            max_rounds=1,
+        )
+        # Contract captured but empty.
+        assert outcome.contract is not None
+        assert outcome.contract.criteria == ()
+        # Evaluator call saw the planner's success_criteria (since
+        # the contract had nothing to replace them with).
+        evaluator_call = provider.calls[3]
+        user_content = next(
+            m.content for m in evaluator_call["messages"] if m.role == "user"
+        )
+        # Planner criteria survive.
+        assert "Empty input should be rejected" in user_content
+
+
+# ── CLI integration ───────────────────────────────────────────────────────
+
+
+@pytest.fixture()
+def fake_litellm_contract(monkeypatch: pytest.MonkeyPatch):
+    fake = types.ModuleType("litellm")
+    calls: list[dict[str, Any]] = []
+
+    def _mk(content: str) -> dict[str, Any]:
+        return {
+            "choices": [
+                {"message": {"content": content}, "finish_reason": "stop"}
+            ],
+            "usage": {"prompt_tokens": 5, "completion_tokens": 10},
+        }
+
+    # Default queue: planner → contract → generator → evaluator(pass).
+    fake._responses = [  # type: ignore[attr-defined]
+        _mk(_VALID_PLAN_JSON),
+        _mk(_VALID_CONTRACT_JSON),
+        _mk("done"),
+        _mk(json.dumps({
+            "verdict": "pass", "overall_score": 1.0, "criteria": [],
+            "summary_feedback": "fine", "revision_directive": "",
+        })),
+    ]
+
+    def completion(**kwargs):
+        calls.append(kwargs)
+        if not fake._responses:  # type: ignore[attr-defined]
+            raise RuntimeError("fake: no more responses")
+        return fake._responses.pop(0)  # type: ignore[attr-defined]
+
+    fake.completion = completion  # type: ignore[attr-defined]
+    fake._calls = calls           # type: ignore[attr-defined]
+    fake._mk = _mk                 # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "litellm", fake)
+    return fake
+
+
+class TestCliContract:
+    def test_contract_without_planner_rejected(self, tmp_path: Path) -> None:
+        from ctx.cli.run import main
+
+        with pytest.raises(SystemExit, match="--contract requires --planner"):
+            main(
+                [
+                    "run",
+                    "--model", "ollama/x",
+                    "--task", "t",
+                    "--sessions-dir", str(tmp_path),
+                    "--evaluator",
+                    "--contract",
+                    "--no-ctx-tools",
+                    "--quiet",
+                ]
+            )
+
+    def test_contract_without_evaluator_rejected(
+        self, tmp_path: Path,
+    ) -> None:
+        """--contract is only meaningful with --evaluator + --planner."""
+        # Without --evaluator the contract flag is silently ignored
+        # (the solo path ignores it since run_with_evaluation isn't
+        # entered); that's acceptable behaviour — document but don't
+        # error. This test pins the current behaviour so a future
+        # change is explicit.
+        from ctx.cli.run import main
+
+        # Should not raise — --contract is silently ignored in the
+        # solo path (run_with_evaluation isn't entered). The solo
+        # path with --planner makes TWO provider calls: the planner
+        # call and the Generator's single iteration.
+        fake = types.ModuleType("litellm")
+
+        def _mk(content: str) -> dict[str, Any]:
+            return {
+                "choices": [
+                    {"message": {"content": content}, "finish_reason": "stop"}
+                ],
+                "usage": {"prompt_tokens": 1, "completion_tokens": 1},
+            }
+
+        fake._responses = [  # type: ignore[attr-defined]
+            _mk(_VALID_PLAN_JSON),  # planner call
+            _mk("generator answer"),  # generator
+        ]
+
+        def completion(**kwargs):
+            return fake._responses.pop(0)  # type: ignore[attr-defined]
+
+        fake.completion = completion  # type: ignore[attr-defined]
+        import sys as _sys
+        _sys.modules["litellm"] = fake
+        exit_code = main(
+            [
+                "run",
+                "--model", "ollama/x",
+                "--task", "t",
+                "--sessions-dir", str(tmp_path),
+                "--planner",       # planner enabled but evaluator isn't
+                "--contract",       # contract solo path doesn't reach run_with_eval
+                "--no-ctx-tools",
+                "--quiet",
+            ]
+        )
+        assert exit_code == 0
+
+    def test_contract_persisted_in_jsonl(
+        self, fake_litellm_contract: Any, tmp_path: Path,
+    ) -> None:
+        from ctx.cli.run import main
+
+        main(
+            [
+                "run",
+                "--model", "ollama/x",
+                "--task", "add validation",
+                "--sessions-dir", str(tmp_path),
+                "--session-id", "cn-run",
+                "--planner",
+                "--evaluator",
+                "--contract",
+                "--no-ctx-tools",
+                "--quiet",
+            ]
+        )
+        # JSONL should carry a 'contract' event with the refined criteria.
+        events = [
+            json.loads(line)
+            for line in (tmp_path / "cn-run.jsonl").read_text(encoding="utf-8").splitlines()
+            if line
+        ]
+        contract_events = [e for e in events if e.get("type") == "contract"]
+        assert len(contract_events) == 1
+        ce = contract_events[0]
+        assert ce["summary"].startswith("Ensure")
+        assert len(ce["criteria"]) == 2
+        # session_start metadata contract_used True.
+        first = events[0]
+        assert first["type"] == "session_start"
+        assert first["contract_used"] is True
+
+    def test_contract_model_override(
+        self, fake_litellm_contract: Any, tmp_path: Path,
+    ) -> None:
+        from ctx.cli.run import main
+
+        main(
+            [
+                "run",
+                "--model", "ollama/main",
+                "--contract-model", "ollama/contract",
+                "--task", "t",
+                "--sessions-dir", str(tmp_path),
+                "--session-id", "cn-override",
+                "--planner",
+                "--evaluator",
+                "--contract",
+                "--no-ctx-tools",
+                "--quiet",
+            ]
+        )
+        calls = fake_litellm_contract._calls
+        # Order: planner → contract → generator → evaluator
+        contract_call = calls[1]
+        assert contract_call["model"] == "ollama/contract"

src/tests/test_harness_state.py

@@ -1,674 +1,674 @@
-"""
-test_harness_state.py -- SessionStore / JsonlObserver / load_session tests.
-
-Covers:
-  * SessionStore lifecycle + append-mode (resume) safety
-  * Event serialisation for every event type the observer emits
-  * JsonlObserver drives a round-trip: a run_loop session written
-    to disk + load_session replay reconstructs the same conversation
-  * Malformed-line tolerance on the reader
-  * ``list_sessions`` + path helpers
-  * Session-id validation rejects traversal-shaped ids
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from ctx.adapters.generic.loop import run_loop, LoopResult
-from ctx.adapters.generic.providers import (
-    CompletionResponse,
-    Message,
-    ModelProvider,
-    ToolCall,
-    ToolDefinition,
-    Usage,
-)
-from ctx.adapters.generic.state import (
-    JsonlObserver,
-    SessionStore,
-    _safe_session_id,
-    default_sessions_dir,
-    list_sessions,
-    load_session,
-    new_session_id,
-)
-
-
-# ── Scripted provider for the round-trip tests ─────────────────────────────
-
-
-def _symlink_or_skip(link: Path, target: Path) -> None:
-    try:
-        link.symlink_to(target)
-    except OSError as exc:
-        pytest.skip(f"symlinks unavailable in this environment: {exc}")
-
-
-class _Scripted(ModelProvider):
-    name = "scripted"
-
-    def __init__(self, responses: list[CompletionResponse]) -> None:
-        self._responses = list(responses)
-
-    def complete(
-        self,
-        messages: list[Message],
-        tools: list[ToolDefinition] | None = None,
-        *,
-        model: str | None = None,
-        temperature: float = 0.7,
-        max_tokens: int | None = None,
-    ) -> CompletionResponse:
-        if not self._responses:
-            raise RuntimeError("scripted: no more responses")
-        return self._responses.pop(0)
-
-
-def _stop_response(content: str = "done") -> CompletionResponse:
-    return CompletionResponse(
-        content=content,
-        tool_calls=(),
-        finish_reason="stop",
-        usage=Usage(input_tokens=5, output_tokens=3),
-        provider="scripted",
-        model="x",
-    )
-
-
-def _tool_response(*calls: ToolCall) -> CompletionResponse:
-    return CompletionResponse(
-        content="",
-        tool_calls=tuple(calls),
-        finish_reason="tool_calls",
-        usage=Usage(input_tokens=10, output_tokens=4),
-        provider="scripted",
-        model="x",
-    )
-
-
-# ── Session-id safety ────────────────────────────────────────────────────
-
-
-class TestSessionIdValidation:
-    @pytest.mark.parametrize(
-        "bad",
-        [
-            "",
-            "../evil",
-            "a/b",
-            "a\\b",
-            ".",
-            "..",
-            "has space",
-            "has.dot",  # dots disallowed — risks '.jsonl' shadowing
-            "a" * 129,  # too long
-        ],
-    )
-    def test_rejects_bad(self, bad: str) -> None:
-        with pytest.raises((ValueError, TypeError)):
-            _safe_session_id(bad)
-
-    @pytest.mark.parametrize(
-        "good",
-        [
-            "abc123",
-            "nightly_backfill",
-            "2026-04-24-trial",
-            "f9eaad988e79443b85b819099f3679a3",
-        ],
-    )
-    def test_accepts_good(self, good: str) -> None:
-        assert _safe_session_id(good) == good
-
-    def test_non_string_rejected(self) -> None:
-        with pytest.raises((ValueError, TypeError)):
-            _safe_session_id(None)  # type: ignore[arg-type]
-
-
-class TestSessionIdGen:
-    def test_new_id_is_32_char_hex(self) -> None:
-        sid = new_session_id()
-        assert len(sid) == 32
-        assert all(c in "0123456789abcdef" for c in sid)
-
-    def test_ids_are_unique(self) -> None:
-        assert new_session_id() != new_session_id()
-
-
-# ── default_sessions_dir ─────────────────────────────────────────────────
-
-
-class TestDefaultSessionsDir:
-    def test_under_home(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("USERPROFILE", str(tmp_path))
-        p = default_sessions_dir()
-        assert p == tmp_path / ".ctx" / "sessions"
-
-    def test_not_created_by_call(
-        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-    ) -> None:
-        monkeypatch.setenv("HOME", str(tmp_path))
-        monkeypatch.setenv("USERPROFILE", str(tmp_path))
-        p = default_sessions_dir()
-        # Intentionally lazy — SessionStore creates it, not the helper.
-        assert not p.exists()
-
-
-# ── SessionStore ────────��────────────────────────────────────────────────
-
-
-class TestSessionStore:
-    def test_create_makes_parent_dir(self, tmp_path: Path) -> None:
-        nested = tmp_path / "deeply" / "nested"
-        store = SessionStore.create(
-            session_id="abc", sessions_dir=nested,
-        )
-        try:
-            assert nested.is_dir()
-            assert store.path == nested / "abc.jsonl"
-        finally:
-            store.close()
-
-    def test_create_auto_generates_id(self, tmp_path: Path) -> None:
-        store = SessionStore.create(sessions_dir=tmp_path)
-        try:
-            assert len(store.session_id) == 32
-        finally:
-            store.close()
-
-    def test_write_event_shapes_line(self, tmp_path: Path) -> None:
-        store = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
-        try:
-            store.write_event("custom", {"key": "value"})
-        finally:
-            store.close()
-        raw = (tmp_path / "s1.jsonl").read_text(encoding="utf-8")
-        event = json.loads(raw)
-        assert event["type"] == "custom"
-        assert event["session_id"] == "s1"
-        assert event["key"] == "value"
-        assert "ts" in event
-
-    def test_create_rejects_existing_session_by_default(self, tmp_path: Path) -> None:
-        path = tmp_path / "s1.jsonl"
-        path.write_text("sentinel\n", encoding="utf-8")
-        with pytest.raises(FileExistsError):
-            SessionStore.create(session_id="s1", sessions_dir=tmp_path)
-        assert path.read_text(encoding="utf-8") == "sentinel\n"
-
-    def test_create_can_overwrite_existing_session_explicitly(
-        self, tmp_path: Path,
-    ) -> None:
-        path = tmp_path / "s1.jsonl"
-        path.write_text("sentinel\n", encoding="utf-8")
-        store = SessionStore.create(
-            session_id="s1",
-            sessions_dir=tmp_path,
-            overwrite=True,
-        )
-        store.close()
-        assert path.read_text(encoding="utf-8") == ""
-
-    def test_create_overwrite_rejects_symlinked_session_log(
-        self, tmp_path: Path,
-    ) -> None:
-        outside = tmp_path / "outside.jsonl"
-        outside.write_text("sentinel\n", encoding="utf-8")
-        _symlink_or_skip(tmp_path / "s1.jsonl", outside)
-
-        with pytest.raises(ValueError, match="symlink"):
-            SessionStore.create(
-                session_id="s1",
-                sessions_dir=tmp_path,
-                overwrite=True,
-            )
-
-        assert outside.read_text(encoding="utf-8") == "sentinel\n"
-
-    def test_context_manager(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s1", sessions_dir=tmp_path) as store:
-            store.write_event("x", {})
-        assert store.closed
-        assert (tmp_path / "s1.jsonl").is_file()
-
-    def test_write_after_close_raises(self, tmp_path: Path) -> None:
-        store = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
-        store.close()
-        with pytest.raises(RuntimeError, match="closed"):
-            store.write_event("x", {})
-
-    def test_close_is_idempotent(self, tmp_path: Path) -> None:
-        store = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
-        store.close()
-        store.close()  # must not raise
-
-    def test_attach_requires_existing_file(self, tmp_path: Path) -> None:
-        with pytest.raises(FileNotFoundError):
-            SessionStore.attach("nope", sessions_dir=tmp_path)
-
-    def test_attach_rejects_symlinked_session_log(self, tmp_path: Path) -> None:
-        outside = tmp_path / "outside.jsonl"
-        outside.write_text("sentinel\n", encoding="utf-8")
-        _symlink_or_skip(tmp_path / "s1.jsonl", outside)
-
-        with pytest.raises(ValueError, match="symlink"):
-            SessionStore.attach("s1", sessions_dir=tmp_path)
-
-    def test_attach_appends_to_existing_file(self, tmp_path: Path) -> None:
-        # Create + write one event.
-        s1 = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
-        s1.write_event("first", {})
-        s1.close()
-        # Attach + append.
-        s2 = SessionStore.attach("s1", sessions_dir=tmp_path)
-        s2.write_event("second", {})
-        s2.close()
-        lines = (tmp_path / "s1.jsonl").read_text(encoding="utf-8").strip().split("\n")
-        types = [json.loads(line)["type"] for line in lines]
-        assert types == ["first", "second"]
-
-    def test_unicode_content_roundtrips(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="uni", sessions_dir=tmp_path) as s:
-            s.write_event("x", {"content": "café 日本 🚀"})
-        event = json.loads((tmp_path / "uni.jsonl").read_text(encoding="utf-8"))
-        assert event["content"] == "café 日本 🚀"
-
-
-# ── Convenience writers ───────────────���──────────────────────────────────
-
-
-class TestConvenienceWriters:
-    def test_write_session_start(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_session_start({"task": "hello", "model": "ollama/x"})
-        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
-        assert event["type"] == "session_start"
-        assert event["task"] == "hello"
-        assert event["model"] == "ollama/x"
-
-    def test_write_message(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_message(Message(role="user", content="hi"))
-            store.write_message(
-                Message(
-                    role="assistant",
-                    content="",
-                    tool_calls=(ToolCall(id="c1", name="t", arguments={"x": 1}),),
-                )
-            )
-        events = [
-            json.loads(line) for line in
-            (tmp_path / "s.jsonl").read_text(encoding="utf-8").splitlines() if line
-        ]
-        assert events[0]["role"] == "user"
-        assert events[1]["tool_calls"][0]["arguments"] == {"x": 1}
-
-    def test_write_model_response(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_model_response(
-                3,
-                CompletionResponse(
-                    content="ok",
-                    tool_calls=(),
-                    finish_reason="stop",
-                    usage=Usage(input_tokens=10, output_tokens=5, cost_usd=0.002),
-                    provider="litellm",
-                    model="openrouter/x",
-                ),
-            )
-        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
-        assert event["iteration"] == 3
-        assert event["usage"]["cost_usd"] == 0.002
-        assert event["provider"] == "litellm"
-        assert event["model"] == "openrouter/x"
-
-    def test_write_tool_call(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_tool_call(
-                1,
-                ToolCall(id="c1", name="fs__read", arguments={"path": "/tmp"}),
-                result="file contents",
-                error=None,
-            )
-        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
-        assert event["call"]["arguments"] == {"path": "/tmp"}
-        assert event["error"] is None
-
-    def test_write_stop(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_stop(
-                LoopResult(
-                    stop_reason="completed",
-                    final_message="done",
-                    iterations=3,
-                    usage=Usage(input_tokens=30, output_tokens=15, cost_usd=0.01),
-                    messages=(),
-                    detail="",
-                )
-            )
-        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
-        assert event["stop_reason"] == "completed"
-        assert event["iterations"] == 3
-
-
-# ── load_session ─────────────────────────────────────────────────────────
-
-
-class TestLoadSession:
-    def test_file_not_found(self, tmp_path: Path) -> None:
-        with pytest.raises(FileNotFoundError):
-            load_session("nope", sessions_dir=tmp_path)
-
-    def test_rejects_symlinked_session_log(self, tmp_path: Path) -> None:
-        outside = tmp_path / "outside.jsonl"
-        outside.write_text(
-            json.dumps({"type": "session_start", "session_id": "s"}) + "\n",
-            encoding="utf-8",
-        )
-        _symlink_or_skip(tmp_path / "s.jsonl", outside)
-
-        with pytest.raises(ValueError, match="symlink"):
-            load_session("s", sessions_dir=tmp_path)
-
-    def test_replay_simple_session(self, tmp_path: Path) -> None:
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_session_start({"task": "hello", "model": "x"})
-            store.write_message(Message(role="system", content="sys"))
-            store.write_message(Message(role="user", content="hi"))
-            store.write_message(Message(role="assistant", content="hello back"))
-            store.write_stop(
-                LoopResult(
-                    stop_reason="completed", final_message="hello back",
-                    iterations=1, usage=Usage(), messages=(), detail="",
-                )
-            )
-        state = load_session("s", sessions_dir=tmp_path)
-        assert state.session_id == "s"
-        assert state.path == tmp_path / "s.jsonl"
-        assert [m.role for m in state.messages] == ["system", "user", "assistant"]
-        assert state.messages[2].content == "hello back"
-        assert state.metadata["task"] == "hello"
-        assert state.stopped is True
-        assert state.stop_reason == "completed"
-
-    def test_replay_unstopped_session(self, tmp_path: Path) -> None:
-        """Session that trails off mid-run (no stop event) is flagged."""
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_session_start({"task": "x"})
-            store.write_message(Message(role="user", content="hi"))
-        state = load_session("s", sessions_dir=tmp_path)
-        assert state.stopped is False
-        assert state.stop_reason is None
-
-    def test_replay_tool_call_messages(self, tmp_path: Path) -> None:
-        """Assistant-with-tool_calls + tool-result must round-trip faithfully."""
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_message(Message(role="user", content="go"))
-            tc = ToolCall(id="c1", name="srv__fetch", arguments={"url": "https://x"})
-            store.write_message(
-                Message(role="assistant", content="", tool_calls=(tc,))
-            )
-            store.write_message(
-                Message(role="tool", content="ok", tool_call_id="c1", name="srv__fetch")
-            )
-        state = load_session("s", sessions_dir=tmp_path)
-        assert len(state.messages) == 3
-        assistant = state.messages[1]
-        assert assistant.tool_calls[0].id == "c1"
-        assert assistant.tool_calls[0].arguments == {"url": "https://x"}
-        tool_msg = state.messages[2]
-        assert tool_msg.tool_call_id == "c1"
-        assert tool_msg.name == "srv__fetch"
-
-    def test_replay_repairs_unresolved_tool_call_tail(self, tmp_path: Path) -> None:
-        """Crash after assistant tool_call message persists must resume safely."""
-        tc = ToolCall(id="c1", name="srv__fetch", arguments={"url": "https://x"})
-        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
-            store.write_message(Message(role="user", content="go"))
-            store.write_model_response(1, _tool_response(tc))
-            store.write_message(Message(role="assistant", content="", tool_calls=(tc,)))
-
-        state = load_session("s", sessions_dir=tmp_path)
-
-        assert [m.role for m in state.messages] == ["user", "assistant", "tool"]
-        tool_msg = state.messages[2]
-        assert tool_msg.tool_call_id == "c1"
-        assert tool_msg.name == "srv__fetch"
-        assert tool_msg.content.startswith("ERROR:")
-
-    def test_malformed_line_is_skipped_not_fatal(self, tmp_path: Path) -> None:
-        path = tmp_path / "s.jsonl"
-        path.write_text(
-            '\n'.join([
-                json.dumps({"type": "session_start", "ts": "t", "session_id": "s", "task": "hi"}),
-                "this is not json at all",
-                json.dumps({"type": "message", "ts": "t", "session_id": "s",
-                            "role": "user", "content": "ok"}),
-            ]) + "\n",
-            encoding="utf-8",
-        )
-        state = load_session("s", sessions_dir=tmp_path)
-        # Malformed line dropped; valid events still processed.
-        assert len(state.messages) == 1
-        assert state.metadata["task"] == "hi"
-
-    def test_empty_lines_are_skipped(self, tmp_path: Path) -> None:
-        path = tmp_path / "s.jsonl"
-        path.write_text(
-            json.dumps({"type": "session_start", "ts": "t", "session_id": "s", "task": "hi"})
-            + "\n\n\n"
-            + json.dumps({"type": "message", "ts": "t", "session_id": "s",
-                          "role": "user", "content": "hi"})
-            + "\n",
-            encoding="utf-8",
-        )
-        state = load_session("s", sessions_dir=tmp_path)
-        assert len(state.messages) == 1
-
-
-# ── list_sessions ────────────────────────────────────────────────────────
-
-
-class TestListSessions:
-    def test_empty_dir_returns_empty(self, tmp_path: Path) -> None:
-        assert list_sessions(sessions_dir=tmp_path) == []
-
-    def test_nonexistent_dir_returns_empty(self, tmp_path: Path) -> None:
-        assert list_sessions(sessions_dir=tmp_path / "missing") == []
-
-    def test_only_jsonl_files_listed(self, tmp_path: Path) -> None:
-        (tmp_path / "alpha.jsonl").write_text("", encoding="utf-8")
-        (tmp_path / "beta.jsonl").write_text("", encoding="utf-8")
-        (tmp_path / "not_a_session.txt").write_text("", encoding="utf-8")
-        (tmp_path / "subdir").mkdir()
-        assert list_sessions(sessions_dir=tmp_path) == ["alpha", "beta"]
-
-    def test_symlinked_jsonl_files_are_skipped(self, tmp_path: Path) -> None:
-        (tmp_path / "alpha.jsonl").write_text("", encoding="utf-8")
-        outside = tmp_path / "outside.jsonl"
-        outside.write_text("", encoding="utf-8")
-        _symlink_or_skip(tmp_path / "linked.jsonl", outside)
-
-        assert list_sessions(sessions_dir=tmp_path) == ["alpha", "outside"]
-
-    def test_sorted_alphabetically(self, tmp_path: Path) -> None:
-        for name in ("zzz", "aaa", "mmm"):
-            (tmp_path / f"{name}.jsonl").write_text("", encoding="utf-8")
-        assert list_sessions(sessions_dir=tmp_path) == ["aaa", "mmm", "zzz"]
-
-
-# ── JsonlObserver end-to-end via run_loop ───────────────────────────────
-
-
-class TestJsonlObserverRoundTrip:
-    def test_simple_completion_replay(self, tmp_path: Path) -> None:
-        provider = _Scripted([_stop_response("final answer")])
-        store = SessionStore.create(session_id="trip1", sessions_dir=tmp_path)
-        observer = JsonlObserver(
-            store,
-            session_metadata={"task": "smoke-test", "model": "ollama/x"},
-        )
-        try:
-            result = run_loop(
-                provider=provider,
-                system_prompt="sys",
-                task="hi",
-                observer=observer,
-            )
-        finally:
-            store.close()
-
-        assert result.stop_reason == "completed"
-
-        state = load_session("trip1", sessions_dir=tmp_path)
-        # Replay must match the live conversation byte-for-byte (for
-        # roles + content).
-        live = [
-            (m.role, m.content) for m in result.messages
-        ]
-        replayed = [(m.role, m.content) for m in state.messages]
-        assert live == replayed
-        assert state.metadata["task"] == "smoke-test"
-        assert state.stop_reason == "completed"
-        assert state.stopped is True
-
-    def test_tool_call_round_trip(self, tmp_path: Path) -> None:
-        tc = ToolCall(id="c1", name="srv__echo", arguments={"text": "hi"})
-        provider = _Scripted(
-            [_tool_response(tc), _stop_response("seen hi")]
-        )
-        store = SessionStore.create(session_id="trip2", sessions_dir=tmp_path)
-        observer = JsonlObserver(store, session_metadata={"task": "go"})
-        try:
-            run_loop(
-                provider=provider,
-                system_prompt="",
-                task="go",
-                tool_executor=lambda call: f"echo:{call.arguments['text']}",
-                observer=observer,
-            )
-        finally:
-            store.close()
-
-        state = load_session("trip2", sessions_dir=tmp_path)
-        roles = [m.role for m in state.messages]
-        # user(task) + assistant(tool_calls) + tool(result) + assistant(final)
-        assert roles == ["user", "assistant", "tool", "assistant"]
-        tool_msg = state.messages[2]
-        assert tool_msg.content == "echo:hi"
-        assert tool_msg.tool_call_id == "c1"
-
-    def test_resume_via_messages_kwarg(self, tmp_path: Path) -> None:
-        """Load a prior session and hand its messages to a fresh run_loop."""
-        # First run.
-        provider1 = _Scripted([_stop_response("first-answer")])
-        store1 = SessionStore.create(session_id="resume1", sessions_dir=tmp_path)
-        try:
-            run_loop(
-                provider=provider1,
-                system_prompt="sys",
-                task="initial task",
-                observer=JsonlObserver(store1, session_metadata={"task": "initial task"}),
-            )
-        finally:
-            store1.close()
-
-        # Resume: load + feed back.
-        state = load_session("resume1", sessions_dir=tmp_path)
-        provider2 = _Scripted([_stop_response("resumed-answer")])
-        store2 = SessionStore.attach("resume1", sessions_dir=tmp_path)
-        try:
-            result2 = run_loop(
-                provider=provider2,
-                system_prompt="sys",
-                task="follow-up",
-                messages=list(state.messages),
-                observer=JsonlObserver(
-                    store2,
-                    session_metadata={},
-                    emit_session_start=False,  # already written in first run
-                    persisted_message_count=len(state.messages),
-                ),
-                append_task_after_messages=True,
-            )
-        finally:
-            store2.close()
-
-        # First run's conversation is visible in the resumed result.
-        resumed_roles = [m.role for m in result2.messages]
-        assert resumed_roles == ["system", "user", "assistant", "user", "assistant"]
-        contents = [m.content for m in result2.messages]
-        assert contents == [
-            "sys",
-            "initial task",
-            "first-answer",
-            "follow-up",
-            "resumed-answer",
-        ]
-        replayed = load_session("resume1", sessions_dir=tmp_path)
-        assert [m.content for m in replayed.messages] == contents
-
-    def test_metadata_includes_seed_messages(self, tmp_path: Path) -> None:
-        """session_start payload captures the seed conversation."""
-        provider = _Scripted([_stop_response("ok")])
-        store = SessionStore.create(session_id="meta", sessions_dir=tmp_path)
-        observer = JsonlObserver(store, session_metadata={"task": "t"})
-        try:
-            run_loop(
-                provider=provider, system_prompt="sys", task="t", observer=observer,
-            )
-        finally:
-            store.close()
-        # Find the session_start event directly so we can inspect seeds.
-        first_line = (tmp_path / "meta.jsonl").read_text(encoding="utf-8").splitlines()[0]
-        event = json.loads(first_line)
-        assert event["type"] == "session_start"
-        assert len(event["seed_messages"]) == 2  # system + user(task)
-        assert event["seed_messages"][0]["role"] == "system"
-        assert event["seed_messages"][1]["role"] == "user"
-
-    def test_observer_no_emit_start(self, tmp_path: Path) -> None:
-        """When emit_session_start=False the observer doesn't write it — caller did."""
-        provider = _Scripted([_stop_response("ok")])
-        store = SessionStore.create(session_id="noe", sessions_dir=tmp_path)
-        observer = JsonlObserver(
-            store, session_metadata={"task": "t"}, emit_session_start=False,
-        )
-        try:
-            run_loop(
-                provider=provider, system_prompt="", task="t", observer=observer,
-            )
-        finally:
-            store.close()
-        events = [
-            json.loads(line) for line in
-            (tmp_path / "noe.jsonl").read_text(encoding="utf-8").splitlines() if line
-        ]
-        types = [e["type"] for e in events]
-        assert "session_start" not in types
-        assert types.count("message") == 2
-
-    def test_stop_event_always_written(self, tmp_path: Path) -> None:
-        provider = _Scripted([_stop_response("ok")])
-        store = SessionStore.create(session_id="stop", sessions_dir=tmp_path)
-        observer = JsonlObserver(store, session_metadata={"task": "t"})
-        try:
-            run_loop(
-                provider=provider, system_prompt="", task="t", observer=observer,
-            )
-        finally:
-            store.close()
-        last_line = (
-            (tmp_path / "stop.jsonl")
-            .read_text(encoding="utf-8")
-            .strip()
-            .split("\n")[-1]
-        )
-        event = json.loads(last_line)
-        assert event["type"] == "stop"
-        assert event["stop_reason"] == "completed"
+"""
+test_harness_state.py -- SessionStore / JsonlObserver / load_session tests.
+
+Covers:
+  * SessionStore lifecycle + append-mode (resume) safety
+  * Event serialisation for every event type the observer emits
+  * JsonlObserver drives a round-trip: a run_loop session written
+    to disk + load_session replay reconstructs the same conversation
+  * Malformed-line tolerance on the reader
+  * ``list_sessions`` + path helpers
+  * Session-id validation rejects traversal-shaped ids
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from ctx.adapters.generic.loop import run_loop, LoopResult
+from ctx.adapters.generic.providers import (
+    CompletionResponse,
+    Message,
+    ModelProvider,
+    ToolCall,
+    ToolDefinition,
+    Usage,
+)
+from ctx.adapters.generic.state import (
+    JsonlObserver,
+    SessionStore,
+    _safe_session_id,
+    default_sessions_dir,
+    list_sessions,
+    load_session,
+    new_session_id,
+)
+
+
+# ── Scripted provider for the round-trip tests ─────────────────────────────
+
+
+def _symlink_or_skip(link: Path, target: Path) -> None:
+    try:
+        link.symlink_to(target)
+    except OSError as exc:
+        pytest.skip(f"symlinks unavailable in this environment: {exc}")
+
+
+class _Scripted(ModelProvider):
+    name = "scripted"
+
+    def __init__(self, responses: list[CompletionResponse]) -> None:
+        self._responses = list(responses)
+
+    def complete(
+        self,
+        messages: list[Message],
+        tools: list[ToolDefinition] | None = None,
+        *,
+        model: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+    ) -> CompletionResponse:
+        if not self._responses:
+            raise RuntimeError("scripted: no more responses")
+        return self._responses.pop(0)
+
+
+def _stop_response(content: str = "done") -> CompletionResponse:
+    return CompletionResponse(
+        content=content,
+        tool_calls=(),
+        finish_reason="stop",
+        usage=Usage(input_tokens=5, output_tokens=3),
+        provider="scripted",
+        model="x",
+    )
+
+
+def _tool_response(*calls: ToolCall) -> CompletionResponse:
+    return CompletionResponse(
+        content="",
+        tool_calls=tuple(calls),
+        finish_reason="tool_calls",
+        usage=Usage(input_tokens=10, output_tokens=4),
+        provider="scripted",
+        model="x",
+    )
+
+
+# ── Session-id safety ────────────────────────────────────────────────────
+
+
+class TestSessionIdValidation:
+    @pytest.mark.parametrize(
+        "bad",
+        [
+            "",
+            "../evil",
+            "a/b",
+            "a\\b",
+            ".",
+            "..",
+            "has space",
+            "has.dot",  # dots disallowed — risks '.jsonl' shadowing
+            "a" * 129,  # too long
+        ],
+    )
+    def test_rejects_bad(self, bad: str) -> None:
+        with pytest.raises((ValueError, TypeError)):
+            _safe_session_id(bad)
+
+    @pytest.mark.parametrize(
+        "good",
+        [
+            "abc123",
+            "nightly_backfill",
+            "2026-04-24-trial",
+            "f9eaad988e79443b85b819099f3679a3",
+        ],
+    )
+    def test_accepts_good(self, good: str) -> None:
+        assert _safe_session_id(good) == good
+
+    def test_non_string_rejected(self) -> None:
+        with pytest.raises((ValueError, TypeError)):
+            _safe_session_id(None)  # type: ignore[arg-type]
+
+
+class TestSessionIdGen:
+    def test_new_id_is_32_char_hex(self) -> None:
+        sid = new_session_id()
+        assert len(sid) == 32
+        assert all(c in "0123456789abcdef" for c in sid)
+
+    def test_ids_are_unique(self) -> None:
+        assert new_session_id() != new_session_id()
+
+
+# ── default_sessions_dir ─────────────────────────────────────────────────
+
+
+class TestDefaultSessionsDir:
+    def test_under_home(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("USERPROFILE", str(tmp_path))
+        p = default_sessions_dir()
+        assert p == tmp_path / ".ctx" / "sessions"
+
+    def test_not_created_by_call(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("USERPROFILE", str(tmp_path))
+        p = default_sessions_dir()
+        # Intentionally lazy — SessionStore creates it, not the helper.
+        assert not p.exists()
+
+
+# ── SessionStore ─────────────────────────────────────────────────────────
+
+
+class TestSessionStore:
+    def test_create_makes_parent_dir(self, tmp_path: Path) -> None:
+        nested = tmp_path / "deeply" / "nested"
+        store = SessionStore.create(
+            session_id="abc", sessions_dir=nested,
+        )
+        try:
+            assert nested.is_dir()
+            assert store.path == nested / "abc.jsonl"
+        finally:
+            store.close()
+
+    def test_create_auto_generates_id(self, tmp_path: Path) -> None:
+        store = SessionStore.create(sessions_dir=tmp_path)
+        try:
+            assert len(store.session_id) == 32
+        finally:
+            store.close()
+
+    def test_write_event_shapes_line(self, tmp_path: Path) -> None:
+        store = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
+        try:
+            store.write_event("custom", {"key": "value"})
+        finally:
+            store.close()
+        raw = (tmp_path / "s1.jsonl").read_text(encoding="utf-8")
+        event = json.loads(raw)
+        assert event["type"] == "custom"
+        assert event["session_id"] == "s1"
+        assert event["key"] == "value"
+        assert "ts" in event
+
+    def test_create_rejects_existing_session_by_default(self, tmp_path: Path) -> None:
+        path = tmp_path / "s1.jsonl"
+        path.write_text("sentinel\n", encoding="utf-8")
+        with pytest.raises(FileExistsError):
+            SessionStore.create(session_id="s1", sessions_dir=tmp_path)
+        assert path.read_text(encoding="utf-8") == "sentinel\n"
+
+    def test_create_can_overwrite_existing_session_explicitly(
+        self, tmp_path: Path,
+    ) -> None:
+        path = tmp_path / "s1.jsonl"
+        path.write_text("sentinel\n", encoding="utf-8")
+        store = SessionStore.create(
+            session_id="s1",
+            sessions_dir=tmp_path,
+            overwrite=True,
+        )
+        store.close()
+        assert path.read_text(encoding="utf-8") == ""
+
+    def test_create_overwrite_rejects_symlinked_session_log(
+        self, tmp_path: Path,
+    ) -> None:
+        outside = tmp_path / "outside.jsonl"
+        outside.write_text("sentinel\n", encoding="utf-8")
+        _symlink_or_skip(tmp_path / "s1.jsonl", outside)
+
+        with pytest.raises(ValueError, match="symlink"):
+            SessionStore.create(
+                session_id="s1",
+                sessions_dir=tmp_path,
+                overwrite=True,
+            )
+
+        assert outside.read_text(encoding="utf-8") == "sentinel\n"
+
+    def test_context_manager(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s1", sessions_dir=tmp_path) as store:
+            store.write_event("x", {})
+        assert store.closed
+        assert (tmp_path / "s1.jsonl").is_file()
+
+    def test_write_after_close_raises(self, tmp_path: Path) -> None:
+        store = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
+        store.close()
+        with pytest.raises(RuntimeError, match="closed"):
+            store.write_event("x", {})
+
+    def test_close_is_idempotent(self, tmp_path: Path) -> None:
+        store = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
+        store.close()
+        store.close()  # must not raise
+
+    def test_attach_requires_existing_file(self, tmp_path: Path) -> None:
+        with pytest.raises(FileNotFoundError):
+            SessionStore.attach("nope", sessions_dir=tmp_path)
+
+    def test_attach_rejects_symlinked_session_log(self, tmp_path: Path) -> None:
+        outside = tmp_path / "outside.jsonl"
+        outside.write_text("sentinel\n", encoding="utf-8")
+        _symlink_or_skip(tmp_path / "s1.jsonl", outside)
+
+        with pytest.raises(ValueError, match="symlink"):
+            SessionStore.attach("s1", sessions_dir=tmp_path)
+
+    def test_attach_appends_to_existing_file(self, tmp_path: Path) -> None:
+        # Create + write one event.
+        s1 = SessionStore.create(session_id="s1", sessions_dir=tmp_path)
+        s1.write_event("first", {})
+        s1.close()
+        # Attach + append.
+        s2 = SessionStore.attach("s1", sessions_dir=tmp_path)
+        s2.write_event("second", {})
+        s2.close()
+        lines = (tmp_path / "s1.jsonl").read_text(encoding="utf-8").strip().split("\n")
+        types = [json.loads(line)["type"] for line in lines]
+        assert types == ["first", "second"]
+
+    def test_unicode_content_roundtrips(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="uni", sessions_dir=tmp_path) as s:
+            s.write_event("x", {"content": "café 日本 🚀"})
+        event = json.loads((tmp_path / "uni.jsonl").read_text(encoding="utf-8"))
+        assert event["content"] == "café 日本 🚀"
+
+
+# ── Convenience writers ──────────────────────────────────────────────────
+
+
+class TestConvenienceWriters:
+    def test_write_session_start(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_session_start({"task": "hello", "model": "ollama/x"})
+        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
+        assert event["type"] == "session_start"
+        assert event["task"] == "hello"
+        assert event["model"] == "ollama/x"
+
+    def test_write_message(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_message(Message(role="user", content="hi"))
+            store.write_message(
+                Message(
+                    role="assistant",
+                    content="",
+                    tool_calls=(ToolCall(id="c1", name="t", arguments={"x": 1}),),
+                )
+            )
+        events = [
+            json.loads(line) for line in
+            (tmp_path / "s.jsonl").read_text(encoding="utf-8").splitlines() if line
+        ]
+        assert events[0]["role"] == "user"
+        assert events[1]["tool_calls"][0]["arguments"] == {"x": 1}
+
+    def test_write_model_response(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_model_response(
+                3,
+                CompletionResponse(
+                    content="ok",
+                    tool_calls=(),
+                    finish_reason="stop",
+                    usage=Usage(input_tokens=10, output_tokens=5, cost_usd=0.002),
+                    provider="litellm",
+                    model="openrouter/x",
+                ),
+            )
+        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
+        assert event["iteration"] == 3
+        assert event["usage"]["cost_usd"] == 0.002
+        assert event["provider"] == "litellm"
+        assert event["model"] == "openrouter/x"
+
+    def test_write_tool_call(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_tool_call(
+                1,
+                ToolCall(id="c1", name="fs__read", arguments={"path": "/tmp"}),
+                result="file contents",
+                error=None,
+            )
+        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
+        assert event["call"]["arguments"] == {"path": "/tmp"}
+        assert event["error"] is None
+
+    def test_write_stop(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_stop(
+                LoopResult(
+                    stop_reason="completed",
+                    final_message="done",
+                    iterations=3,
+                    usage=Usage(input_tokens=30, output_tokens=15, cost_usd=0.01),
+                    messages=(),
+                    detail="",
+                )
+            )
+        event = json.loads((tmp_path / "s.jsonl").read_text(encoding="utf-8"))
+        assert event["stop_reason"] == "completed"
+        assert event["iterations"] == 3
+
+
+# ── load_session ─────────────────────────────────────────────────────────
+
+
+class TestLoadSession:
+    def test_file_not_found(self, tmp_path: Path) -> None:
+        with pytest.raises(FileNotFoundError):
+            load_session("nope", sessions_dir=tmp_path)
+
+    def test_rejects_symlinked_session_log(self, tmp_path: Path) -> None:
+        outside = tmp_path / "outside.jsonl"
+        outside.write_text(
+            json.dumps({"type": "session_start", "session_id": "s"}) + "\n",
+            encoding="utf-8",
+        )
+        _symlink_or_skip(tmp_path / "s.jsonl", outside)
+
+        with pytest.raises(ValueError, match="symlink"):
+            load_session("s", sessions_dir=tmp_path)
+
+    def test_replay_simple_session(self, tmp_path: Path) -> None:
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_session_start({"task": "hello", "model": "x"})
+            store.write_message(Message(role="system", content="sys"))
+            store.write_message(Message(role="user", content="hi"))
+            store.write_message(Message(role="assistant", content="hello back"))
+            store.write_stop(
+                LoopResult(
+                    stop_reason="completed", final_message="hello back",
+                    iterations=1, usage=Usage(), messages=(), detail="",
+                )
+            )
+        state = load_session("s", sessions_dir=tmp_path)
+        assert state.session_id == "s"
+        assert state.path == tmp_path / "s.jsonl"
+        assert [m.role for m in state.messages] == ["system", "user", "assistant"]
+        assert state.messages[2].content == "hello back"
+        assert state.metadata["task"] == "hello"
+        assert state.stopped is True
+        assert state.stop_reason == "completed"
+
+    def test_replay_unstopped_session(self, tmp_path: Path) -> None:
+        """Session that trails off mid-run (no stop event) is flagged."""
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_session_start({"task": "x"})
+            store.write_message(Message(role="user", content="hi"))
+        state = load_session("s", sessions_dir=tmp_path)
+        assert state.stopped is False
+        assert state.stop_reason is None
+
+    def test_replay_tool_call_messages(self, tmp_path: Path) -> None:
+        """Assistant-with-tool_calls + tool-result must round-trip faithfully."""
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_message(Message(role="user", content="go"))
+            tc = ToolCall(id="c1", name="srv__fetch", arguments={"url": "https://x"})
+            store.write_message(
+                Message(role="assistant", content="", tool_calls=(tc,))
+            )
+            store.write_message(
+                Message(role="tool", content="ok", tool_call_id="c1", name="srv__fetch")
+            )
+        state = load_session("s", sessions_dir=tmp_path)
+        assert len(state.messages) == 3
+        assistant = state.messages[1]
+        assert assistant.tool_calls[0].id == "c1"
+        assert assistant.tool_calls[0].arguments == {"url": "https://x"}
+        tool_msg = state.messages[2]
+        assert tool_msg.tool_call_id == "c1"
+        assert tool_msg.name == "srv__fetch"
+
+    def test_replay_repairs_unresolved_tool_call_tail(self, tmp_path: Path) -> None:
+        """Crash after assistant tool_call message persists must resume safely."""
+        tc = ToolCall(id="c1", name="srv__fetch", arguments={"url": "https://x"})
+        with SessionStore.create(session_id="s", sessions_dir=tmp_path) as store:
+            store.write_message(Message(role="user", content="go"))
+            store.write_model_response(1, _tool_response(tc))
+            store.write_message(Message(role="assistant", content="", tool_calls=(tc,)))
+
+        state = load_session("s", sessions_dir=tmp_path)
+
+        assert [m.role for m in state.messages] == ["user", "assistant", "tool"]
+        tool_msg = state.messages[2]
+        assert tool_msg.tool_call_id == "c1"
+        assert tool_msg.name == "srv__fetch"
+        assert tool_msg.content.startswith("ERROR:")
+
+    def test_malformed_line_is_skipped_not_fatal(self, tmp_path: Path) -> None:
+        path = tmp_path / "s.jsonl"
+        path.write_text(
+            '\n'.join([
+                json.dumps({"type": "session_start", "ts": "t", "session_id": "s", "task": "hi"}),
+                "this is not json at all",
+                json.dumps({"type": "message", "ts": "t", "session_id": "s",
+                            "role": "user", "content": "ok"}),
+            ]) + "\n",
+            encoding="utf-8",
+        )
+        state = load_session("s", sessions_dir=tmp_path)
+        # Malformed line dropped; valid events still processed.
+        assert len(state.messages) == 1
+        assert state.metadata["task"] == "hi"
+
+    def test_empty_lines_are_skipped(self, tmp_path: Path) -> None:
+        path = tmp_path / "s.jsonl"
+        path.write_text(
+            json.dumps({"type": "session_start", "ts": "t", "session_id": "s", "task": "hi"})
+            + "\n\n\n"
+            + json.dumps({"type": "message", "ts": "t", "session_id": "s",
+                          "role": "user", "content": "hi"})
+            + "\n",
+            encoding="utf-8",
+        )
+        state = load_session("s", sessions_dir=tmp_path)
+        assert len(state.messages) == 1
+
+
+# ── list_sessions ────────────────────────────────────────────────────────
+
+
+class TestListSessions:
+    def test_empty_dir_returns_empty(self, tmp_path: Path) -> None:
+        assert list_sessions(sessions_dir=tmp_path) == []
+
+    def test_nonexistent_dir_returns_empty(self, tmp_path: Path) -> None:
+        assert list_sessions(sessions_dir=tmp_path / "missing") == []
+
+    def test_only_jsonl_files_listed(self, tmp_path: Path) -> None:
+        (tmp_path / "alpha.jsonl").write_text("", encoding="utf-8")
+        (tmp_path / "beta.jsonl").write_text("", encoding="utf-8")
+        (tmp_path / "not_a_session.txt").write_text("", encoding="utf-8")
+        (tmp_path / "subdir").mkdir()
+        assert list_sessions(sessions_dir=tmp_path) == ["alpha", "beta"]
+
+    def test_symlinked_jsonl_files_are_skipped(self, tmp_path: Path) -> None:
+        (tmp_path / "alpha.jsonl").write_text("", encoding="utf-8")
+        outside = tmp_path / "outside.jsonl"
+        outside.write_text("", encoding="utf-8")
+        _symlink_or_skip(tmp_path / "linked.jsonl", outside)
+
+        assert list_sessions(sessions_dir=tmp_path) == ["alpha", "outside"]
+
+    def test_sorted_alphabetically(self, tmp_path: Path) -> None:
+        for name in ("zzz", "aaa", "mmm"):
+            (tmp_path / f"{name}.jsonl").write_text("", encoding="utf-8")
+        assert list_sessions(sessions_dir=tmp_path) == ["aaa", "mmm", "zzz"]
+
+
+# ── JsonlObserver end-to-end via run_loop ───────────────────────────────
+
+
+class TestJsonlObserverRoundTrip:
+    def test_simple_completion_replay(self, tmp_path: Path) -> None:
+        provider = _Scripted([_stop_response("final answer")])
+        store = SessionStore.create(session_id="trip1", sessions_dir=tmp_path)
+        observer = JsonlObserver(
+            store,
+            session_metadata={"task": "smoke-test", "model": "ollama/x"},
+        )
+        try:
+            result = run_loop(
+                provider=provider,
+                system_prompt="sys",
+                task="hi",
+                observer=observer,
+            )
+        finally:
+            store.close()
+
+        assert result.stop_reason == "completed"
+
+        state = load_session("trip1", sessions_dir=tmp_path)
+        # Replay must match the live conversation byte-for-byte (for
+        # roles + content).
+        live = [
+            (m.role, m.content) for m in result.messages
+        ]
+        replayed = [(m.role, m.content) for m in state.messages]
+        assert live == replayed
+        assert state.metadata["task"] == "smoke-test"
+        assert state.stop_reason == "completed"
+        assert state.stopped is True
+
+    def test_tool_call_round_trip(self, tmp_path: Path) -> None:
+        tc = ToolCall(id="c1", name="srv__echo", arguments={"text": "hi"})
+        provider = _Scripted(
+            [_tool_response(tc), _stop_response("seen hi")]
+        )
+        store = SessionStore.create(session_id="trip2", sessions_dir=tmp_path)
+        observer = JsonlObserver(store, session_metadata={"task": "go"})
+        try:
+            run_loop(
+                provider=provider,
+                system_prompt="",
+                task="go",
+                tool_executor=lambda call: f"echo:{call.arguments['text']}",
+                observer=observer,
+            )
+        finally:
+            store.close()
+
+        state = load_session("trip2", sessions_dir=tmp_path)
+        roles = [m.role for m in state.messages]
+        # user(task) + assistant(tool_calls) + tool(result) + assistant(final)
+        assert roles == ["user", "assistant", "tool", "assistant"]
+        tool_msg = state.messages[2]
+        assert tool_msg.content == "echo:hi"
+        assert tool_msg.tool_call_id == "c1"
+
+    def test_resume_via_messages_kwarg(self, tmp_path: Path) -> None:
+        """Load a prior session and hand its messages to a fresh run_loop."""
+        # First run.
+        provider1 = _Scripted([_stop_response("first-answer")])
+        store1 = SessionStore.create(session_id="resume1", sessions_dir=tmp_path)
+        try:
+            run_loop(
+                provider=provider1,
+                system_prompt="sys",
+                task="initial task",
+                observer=JsonlObserver(store1, session_metadata={"task": "initial task"}),
+            )
+        finally:
+            store1.close()
+
+        # Resume: load + feed back.
+        state = load_session("resume1", sessions_dir=tmp_path)
+        provider2 = _Scripted([_stop_response("resumed-answer")])
+        store2 = SessionStore.attach("resume1", sessions_dir=tmp_path)
+        try:
+            result2 = run_loop(
+                provider=provider2,
+                system_prompt="sys",
+                task="follow-up",
+                messages=list(state.messages),
+                observer=JsonlObserver(
+                    store2,
+                    session_metadata={},
+                    emit_session_start=False,  # already written in first run
+                    persisted_message_count=len(state.messages),
+                ),
+                append_task_after_messages=True,
+            )
+        finally:
+            store2.close()
+
+        # First run's conversation is visible in the resumed result.
+        resumed_roles = [m.role for m in result2.messages]
+        assert resumed_roles == ["system", "user", "assistant", "user", "assistant"]
+        contents = [m.content for m in result2.messages]
+        assert contents == [
+            "sys",
+            "initial task",
+            "first-answer",
+            "follow-up",
+            "resumed-answer",
+        ]
+        replayed = load_session("resume1", sessions_dir=tmp_path)
+        assert [m.content for m in replayed.messages] == contents
+
+    def test_metadata_includes_seed_messages(self, tmp_path: Path) -> None:
+        """session_start payload captures the seed conversation."""
+        provider = _Scripted([_stop_response("ok")])
+        store = SessionStore.create(session_id="meta", sessions_dir=tmp_path)
+        observer = JsonlObserver(store, session_metadata={"task": "t"})
+        try:
+            run_loop(
+                provider=provider, system_prompt="sys", task="t", observer=observer,
+            )
+        finally:
+            store.close()
+        # Find the session_start event directly so we can inspect seeds.
+        first_line = (tmp_path / "meta.jsonl").read_text(encoding="utf-8").splitlines()[0]
+        event = json.loads(first_line)
+        assert event["type"] == "session_start"
+        assert len(event["seed_messages"]) == 2  # system + user(task)
+        assert event["seed_messages"][0]["role"] == "system"
+        assert event["seed_messages"][1]["role"] == "user"
+
+    def test_observer_no_emit_start(self, tmp_path: Path) -> None:
+        """When emit_session_start=False the observer doesn't write it — caller did."""
+        provider = _Scripted([_stop_response("ok")])
+        store = SessionStore.create(session_id="noe", sessions_dir=tmp_path)
+        observer = JsonlObserver(
+            store, session_metadata={"task": "t"}, emit_session_start=False,
+        )
+        try:
+            run_loop(
+                provider=provider, system_prompt="", task="t", observer=observer,
+            )
+        finally:
+            store.close()
+        events = [
+            json.loads(line) for line in
+            (tmp_path / "noe.jsonl").read_text(encoding="utf-8").splitlines() if line
+        ]
+        types = [e["type"] for e in events]
+        assert "session_start" not in types
+        assert types.count("message") == 2
+
+    def test_stop_event_always_written(self, tmp_path: Path) -> None:
+        provider = _Scripted([_stop_response("ok")])
+        store = SessionStore.create(session_id="stop", sessions_dir=tmp_path)
+        observer = JsonlObserver(store, session_metadata={"task": "t"})
+        try:
+            run_loop(
+                provider=provider, system_prompt="", task="t", observer=observer,
+            )
+        finally:
+            store.close()
+        last_line = (
+            (tmp_path / "stop.jsonl")
+            .read_text(encoding="utf-8")
+            .strip()
+            .split("\n")[-1]
+        )
+        event = json.loads(last_line)
+        assert event["type"] == "stop"
+        assert event["stop_reason"] == "completed"

src/tests/test_incremental_attach_shadow.py

@@ -1,210 +1,210 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-import networkx as nx
-import numpy as np
-
-from ctx.core.graph.incremental_shadow import main, run_shadow_validation
-from ctx.core.graph.semantic_edges import (
-    _l2_normalize,
-    _topk_pairs,
-    _topk_pairs_subset_with_optional_index,
-)
-from ctx.core.graph.vector_index import build_vector_index
-from ctx.core.wiki import wiki_graphify as wg
-
-
-def test_shadow_indexed_subset_matches_batch_semantic_candidates() -> None:
-    vecs = _l2_normalize(
-        np.array(
-            [
-                [1.0, 0.0],
-                [0.95, 0.05],
-                [0.0, 1.0],
-                [0.97, 0.03],
-            ],
-            dtype="float32",
-        )
-    )
-    node_ids = ["skill:alpha", "skill:beta", "skill:gamma", "skill:new"]
-    hashes = ["ha", "hb", "hc", "hn"]
-
-    batch = {
-        pair: score
-        for pair, score in _topk_pairs(vecs, node_ids, top_k=2, min_cosine=0.5).items()
-        if "skill:new" in pair
-    }
-    indexed = _topk_pairs_subset_with_optional_index(
-        vecs,
-        node_ids,
-        hashes,
-        [3],
-        top_k=2,
-        min_cosine=0.5,
-        vector_index_kind="numpy-flat",
-        model_id="model-a",
-        ann_enabled_above_nodes=1,
-        cache_dir=Path(),
-        persist_index=False,
-    )
-
-    assert indexed == batch
-
-
-def test_shadow_validation_reports_topk_overlap(tmp_path: Path) -> None:
-    index_dir = tmp_path / "vector-index"
-    build_vector_index(
-        kind="numpy-flat",
-        model_id="model-a",
-        node_ids=["skill:alpha", "skill:beta", "skill:gamma"],
-        content_hashes=["ha", "hb", "hc"],
-        vectors=np.asarray(
-            [[1.0, 0.0], [0.95, 0.05], [0.0, 1.0]],
-            dtype="float32",
-        ),
-    ).save(index_dir)
-
-    report = run_shadow_validation(
-        index_dir=index_dir,
-        node_ids=["skill:alpha"],
-        top_ks=(1, 2),
-        min_score=0.5,
-        min_overlap=0.85,
-    )
-
-    assert report["gate_passed"] is True
-    assert report["baseline"] == "exact-vector-topk"
-    assert report["metrics"]["top_1"]["recall"] == 1.0
-    assert report["score_deltas"]["max_abs"] == 0.0
-    assert report["bad_examples"] == []
-
-
-def test_shadow_validation_can_gate_against_graph_baseline(tmp_path: Path) -> None:
-    index_dir = tmp_path / "vector-index"
-    build_vector_index(
-        kind="numpy-flat",
-        model_id="model-a",
-        node_ids=["skill:alpha", "skill:expected", "skill:actual"],
-        content_hashes=["ha", "he", "hc"],
-        vectors=np.asarray(
-            [[1.0, 0.0], [0.0, 1.0], [0.97, 0.03]],
-            dtype="float32",
-        ),
-    ).save(index_dir)
-    graph = nx.Graph()
-    graph.add_edge("skill:alpha", "skill:expected", semantic_sim=0.9)
-
-    report = run_shadow_validation(
-        index_dir=index_dir,
-        graph=graph,
-        node_ids=["skill:alpha"],
-        top_ks=(1,),
-        min_score=0.5,
-        min_final_weight=0.03,
-        min_overlap=0.85,
-    )
-
-    assert report["gate_passed"] is False
-    assert report["metrics"]["top_1"]["recall"] == 0.0
-    assert report["bad_examples"][0]["missing"] == ["skill:expected"]
-
-
-def test_shadow_cli_returns_nonzero_when_gate_fails(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.0, 1.0]], dtype="float32"),
-    ).save(index_dir)
-    graph = nx.Graph()
-    graph.add_edge("skill:alpha", "skill:beta", semantic_sim=0.9)
-    graph_path = tmp_path / "graph.json"
-    from networkx.readwrite import node_link_data
-
-    graph_path.write_text(json.dumps(node_link_data(graph, edges="edges")), encoding="utf-8")
-
-    rc = main([
-        "--index-dir", str(index_dir),
-        "--graph", str(graph_path),
-        "--node", "skill:alpha",
-        "--top-k", "1",
-        "--min-score", "0.95",
-        "--json",
-    ])
-
-    assert rc == 2
-    assert '"gate_passed": false' in capsys.readouterr().out
-
-
-def test_shadow_incremental_graph_matches_full_graph(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    import ctx_config
-
-    wiki = tmp_path / "wiki"
-    _isolate_graphify(wiki, tmp_path / "quality", monkeypatch)
-    monkeypatch.setattr(ctx_config.cfg, "graph_edge_weight_semantic", 0.0)
-
-    _write_entity(wiki / "entities" / "skills" / "alpha.md", "alpha", ["python"])
-    _write_entity(wiki / "entities" / "skills" / "beta.md", "beta", ["python"])
-    prior, _ = wg.build_graph(incremental=False)
-
-    _write_entity(wiki / "entities" / "skills" / "gamma.md", "gamma", ["python"])
-    monkeypatch.setattr(wg, "load_prior_graph", lambda: prior.copy())
-    incremental, _ = wg.build_graph(incremental=True)
-
-    monkeypatch.setattr(wg, "load_prior_graph", lambda: None)
-    full, _ = wg.build_graph(incremental=False)
-
-    assert _node_snapshot(incremental) == _node_snapshot(full)
-    assert _edge_snapshot(incremental) == _edge_snapshot(full)
-
-
-def _isolate_graphify(wiki: Path, quality: Path, monkeypatch) -> None:
-    monkeypatch.setattr(wg, "WIKI_DIR", wiki)
-    monkeypatch.setattr(wg, "SKILL_ENTITIES", wiki / "entities" / "skills")
-    monkeypatch.setattr(wg, "AGENT_ENTITIES", wiki / "entities" / "agents")
-    monkeypatch.setattr(wg, "MCP_ENTITIES", wiki / "entities" / "mcp-servers")
-    monkeypatch.setattr(wg, "HARNESS_ENTITIES", wiki / "entities" / "harnesses")
-    monkeypatch.setattr(wg, "GRAPH_OUT", wiki / "graphify-out")
-    monkeypatch.setattr(wg, "QUALITY_SIDECAR_DIR", quality)
-    monkeypatch.setattr(wg, "load_prior_graph", lambda: None)
-
-
-def _write_entity(path: Path, slug: str, tags: list[str]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    lines = ["---", f"title: {slug}", "type: skill", "tags:"]
-    lines.extend(f"  - {tag}" for tag in tags)
-    lines.extend(["---", f"# {slug}", "body"])
-    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-
-
-def _node_snapshot(G: nx.Graph) -> dict[str, dict[str, Any]]:
-    keys = {"label", "type", "tags", "never_load"}
-    return {
-        node_id: {key: G.nodes[node_id].get(key) for key in keys}
-        for node_id in sorted(G.nodes)
-    }
-
-
-def _edge_snapshot(G: nx.Graph) -> dict[tuple[str, str], dict[str, Any]]:
-    keys = {
-        "weight",
-        "final_weight",
-        "semantic_sim",
-        "tag_sim",
-        "token_sim",
-        "shared_tags",
-        "shared_tokens",
-        "edge_reasons",
-    }
-    return {
-        tuple(sorted((left, right))): {key: attrs.get(key) for key in keys}
-        for left, right, attrs in G.edges(data=True)
-    }
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import networkx as nx
+import numpy as np
+
+from ctx.core.graph.incremental_shadow import main, run_shadow_validation
+from ctx.core.graph.semantic_edges import (
+    _l2_normalize,
+    _topk_pairs,
+    _topk_pairs_subset_with_optional_index,
+)
+from ctx.core.graph.vector_index import build_vector_index
+from ctx.core.wiki import wiki_graphify as wg
+
+
+def test_shadow_indexed_subset_matches_batch_semantic_candidates() -> None:
+    vecs = _l2_normalize(
+        np.array(
+            [
+                [1.0, 0.0],
+                [0.95, 0.05],
+                [0.0, 1.0],
+                [0.97, 0.03],
+            ],
+            dtype="float32",
+        )
+    )
+    node_ids = ["skill:alpha", "skill:beta", "skill:gamma", "skill:new"]
+    hashes = ["ha", "hb", "hc", "hn"]
+
+    batch = {
+        pair: score
+        for pair, score in _topk_pairs(vecs, node_ids, top_k=2, min_cosine=0.5).items()
+        if "skill:new" in pair
+    }
+    indexed = _topk_pairs_subset_with_optional_index(
+        vecs,
+        node_ids,
+        hashes,
+        [3],
+        top_k=2,
+        min_cosine=0.5,
+        vector_index_kind="numpy-flat",
+        model_id="model-a",
+        ann_enabled_above_nodes=1,
+        cache_dir=Path(),
+        persist_index=False,
+    )
+
+    assert indexed == batch
+
+
+def test_shadow_validation_reports_topk_overlap(tmp_path: Path) -> None:
+    index_dir = tmp_path / "vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:alpha", "skill:beta", "skill:gamma"],
+        content_hashes=["ha", "hb", "hc"],
+        vectors=np.asarray(
+            [[1.0, 0.0], [0.95, 0.05], [0.0, 1.0]],
+            dtype="float32",
+        ),
+    ).save(index_dir)
+
+    report = run_shadow_validation(
+        index_dir=index_dir,
+        node_ids=["skill:alpha"],
+        top_ks=(1, 2),
+        min_score=0.5,
+        min_overlap=0.85,
+    )
+
+    assert report["gate_passed"] is True
+    assert report["baseline"] == "exact-vector-topk"
+    assert report["metrics"]["top_1"]["recall"] == 1.0
+    assert report["score_deltas"]["max_abs"] == 0.0
+    assert report["bad_examples"] == []
+
+
+def test_shadow_validation_can_gate_against_graph_baseline(tmp_path: Path) -> None:
+    index_dir = tmp_path / "vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:alpha", "skill:expected", "skill:actual"],
+        content_hashes=["ha", "he", "hc"],
+        vectors=np.asarray(
+            [[1.0, 0.0], [0.0, 1.0], [0.97, 0.03]],
+            dtype="float32",
+        ),
+    ).save(index_dir)
+    graph = nx.Graph()
+    graph.add_edge("skill:alpha", "skill:expected", semantic_sim=0.9)
+
+    report = run_shadow_validation(
+        index_dir=index_dir,
+        graph=graph,
+        node_ids=["skill:alpha"],
+        top_ks=(1,),
+        min_score=0.5,
+        min_final_weight=0.03,
+        min_overlap=0.85,
+    )
+
+    assert report["gate_passed"] is False
+    assert report["metrics"]["top_1"]["recall"] == 0.0
+    assert report["bad_examples"][0]["missing"] == ["skill:expected"]
+
+
+def test_shadow_cli_returns_nonzero_when_gate_fails(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.0, 1.0]], dtype="float32"),
+    ).save(index_dir)
+    graph = nx.Graph()
+    graph.add_edge("skill:alpha", "skill:beta", semantic_sim=0.9)
+    graph_path = tmp_path / "graph.json"
+    from networkx.readwrite import node_link_data
+
+    graph_path.write_text(json.dumps(node_link_data(graph, edges="edges")), encoding="utf-8")
+
+    rc = main([
+        "--index-dir", str(index_dir),
+        "--graph", str(graph_path),
+        "--node", "skill:alpha",
+        "--top-k", "1",
+        "--min-score", "0.95",
+        "--json",
+    ])
+
+    assert rc == 2
+    assert '"gate_passed": false' in capsys.readouterr().out
+
+
+def test_shadow_incremental_graph_matches_full_graph(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    import ctx_config
+
+    wiki = tmp_path / "wiki"
+    _isolate_graphify(wiki, tmp_path / "quality", monkeypatch)
+    monkeypatch.setattr(ctx_config.cfg, "graph_edge_weight_semantic", 0.0)
+
+    _write_entity(wiki / "entities" / "skills" / "alpha.md", "alpha", ["python"])
+    _write_entity(wiki / "entities" / "skills" / "beta.md", "beta", ["python"])
+    prior, _ = wg.build_graph(incremental=False)
+
+    _write_entity(wiki / "entities" / "skills" / "gamma.md", "gamma", ["python"])
+    monkeypatch.setattr(wg, "load_prior_graph", lambda: prior.copy())
+    incremental, _ = wg.build_graph(incremental=True)
+
+    monkeypatch.setattr(wg, "load_prior_graph", lambda: None)
+    full, _ = wg.build_graph(incremental=False)
+
+    assert _node_snapshot(incremental) == _node_snapshot(full)
+    assert _edge_snapshot(incremental) == _edge_snapshot(full)
+
+
+def _isolate_graphify(wiki: Path, quality: Path, monkeypatch) -> None:
+    monkeypatch.setattr(wg, "WIKI_DIR", wiki)
+    monkeypatch.setattr(wg, "SKILL_ENTITIES", wiki / "entities" / "skills")
+    monkeypatch.setattr(wg, "AGENT_ENTITIES", wiki / "entities" / "agents")
+    monkeypatch.setattr(wg, "MCP_ENTITIES", wiki / "entities" / "mcp-servers")
+    monkeypatch.setattr(wg, "HARNESS_ENTITIES", wiki / "entities" / "harnesses")
+    monkeypatch.setattr(wg, "GRAPH_OUT", wiki / "graphify-out")
+    monkeypatch.setattr(wg, "QUALITY_SIDECAR_DIR", quality)
+    monkeypatch.setattr(wg, "load_prior_graph", lambda: None)
+
+
+def _write_entity(path: Path, slug: str, tags: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["---", f"title: {slug}", "type: skill", "tags:"]
+    lines.extend(f"  - {tag}" for tag in tags)
+    lines.extend(["---", f"# {slug}", "body"])
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def _node_snapshot(G: nx.Graph) -> dict[str, dict[str, Any]]:
+    keys = {"label", "type", "tags", "never_load"}
+    return {
+        node_id: {key: G.nodes[node_id].get(key) for key in keys}
+        for node_id in sorted(G.nodes)
+    }
+
+
+def _edge_snapshot(G: nx.Graph) -> dict[tuple[str, str], dict[str, Any]]:
+    keys = {
+        "weight",
+        "final_weight",
+        "semantic_sim",
+        "tag_sim",
+        "token_sim",
+        "shared_tags",
+        "shared_tokens",
+        "edge_reasons",
+    }
+    return {
+        tuple(sorted((left, right))): {key: attrs.get(key) for key in keys}
+        for left, right, attrs in G.edges(data=True)
+    }

src/tests/test_inject_hooks_security.py

@@ -1,376 +1,376 @@
-"""
-test_inject_hooks_security.py -- Security regression tests for inject_hooks.py.
-
-Verifies:
-1. Generated hook commands do NOT contain $CLAUDE_TOOL_INPUT or $CLAUDE_TOOL_NAME
-   as literal substrings (shell injection vectors).
-2. The Stop array contains BOTH usage_tracker and quality_on_session_end entries.
-3. Concurrent/repeated writes to settings.json leave a valid JSON file
-   (atomic write correctness).
-"""
-
-import json
-import sys
-import threading
-from pathlib import Path
-
-import pytest
-
-# Ensure src/ is importable
-_SRC = Path(__file__).resolve().parent.parent
-if str(_SRC) not in sys.path:
-    sys.path.insert(0, str(_SRC))
-
-from ctx.adapters.claude_code import inject_hooks  # noqa: E402
-from ctx.adapters.claude_code.inject_hooks import make_hooks, merge_hooks, write_settings_atomic  # noqa: E402
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _all_commands(hooks_block: dict) -> list[str]:
-    """Flatten every 'command' string out of a hooks block dict."""
-    cmds: list[str] = []
-    for entries in hooks_block.values():
-        for entry in entries:
-            if not isinstance(entry, dict):
-                continue
-            if "command" in entry:
-                cmds.append(entry["command"])
-            for sub in entry.get("hooks", []):
-                if isinstance(sub, dict) and "command" in sub:
-                    cmds.append(sub["command"])
-    return cmds
-
-
-def _all_modules(hooks_block: dict) -> list[str]:
-    """Return every module invoked through ``python -m`` hook commands."""
-    modules: list[str] = []
-    for cmd in _all_commands(hooks_block):
-        parts = cmd.split()
-        if "-m" in parts:
-            idx = parts.index("-m")
-            if idx + 1 < len(parts):
-                modules.append(parts[idx + 1])
-    return modules
-
-
-def _run_inject(ctx_dir: str, settings_path: Path) -> None:
-    """Run the full inject pipeline (load → merge → atomic write)."""
-    from ctx.adapters.claude_code.inject_hooks import load_settings, _remove_stale_hooks
-
-    settings = load_settings(settings_path)
-    settings = _remove_stale_hooks(settings)
-    new_hooks = make_hooks(ctx_dir)
-    updated = merge_hooks(settings, new_hooks)
-    write_settings_atomic(settings_path, updated)
-
-
-# ---------------------------------------------------------------------------
-# Fix 1 — No shell-injection env vars in command strings
-# ---------------------------------------------------------------------------
-
-
-class TestNoShellInjectionVars:
-    """Hook commands must not embed $CLAUDE_TOOL_INPUT or $CLAUDE_TOOL_NAME."""
-
-    def test_make_hooks_no_tool_input_var(self, tmp_path: Path) -> None:
-        ctx_dir = str(tmp_path / "ctx")
-        hooks = make_hooks(ctx_dir)
-        cmds = _all_commands(hooks)
-        for cmd in cmds:
-            assert "$CLAUDE_TOOL_INPUT" not in cmd, (
-                f"Shell injection vector $CLAUDE_TOOL_INPUT found in command: {cmd!r}"
-            )
-
-    def test_make_hooks_no_tool_name_var(self, tmp_path: Path) -> None:
-        ctx_dir = str(tmp_path / "ctx")
-        hooks = make_hooks(ctx_dir)
-        cmds = _all_commands(hooks)
-        for cmd in cmds:
-            assert "$CLAUDE_TOOL_NAME" not in cmd, (
-                f"Shell injection vector $CLAUDE_TOOL_NAME found in command: {cmd!r}"
-            )
-
-    def test_generated_settings_no_tool_input_var(self, tmp_path: Path) -> None:
-        """End-to-end: the JSON written to disk must not contain the injection vars."""
-        settings_path = tmp_path / "settings.json"
-        ctx_dir = str(tmp_path / "ctx")
-        _run_inject(ctx_dir, settings_path)
-
-        raw = settings_path.read_text(encoding="utf-8")
-        assert "$CLAUDE_TOOL_INPUT" not in raw, (
-            "$CLAUDE_TOOL_INPUT found in written settings.json"
-        )
-        assert "$CLAUDE_TOOL_NAME" not in raw, (
-            "$CLAUDE_TOOL_NAME found in written settings.json"
-        )
-
-    def test_from_stdin_flag_present_in_posttooluse_commands(
-        self, tmp_path: Path
-    ) -> None:
-        """PostToolUse commands that replaced env-var args must use --from-stdin."""
-        ctx_dir = str(tmp_path / "ctx")
-        hooks = make_hooks(ctx_dir)
-        post_tool_entries = hooks.get("PostToolUse", [])
-        assert post_tool_entries, "PostToolUse block must not be empty"
-
-        # context_monitor and skill_add_detector commands must carry --from-stdin
-        sub_hooks = post_tool_entries[0].get("hooks", [])
-        cmds_with_stdin = [
-            h["command"] for h in sub_hooks
-            if isinstance(h, dict) and "--from-stdin" in h.get("command", "")
-        ]
-        assert len(cmds_with_stdin) >= 2, (
-            f"Expected at least 2 --from-stdin commands; found {len(cmds_with_stdin)}: "
-            f"{cmds_with_stdin}"
-        )
-
-    def test_merge_hooks_repairs_partial_posttooluse_matcher(
-        self,
-        tmp_path: Path,
-    ) -> None:
-        new_hooks = make_hooks(str(tmp_path / "ctx"))
-        existing = {
-            "hooks": {
-                "PostToolUse": [
-                    {
-                        "matcher": ".*",
-                        "hooks": [new_hooks["PostToolUse"][0]["hooks"][0]],
-                    },
-                ],
-            },
-        }
-
-        merged = merge_hooks(existing, new_hooks)
-
-        commands = _all_commands({"PostToolUse": merged["hooks"]["PostToolUse"]})
-        assert any("context_monitor" in command for command in commands)
-        assert any("skill_add_detector" in command for command in commands)
-        assert any("bundle_orchestrator" in command for command in commands)
-
-
-# ---------------------------------------------------------------------------
-# Fix 2 — Stop array contains both usage_tracker and quality_on_session_end
-# ---------------------------------------------------------------------------
-
-
-class TestStopHooks:
-    def _stop_commands(self, hooks: dict) -> list[str]:
-        """Flatten both legacy (flat) + current ({"hooks":[...]} matcher)
-        Stop-hook shapes into a list of command strings. The current
-        generator produces the matcher shape (required by Claude Code's
-        schema) but we accept both so legacy settings.json files that
-        still use the flat shape don't make the assertions drift.
-        """
-        out: list[str] = []
-        for entry in hooks.get("Stop", []):
-            if not isinstance(entry, dict):
-                continue
-            if "command" in entry:
-                out.append(entry["command"])
-            for sub in entry.get("hooks", []):
-                if isinstance(sub, dict) and "command" in sub:
-                    out.append(sub["command"])
-        return out
-
-    def test_stop_contains_usage_tracker(self, tmp_path: Path) -> None:
-        ctx_dir = str(tmp_path / "ctx")
-        hooks = make_hooks(ctx_dir)
-        stop_cmds = self._stop_commands(hooks)
-        assert any("-m usage_tracker" in c for c in stop_cmds), (
-            f"usage_tracker module not found in Stop hooks: {stop_cmds}"
-        )
-
-    def test_stop_contains_quality_on_session_end(self, tmp_path: Path) -> None:
-        ctx_dir = str(tmp_path / "ctx")
-        hooks = make_hooks(ctx_dir)
-        stop_cmds = self._stop_commands(hooks)
-        assert any("ctx.adapters.claude_code.hooks.lifecycle_hooks quality-on-session-end" in c for c in stop_cmds), (
-            f"quality hook module not found in Stop hooks: {stop_cmds}"
-        )
-
-    def test_stop_contains_both_in_generated_settings(self, tmp_path: Path) -> None:
-        settings_path = tmp_path / "settings.json"
-        ctx_dir = str(tmp_path / "ctx")
-        _run_inject(ctx_dir, settings_path)
-
-        data = json.loads(settings_path.read_text(encoding="utf-8"))
-        stop_cmds = self._stop_commands(data.get("hooks", {}))
-
-        assert any("-m usage_tracker" in c for c in stop_cmds), (
-            f"usage_tracker module missing from persisted Stop hooks: {stop_cmds}"
-        )
-        assert any("ctx.adapters.claude_code.hooks.lifecycle_hooks quality-on-session-end" in c for c in stop_cmds), (
-            f"quality hook module missing from persisted Stop hooks: {stop_cmds}"
-        )
-
-    def test_stop_hook_count_is_two(self, tmp_path: Path) -> None:
-        """Both Stop hook commands must be present (usage_tracker + quality)."""
-        ctx_dir = str(tmp_path / "ctx")
-        hooks = make_hooks(ctx_dir)
-        stop_cmds = self._stop_commands(hooks)
-        assert len(stop_cmds) == 2, (
-            f"Expected exactly 2 Stop commands; got {len(stop_cmds)}: {stop_cmds}"
-        )
-
-
-# ---------------------------------------------------------------------------
-# Fix 3 — shlex.quote protects ctx_dir with special characters
-# ---------------------------------------------------------------------------
-
-
-class TestCtxDirQuoting:
-    def test_path_with_spaces_is_quoted(self, tmp_path: Path) -> None:
-        ctx_dir = str(tmp_path / "my ctx dir")
-        hooks = make_hooks(ctx_dir)
-        cmds = _all_commands(hooks)
-        for cmd in cmds:
-            # If the path contained spaces, the shell command must quote it —
-            # a bare space would split the path across two argv tokens.
-            if "my ctx dir" in cmd:
-                # shlex.quote wraps in single-quotes: 'my ctx dir'
-                assert "my ctx dir" not in cmd or "'" in cmd, (
-                    f"Path with space is not quoted in: {cmd!r}"
-                )
-
-    def test_path_with_dollar_is_safe(self, tmp_path: Path) -> None:
-        """A ctx_dir with a literal $ must be quoted so the shell doesn't expand it."""
-        import shlex as _shlex
-        ctx_dir = "/home/user/$HOME/ctx"
-        hooks = make_hooks(ctx_dir)
-        cmds = _all_commands(hooks)
-        quoted = _shlex.quote(ctx_dir)
-        for cmd in cmds:
-            if ctx_dir in cmd or quoted in cmd:
-                # The raw unquoted path must not appear unless it's the quoted form
-                assert f" {ctx_dir}/" not in cmd, (
-                    f"Unquoted $ path found in: {cmd!r}"
-                )
-
-    def test_windows_python_path_with_spaces_uses_windows_quoting(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-    ) -> None:
-        monkeypatch.setattr(
-            inject_hooks.sys,
-            "executable",
-            r"C:\Program Files\Python311\python.exe",
-        )
-        monkeypatch.setattr(inject_hooks.os, "name", "nt")
-
-        cmd = inject_hooks._module_cmd("usage_tracker", "--sync")
-
-        assert cmd == r'"C:\Program Files\Python311\python.exe" -m usage_tracker --sync'
-        assert "'" not in cmd
-
-
-class TestPackagedHookCommands:
-    def test_commands_use_importable_modules_not_repo_paths(
-        self, tmp_path: Path
-    ) -> None:
-        hooks = make_hooks(str(tmp_path / "ctx"))
-        cmds = _all_commands(hooks)
-
-        assert cmds
-        assert all(".py" not in cmd for cmd in cmds)
-        assert all("/../hooks/" not in cmd and "\\..\\hooks\\" not in cmd for cmd in cmds)
-        assert all(" 2>/dev/null" not in cmd and "|| true" not in cmd for cmd in cmds)
-
-        modules = _all_modules(hooks)
-        assert {
-            "ctx.adapters.claude_code.hooks.context_monitor",
-            "skill_add_detector",
-            "ctx.adapters.claude_code.hooks.bundle_orchestrator",
-            "usage_tracker",
-            "ctx.adapters.claude_code.hooks.lifecycle_hooks",
-        } <= set(modules)
-
-
-# ---------------------------------------------------------------------------
-# Fix 4 — Atomic write: concurrent writes leave valid JSON
-# ---------------------------------------------------------------------------
-
-
-class TestAtomicWrite:
-    def test_single_write_produces_valid_json(self, tmp_path: Path) -> None:
-        settings_path = tmp_path / "settings.json"
-        ctx_dir = str(tmp_path / "ctx")
-        _run_inject(ctx_dir, settings_path)
-        data = json.loads(settings_path.read_text(encoding="utf-8"))
-        assert "hooks" in data
-
-    def test_repeated_writes_leave_valid_json(self, tmp_path: Path) -> None:
-        """Running inject twice (idempotent) must leave a valid, parseable JSON."""
-        settings_path = tmp_path / "settings.json"
-        ctx_dir = str(tmp_path / "ctx")
-        _run_inject(ctx_dir, settings_path)
-        _run_inject(ctx_dir, settings_path)
-
-        data = json.loads(settings_path.read_text(encoding="utf-8"))
-        assert "hooks" in data
-
-    def test_concurrent_writes_leave_valid_json(self, tmp_path: Path) -> None:
-        """Concurrent write_settings_atomic calls must not produce a torn file.
-
-        The fix being tested: write goes to a tempfile then os.replace(), so a
-        reader never sees a partially-written JSON.  We call write_settings_atomic
-        directly (bypassing load_settings) to isolate the write path from the
-        Windows file-lock behaviour on the read side.
-        """
-        from ctx.adapters.claude_code.inject_hooks import write_settings_atomic
-
-        settings_path = tmp_path / "settings.json"
-        payload = {"hooks": {"Stop": [{"type": "command", "command": "python x.py"}]}}
-
-        # Seed the file.
-        write_settings_atomic(settings_path, payload)
-
-        errors: list[Exception] = []
-
-        def _writer() -> None:
-            try:
-                for _ in range(10):
-                    write_settings_atomic(settings_path, payload)
-            except Exception as exc:
-                errors.append(exc)
-
-        t1 = threading.Thread(target=_writer)
-        t2 = threading.Thread(target=_writer)
-        t1.start()
-        t2.start()
-        t1.join()
-        t2.join()
-
-        assert not errors, f"Thread errors during concurrent writes: {errors}"
-
-        # File must still be valid JSON after concurrent writes.
-        raw = settings_path.read_text(encoding="utf-8")
-        data = json.loads(raw)
-        assert "hooks" in data
-
-    def test_write_settings_atomic_cleans_up_on_failure(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        """If os.replace() raises, the tempfile is removed and no stale .tmp lingers."""
-        import os as _os
-        from ctx.adapters.claude_code import inject_hooks as _ih
-
-        settings_path = tmp_path / "settings.json"
-
-        call_count = {"n": 0}
-
-        def _failing_replace(src: str, dst: str) -> None:
-            call_count["n"] += 1
-            raise OSError("simulated disk full")
-
-        monkeypatch.setattr(_os, "replace", _failing_replace)
-
-        with pytest.raises(OSError, match="simulated disk full"):
-            _ih.write_settings_atomic(settings_path, {"hooks": {}})
-
-        # No stale .tmp files should remain
-        tmp_files = list(tmp_path.glob("settings.json.*.tmp"))
-        assert not tmp_files, f"Stale tempfiles not cleaned up: {tmp_files}"
+"""
+test_inject_hooks_security.py -- Security regression tests for inject_hooks.py.
+
+Verifies:
+1. Generated hook commands do NOT contain $CLAUDE_TOOL_INPUT or $CLAUDE_TOOL_NAME
+   as literal substrings (shell injection vectors).
+2. The Stop array contains BOTH usage_tracker and quality_on_session_end entries.
+3. Concurrent/repeated writes to settings.json leave a valid JSON file
+   (atomic write correctness).
+"""
+
+import json
+import sys
+import threading
+from pathlib import Path
+
+import pytest
+
+# Ensure src/ is importable
+_SRC = Path(__file__).resolve().parent.parent
+if str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+
+from ctx.adapters.claude_code import inject_hooks  # noqa: E402
+from ctx.adapters.claude_code.inject_hooks import make_hooks, merge_hooks, write_settings_atomic  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _all_commands(hooks_block: dict) -> list[str]:
+    """Flatten every 'command' string out of a hooks block dict."""
+    cmds: list[str] = []
+    for entries in hooks_block.values():
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            if "command" in entry:
+                cmds.append(entry["command"])
+            for sub in entry.get("hooks", []):
+                if isinstance(sub, dict) and "command" in sub:
+                    cmds.append(sub["command"])
+    return cmds
+
+
+def _all_modules(hooks_block: dict) -> list[str]:
+    """Return every module invoked through ``python -m`` hook commands."""
+    modules: list[str] = []
+    for cmd in _all_commands(hooks_block):
+        parts = cmd.split()
+        if "-m" in parts:
+            idx = parts.index("-m")
+            if idx + 1 < len(parts):
+                modules.append(parts[idx + 1])
+    return modules
+
+
+def _run_inject(ctx_dir: str, settings_path: Path) -> None:
+    """Run the full inject pipeline (load → merge → atomic write)."""
+    from ctx.adapters.claude_code.inject_hooks import load_settings, _remove_stale_hooks
+
+    settings = load_settings(settings_path)
+    settings = _remove_stale_hooks(settings)
+    new_hooks = make_hooks(ctx_dir)
+    updated = merge_hooks(settings, new_hooks)
+    write_settings_atomic(settings_path, updated)
+
+
+# ---------------------------------------------------------------------------
+# Fix 1 — No shell-injection env vars in command strings
+# ---------------------------------------------------------------------------
+
+
+class TestNoShellInjectionVars:
+    """Hook commands must not embed $CLAUDE_TOOL_INPUT or $CLAUDE_TOOL_NAME."""
+
+    def test_make_hooks_no_tool_input_var(self, tmp_path: Path) -> None:
+        ctx_dir = str(tmp_path / "ctx")
+        hooks = make_hooks(ctx_dir)
+        cmds = _all_commands(hooks)
+        for cmd in cmds:
+            assert "$CLAUDE_TOOL_INPUT" not in cmd, (
+                f"Shell injection vector $CLAUDE_TOOL_INPUT found in command: {cmd!r}"
+            )
+
+    def test_make_hooks_no_tool_name_var(self, tmp_path: Path) -> None:
+        ctx_dir = str(tmp_path / "ctx")
+        hooks = make_hooks(ctx_dir)
+        cmds = _all_commands(hooks)
+        for cmd in cmds:
+            assert "$CLAUDE_TOOL_NAME" not in cmd, (
+                f"Shell injection vector $CLAUDE_TOOL_NAME found in command: {cmd!r}"
+            )
+
+    def test_generated_settings_no_tool_input_var(self, tmp_path: Path) -> None:
+        """End-to-end: the JSON written to disk must not contain the injection vars."""
+        settings_path = tmp_path / "settings.json"
+        ctx_dir = str(tmp_path / "ctx")
+        _run_inject(ctx_dir, settings_path)
+
+        raw = settings_path.read_text(encoding="utf-8")
+        assert "$CLAUDE_TOOL_INPUT" not in raw, (
+            "$CLAUDE_TOOL_INPUT found in written settings.json"
+        )
+        assert "$CLAUDE_TOOL_NAME" not in raw, (
+            "$CLAUDE_TOOL_NAME found in written settings.json"
+        )
+
+    def test_from_stdin_flag_present_in_posttooluse_commands(
+        self, tmp_path: Path
+    ) -> None:
+        """PostToolUse commands that replaced env-var args must use --from-stdin."""
+        ctx_dir = str(tmp_path / "ctx")
+        hooks = make_hooks(ctx_dir)
+        post_tool_entries = hooks.get("PostToolUse", [])
+        assert post_tool_entries, "PostToolUse block must not be empty"
+
+        # context_monitor and skill_add_detector commands must carry --from-stdin
+        sub_hooks = post_tool_entries[0].get("hooks", [])
+        cmds_with_stdin = [
+            h["command"] for h in sub_hooks
+            if isinstance(h, dict) and "--from-stdin" in h.get("command", "")
+        ]
+        assert len(cmds_with_stdin) >= 2, (
+            f"Expected at least 2 --from-stdin commands; found {len(cmds_with_stdin)}: "
+            f"{cmds_with_stdin}"
+        )
+
+    def test_merge_hooks_repairs_partial_posttooluse_matcher(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        new_hooks = make_hooks(str(tmp_path / "ctx"))
+        existing = {
+            "hooks": {
+                "PostToolUse": [
+                    {
+                        "matcher": ".*",
+                        "hooks": [new_hooks["PostToolUse"][0]["hooks"][0]],
+                    },
+                ],
+            },
+        }
+
+        merged = merge_hooks(existing, new_hooks)
+
+        commands = _all_commands({"PostToolUse": merged["hooks"]["PostToolUse"]})
+        assert any("context_monitor" in command for command in commands)
+        assert any("skill_add_detector" in command for command in commands)
+        assert any("bundle_orchestrator" in command for command in commands)
+
+
+# ---------------------------------------------------------------------------
+# Fix 2 — Stop array contains both usage_tracker and quality_on_session_end
+# ---------------------------------------------------------------------------
+
+
+class TestStopHooks:
+    def _stop_commands(self, hooks: dict) -> list[str]:
+        """Flatten both legacy (flat) + current ({"hooks":[...]} matcher)
+        Stop-hook shapes into a list of command strings. The current
+        generator produces the matcher shape (required by Claude Code's
+        schema) but we accept both so legacy settings.json files that
+        still use the flat shape don't make the assertions drift.
+        """
+        out: list[str] = []
+        for entry in hooks.get("Stop", []):
+            if not isinstance(entry, dict):
+                continue
+            if "command" in entry:
+                out.append(entry["command"])
+            for sub in entry.get("hooks", []):
+                if isinstance(sub, dict) and "command" in sub:
+                    out.append(sub["command"])
+        return out
+
+    def test_stop_contains_usage_tracker(self, tmp_path: Path) -> None:
+        ctx_dir = str(tmp_path / "ctx")
+        hooks = make_hooks(ctx_dir)
+        stop_cmds = self._stop_commands(hooks)
+        assert any("-m usage_tracker" in c for c in stop_cmds), (
+            f"usage_tracker module not found in Stop hooks: {stop_cmds}"
+        )
+
+    def test_stop_contains_quality_on_session_end(self, tmp_path: Path) -> None:
+        ctx_dir = str(tmp_path / "ctx")
+        hooks = make_hooks(ctx_dir)
+        stop_cmds = self._stop_commands(hooks)
+        assert any("ctx.adapters.claude_code.hooks.lifecycle_hooks quality-on-session-end" in c for c in stop_cmds), (
+            f"quality hook module not found in Stop hooks: {stop_cmds}"
+        )
+
+    def test_stop_contains_both_in_generated_settings(self, tmp_path: Path) -> None:
+        settings_path = tmp_path / "settings.json"
+        ctx_dir = str(tmp_path / "ctx")
+        _run_inject(ctx_dir, settings_path)
+
+        data = json.loads(settings_path.read_text(encoding="utf-8"))
+        stop_cmds = self._stop_commands(data.get("hooks", {}))
+
+        assert any("-m usage_tracker" in c for c in stop_cmds), (
+            f"usage_tracker module missing from persisted Stop hooks: {stop_cmds}"
+        )
+        assert any("ctx.adapters.claude_code.hooks.lifecycle_hooks quality-on-session-end" in c for c in stop_cmds), (
+            f"quality hook module missing from persisted Stop hooks: {stop_cmds}"
+        )
+
+    def test_stop_hook_count_is_two(self, tmp_path: Path) -> None:
+        """Both Stop hook commands must be present (usage_tracker + quality)."""
+        ctx_dir = str(tmp_path / "ctx")
+        hooks = make_hooks(ctx_dir)
+        stop_cmds = self._stop_commands(hooks)
+        assert len(stop_cmds) == 2, (
+            f"Expected exactly 2 Stop commands; got {len(stop_cmds)}: {stop_cmds}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Fix 3 — shlex.quote protects ctx_dir with special characters
+# ---------------------------------------------------------------------------
+
+
+class TestCtxDirQuoting:
+    def test_path_with_spaces_is_quoted(self, tmp_path: Path) -> None:
+        ctx_dir = str(tmp_path / "my ctx dir")
+        hooks = make_hooks(ctx_dir)
+        cmds = _all_commands(hooks)
+        for cmd in cmds:
+            # If the path contained spaces, the shell command must quote it —
+            # a bare space would split the path across two argv tokens.
+            if "my ctx dir" in cmd:
+                # shlex.quote wraps in single-quotes: 'my ctx dir'
+                assert "my ctx dir" not in cmd or "'" in cmd, (
+                    f"Path with space is not quoted in: {cmd!r}"
+                )
+
+    def test_path_with_dollar_is_safe(self, tmp_path: Path) -> None:
+        """A ctx_dir with a literal $ must be quoted so the shell doesn't expand it."""
+        import shlex as _shlex
+        ctx_dir = "/home/user/$HOME/ctx"
+        hooks = make_hooks(ctx_dir)
+        cmds = _all_commands(hooks)
+        quoted = _shlex.quote(ctx_dir)
+        for cmd in cmds:
+            if ctx_dir in cmd or quoted in cmd:
+                # The raw unquoted path must not appear unless it's the quoted form
+                assert f" {ctx_dir}/" not in cmd, (
+                    f"Unquoted $ path found in: {cmd!r}"
+                )
+
+    def test_windows_python_path_with_spaces_uses_windows_quoting(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setattr(
+            inject_hooks.sys,
+            "executable",
+            r"C:\Program Files\Python311\python.exe",
+        )
+        monkeypatch.setattr(inject_hooks.os, "name", "nt")
+
+        cmd = inject_hooks._module_cmd("usage_tracker", "--sync")
+
+        assert cmd == r'"C:\Program Files\Python311\python.exe" -m usage_tracker --sync'
+        assert "'" not in cmd
+
+
+class TestPackagedHookCommands:
+    def test_commands_use_importable_modules_not_repo_paths(
+        self, tmp_path: Path
+    ) -> None:
+        hooks = make_hooks(str(tmp_path / "ctx"))
+        cmds = _all_commands(hooks)
+
+        assert cmds
+        assert all(".py" not in cmd for cmd in cmds)
+        assert all("/../hooks/" not in cmd and "\\..\\hooks\\" not in cmd for cmd in cmds)
+        assert all(" 2>/dev/null" not in cmd and "|| true" not in cmd for cmd in cmds)
+
+        modules = _all_modules(hooks)
+        assert {
+            "ctx.adapters.claude_code.hooks.context_monitor",
+            "skill_add_detector",
+            "ctx.adapters.claude_code.hooks.bundle_orchestrator",
+            "usage_tracker",
+            "ctx.adapters.claude_code.hooks.lifecycle_hooks",
+        } <= set(modules)
+
+
+# ---------------------------------------------------------------------------
+# Fix 4 — Atomic write: concurrent writes leave valid JSON
+# ---------------------------------------------------------------------------
+
+
+class TestAtomicWrite:
+    def test_single_write_produces_valid_json(self, tmp_path: Path) -> None:
+        settings_path = tmp_path / "settings.json"
+        ctx_dir = str(tmp_path / "ctx")
+        _run_inject(ctx_dir, settings_path)
+        data = json.loads(settings_path.read_text(encoding="utf-8"))
+        assert "hooks" in data
+
+    def test_repeated_writes_leave_valid_json(self, tmp_path: Path) -> None:
+        """Running inject twice (idempotent) must leave a valid, parseable JSON."""
+        settings_path = tmp_path / "settings.json"
+        ctx_dir = str(tmp_path / "ctx")
+        _run_inject(ctx_dir, settings_path)
+        _run_inject(ctx_dir, settings_path)
+
+        data = json.loads(settings_path.read_text(encoding="utf-8"))
+        assert "hooks" in data
+
+    def test_concurrent_writes_leave_valid_json(self, tmp_path: Path) -> None:
+        """Concurrent write_settings_atomic calls must not produce a torn file.
+
+        The fix being tested: write goes to a tempfile then os.replace(), so a
+        reader never sees a partially-written JSON.  We call write_settings_atomic
+        directly (bypassing load_settings) to isolate the write path from the
+        Windows file-lock behaviour on the read side.
+        """
+        from ctx.adapters.claude_code.inject_hooks import write_settings_atomic
+
+        settings_path = tmp_path / "settings.json"
+        payload = {"hooks": {"Stop": [{"type": "command", "command": "python x.py"}]}}
+
+        # Seed the file.
+        write_settings_atomic(settings_path, payload)
+
+        errors: list[Exception] = []
+
+        def _writer() -> None:
+            try:
+                for _ in range(10):
+                    write_settings_atomic(settings_path, payload)
+            except Exception as exc:
+                errors.append(exc)
+
+        t1 = threading.Thread(target=_writer)
+        t2 = threading.Thread(target=_writer)
+        t1.start()
+        t2.start()
+        t1.join()
+        t2.join()
+
+        assert not errors, f"Thread errors during concurrent writes: {errors}"
+
+        # File must still be valid JSON after concurrent writes.
+        raw = settings_path.read_text(encoding="utf-8")
+        data = json.loads(raw)
+        assert "hooks" in data
+
+    def test_write_settings_atomic_cleans_up_on_failure(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """If os.replace() raises, the tempfile is removed and no stale .tmp lingers."""
+        import os as _os
+        from ctx.adapters.claude_code import inject_hooks as _ih
+
+        settings_path = tmp_path / "settings.json"
+
+        call_count = {"n": 0}
+
+        def _failing_replace(src: str, dst: str) -> None:
+            call_count["n"] += 1
+            raise OSError("simulated disk full")
+
+        monkeypatch.setattr(_os, "replace", _failing_replace)
+
+        with pytest.raises(OSError, match="simulated disk full"):
+            _ih.write_settings_atomic(settings_path, {"hooks": {}})
+
+        # No stale .tmp files should remain
+        tmp_files = list(tmp_path.glob("settings.json.*.tmp"))
+        assert not tmp_files, f"Stale tempfiles not cleaned up: {tmp_files}"

src/tests/test_mcp_enrich_render_scalar.py

@@ -1,121 +1,121 @@
-"""
-test_mcp_enrich_render_scalar.py -- pins the YAML-scalar rendering contract.
-
-Security-auditor H-1: ``_render_scalar`` in ``mcp_enrich`` didn't
-escape ``\\n`` / ``\\r`` in string values. The pulsemcp parser
-happens to strip newlines from its regex groups today, but every
-Source protocol implementation (future glama, mcp-get, ...) feeds
-values straight into ``apply_enrichment`` which writes them into
-YAML frontmatter. A multi-line value like
-
-    "https://github.com/a/b\\nstatus: installed\\ninstall_cmd: /tmp/evil"
-
-would inject fake frontmatter keys. Once ``install_cmd`` lands in the
-frontmatter, ``ctx-mcp-install`` on that slug would pick it up on
-reinstall — defense-in-depth mattered (commit b79be55 added an
-executable allowlist that catches most malicious values, but the
-injection vector should be shut at the writer).
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-
-sys.path.insert(0, str(Path(__file__).parents[1]))
-
-import mcp_enrich as _me
-
-
-class TestRenderScalar:
-    def test_none_yields_null(self):
-        assert _me._render_scalar(None) == "null"
-
-    def test_int_unquoted(self):
-        assert _me._render_scalar(42) == "42"
-
-    def test_bare_string_unquoted(self):
-        assert _me._render_scalar("plain-value") == "plain-value"
-
-    def test_colon_in_string_forces_quote(self):
-        out = _me._render_scalar("https://github.com/foo/bar")
-        assert out.startswith('"')
-        assert out.endswith('"')
-
-    def test_embedded_newline_is_escaped_or_stripped(self):
-        """H-1 regression. A newline inside a scalar must NOT survive
-        into the rendered YAML — otherwise it injects fake keys."""
-        out = _me._render_scalar("https://a.example/b\nstatus: installed")
-        # The rendered form must be a single YAML line. Accept either
-        # sanitisation (replace \\n with space) or escape (\\n literal
-        # inside a quoted string) — pin that NEITHER approach leaves a
-        # raw newline in the output.
-        assert "\n" not in out, (
-            f"rendered scalar contains raw newline — YAML injection "
-            f"vector: {out!r}"
-        )
-        # Whatever sanitisation happens, the string must not produce
-        # a ``status: installed`` key at the YAML top level. If the
-        # writer sanitises the newline to a space, the content still
-        # renders but as a single scalar value, not as a separate key.
-        lines = out.splitlines()
-        assert len(lines) == 1
-
-    def test_embedded_carriage_return_is_escaped_or_stripped(self):
-        out = _me._render_scalar("evil\rstatus: installed")
-        assert "\r" not in out
-        assert "\n" not in out
-
-    def test_windows_crlf_is_neutralised(self):
-        """CRLF from a Windows source file must not pass through either."""
-        out = _me._render_scalar("a\r\nstatus: pwned")
-        assert "\r" not in out
-        assert "\n" not in out
-        # And the second "key" must not survive as an actual YAML key
-        # — it must be subsumed into the rendered scalar.
-        assert out.count(":") <= 2, (
-            f"suspicious colon count in {out!r} — possible key injection"
-        )
-
-    def test_null_sentinel_roundtrip_unaffected(self):
-        """Empty string and None distinct rendering preserved — None
-        becomes ``null`` (YAML sentinel), '' stays as empty string."""
-        assert _me._render_scalar(None) == "null"
-        # Empty string hits the isinstance(str) branch but has no
-        # special chars — returns as-is.
-        assert _me._render_scalar("") == ""
-
-    def test_round_trip_through_apply_enrichment(self, tmp_path):
-        """End-to-end: a poisoned enrichment value flows through
-        ``apply_enrichment`` and the resulting file must NOT have
-        a fake ``status`` or ``install_cmd`` key inserted."""
-        entity = tmp_path / "e.md"
-        entity.write_text(
-            "---\n"
-            "slug: sample\n"
-            "github_url: null\n"
-            "updated: '2026-01-01'\n"
-            "---\n# sample\nbody\n",
-            encoding="utf-8",
-        )
-        # A Source that returned a multi-line URL injection attempt.
-        poisoned = {
-            "github_url": "https://evil.example/x\nstatus: installed",
-        }
-        _me.apply_enrichment(entity, poisoned, dry_run=False)
-        text = entity.read_text(encoding="utf-8")
-        # Count the number of top-level ``status:`` keys in the
-        # frontmatter. Zero expected — the poisoned newline must not
-        # have injected one.
-        fm = text.split("---", 2)[1]
-        status_keys = [
-            line for line in fm.splitlines()
-            if line.lstrip().startswith("status:")
-            # Must be at column 0 (not inside a quoted scalar).
-            and not line.startswith(" ")
-        ]
-        assert len(status_keys) == 0, (
-            f"YAML injection via newline succeeded — found status keys: "
-            f"{status_keys!r}\nFull frontmatter:\n{fm}"
-        )
+"""
+test_mcp_enrich_render_scalar.py -- pins the YAML-scalar rendering contract.
+
+Security-auditor H-1: ``_render_scalar`` in ``mcp_enrich`` didn't
+escape ``\\n`` / ``\\r`` in string values. The pulsemcp parser
+happens to strip newlines from its regex groups today, but every
+Source protocol implementation (future glama, mcp-get, ...) feeds
+values straight into ``apply_enrichment`` which writes them into
+YAML frontmatter. A multi-line value like
+
+    "https://github.com/a/b\\nstatus: installed\\ninstall_cmd: /tmp/evil"
+
+would inject fake frontmatter keys. Once ``install_cmd`` lands in the
+frontmatter, ``ctx-mcp-install`` on that slug would pick it up on
+reinstall — defense-in-depth mattered (commit b79be55 added an
+executable allowlist that catches most malicious values, but the
+injection vector should be shut at the writer).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).parents[1]))
+
+import mcp_enrich as _me
+
+
+class TestRenderScalar:
+    def test_none_yields_null(self):
+        assert _me._render_scalar(None) == "null"
+
+    def test_int_unquoted(self):
+        assert _me._render_scalar(42) == "42"
+
+    def test_bare_string_unquoted(self):
+        assert _me._render_scalar("plain-value") == "plain-value"
+
+    def test_colon_in_string_forces_quote(self):
+        out = _me._render_scalar("https://github.com/foo/bar")
+        assert out.startswith('"')
+        assert out.endswith('"')
+
+    def test_embedded_newline_is_escaped_or_stripped(self):
+        """H-1 regression. A newline inside a scalar must NOT survive
+        into the rendered YAML — otherwise it injects fake keys."""
+        out = _me._render_scalar("https://a.example/b\nstatus: installed")
+        # The rendered form must be a single YAML line. Accept either
+        # sanitisation (replace \\n with space) or escape (\\n literal
+        # inside a quoted string) — pin that NEITHER approach leaves a
+        # raw newline in the output.
+        assert "\n" not in out, (
+            f"rendered scalar contains raw newline — YAML injection "
+            f"vector: {out!r}"
+        )
+        # Whatever sanitisation happens, the string must not produce
+        # a ``status: installed`` key at the YAML top level. If the
+        # writer sanitises the newline to a space, the content still
+        # renders but as a single scalar value, not as a separate key.
+        lines = out.splitlines()
+        assert len(lines) == 1
+
+    def test_embedded_carriage_return_is_escaped_or_stripped(self):
+        out = _me._render_scalar("evil\rstatus: installed")
+        assert "\r" not in out
+        assert "\n" not in out
+
+    def test_windows_crlf_is_neutralised(self):
+        """CRLF from a Windows source file must not pass through either."""
+        out = _me._render_scalar("a\r\nstatus: pwned")
+        assert "\r" not in out
+        assert "\n" not in out
+        # And the second "key" must not survive as an actual YAML key
+        # — it must be subsumed into the rendered scalar.
+        assert out.count(":") <= 2, (
+            f"suspicious colon count in {out!r} — possible key injection"
+        )
+
+    def test_null_sentinel_roundtrip_unaffected(self):
+        """Empty string and None distinct rendering preserved — None
+        becomes ``null`` (YAML sentinel), '' stays as empty string."""
+        assert _me._render_scalar(None) == "null"
+        # Empty string hits the isinstance(str) branch but has no
+        # special chars — returns as-is.
+        assert _me._render_scalar("") == ""
+
+    def test_round_trip_through_apply_enrichment(self, tmp_path):
+        """End-to-end: a poisoned enrichment value flows through
+        ``apply_enrichment`` and the resulting file must NOT have
+        a fake ``status`` or ``install_cmd`` key inserted."""
+        entity = tmp_path / "e.md"
+        entity.write_text(
+            "---\n"
+            "slug: sample\n"
+            "github_url: null\n"
+            "updated: '2026-01-01'\n"
+            "---\n# sample\nbody\n",
+            encoding="utf-8",
+        )
+        # A Source that returned a multi-line URL injection attempt.
+        poisoned = {
+            "github_url": "https://evil.example/x\nstatus: installed",
+        }
+        _me.apply_enrichment(entity, poisoned, dry_run=False)
+        text = entity.read_text(encoding="utf-8")
+        # Count the number of top-level ``status:`` keys in the
+        # frontmatter. Zero expected — the poisoned newline must not
+        # have injected one.
+        fm = text.split("---", 2)[1]
+        status_keys = [
+            line for line in fm.splitlines()
+            if line.lstrip().startswith("status:")
+            # Must be at column 0 (not inside a quoted scalar).
+            and not line.startswith(" ")
+        ]
+        assert len(status_keys) == 0, (
+            f"YAML injection via newline succeeded — found status keys: "
+            f"{status_keys!r}\nFull frontmatter:\n{fm}"
+        )

src/tests/test_mcp_router.py

@@ -1,423 +1,423 @@
-"""
-test_mcp_router.py -- McpClient + McpRouter tests against a real subprocess.
-
-These tests spawn the fake MCP server in src/tests/fixtures/fake_mcp_server.py
-as an actual subprocess and round-trip real JSON-RPC frames. That is
-slower than mocking stdio, but the whole POINT of the router is to
-talk JSON-RPC to a real child — mocking the subprocess surface would
-verify nothing load-bearing. Each test starts + stops its own server,
-so there's no cross-test state.
-"""
-
-from __future__ import annotations
-
-import sys
-import time
-from pathlib import Path
-
-import pytest
-
-from ctx.adapters.generic.tools import (
-    McpClient,
-    McpRouter,
-    McpServerConfig,
-    McpServerError,
-    mcp_router,
-    running_router,
-)
-
-
-_FIXTURE = Path(__file__).parent / "fixtures" / "fake_mcp_server.py"
-
-
-def _make_config(
-    name: str = "fake",
-    *,
-    extra_env: dict[str, str] | None = None,
-    credential_env: tuple[str, ...] = (),
-    startup_timeout: float = 5.0,
-    request_timeout: float = 5.0,
-    inherit_env: bool = False,
-) -> McpServerConfig:
-    """Return a config that launches the fake server via the test Python."""
-    return McpServerConfig(
-        name=name,
-        command=sys.executable,
-        args=(str(_FIXTURE),),
-        env=dict(extra_env or {}),
-        credential_env=credential_env,
-        startup_timeout=startup_timeout,
-        request_timeout=request_timeout,
-        inherit_env=inherit_env,
-    )
-
-
-# ── McpClient basics ─────────────────────────────────────────────────────────
-
-
-class TestClientLifecycle:
-    def test_start_and_stop(self) -> None:
-        client = McpClient(_make_config())
-        client.start()
-        try:
-            # Trivial health: list_tools succeeds → handshake completed.
-            tools = client.list_tools()
-            assert len(tools) >= 2  # echo + add
-        finally:
-            client.stop()
-
-    def test_context_manager(self) -> None:
-        with McpClient(_make_config()) as client:
-            tools = client.list_tools()
-            names = {t.name for t in tools}
-            assert {"echo", "add"} <= names
-
-    def test_double_start_rejected(self) -> None:
-        client = McpClient(_make_config())
-        client.start()
-        try:
-            with pytest.raises(RuntimeError, match="already started"):
-                client.start()
-        finally:
-            client.stop()
-
-    def test_stop_before_start_is_noop(self) -> None:
-        client = McpClient(_make_config())
-        client.stop()  # must not raise
-
-    def test_bare_command_resolved_through_path(
-        self,
-        tmp_path: Path,
-        monkeypatch: pytest.MonkeyPatch,
-    ) -> None:
-        resolved = tmp_path / ("npx.cmd" if sys.platform == "win32" else "npx")
-        resolved.write_text("", encoding="utf-8")
-        monkeypatch.setattr(
-            mcp_router.shutil,
-            "which",
-            lambda command, path=None: str(resolved) if command == "npx" else None,
-        )
-
-        assert mcp_router._resolve_executable("npx", {"PATH": str(tmp_path)}) == str(resolved)
-
-    def test_idempotent_stop(self) -> None:
-        client = McpClient(_make_config())
-        client.start()
-        client.stop()
-        client.stop()  # second call is a no-op
-
-
-class TestClientToolOperations:
-    def test_list_tools_shape(self) -> None:
-        with McpClient(_make_config()) as client:
-            tools = client.list_tools()
-            echo = next(t for t in tools if t.name == "echo")
-            assert echo.description == "Echo the input text verbatim."
-            assert echo.parameters["required"] == ["text"]
-
-    def test_list_tools_cached(self) -> None:
-        """Second call must not fire a fresh tools/list RPC."""
-        with McpClient(_make_config()) as client:
-            first = client.list_tools()
-            second = client.list_tools()
-            assert first == second
-            # Cache check: same object identity on the list elements
-            assert first[0] is second[0]
-
-    def test_call_echo_round_trip(self) -> None:
-        with McpClient(_make_config()) as client:
-            result = client.call_tool("echo", {"text": "hello, world"})
-            assert result == "hello, world"
-
-    def test_call_add_integer_args(self) -> None:
-        with McpClient(_make_config()) as client:
-            result = client.call_tool("add", {"a": 3, "b": 4})
-            assert result == "7"
-
-    def test_call_unknown_tool_raises(self) -> None:
-        with McpClient(_make_config()) as client:
-            with pytest.raises(McpServerError, match="code=-32601"):
-                client.call_tool("nope", {})
-
-    def test_tool_reports_error(self) -> None:
-        with McpClient(_make_config(extra_env={"FAKE_MCP_TOOL_ERROR": "1"})) as c:
-            with pytest.raises(McpServerError, match="isError"):
-                c.call_tool("echo", {"text": "x"})
-
-
-class TestClientRobustness:
-    def test_init_failure_surfaces_and_reaps_child(self) -> None:
-        """When initialize errors, start() must clean up — no zombie child."""
-        client = McpClient(_make_config(extra_env={"FAKE_MCP_FAIL_INIT": "1"}))
-        with pytest.raises(McpServerError, match="init-forbidden"):
-            client.start()
-        # After failed start, _proc is reset to None so a follow-up stop()
-        # is a safe no-op and no resource leaks.
-        client.stop()
-
-    def test_server_crash_during_call(self) -> None:
-        secret = "GITHUB_TOKEN=ghp_supersecret123456789"
-        cfg = _make_config(
-            extra_env={
-                "FAKE_MCP_CRASH_ON_TOOL": "1",
-                "FAKE_MCP_STDERR_LINE": secret,
-            }
-        )
-        with McpClient(cfg) as c:
-            with pytest.raises(McpServerError, match="pipe closed") as excinfo:
-                c.call_tool("echo", {"text": "x"})
-        message = str(excinfo.value)
-        assert "ghp_supersecret" not in message
-        assert "[REDACTED]" in message
-
-    def test_killed_child_after_tool_listing_raises_mcp_error(self) -> None:
-        client = McpClient(_make_config())
-        client.start()
-        try:
-            client.list_tools()
-            proc = client._proc
-            assert proc is not None
-            proc.kill()
-            proc.wait(timeout=2.0)
-
-            with pytest.raises(McpServerError, match="write failed"):
-                client.call_tool("echo", {"text": "x"})
-        finally:
-            client.stop()
-
-    def test_server_notification_is_skipped(self) -> None:
-        """The client ignores notifications that interleave with a response."""
-        cfg = _make_config(extra_env={"FAKE_MCP_EMIT_NOTIFICATION": "1"})
-        with McpClient(cfg) as client:
-            result = client.call_tool("echo", {"text": "hi"})
-            assert result == "hi"
-
-    def test_stderr_captured_on_startup(self) -> None:
-        cfg = _make_config(extra_env={"FAKE_MCP_NOISY_STDERR": "1"})
-        with McpClient(cfg) as client:
-            client.list_tools()  # let the server run
-        # Can't poke at internal state much — just confirm no hang.
-        # The drain thread is a daemon; if it deadlocked the pipe,
-        # list_tools above would have timed out.
-
-    def test_request_before_start_raises(self) -> None:
-        client = McpClient(_make_config())
-        with pytest.raises(RuntimeError, match="not started"):
-            client.list_tools()
-
-    def test_request_timeout_when_server_stays_silent(self) -> None:
-        cfg = _make_config(
-            extra_env={"FAKE_MCP_IGNORE_TOOL": "1"},
-            request_timeout=0.2,
-        )
-        with McpClient(cfg) as client:
-            started = time.monotonic()
-            with pytest.raises(McpServerError, match="timed out after 0.2s"):
-                client.call_tool("echo", {"text": "x"})
-            assert time.monotonic() - started < 1.5
-
-    def test_parent_env_is_not_inherited_by_default(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.setenv("CTX_SECRET_SHOULD_NOT_LEAK", "leaked")
-        with McpClient(_make_config()) as client:
-            assert client.call_tool(
-                "echo_env", {"name": "CTX_SECRET_SHOULD_NOT_LEAK"}
-            ) == ""
-        with McpClient(
-            _make_config(credential_env=("CTX_SECRET_SHOULD_NOT_LEAK",))
-        ) as client:
-            assert client.call_tool(
-                "echo_env", {"name": "CTX_SECRET_SHOULD_NOT_LEAK"}
-            ) == "leaked"
-
-    def test_explicit_env_overlay_is_passed(self) -> None:
-        cfg = _make_config(extra_env={"CTX_ALLOWED_FOR_TEST": "visible"})
-        with McpClient(cfg) as client:
-            assert client.call_tool(
-                "echo_env", {"name": "CTX_ALLOWED_FOR_TEST"}
-            ) == "visible"
-
-    def test_full_env_inheritance_requires_opt_in(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
-        monkeypatch.setenv("CTX_LEGACY_INHERIT_TEST", "visible")
-        with McpClient(_make_config(inherit_env=True)) as client:
-            assert client.call_tool(
-                "echo_env", {"name": "CTX_LEGACY_INHERIT_TEST"}
-            ) == "visible"
-
-
-# ── McpRouter ─────────────────────────────────────────────────────────────────
-
-
-class TestRouter:
-    def test_single_server(self) -> None:
-        with running_router([_make_config("fake")]) as router:
-            tools = router.list_tools()
-            names = {t.name for t in tools}
-            assert {"fake__echo", "fake__add"} <= names
-
-    def test_namespaced_call(self) -> None:
-        with running_router([_make_config("fake")]) as router:
-            result = router.call("fake__echo", {"text": "round-trip"})
-            assert result == "round-trip"
-
-    def test_multi_server_union(self) -> None:
-        cfgs = [
-            _make_config("a"),
-            _make_config("b", extra_env={"FAKE_MCP_EXTRA_TOOL": "special"}),
-        ]
-        with running_router(cfgs) as router:
-            tools = router.list_tools()
-            names = {t.name for t in tools}
-            assert "a__echo" in names
-            assert "a__add" in names
-            assert "b__echo" in names
-            assert "b__special" in names
-
-    def test_multi_server_routing(self) -> None:
-        """Each server must get the call meant for it, and only it."""
-        cfgs = [_make_config("a"), _make_config("b")]
-        with running_router(cfgs) as router:
-            a_result = router.call("a__echo", {"text": "from-a"})
-            b_result = router.call("b__echo", {"text": "from-b"})
-            assert a_result == "from-a"
-            assert b_result == "from-b"
-
-    def test_unknown_server(self) -> None:
-        with running_router([_make_config("fake")]) as router:
-            with pytest.raises(ValueError, match="unknown MCP server"):
-                router.call("ghost__echo", {})
-
-    def test_malformed_qualified_name(self) -> None:
-        with running_router([_make_config("fake")]) as router:
-            with pytest.raises(ValueError, match="expected"):
-                router.call("no_separator_here", {})
-
-    def test_duplicate_server_name_rejected(self) -> None:
-        router = McpRouter([_make_config("dup"), _make_config("dup")])
-        with pytest.raises(ValueError, match="duplicate MCP server"):
-            router.start()
-        # Atomic rollback — the first (already-started) server must be
-        # reaped so we don't leak child processes.
-        assert router.server_names == []
-
-    def test_server_name_cannot_contain_router_separator(self) -> None:
-        with pytest.raises(ValueError, match="may not contain"):
-            McpServerConfig(name="foo__bar", command=sys.executable)
-        with pytest.raises(ValueError, match="reserved"):
-            McpServerConfig(name="ctx", command=sys.executable)
-        with running_router(
-            [_make_config("fake", extra_env={"FAKE_MCP_EXTRA_TOOL": "echo"})]
-        ) as router:
-            with pytest.raises(ValueError, match="duplicate MCP tool name"):
-                router.list_tools()
-
-    def test_stopped_router_rejects_calls(self) -> None:
-        router = McpRouter([_make_config("fake")])
-        with pytest.raises(RuntimeError, match="not started"):
-            router.list_tools()
-        with pytest.raises(RuntimeError, match="not started"):
-            router.call("fake__echo", {})
-
-    def test_double_start_is_idempotent(self) -> None:
-        router = McpRouter([_make_config("fake")])
-        router.start()
-        try:
-            router.start()  # must not spawn a second server
-            assert router.server_names == ["fake"]
-        finally:
-            router.stop()
-
-    def test_tool_descriptions_unchanged_by_namespacing(self) -> None:
-        """The server prefix goes on the NAME only — descriptions stay clean."""
-        with running_router([_make_config("fake")]) as router:
-            tools = router.list_tools()
-            echo = next(t for t in tools if t.name == "fake__echo")
-            # Description is the server-local one, no "fake__" prefix.
-            assert echo.description == "Echo the input text verbatim."
-
-    def test_server_names_sorted(self) -> None:
-        cfgs = [_make_config("beta"), _make_config("alpha"), _make_config("gamma")]
-        with running_router(cfgs) as router:
-            assert router.server_names == ["alpha", "beta", "gamma"]
-
-    def test_atomic_startup_on_second_config_failure(self) -> None:
-        """If one server fails to start, already-spawned ones must be reaped."""
-        cfgs = [
-            _make_config("ok"),
-            _make_config("bad", extra_env={"FAKE_MCP_FAIL_INIT": "1"}),
-        ]
-        router = McpRouter(cfgs)
-        with pytest.raises(McpServerError):
-            router.start()
-        assert router.server_names == []
-
-
-# ── _flatten_content ────────────────────────────────────────────────────────
-
-
-class TestFlattenContent:
-    def test_empty(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        assert _flatten_content([]) == ""
-        assert _flatten_content(None) == ""
-
-    def test_single_text(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        assert _flatten_content([{"type": "text", "text": "hi"}]) == "hi"
-
-    def test_multi_text_concatenated(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        assert _flatten_content(
-            [
-                {"type": "text", "text": "a"},
-                {"type": "text", "text": "b"},
-                {"type": "text", "text": "c"},
-            ]
-        ) == "abc"
-
-    def test_image_block_summarised(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        out = _flatten_content([{"type": "image", "mimeType": "image/png"}])
-        assert "[image/png image omitted]" in out
-
-    def test_resource_block_summarised(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        out = _flatten_content([
-            {"type": "resource", "resource": {"uri": "file:///x.md"}}
-        ])
-        assert "[resource: file:///x.md]" in out
-
-    def test_unknown_type(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        out = _flatten_content([{"type": "fancy", "blob": "opaque"}])
-        assert "[fancy block omitted]" in out
-
-    def test_non_dict_block(self) -> None:
-        from ctx.adapters.generic.tools.mcp_router import _flatten_content
-
-        assert _flatten_content(["just a string"]) == "just a string"
-
-
-# ── Config dataclass ────────────────────────────────────────────────────────
-
-
-class TestConfig:
-    def test_frozen(self) -> None:
-        cfg = _make_config("x")
-        with pytest.raises(Exception):  # FrozenInstanceError
-            cfg.name = "y"  # type: ignore[misc]
-
-    def test_default_env_is_fresh_dict_per_instance(self) -> None:
-        a = McpServerConfig(name="a", command="python")
-        b = McpServerConfig(name="b", command="python")
-        # dataclass field(default_factory=dict) must not share state.
-        assert a.env is not b.env
+"""
+test_mcp_router.py -- McpClient + McpRouter tests against a real subprocess.
+
+These tests spawn the fake MCP server in src/tests/fixtures/fake_mcp_server.py
+as an actual subprocess and round-trip real JSON-RPC frames. That is
+slower than mocking stdio, but the whole POINT of the router is to
+talk JSON-RPC to a real child — mocking the subprocess surface would
+verify nothing load-bearing. Each test starts + stops its own server,
+so there's no cross-test state.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+from ctx.adapters.generic.tools import (
+    McpClient,
+    McpRouter,
+    McpServerConfig,
+    McpServerError,
+    mcp_router,
+    running_router,
+)
+
+
+_FIXTURE = Path(__file__).parent / "fixtures" / "fake_mcp_server.py"
+
+
+def _make_config(
+    name: str = "fake",
+    *,
+    extra_env: dict[str, str] | None = None,
+    credential_env: tuple[str, ...] = (),
+    startup_timeout: float = 5.0,
+    request_timeout: float = 5.0,
+    inherit_env: bool = False,
+) -> McpServerConfig:
+    """Return a config that launches the fake server via the test Python."""
+    return McpServerConfig(
+        name=name,
+        command=sys.executable,
+        args=(str(_FIXTURE),),
+        env=dict(extra_env or {}),
+        credential_env=credential_env,
+        startup_timeout=startup_timeout,
+        request_timeout=request_timeout,
+        inherit_env=inherit_env,
+    )
+
+
+# ── McpClient basics ─────────────────────────────────────────────────────────
+
+
+class TestClientLifecycle:
+    def test_start_and_stop(self) -> None:
+        client = McpClient(_make_config())
+        client.start()
+        try:
+            # Trivial health: list_tools succeeds → handshake completed.
+            tools = client.list_tools()
+            assert len(tools) >= 2  # echo + add
+        finally:
+            client.stop()
+
+    def test_context_manager(self) -> None:
+        with McpClient(_make_config()) as client:
+            tools = client.list_tools()
+            names = {t.name for t in tools}
+            assert {"echo", "add"} <= names
+
+    def test_double_start_rejected(self) -> None:
+        client = McpClient(_make_config())
+        client.start()
+        try:
+            with pytest.raises(RuntimeError, match="already started"):
+                client.start()
+        finally:
+            client.stop()
+
+    def test_stop_before_start_is_noop(self) -> None:
+        client = McpClient(_make_config())
+        client.stop()  # must not raise
+
+    def test_bare_command_resolved_through_path(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        resolved = tmp_path / ("npx.cmd" if sys.platform == "win32" else "npx")
+        resolved.write_text("", encoding="utf-8")
+        monkeypatch.setattr(
+            mcp_router.shutil,
+            "which",
+            lambda command, path=None: str(resolved) if command == "npx" else None,
+        )
+
+        assert mcp_router._resolve_executable("npx", {"PATH": str(tmp_path)}) == str(resolved)
+
+    def test_idempotent_stop(self) -> None:
+        client = McpClient(_make_config())
+        client.start()
+        client.stop()
+        client.stop()  # second call is a no-op
+
+
+class TestClientToolOperations:
+    def test_list_tools_shape(self) -> None:
+        with McpClient(_make_config()) as client:
+            tools = client.list_tools()
+            echo = next(t for t in tools if t.name == "echo")
+            assert echo.description == "Echo the input text verbatim."
+            assert echo.parameters["required"] == ["text"]
+
+    def test_list_tools_cached(self) -> None:
+        """Second call must not fire a fresh tools/list RPC."""
+        with McpClient(_make_config()) as client:
+            first = client.list_tools()
+            second = client.list_tools()
+            assert first == second
+            # Cache check: same object identity on the list elements
+            assert first[0] is second[0]
+
+    def test_call_echo_round_trip(self) -> None:
+        with McpClient(_make_config()) as client:
+            result = client.call_tool("echo", {"text": "hello, world"})
+            assert result == "hello, world"
+
+    def test_call_add_integer_args(self) -> None:
+        with McpClient(_make_config()) as client:
+            result = client.call_tool("add", {"a": 3, "b": 4})
+            assert result == "7"
+
+    def test_call_unknown_tool_raises(self) -> None:
+        with McpClient(_make_config()) as client:
+            with pytest.raises(McpServerError, match="code=-32601"):
+                client.call_tool("nope", {})
+
+    def test_tool_reports_error(self) -> None:
+        with McpClient(_make_config(extra_env={"FAKE_MCP_TOOL_ERROR": "1"})) as c:
+            with pytest.raises(McpServerError, match="isError"):
+                c.call_tool("echo", {"text": "x"})
+
+
+class TestClientRobustness:
+    def test_init_failure_surfaces_and_reaps_child(self) -> None:
+        """When initialize errors, start() must clean up — no zombie child."""
+        client = McpClient(_make_config(extra_env={"FAKE_MCP_FAIL_INIT": "1"}))
+        with pytest.raises(McpServerError, match="init-forbidden"):
+            client.start()
+        # After failed start, _proc is reset to None so a follow-up stop()
+        # is a safe no-op and no resource leaks.
+        client.stop()
+
+    def test_server_crash_during_call(self) -> None:
+        secret = "GITHUB_TOKEN=ghp_supersecret123456789"
+        cfg = _make_config(
+            extra_env={
+                "FAKE_MCP_CRASH_ON_TOOL": "1",
+                "FAKE_MCP_STDERR_LINE": secret,
+            }
+        )
+        with McpClient(cfg) as c:
+            with pytest.raises(McpServerError, match="pipe closed") as excinfo:
+                c.call_tool("echo", {"text": "x"})
+        message = str(excinfo.value)
+        assert "ghp_supersecret" not in message
+        assert "[REDACTED]" in message
+
+    def test_killed_child_after_tool_listing_raises_mcp_error(self) -> None:
+        client = McpClient(_make_config())
+        client.start()
+        try:
+            client.list_tools()
+            proc = client._proc
+            assert proc is not None
+            proc.kill()
+            proc.wait(timeout=2.0)
+
+            with pytest.raises(McpServerError, match="write failed"):
+                client.call_tool("echo", {"text": "x"})
+        finally:
+            client.stop()
+
+    def test_server_notification_is_skipped(self) -> None:
+        """The client ignores notifications that interleave with a response."""
+        cfg = _make_config(extra_env={"FAKE_MCP_EMIT_NOTIFICATION": "1"})
+        with McpClient(cfg) as client:
+            result = client.call_tool("echo", {"text": "hi"})
+            assert result == "hi"
+
+    def test_stderr_captured_on_startup(self) -> None:
+        cfg = _make_config(extra_env={"FAKE_MCP_NOISY_STDERR": "1"})
+        with McpClient(cfg) as client:
+            client.list_tools()  # let the server run
+        # Can't poke at internal state much — just confirm no hang.
+        # The drain thread is a daemon; if it deadlocked the pipe,
+        # list_tools above would have timed out.
+
+    def test_request_before_start_raises(self) -> None:
+        client = McpClient(_make_config())
+        with pytest.raises(RuntimeError, match="not started"):
+            client.list_tools()
+
+    def test_request_timeout_when_server_stays_silent(self) -> None:
+        cfg = _make_config(
+            extra_env={"FAKE_MCP_IGNORE_TOOL": "1"},
+            request_timeout=0.2,
+        )
+        with McpClient(cfg) as client:
+            started = time.monotonic()
+            with pytest.raises(McpServerError, match="timed out after 0.2s"):
+                client.call_tool("echo", {"text": "x"})
+            assert time.monotonic() - started < 1.5
+
+    def test_parent_env_is_not_inherited_by_default(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("CTX_SECRET_SHOULD_NOT_LEAK", "leaked")
+        with McpClient(_make_config()) as client:
+            assert client.call_tool(
+                "echo_env", {"name": "CTX_SECRET_SHOULD_NOT_LEAK"}
+            ) == ""
+        with McpClient(
+            _make_config(credential_env=("CTX_SECRET_SHOULD_NOT_LEAK",))
+        ) as client:
+            assert client.call_tool(
+                "echo_env", {"name": "CTX_SECRET_SHOULD_NOT_LEAK"}
+            ) == "leaked"
+
+    def test_explicit_env_overlay_is_passed(self) -> None:
+        cfg = _make_config(extra_env={"CTX_ALLOWED_FOR_TEST": "visible"})
+        with McpClient(cfg) as client:
+            assert client.call_tool(
+                "echo_env", {"name": "CTX_ALLOWED_FOR_TEST"}
+            ) == "visible"
+
+    def test_full_env_inheritance_requires_opt_in(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("CTX_LEGACY_INHERIT_TEST", "visible")
+        with McpClient(_make_config(inherit_env=True)) as client:
+            assert client.call_tool(
+                "echo_env", {"name": "CTX_LEGACY_INHERIT_TEST"}
+            ) == "visible"
+
+
+# ── McpRouter ─────────────────────────────────────────────────────────────────
+
+
+class TestRouter:
+    def test_single_server(self) -> None:
+        with running_router([_make_config("fake")]) as router:
+            tools = router.list_tools()
+            names = {t.name for t in tools}
+            assert {"fake__echo", "fake__add"} <= names
+
+    def test_namespaced_call(self) -> None:
+        with running_router([_make_config("fake")]) as router:
+            result = router.call("fake__echo", {"text": "round-trip"})
+            assert result == "round-trip"
+
+    def test_multi_server_union(self) -> None:
+        cfgs = [
+            _make_config("a"),
+            _make_config("b", extra_env={"FAKE_MCP_EXTRA_TOOL": "special"}),
+        ]
+        with running_router(cfgs) as router:
+            tools = router.list_tools()
+            names = {t.name for t in tools}
+            assert "a__echo" in names
+            assert "a__add" in names
+            assert "b__echo" in names
+            assert "b__special" in names
+
+    def test_multi_server_routing(self) -> None:
+        """Each server must get the call meant for it, and only it."""
+        cfgs = [_make_config("a"), _make_config("b")]
+        with running_router(cfgs) as router:
+            a_result = router.call("a__echo", {"text": "from-a"})
+            b_result = router.call("b__echo", {"text": "from-b"})
+            assert a_result == "from-a"
+            assert b_result == "from-b"
+
+    def test_unknown_server(self) -> None:
+        with running_router([_make_config("fake")]) as router:
+            with pytest.raises(ValueError, match="unknown MCP server"):
+                router.call("ghost__echo", {})
+
+    def test_malformed_qualified_name(self) -> None:
+        with running_router([_make_config("fake")]) as router:
+            with pytest.raises(ValueError, match="expected"):
+                router.call("no_separator_here", {})
+
+    def test_duplicate_server_name_rejected(self) -> None:
+        router = McpRouter([_make_config("dup"), _make_config("dup")])
+        with pytest.raises(ValueError, match="duplicate MCP server"):
+            router.start()
+        # Atomic rollback — the first (already-started) server must be
+        # reaped so we don't leak child processes.
+        assert router.server_names == []
+
+    def test_server_name_cannot_contain_router_separator(self) -> None:
+        with pytest.raises(ValueError, match="may not contain"):
+            McpServerConfig(name="foo__bar", command=sys.executable)
+        with pytest.raises(ValueError, match="reserved"):
+            McpServerConfig(name="ctx", command=sys.executable)
+        with running_router(
+            [_make_config("fake", extra_env={"FAKE_MCP_EXTRA_TOOL": "echo"})]
+        ) as router:
+            with pytest.raises(ValueError, match="duplicate MCP tool name"):
+                router.list_tools()
+
+    def test_stopped_router_rejects_calls(self) -> None:
+        router = McpRouter([_make_config("fake")])
+        with pytest.raises(RuntimeError, match="not started"):
+            router.list_tools()
+        with pytest.raises(RuntimeError, match="not started"):
+            router.call("fake__echo", {})
+
+    def test_double_start_is_idempotent(self) -> None:
+        router = McpRouter([_make_config("fake")])
+        router.start()
+        try:
+            router.start()  # must not spawn a second server
+            assert router.server_names == ["fake"]
+        finally:
+            router.stop()
+
+    def test_tool_descriptions_unchanged_by_namespacing(self) -> None:
+        """The server prefix goes on the NAME only — descriptions stay clean."""
+        with running_router([_make_config("fake")]) as router:
+            tools = router.list_tools()
+            echo = next(t for t in tools if t.name == "fake__echo")
+            # Description is the server-local one, no "fake__" prefix.
+            assert echo.description == "Echo the input text verbatim."
+
+    def test_server_names_sorted(self) -> None:
+        cfgs = [_make_config("beta"), _make_config("alpha"), _make_config("gamma")]
+        with running_router(cfgs) as router:
+            assert router.server_names == ["alpha", "beta", "gamma"]
+
+    def test_atomic_startup_on_second_config_failure(self) -> None:
+        """If one server fails to start, already-spawned ones must be reaped."""
+        cfgs = [
+            _make_config("ok"),
+            _make_config("bad", extra_env={"FAKE_MCP_FAIL_INIT": "1"}),
+        ]
+        router = McpRouter(cfgs)
+        with pytest.raises(McpServerError):
+            router.start()
+        assert router.server_names == []
+
+
+# ── _flatten_content ────────────────────────────────────────────────────────
+
+
+class TestFlattenContent:
+    def test_empty(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        assert _flatten_content([]) == ""
+        assert _flatten_content(None) == ""
+
+    def test_single_text(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        assert _flatten_content([{"type": "text", "text": "hi"}]) == "hi"
+
+    def test_multi_text_concatenated(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        assert _flatten_content(
+            [
+                {"type": "text", "text": "a"},
+                {"type": "text", "text": "b"},
+                {"type": "text", "text": "c"},
+            ]
+        ) == "abc"
+
+    def test_image_block_summarised(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        out = _flatten_content([{"type": "image", "mimeType": "image/png"}])
+        assert "[image/png image omitted]" in out
+
+    def test_resource_block_summarised(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        out = _flatten_content([
+            {"type": "resource", "resource": {"uri": "file:///x.md"}}
+        ])
+        assert "[resource: file:///x.md]" in out
+
+    def test_unknown_type(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        out = _flatten_content([{"type": "fancy", "blob": "opaque"}])
+        assert "[fancy block omitted]" in out
+
+    def test_non_dict_block(self) -> None:
+        from ctx.adapters.generic.tools.mcp_router import _flatten_content
+
+        assert _flatten_content(["just a string"]) == "just a string"
+
+
+# ── Config dataclass ────────────────────────────────────────────────────────
+
+
+class TestConfig:
+    def test_frozen(self) -> None:
+        cfg = _make_config("x")
+        with pytest.raises(Exception):  # FrozenInstanceError
+            cfg.name = "y"  # type: ignore[misc]
+
+    def test_default_env_is_fresh_dict_per_instance(self) -> None:
+        a = McpServerConfig(name="a", command="python")
+        b = McpServerConfig(name="b", command="python")
+        # dataclass field(default_factory=dict) must not share state.
+        assert a.env is not b.env

src/tests/test_mcp_sources_awesome.py

@@ -1,169 +1,169 @@
-"""
-tests/test_mcp_sources_awesome.py -- Unit tests for mcp_sources.awesome_mcp.
-
-Contracts tested (Phase 2a locked spec):
-  - _parse_readme(text) -> list[dict]   (pure function, no network)
-  - Each dict has name, description, sources=["awesome-mcp"]
-  - GitHub links extracted to github_url
-  - Non-github links extracted to homepage_url
-  - Section headers produce tag entries
-  - Malformed lines skipped gracefully
-  - Parsed dicts round-trip through McpRecord.from_dict()
-  - SOURCE singleton has expected name / homepage attributes
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-import pytest
-
-SRC_DIR = Path(__file__).resolve().parents[1]
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
-
-_FIXTURE_PATH = Path(__file__).parent / "fixtures" / "awesome_mcp_excerpt.md"
-
-from mcp_sources.awesome_mcp import SOURCE, _parse_readme  # type: ignore[import-untyped]  # noqa: E402
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _excerpt() -> str:
-    return _FIXTURE_PATH.read_text(encoding="utf-8")
-
-
-# ---------------------------------------------------------------------------
-# _parse_readme — edge cases
-# ---------------------------------------------------------------------------
-
-
-class TestParseReadmeEdgeCases:
-    def test_empty_string_returns_empty_list(self) -> None:
-        result = _parse_readme("")
-        assert result == []
-
-    def test_whitespace_only_returns_empty_list(self) -> None:
-        result = _parse_readme("   \n\n  \n")
-        assert result == []
-
-    def test_malformed_line_does_not_crash(self) -> None:
-        # Parser only emits records found AFTER the ## Server Implementations
-        # gate; we include it so the ### subsection below is in scope.
-        text = (
-            "## Server Implementations\n\n"
-            "### 🛠️ Tools\n\n"
-            "This line has no link and should be skipped gracefully by the parser.\n"
-            "- [valid-mcp](https://github.com/example/valid-mcp) - A valid entry.\n"
-        )
-        result = _parse_readme(text)
-        assert [r["name"] for r in result] == ["valid-mcp"]
-
-
-# ---------------------------------------------------------------------------
-# _parse_readme — excerpt fixture (5 well-formed entries)
-# ---------------------------------------------------------------------------
-
-
-class TestParseReadmeExcerpt:
-    def test_excerpt_produces_correct_entry_count(self) -> None:
-        result = _parse_readme(_excerpt())
-        assert len(result) == 6
-
-    def test_excerpt_produces_exact_expected_names(self) -> None:
-        result = _parse_readme(_excerpt())
-        assert [entry["name"] for entry in result] == [
-            "github-mcp",
-            "gitlab-mcp",
-            "postgres-mcp",
-            "sqlite-mcp",
-            "notion-mcp",
-            "another-tool",
-        ]
-
-    def test_each_dict_has_name_key(self) -> None:
-        result = _parse_readme(_excerpt())
-        for entry in result:
-            assert "name" in entry, f"Missing 'name' in {entry}"
-
-    def test_each_dict_has_description_key(self) -> None:
-        result = _parse_readme(_excerpt())
-        for entry in result:
-            assert "description" in entry, f"Missing 'description' in {entry}"
-
-    def test_each_dict_has_sources_list(self) -> None:
-        result = _parse_readme(_excerpt())
-        for entry in result:
-            assert "sources" in entry, f"Missing 'sources' in {entry}"
-            assert isinstance(entry["sources"], list)
-
-    def test_sources_contains_awesome_mcp(self) -> None:
-        result = _parse_readme(_excerpt())
-        for entry in result:
-            assert "awesome-mcp" in entry["sources"], (
-                f"'awesome-mcp' not in sources for {entry['name']}"
-            )
-
-    def test_github_url_extracted_for_github_links(self) -> None:
-        result = {entry["name"]: entry for entry in _parse_readme(_excerpt())}
-        assert result["github-mcp"]["github_url"] == (
-            "https://github.com/modelcontextprotocol/github-mcp"
-        )
-        assert result["gitlab-mcp"]["github_url"] == "https://github.com/acmecorp/gitlab-mcp"
-        assert result["postgres-mcp"]["github_url"] == "https://github.com/example/postgres-mcp"
-        assert result["sqlite-mcp"]["github_url"] == "https://github.com/example/sqlite-mcp"
-        assert result["another-tool"]["github_url"] == "https://github.com/example/another-tool"
-        assert "github_url" not in result["notion-mcp"]
-
-    def test_non_github_url_extracted_as_homepage_url(self) -> None:
-        # The fixture has notion-mcp linking to www.notion.so — not github
-        result = {entry["name"]: entry for entry in _parse_readme(_excerpt())}
-        assert result["notion-mcp"]["homepage_url"] == (
-            "https://www.notion.so/integrations/notion-mcp"
-        )
-        assert "homepage_url" not in result["github-mcp"]
-
-    def test_section_header_produces_tag_on_entries_below(self) -> None:
-        # Entries under "### 🐙 Version Control" should carry a version-control tag
-        result = {entry["name"]: entry for entry in _parse_readme(_excerpt())}
-        assert result["github-mcp"]["tags"] == ["version-control"]
-        assert result["gitlab-mcp"]["tags"] == ["version-control"]
-        assert result["postgres-mcp"]["tags"] == ["databases"]
-        assert result["sqlite-mcp"]["tags"] == ["databases"]
-        assert result["notion-mcp"]["tags"] == ["productivity"]
-        assert result["another-tool"]["tags"] == ["productivity"]
-
-    def test_parsed_dicts_round_trip_through_mcp_record(self) -> None:
-        from mcp_entity import McpRecord  # noqa: PLC0415
-
-        result = _parse_readme(_excerpt())
-        for entry in result:
-            try:
-                McpRecord.from_dict(entry)
-            except Exception as exc:
-                pytest.fail(
-                    f"McpRecord.from_dict() raised for entry {entry.get('name')!r}: {exc}"
-                )
-
-
-# ---------------------------------------------------------------------------
-# SOURCE singleton
-# ---------------------------------------------------------------------------
-
-
-class TestSourceSingleton:
-    def test_source_name_is_awesome_mcp(self) -> None:
-        assert SOURCE.name == "awesome-mcp"
-
-    def test_source_homepage_is_non_empty_string(self) -> None:
-        assert isinstance(SOURCE.homepage, str)
-        assert SOURCE.homepage.strip() != ""
-
-    def test_source_homepage_looks_like_url(self) -> None:
-        assert SOURCE.homepage.startswith("http"), (
-            f"SOURCE.homepage should start with 'http', got: {SOURCE.homepage!r}"
-        )
+"""
+tests/test_mcp_sources_awesome.py -- Unit tests for mcp_sources.awesome_mcp.
+
+Contracts tested (Phase 2a locked spec):
+  - _parse_readme(text) -> list[dict]   (pure function, no network)
+  - Each dict has name, description, sources=["awesome-mcp"]
+  - GitHub links extracted to github_url
+  - Non-github links extracted to homepage_url
+  - Section headers produce tag entries
+  - Malformed lines skipped gracefully
+  - Parsed dicts round-trip through McpRecord.from_dict()
+  - SOURCE singleton has expected name / homepage attributes
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+SRC_DIR = Path(__file__).resolve().parents[1]
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+_FIXTURE_PATH = Path(__file__).parent / "fixtures" / "awesome_mcp_excerpt.md"
+
+from mcp_sources.awesome_mcp import SOURCE, _parse_readme  # type: ignore[import-untyped]  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _excerpt() -> str:
+    return _FIXTURE_PATH.read_text(encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# _parse_readme — edge cases
+# ---------------------------------------------------------------------------
+
+
+class TestParseReadmeEdgeCases:
+    def test_empty_string_returns_empty_list(self) -> None:
+        result = _parse_readme("")
+        assert result == []
+
+    def test_whitespace_only_returns_empty_list(self) -> None:
+        result = _parse_readme("   \n\n  \n")
+        assert result == []
+
+    def test_malformed_line_does_not_crash(self) -> None:
+        # Parser only emits records found AFTER the ## Server Implementations
+        # gate; we include it so the ### subsection below is in scope.
+        text = (
+            "## Server Implementations\n\n"
+            "### 🛠️ Tools\n\n"
+            "This line has no link and should be skipped gracefully by the parser.\n"
+            "- [valid-mcp](https://github.com/example/valid-mcp) - A valid entry.\n"
+        )
+        result = _parse_readme(text)
+        assert [r["name"] for r in result] == ["valid-mcp"]
+
+
+# ---------------------------------------------------------------------------
+# _parse_readme — excerpt fixture (5 well-formed entries)
+# ---------------------------------------------------------------------------
+
+
+class TestParseReadmeExcerpt:
+    def test_excerpt_produces_correct_entry_count(self) -> None:
+        result = _parse_readme(_excerpt())
+        assert len(result) == 6
+
+    def test_excerpt_produces_exact_expected_names(self) -> None:
+        result = _parse_readme(_excerpt())
+        assert [entry["name"] for entry in result] == [
+            "github-mcp",
+            "gitlab-mcp",
+            "postgres-mcp",
+            "sqlite-mcp",
+            "notion-mcp",
+            "another-tool",
+        ]
+
+    def test_each_dict_has_name_key(self) -> None:
+        result = _parse_readme(_excerpt())
+        for entry in result:
+            assert "name" in entry, f"Missing 'name' in {entry}"
+
+    def test_each_dict_has_description_key(self) -> None:
+        result = _parse_readme(_excerpt())
+        for entry in result:
+            assert "description" in entry, f"Missing 'description' in {entry}"
+
+    def test_each_dict_has_sources_list(self) -> None:
+        result = _parse_readme(_excerpt())
+        for entry in result:
+            assert "sources" in entry, f"Missing 'sources' in {entry}"
+            assert isinstance(entry["sources"], list)
+
+    def test_sources_contains_awesome_mcp(self) -> None:
+        result = _parse_readme(_excerpt())
+        for entry in result:
+            assert "awesome-mcp" in entry["sources"], (
+                f"'awesome-mcp' not in sources for {entry['name']}"
+            )
+
+    def test_github_url_extracted_for_github_links(self) -> None:
+        result = {entry["name"]: entry for entry in _parse_readme(_excerpt())}
+        assert result["github-mcp"]["github_url"] == (
+            "https://github.com/modelcontextprotocol/github-mcp"
+        )
+        assert result["gitlab-mcp"]["github_url"] == "https://github.com/acmecorp/gitlab-mcp"
+        assert result["postgres-mcp"]["github_url"] == "https://github.com/example/postgres-mcp"
+        assert result["sqlite-mcp"]["github_url"] == "https://github.com/example/sqlite-mcp"
+        assert result["another-tool"]["github_url"] == "https://github.com/example/another-tool"
+        assert "github_url" not in result["notion-mcp"]
+
+    def test_non_github_url_extracted_as_homepage_url(self) -> None:
+        # The fixture has notion-mcp linking to www.notion.so — not github
+        result = {entry["name"]: entry for entry in _parse_readme(_excerpt())}
+        assert result["notion-mcp"]["homepage_url"] == (
+            "https://www.notion.so/integrations/notion-mcp"
+        )
+        assert "homepage_url" not in result["github-mcp"]
+
+    def test_section_header_produces_tag_on_entries_below(self) -> None:
+        # Entries under "### 🐙 Version Control" should carry a version-control tag
+        result = {entry["name"]: entry for entry in _parse_readme(_excerpt())}
+        assert result["github-mcp"]["tags"] == ["version-control"]
+        assert result["gitlab-mcp"]["tags"] == ["version-control"]
+        assert result["postgres-mcp"]["tags"] == ["databases"]
+        assert result["sqlite-mcp"]["tags"] == ["databases"]
+        assert result["notion-mcp"]["tags"] == ["productivity"]
+        assert result["another-tool"]["tags"] == ["productivity"]
+
+    def test_parsed_dicts_round_trip_through_mcp_record(self) -> None:
+        from mcp_entity import McpRecord  # noqa: PLC0415
+
+        result = _parse_readme(_excerpt())
+        for entry in result:
+            try:
+                McpRecord.from_dict(entry)
+            except Exception as exc:
+                pytest.fail(
+                    f"McpRecord.from_dict() raised for entry {entry.get('name')!r}: {exc}"
+                )
+
+
+# ---------------------------------------------------------------------------
+# SOURCE singleton
+# ---------------------------------------------------------------------------
+
+
+class TestSourceSingleton:
+    def test_source_name_is_awesome_mcp(self) -> None:
+        assert SOURCE.name == "awesome-mcp"
+
+    def test_source_homepage_is_non_empty_string(self) -> None:
+        assert isinstance(SOURCE.homepage, str)
+        assert SOURCE.homepage.strip() != ""
+
+    def test_source_homepage_looks_like_url(self) -> None:
+        assert SOURCE.homepage.startswith("http"), (
+            f"SOURCE.homepage should start with 'http', got: {SOURCE.homepage!r}"
+        )

src/tests/test_patch_graph.py

@@ -1,394 +1,394 @@
-"""
-test_patch_graph.py -- Coverage for wiki_graphify.patch_graph.
-
-patch_graph is the incremental-update core: given a prior graph + a
-set of affected nodes + target edges, it mutates the prior graph
-in-place so it matches the new target state while preserving edges
-between unaffected node pairs.
-
-A bug here produces silent gaps (missing edges), silent stale
-edges (wrong weights lingering), or full-rebuild performance
-regressions.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import networkx as nx
-import pytest
-
-from ctx.core.wiki.wiki_graphify import patch_graph
-
-
-# ── Helpers ──────────────────────────────────────────────────────────────────
-
-
-def _make_prior(
-    nodes: list[tuple[str, dict[str, Any]]] | None = None,
-    edges: list[tuple[str, str, dict[str, Any]]] | None = None,
-) -> nx.Graph:
-    G = nx.Graph()
-    for nid, attrs in (nodes or []):
-        G.add_node(nid, **attrs)
-    for u, v, attrs in (edges or []):
-        G.add_edge(u, v, **attrs)
-    return G
-
-
-def _info(label: str, type_: str = "skill", tags: list[str] | None = None) -> dict:
-    return {"label": label, "type": type_, "tags": list(tags or [])}
-
-
-# ── Node-level delta ─────────────────────────────────────────────────────────
-
-
-class TestNodeDelta:
-    def test_new_node_added_with_attrs(self) -> None:
-        prior = _make_prior()
-        current = {"skill:a": _info("a", "skill", ["py"])}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        assert "skill:a" in prior
-        assert prior.nodes["skill:a"]["label"] == "a"
-        assert prior.nodes["skill:a"]["type"] == "skill"
-        assert prior.nodes["skill:a"]["tags"] == ["py"]
-
-    def test_removed_node_dropped(self) -> None:
-        prior = _make_prior([("skill:gone", _info("gone"))])
-        patch_graph(
-            prior,
-            current_node_info={},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        assert "skill:gone" not in prior
-
-    def test_existing_node_attrs_refreshed(self) -> None:
-        """Tags may have changed between runs — patch must refresh."""
-        prior = _make_prior(
-            [("skill:a", {"label": "a", "type": "skill", "tags": ["old"]})]
-        )
-        current = {"skill:a": _info("a", "skill", ["new"])}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        assert prior.nodes["skill:a"]["tags"] == ["new"]
-
-    def test_label_defaults_from_nid_suffix(self) -> None:
-        prior = _make_prior()
-        patch_graph(
-            prior,
-            current_node_info={"skill:fastapi-pro": {}},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        assert prior.nodes["skill:fastapi-pro"]["label"] == "fastapi-pro"
-
-    def test_type_preserved_when_info_omits_it(self) -> None:
-        """Refresh on existing node should preserve the prior type if new info has none."""
-        prior = _make_prior(
-            [("skill:a", {"label": "a", "type": "skill", "tags": []})]
-        )
-        patch_graph(
-            prior,
-            current_node_info={"skill:a": {"label": "a", "tags": []}},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        assert prior.nodes["skill:a"]["type"] == "skill"
-
-    def test_tags_stored_as_fresh_list(self) -> None:
-        """Mutating the info afterwards must not leak into the graph."""
-        tags = ["py"]
-        prior = _make_prior()
-        patch_graph(
-            prior,
-            current_node_info={"skill:a": _info("a", "skill", tags)},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        tags.append("leak")
-        assert "leak" not in prior.nodes["skill:a"]["tags"]
-
-
-# ── Edge-level delta ─────────────────────────────────────────────────────────
-
-
-class TestEdgeDelta:
-    def test_edges_between_unaffected_pairs_preserved(self) -> None:
-        """The core invariant: unaffected pairs keep their prior edges untouched."""
-        prior = _make_prior(
-            [("skill:a", _info("a")), ("skill:b", _info("b"))],
-            [("skill:a", "skill:b", {"weight": 0.8, "semantic_sim": 0.8})],
-        )
-        current = {
-            "skill:a": _info("a"),
-            "skill:b": _info("b"),
-        }
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        # Both nodes unaffected → edge should survive.
-        assert prior.has_edge("skill:a", "skill:b")
-        assert prior["skill:a"]["skill:b"]["weight"] == 0.8
-
-    def test_edge_incident_on_affected_node_refreshed(self) -> None:
-        prior = _make_prior(
-            [("skill:a", _info("a")), ("skill:b", _info("b"))],
-            [("skill:a", "skill:b", {"weight": 0.8})],
-        )
-        current = {
-            "skill:a": _info("a"),
-            "skill:b": _info("b"),
-        }
-        target = {("skill:a", "skill:b"): {"weight": 0.5, "semantic_sim": 0.5}}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids={"skill:a"},
-        )
-        assert prior["skill:a"]["skill:b"]["weight"] == 0.5
-        assert prior["skill:a"]["skill:b"]["semantic_sim"] == 0.5
-
-    def test_edge_to_removed_node_disappears(self) -> None:
-        prior = _make_prior(
-            [("skill:a", _info("a")), ("skill:gone", _info("gone"))],
-            [("skill:a", "skill:gone", {"weight": 0.5})],
-        )
-        patch_graph(
-            prior,
-            current_node_info={"skill:a": _info("a")},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        # Removing node also cleans up its edges (NetworkX semantics).
-        assert not prior.has_edge("skill:a", "skill:gone")
-        assert "skill:gone" not in prior
-
-    def test_new_edge_between_new_nodes(self) -> None:
-        prior = _make_prior()
-        current = {
-            "skill:a": _info("a"),
-            "skill:b": _info("b"),
-        }
-        target = {("skill:a", "skill:b"): {"weight": 0.7}}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids=set(),
-        )
-        assert prior.has_edge("skill:a", "skill:b")
-        assert prior["skill:a"]["skill:b"]["weight"] == 0.7
-
-    def test_target_edge_with_missing_endpoint_skipped(self) -> None:
-        """Target edges referencing a node absent from current_node_info must not materialize."""
-        prior = _make_prior()
-        current = {"skill:a": _info("a")}
-        target = {("skill:a", "skill:ghost"): {"weight": 0.5}}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids={"skill:a"},
-        )
-        assert not prior.has_edge("skill:a", "skill:ghost")
-
-    def test_stale_edge_on_affected_node_removed(self) -> None:
-        """Affected node loses all incident edges that aren't re-added by target_edges."""
-        prior = _make_prior(
-            [
-                ("skill:a", _info("a")),
-                ("skill:b", _info("b")),
-                ("skill:c", _info("c")),
-            ],
-            [
-                ("skill:a", "skill:b", {"weight": 0.5}),
-                ("skill:a", "skill:c", {"weight": 0.5}),
-            ],
-        )
-        current = {
-            "skill:a": _info("a"),
-            "skill:b": _info("b"),
-            "skill:c": _info("c"),
-        }
-        # Only a-b is in the new target; a-c should be dropped.
-        target = {("skill:a", "skill:b"): {"weight": 0.6}}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids={"skill:a"},
-        )
-        assert prior.has_edge("skill:a", "skill:b")
-        assert prior["skill:a"]["skill:b"]["weight"] == 0.6
-        assert not prior.has_edge("skill:a", "skill:c")
-
-
-# ── Affected set semantics ───────────────────────────────────────────────────
-
-
-class TestAffectedSet:
-    def test_affected_union_new_nodes(self) -> None:
-        """New nodes join the affected set implicitly — their edges must be evaluated."""
-        prior = _make_prior(
-            [("skill:a", _info("a"))],
-            [],
-        )
-        current = {
-            "skill:a": _info("a"),
-            "skill:b": _info("b"),
-        }
-        # Only b is new; caller did NOT include it in affected_node_ids.
-        target = {("skill:a", "skill:b"): {"weight": 0.9}}
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids=set(),  # empty
-        )
-        # Still materializes because new nodes are auto-affected.
-        assert prior.has_edge("skill:a", "skill:b")
-
-    def test_affected_union_removed_nodes(self) -> None:
-        """Removed nodes' edges are dropped even when caller omits them from affected."""
-        prior = _make_prior(
-            [("skill:a", _info("a")), ("skill:gone", _info("gone"))],
-            [("skill:a", "skill:gone", {"weight": 0.5})],
-        )
-        patch_graph(
-            prior,
-            current_node_info={"skill:a": _info("a")},
-            target_edges={},
-            affected_node_ids=set(),  # empty — but gone is removed
-        )
-        assert "skill:gone" not in prior
-
-    def test_affected_node_not_in_prior_tolerated(self) -> None:
-        """Affected set may list a node not yet in prior — patch should not crash."""
-        prior = _make_prior()
-        patch_graph(
-            prior,
-            current_node_info={"skill:a": _info("a")},
-            target_edges={},
-            affected_node_ids={"skill:a", "skill:does-not-exist-yet"},
-        )
-        assert "skill:a" in prior
-        assert "skill:does-not-exist-yet" not in prior
-
-
-# ── Return value ─────────────────────────────────────────────────────────────
-
-
-class TestReturnValue:
-    def test_returns_same_instance(self) -> None:
-        """Caller expects the same graph object they passed in."""
-        prior = _make_prior()
-        out = patch_graph(
-            prior,
-            current_node_info={},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        assert out is prior
-
-
-# ── Integration: full cycle ─────────────────────────────────────────────────
-
-
-class TestFullCycle:
-    def test_no_op_when_nothing_changes(self) -> None:
-        """Idempotent: same inputs twice should leave the graph identical."""
-        prior = _make_prior(
-            [("skill:a", _info("a", tags=["py"])),
-             ("skill:b", _info("b", tags=["py"]))],
-            [("skill:a", "skill:b", {"weight": 0.5})],
-        )
-        current = {
-            "skill:a": _info("a", tags=["py"]),
-            "skill:b": _info("b", tags=["py"]),
-        }
-        target = {("skill:a", "skill:b"): {"weight": 0.5}}
-
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids=set(),
-        )
-        snapshot = (
-            set(prior.nodes()),
-            sorted(prior.edges()),
-            prior["skill:a"]["skill:b"]["weight"],
-        )
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids=set(),
-        )
-        assert (
-            set(prior.nodes()),
-            sorted(prior.edges()),
-            prior["skill:a"]["skill:b"]["weight"],
-        ) == snapshot
-
-    def test_prints_summary(self, capsys: pytest.CaptureFixture[str]) -> None:
-        """Operational summary line must be emitted."""
-        prior = _make_prior()
-        patch_graph(
-            prior,
-            current_node_info={"skill:a": _info("a")},
-            target_edges={},
-            affected_node_ids=set(),
-        )
-        out = capsys.readouterr().out
-        assert "patch_graph:" in out
-        assert "added=1 nodes" in out
-
-    def test_combined_add_remove_update(self) -> None:
-        """Stress: one node removed, one added, one updated, edges refreshed."""
-        prior = _make_prior(
-            [
-                ("skill:a", _info("a", tags=["old"])),
-                ("skill:b", _info("b")),
-                ("skill:gone", _info("gone")),
-            ],
-            [
-                ("skill:a", "skill:b", {"weight": 0.3}),
-                ("skill:a", "skill:gone", {"weight": 0.4}),
-            ],
-        )
-        current = {
-            "skill:a": _info("a", tags=["fresh"]),
-            "skill:b": _info("b"),
-            "skill:new": _info("new"),
-        }
-        target = {
-            ("skill:a", "skill:b"): {"weight": 0.7},
-            ("skill:b", "skill:new"): {"weight": 0.6},
-        }
-        patch_graph(
-            prior,
-            current_node_info=current,
-            target_edges=target,
-            affected_node_ids={"skill:a"},
-        )
-        assert "skill:gone" not in prior
-        assert "skill:new" in prior
-        assert prior.nodes["skill:a"]["tags"] == ["fresh"]
-        assert prior["skill:a"]["skill:b"]["weight"] == 0.7
-        assert prior.has_edge("skill:b", "skill:new")
-        assert prior["skill:b"]["skill:new"]["weight"] == 0.6
+"""
+test_patch_graph.py -- Coverage for wiki_graphify.patch_graph.
+
+patch_graph is the incremental-update core: given a prior graph + a
+set of affected nodes + target edges, it mutates the prior graph
+in-place so it matches the new target state while preserving edges
+between unaffected node pairs.
+
+A bug here produces silent gaps (missing edges), silent stale
+edges (wrong weights lingering), or full-rebuild performance
+regressions.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import networkx as nx
+import pytest
+
+from ctx.core.wiki.wiki_graphify import patch_graph
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _make_prior(
+    nodes: list[tuple[str, dict[str, Any]]] | None = None,
+    edges: list[tuple[str, str, dict[str, Any]]] | None = None,
+) -> nx.Graph:
+    G = nx.Graph()
+    for nid, attrs in (nodes or []):
+        G.add_node(nid, **attrs)
+    for u, v, attrs in (edges or []):
+        G.add_edge(u, v, **attrs)
+    return G
+
+
+def _info(label: str, type_: str = "skill", tags: list[str] | None = None) -> dict:
+    return {"label": label, "type": type_, "tags": list(tags or [])}
+
+
+# ── Node-level delta ─────────────────────────────────────────────────────────
+
+
+class TestNodeDelta:
+    def test_new_node_added_with_attrs(self) -> None:
+        prior = _make_prior()
+        current = {"skill:a": _info("a", "skill", ["py"])}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        assert "skill:a" in prior
+        assert prior.nodes["skill:a"]["label"] == "a"
+        assert prior.nodes["skill:a"]["type"] == "skill"
+        assert prior.nodes["skill:a"]["tags"] == ["py"]
+
+    def test_removed_node_dropped(self) -> None:
+        prior = _make_prior([("skill:gone", _info("gone"))])
+        patch_graph(
+            prior,
+            current_node_info={},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        assert "skill:gone" not in prior
+
+    def test_existing_node_attrs_refreshed(self) -> None:
+        """Tags may have changed between runs — patch must refresh."""
+        prior = _make_prior(
+            [("skill:a", {"label": "a", "type": "skill", "tags": ["old"]})]
+        )
+        current = {"skill:a": _info("a", "skill", ["new"])}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        assert prior.nodes["skill:a"]["tags"] == ["new"]
+
+    def test_label_defaults_from_nid_suffix(self) -> None:
+        prior = _make_prior()
+        patch_graph(
+            prior,
+            current_node_info={"skill:fastapi-pro": {}},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        assert prior.nodes["skill:fastapi-pro"]["label"] == "fastapi-pro"
+
+    def test_type_preserved_when_info_omits_it(self) -> None:
+        """Refresh on existing node should preserve the prior type if new info has none."""
+        prior = _make_prior(
+            [("skill:a", {"label": "a", "type": "skill", "tags": []})]
+        )
+        patch_graph(
+            prior,
+            current_node_info={"skill:a": {"label": "a", "tags": []}},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        assert prior.nodes["skill:a"]["type"] == "skill"
+
+    def test_tags_stored_as_fresh_list(self) -> None:
+        """Mutating the info afterwards must not leak into the graph."""
+        tags = ["py"]
+        prior = _make_prior()
+        patch_graph(
+            prior,
+            current_node_info={"skill:a": _info("a", "skill", tags)},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        tags.append("leak")
+        assert "leak" not in prior.nodes["skill:a"]["tags"]
+
+
+# ── Edge-level delta ─────────────────────────────────────────────────────────
+
+
+class TestEdgeDelta:
+    def test_edges_between_unaffected_pairs_preserved(self) -> None:
+        """The core invariant: unaffected pairs keep their prior edges untouched."""
+        prior = _make_prior(
+            [("skill:a", _info("a")), ("skill:b", _info("b"))],
+            [("skill:a", "skill:b", {"weight": 0.8, "semantic_sim": 0.8})],
+        )
+        current = {
+            "skill:a": _info("a"),
+            "skill:b": _info("b"),
+        }
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        # Both nodes unaffected → edge should survive.
+        assert prior.has_edge("skill:a", "skill:b")
+        assert prior["skill:a"]["skill:b"]["weight"] == 0.8
+
+    def test_edge_incident_on_affected_node_refreshed(self) -> None:
+        prior = _make_prior(
+            [("skill:a", _info("a")), ("skill:b", _info("b"))],
+            [("skill:a", "skill:b", {"weight": 0.8})],
+        )
+        current = {
+            "skill:a": _info("a"),
+            "skill:b": _info("b"),
+        }
+        target = {("skill:a", "skill:b"): {"weight": 0.5, "semantic_sim": 0.5}}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids={"skill:a"},
+        )
+        assert prior["skill:a"]["skill:b"]["weight"] == 0.5
+        assert prior["skill:a"]["skill:b"]["semantic_sim"] == 0.5
+
+    def test_edge_to_removed_node_disappears(self) -> None:
+        prior = _make_prior(
+            [("skill:a", _info("a")), ("skill:gone", _info("gone"))],
+            [("skill:a", "skill:gone", {"weight": 0.5})],
+        )
+        patch_graph(
+            prior,
+            current_node_info={"skill:a": _info("a")},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        # Removing node also cleans up its edges (NetworkX semantics).
+        assert not prior.has_edge("skill:a", "skill:gone")
+        assert "skill:gone" not in prior
+
+    def test_new_edge_between_new_nodes(self) -> None:
+        prior = _make_prior()
+        current = {
+            "skill:a": _info("a"),
+            "skill:b": _info("b"),
+        }
+        target = {("skill:a", "skill:b"): {"weight": 0.7}}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids=set(),
+        )
+        assert prior.has_edge("skill:a", "skill:b")
+        assert prior["skill:a"]["skill:b"]["weight"] == 0.7
+
+    def test_target_edge_with_missing_endpoint_skipped(self) -> None:
+        """Target edges referencing a node absent from current_node_info must not materialize."""
+        prior = _make_prior()
+        current = {"skill:a": _info("a")}
+        target = {("skill:a", "skill:ghost"): {"weight": 0.5}}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids={"skill:a"},
+        )
+        assert not prior.has_edge("skill:a", "skill:ghost")
+
+    def test_stale_edge_on_affected_node_removed(self) -> None:
+        """Affected node loses all incident edges that aren't re-added by target_edges."""
+        prior = _make_prior(
+            [
+                ("skill:a", _info("a")),
+                ("skill:b", _info("b")),
+                ("skill:c", _info("c")),
+            ],
+            [
+                ("skill:a", "skill:b", {"weight": 0.5}),
+                ("skill:a", "skill:c", {"weight": 0.5}),
+            ],
+        )
+        current = {
+            "skill:a": _info("a"),
+            "skill:b": _info("b"),
+            "skill:c": _info("c"),
+        }
+        # Only a-b is in the new target; a-c should be dropped.
+        target = {("skill:a", "skill:b"): {"weight": 0.6}}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids={"skill:a"},
+        )
+        assert prior.has_edge("skill:a", "skill:b")
+        assert prior["skill:a"]["skill:b"]["weight"] == 0.6
+        assert not prior.has_edge("skill:a", "skill:c")
+
+
+# ── Affected set semantics ───────────────────────────────────────────────────
+
+
+class TestAffectedSet:
+    def test_affected_union_new_nodes(self) -> None:
+        """New nodes join the affected set implicitly — their edges must be evaluated."""
+        prior = _make_prior(
+            [("skill:a", _info("a"))],
+            [],
+        )
+        current = {
+            "skill:a": _info("a"),
+            "skill:b": _info("b"),
+        }
+        # Only b is new; caller did NOT include it in affected_node_ids.
+        target = {("skill:a", "skill:b"): {"weight": 0.9}}
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids=set(),  # empty
+        )
+        # Still materializes because new nodes are auto-affected.
+        assert prior.has_edge("skill:a", "skill:b")
+
+    def test_affected_union_removed_nodes(self) -> None:
+        """Removed nodes' edges are dropped even when caller omits them from affected."""
+        prior = _make_prior(
+            [("skill:a", _info("a")), ("skill:gone", _info("gone"))],
+            [("skill:a", "skill:gone", {"weight": 0.5})],
+        )
+        patch_graph(
+            prior,
+            current_node_info={"skill:a": _info("a")},
+            target_edges={},
+            affected_node_ids=set(),  # empty — but gone is removed
+        )
+        assert "skill:gone" not in prior
+
+    def test_affected_node_not_in_prior_tolerated(self) -> None:
+        """Affected set may list a node not yet in prior — patch should not crash."""
+        prior = _make_prior()
+        patch_graph(
+            prior,
+            current_node_info={"skill:a": _info("a")},
+            target_edges={},
+            affected_node_ids={"skill:a", "skill:does-not-exist-yet"},
+        )
+        assert "skill:a" in prior
+        assert "skill:does-not-exist-yet" not in prior
+
+
+# ── Return value ─────────────────────────────────────────────────────────────
+
+
+class TestReturnValue:
+    def test_returns_same_instance(self) -> None:
+        """Caller expects the same graph object they passed in."""
+        prior = _make_prior()
+        out = patch_graph(
+            prior,
+            current_node_info={},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        assert out is prior
+
+
+# ── Integration: full cycle ─────────────────────────────────────────────────
+
+
+class TestFullCycle:
+    def test_no_op_when_nothing_changes(self) -> None:
+        """Idempotent: same inputs twice should leave the graph identical."""
+        prior = _make_prior(
+            [("skill:a", _info("a", tags=["py"])),
+             ("skill:b", _info("b", tags=["py"]))],
+            [("skill:a", "skill:b", {"weight": 0.5})],
+        )
+        current = {
+            "skill:a": _info("a", tags=["py"]),
+            "skill:b": _info("b", tags=["py"]),
+        }
+        target = {("skill:a", "skill:b"): {"weight": 0.5}}
+
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids=set(),
+        )
+        snapshot = (
+            set(prior.nodes()),
+            sorted(prior.edges()),
+            prior["skill:a"]["skill:b"]["weight"],
+        )
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids=set(),
+        )
+        assert (
+            set(prior.nodes()),
+            sorted(prior.edges()),
+            prior["skill:a"]["skill:b"]["weight"],
+        ) == snapshot
+
+    def test_prints_summary(self, capsys: pytest.CaptureFixture[str]) -> None:
+        """Operational summary line must be emitted."""
+        prior = _make_prior()
+        patch_graph(
+            prior,
+            current_node_info={"skill:a": _info("a")},
+            target_edges={},
+            affected_node_ids=set(),
+        )
+        out = capsys.readouterr().out
+        assert "patch_graph:" in out
+        assert "added=1 nodes" in out
+
+    def test_combined_add_remove_update(self) -> None:
+        """Stress: one node removed, one added, one updated, edges refreshed."""
+        prior = _make_prior(
+            [
+                ("skill:a", _info("a", tags=["old"])),
+                ("skill:b", _info("b")),
+                ("skill:gone", _info("gone")),
+            ],
+            [
+                ("skill:a", "skill:b", {"weight": 0.3}),
+                ("skill:a", "skill:gone", {"weight": 0.4}),
+            ],
+        )
+        current = {
+            "skill:a": _info("a", tags=["fresh"]),
+            "skill:b": _info("b"),
+            "skill:new": _info("new"),
+        }
+        target = {
+            ("skill:a", "skill:b"): {"weight": 0.7},
+            ("skill:b", "skill:new"): {"weight": 0.6},
+        }
+        patch_graph(
+            prior,
+            current_node_info=current,
+            target_edges=target,
+            affected_node_ids={"skill:a"},
+        )
+        assert "skill:gone" not in prior
+        assert "skill:new" in prior
+        assert prior.nodes["skill:a"]["tags"] == ["fresh"]
+        assert prior["skill:a"]["skill:b"]["weight"] == 0.7
+        assert prior.has_edge("skill:b", "skill:new")
+        assert prior["skill:b"]["skill:new"]["weight"] == 0.6

src/tests/test_query.py

@@ -1,247 +1,247 @@
-"""
-test_query.py -- Tests for wiki_query (keyword search, tag filter, stats, related).
-
-Every test builds its own minimal wiki structure via tmp_path so the real
-~/.claude/skill-wiki is never touched.
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-# Ensure the project root is importable regardless of working directory.
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-from ctx.core.wiki import wiki_query as wq  # noqa: E402
-
-from ._wiki_helpers import make_entity_page, make_wiki  # noqa: E402
-
-
-def _write_entity_page(
-    wiki: Path,
-    relpath: str,
-    *,
-    title: str,
-    entity_type: str,
-    tags: list[str],
-    body: str,
-    description: str = "",
-    status: str = "installed",
-) -> Path:
-    path = wiki / relpath
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tags_str = "[" + ", ".join(tags) + "]"
-    path.write_text(
-        "\n".join([
-            "---",
-            f"title: {title}",
-            f"type: {entity_type}",
-            *([f"description: {description}"] if description else []),
-            f"tags: {tags_str}",
-            f"status: {status}",
-            "---",
-            "",
-            body,
-        ]),
-        encoding="utf-8",
-    )
-    return path
-
-
-class TestQueryKeywordMatch:
-    """test_query_keyword_match -- searching 'docker' finds skills with docker in name/body."""
-
-    def test_query_keyword_match(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        make_entity_page(wiki, "docker-compose-pro", ["docker"], body="Use docker-compose for local dev.")
-        # status="" ensures this page scores exactly 0 for a "docker" query (no installed bonus).
-        make_entity_page(wiki, "python-basics", ["python"], body="Learn Python fundamentals.", status="")
-
-        pages = wq.load_all_pages(wiki)
-        results = wq.search_by_query(pages, "docker")
-
-        names = [p.name for p in results]
-        assert "docker-compose-pro" in names, "docker skill must be returned for 'docker' query"
-        assert "python-basics" not in names, "unrelated skill must not appear"
-
-    def test_load_all_pages_includes_agents_and_sharded_mcps(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        make_entity_page(wiki, "python-patterns", ["python"], body="Python skill.")
-        _write_entity_page(
-            wiki,
-            "entities/agents/code-reviewer.md",
-            title="Code Reviewer",
-            entity_type="agent",
-            tags=["review", "quality"],
-            body="Reviews code for defects.",
-        )
-        _write_entity_page(
-            wiki,
-            "entities/mcp-servers/f/filesystem.md",
-            title="Filesystem MCP",
-            entity_type="mcp-server",
-            tags=["filesystem", "io"],
-            body="Filesystem tools for local files.",
-        )
-
-        pages = wq.load_all_pages(wiki)
-
-        by_name = {p.name: p for p in pages}
-        assert by_name["python-patterns"].entity_type == "skill"
-        assert by_name["code-reviewer"].entity_type == "agent"
-        assert by_name["filesystem"].entity_type == "mcp-server"
-        assert by_name["filesystem"].wikilink == "[[entities/mcp-servers/f/filesystem]]"
-
-    def test_load_all_pages_validates_mcp_shards_and_slugs(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        _write_entity_page(
-            wiki,
-            "entities/mcp-servers/0-9/1password.md",
-            title="1Password MCP",
-            entity_type="mcp-server",
-            tags=["secrets"],
-            body="Secret-management tools.",
-        )
-        _write_entity_page(
-            wiki,
-            "entities/mcp-servers/x/2wrong.md",
-            title="Mis-sharded MCP",
-            entity_type="mcp-server",
-            tags=["bad"],
-            body="Wrong shard.",
-        )
-        _write_entity_page(
-            wiki,
-            "entities/mcp-servers/f/Filesystem.md",
-            title="Uppercase MCP",
-            entity_type="mcp-server",
-            tags=["bad"],
-            body="Unsafe slug.",
-        )
-
-        pages = wq.load_all_pages(wiki)
-
-        by_name = {p.name: p for p in pages}
-        assert by_name["1password"].wikilink == "[[entities/mcp-servers/0-9/1password]]"
-        assert "2wrong" not in by_name
-        assert "Filesystem" not in by_name
-
-    def test_search_by_query_returns_agent_and_mcp_pages(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        _write_entity_page(
-            wiki,
-            "entities/agents/code-reviewer.md",
-            title="Code Reviewer",
-            entity_type="agent",
-            tags=["review", "quality"],
-            body="Reviews code for defects.",
-        )
-        _write_entity_page(
-            wiki,
-            "entities/mcp-servers/f/filesystem.md",
-            title="Filesystem MCP",
-            entity_type="mcp-server",
-            tags=["filesystem", "io"],
-            body="Filesystem tools for local files.",
-        )
-
-        pages = wq.load_all_pages(wiki)
-        results = wq.search_by_query(pages, "filesystem review", top_n=10)
-
-        names = {p.name for p in results}
-        assert {"code-reviewer", "filesystem"} <= names
-        query_results = {r.name: r for r in map(wq._to_result, results)}
-        assert query_results["code-reviewer"].entity_type == "agent"
-        assert query_results["code-reviewer"].wikilink == "[[entities/agents/code-reviewer]]"
-        assert query_results["filesystem"].entity_type == "mcp-server"
-        assert query_results["filesystem"].wikilink == "[[entities/mcp-servers/f/filesystem]]"
-
-    def test_search_by_query_matches_title_and_description(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        _write_entity_page(
-            wiki,
-            "entities/agents/sre-playbook.md",
-            title="Latency Debugger",
-            entity_type="agent",
-            description="Incident response runbook for production services.",
-            tags=[],
-            body="Operational checklist.",
-            status="",
-        )
-
-        pages = wq.load_all_pages(wiki)
-        title_hits = {p.name for p in wq.search_by_query(pages, "latency", top_n=10)}
-        description_hits = {p.name for p in wq.search_by_query(pages, "incident", top_n=10)}
-
-        assert "sre-playbook" in title_hits
-        assert "sre-playbook" in description_hits
-
-
-class TestQueryTagFilter:
-    """test_query_tag_filter -- --tag python returns only python-tagged skills."""
-
-    def test_query_tag_filter(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        make_entity_page(wiki, "fastapi-service", ["python", "fastapi"], body="FastAPI patterns.")
-        make_entity_page(wiki, "docker-network", ["docker"], body="Docker networking tips.")
-        make_entity_page(wiki, "pytest-patterns", ["python", "testing"], body="Pytest best practices.")
-
-        pages = wq.load_all_pages(wiki)
-        results = wq.filter_by_tag(pages, "python")
-
-        names = {p.name for p in results}
-        assert "fastapi-service" in names
-        assert "pytest-patterns" in names
-        assert "docker-network" not in names, "non-python skill must be excluded"
-
-
-class TestQueryStats:
-    """test_query_stats -- compute_stats returns total_entity_pages, top_tags, with_pipeline."""
-
-    def test_query_stats(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        make_entity_page(wiki, "skill-a", ["python"], body="A skill.")
-        make_entity_page(wiki, "skill-b", ["python", "fastapi"], body="B skill.", has_pipeline=True)
-        make_entity_page(wiki, "skill-c", ["docker"], body="C skill.")
-        # Create the converted dir so has_pipeline resolves
-        (wiki / "converted" / "skill-b").mkdir(parents=True)
-
-        pages = wq.load_all_pages(wiki)
-        stats = wq.compute_stats(wiki, pages)
-
-        assert stats["total_entity_pages"] == 3
-        assert stats["with_pipeline"] == 1
-        tag_keys = [t for t, _ in stats["top_tags"]]
-        assert "python" in tag_keys
-        assert "docker" in tag_keys
-
-
-class TestQueryRelated:
-    """test_query_related -- --related fastapi-pro finds python-tagged skills."""
-
-    def test_query_related(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        make_entity_page(wiki, "fastapi-pro", ["python", "fastapi"], body="The target skill.")
-        make_entity_page(wiki, "pydantic-models", ["python", "fastapi"], body="Pydantic usage.")
-        make_entity_page(wiki, "docker-compose-pro", ["docker"], body="Docker only.")
-
-        pages = wq.load_all_pages(wiki)
-        related = wq.find_related(pages, "fastapi-pro")
-
-        names = [p.name for p in related]
-        assert "pydantic-models" in names, "pydantic-models shares tags so must appear as related"
-        assert "docker-compose-pro" not in names, "no shared tags with fastapi-pro"
-
-
-class TestQueryNoResults:
-    """test_query_no_results -- searching 'xyznonexistent' returns empty list."""
-
-    def test_query_no_results(self, tmp_path: Path) -> None:
-        wiki = make_wiki(tmp_path)
-        make_entity_page(wiki, "python-basics", ["python"], body="Learn Python.")
-
-        pages = wq.load_all_pages(wiki)
-        results = wq.search_by_query(pages, "xyznonexistent")
-
-        assert results == [], f"Expected no results, got {[p.name for p in results]}"
+"""
+test_query.py -- Tests for wiki_query (keyword search, tag filter, stats, related).
+
+Every test builds its own minimal wiki structure via tmp_path so the real
+~/.claude/skill-wiki is never touched.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# Ensure the project root is importable regardless of working directory.
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from ctx.core.wiki import wiki_query as wq  # noqa: E402
+
+from ._wiki_helpers import make_entity_page, make_wiki  # noqa: E402
+
+
+def _write_entity_page(
+    wiki: Path,
+    relpath: str,
+    *,
+    title: str,
+    entity_type: str,
+    tags: list[str],
+    body: str,
+    description: str = "",
+    status: str = "installed",
+) -> Path:
+    path = wiki / relpath
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tags_str = "[" + ", ".join(tags) + "]"
+    path.write_text(
+        "\n".join([
+            "---",
+            f"title: {title}",
+            f"type: {entity_type}",
+            *([f"description: {description}"] if description else []),
+            f"tags: {tags_str}",
+            f"status: {status}",
+            "---",
+            "",
+            body,
+        ]),
+        encoding="utf-8",
+    )
+    return path
+
+
+class TestQueryKeywordMatch:
+    """test_query_keyword_match -- searching 'docker' finds skills with docker in name/body."""
+
+    def test_query_keyword_match(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        make_entity_page(wiki, "docker-compose-pro", ["docker"], body="Use docker-compose for local dev.")
+        # status="" ensures this page scores exactly 0 for a "docker" query (no installed bonus).
+        make_entity_page(wiki, "python-basics", ["python"], body="Learn Python fundamentals.", status="")
+
+        pages = wq.load_all_pages(wiki)
+        results = wq.search_by_query(pages, "docker")
+
+        names = [p.name for p in results]
+        assert "docker-compose-pro" in names, "docker skill must be returned for 'docker' query"
+        assert "python-basics" not in names, "unrelated skill must not appear"
+
+    def test_load_all_pages_includes_agents_and_sharded_mcps(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        make_entity_page(wiki, "python-patterns", ["python"], body="Python skill.")
+        _write_entity_page(
+            wiki,
+            "entities/agents/code-reviewer.md",
+            title="Code Reviewer",
+            entity_type="agent",
+            tags=["review", "quality"],
+            body="Reviews code for defects.",
+        )
+        _write_entity_page(
+            wiki,
+            "entities/mcp-servers/f/filesystem.md",
+            title="Filesystem MCP",
+            entity_type="mcp-server",
+            tags=["filesystem", "io"],
+            body="Filesystem tools for local files.",
+        )
+
+        pages = wq.load_all_pages(wiki)
+
+        by_name = {p.name: p for p in pages}
+        assert by_name["python-patterns"].entity_type == "skill"
+        assert by_name["code-reviewer"].entity_type == "agent"
+        assert by_name["filesystem"].entity_type == "mcp-server"
+        assert by_name["filesystem"].wikilink == "[[entities/mcp-servers/f/filesystem]]"
+
+    def test_load_all_pages_validates_mcp_shards_and_slugs(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        _write_entity_page(
+            wiki,
+            "entities/mcp-servers/0-9/1password.md",
+            title="1Password MCP",
+            entity_type="mcp-server",
+            tags=["secrets"],
+            body="Secret-management tools.",
+        )
+        _write_entity_page(
+            wiki,
+            "entities/mcp-servers/x/2wrong.md",
+            title="Mis-sharded MCP",
+            entity_type="mcp-server",
+            tags=["bad"],
+            body="Wrong shard.",
+        )
+        _write_entity_page(
+            wiki,
+            "entities/mcp-servers/f/Filesystem.md",
+            title="Uppercase MCP",
+            entity_type="mcp-server",
+            tags=["bad"],
+            body="Unsafe slug.",
+        )
+
+        pages = wq.load_all_pages(wiki)
+
+        by_name = {p.name: p for p in pages}
+        assert by_name["1password"].wikilink == "[[entities/mcp-servers/0-9/1password]]"
+        assert "2wrong" not in by_name
+        assert "Filesystem" not in by_name
+
+    def test_search_by_query_returns_agent_and_mcp_pages(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        _write_entity_page(
+            wiki,
+            "entities/agents/code-reviewer.md",
+            title="Code Reviewer",
+            entity_type="agent",
+            tags=["review", "quality"],
+            body="Reviews code for defects.",
+        )
+        _write_entity_page(
+            wiki,
+            "entities/mcp-servers/f/filesystem.md",
+            title="Filesystem MCP",
+            entity_type="mcp-server",
+            tags=["filesystem", "io"],
+            body="Filesystem tools for local files.",
+        )
+
+        pages = wq.load_all_pages(wiki)
+        results = wq.search_by_query(pages, "filesystem review", top_n=10)
+
+        names = {p.name for p in results}
+        assert {"code-reviewer", "filesystem"} <= names
+        query_results = {r.name: r for r in map(wq._to_result, results)}
+        assert query_results["code-reviewer"].entity_type == "agent"
+        assert query_results["code-reviewer"].wikilink == "[[entities/agents/code-reviewer]]"
+        assert query_results["filesystem"].entity_type == "mcp-server"
+        assert query_results["filesystem"].wikilink == "[[entities/mcp-servers/f/filesystem]]"
+
+    def test_search_by_query_matches_title_and_description(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        _write_entity_page(
+            wiki,
+            "entities/agents/sre-playbook.md",
+            title="Latency Debugger",
+            entity_type="agent",
+            description="Incident response runbook for production services.",
+            tags=[],
+            body="Operational checklist.",
+            status="",
+        )
+
+        pages = wq.load_all_pages(wiki)
+        title_hits = {p.name for p in wq.search_by_query(pages, "latency", top_n=10)}
+        description_hits = {p.name for p in wq.search_by_query(pages, "incident", top_n=10)}
+
+        assert "sre-playbook" in title_hits
+        assert "sre-playbook" in description_hits
+
+
+class TestQueryTagFilter:
+    """test_query_tag_filter -- --tag python returns only python-tagged skills."""
+
+    def test_query_tag_filter(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        make_entity_page(wiki, "fastapi-service", ["python", "fastapi"], body="FastAPI patterns.")
+        make_entity_page(wiki, "docker-network", ["docker"], body="Docker networking tips.")
+        make_entity_page(wiki, "pytest-patterns", ["python", "testing"], body="Pytest best practices.")
+
+        pages = wq.load_all_pages(wiki)
+        results = wq.filter_by_tag(pages, "python")
+
+        names = {p.name for p in results}
+        assert "fastapi-service" in names
+        assert "pytest-patterns" in names
+        assert "docker-network" not in names, "non-python skill must be excluded"
+
+
+class TestQueryStats:
+    """test_query_stats -- compute_stats returns total_entity_pages, top_tags, with_pipeline."""
+
+    def test_query_stats(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        make_entity_page(wiki, "skill-a", ["python"], body="A skill.")
+        make_entity_page(wiki, "skill-b", ["python", "fastapi"], body="B skill.", has_pipeline=True)
+        make_entity_page(wiki, "skill-c", ["docker"], body="C skill.")
+        # Create the converted dir so has_pipeline resolves
+        (wiki / "converted" / "skill-b").mkdir(parents=True)
+
+        pages = wq.load_all_pages(wiki)
+        stats = wq.compute_stats(wiki, pages)
+
+        assert stats["total_entity_pages"] == 3
+        assert stats["with_pipeline"] == 1
+        tag_keys = [t for t, _ in stats["top_tags"]]
+        assert "python" in tag_keys
+        assert "docker" in tag_keys
+
+
+class TestQueryRelated:
+    """test_query_related -- --related fastapi-pro finds python-tagged skills."""
+
+    def test_query_related(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        make_entity_page(wiki, "fastapi-pro", ["python", "fastapi"], body="The target skill.")
+        make_entity_page(wiki, "pydantic-models", ["python", "fastapi"], body="Pydantic usage.")
+        make_entity_page(wiki, "docker-compose-pro", ["docker"], body="Docker only.")
+
+        pages = wq.load_all_pages(wiki)
+        related = wq.find_related(pages, "fastapi-pro")
+
+        names = [p.name for p in related]
+        assert "pydantic-models" in names, "pydantic-models shares tags so must appear as related"
+        assert "docker-compose-pro" not in names, "no shared tags with fastapi-pro"
+
+
+class TestQueryNoResults:
+    """test_query_no_results -- searching 'xyznonexistent' returns empty list."""
+
+    def test_query_no_results(self, tmp_path: Path) -> None:
+        wiki = make_wiki(tmp_path)
+        make_entity_page(wiki, "python-basics", ["python"], body="Learn Python.")
+
+        pages = wq.load_all_pages(wiki)
+        results = wq.search_by_query(pages, "xyznonexistent")
+
+        assert results == [], f"Expected no results, got {[p.name for p in results]}"

src/tests/test_resolve_skills.py

@@ -1,758 +1,758 @@
-"""
-tests/test_resolve_skills.py -- pytest suite for resolve_skills module.
-
-Covers:
-  - discover_available_skills   (happy path, empty dir, malformed frontmatter)
-  - read_wiki_overrides         (happy path, missing dir, bad use_count, boolean flags)
-  - resolve                     (basic load, conflict resolution, always/never_load, cap)
-  - read_intent_signals         (happy path, missing file, bad JSON lines, wrong date)
-  - apply_intent_boosts         (boost in needed, suggestion when available only)
-  - main()                      (via subprocess with --profile arg)
-"""
-
-import json
-import sys
-from pathlib import Path
-
-
-sys.path.insert(0, str(Path(__file__).parents[1]))
-
-from ctx.core.resolve.resolve_skills import (
-    apply_intent_boosts,
-    discover_available_skills,
-    read_intent_signals,
-    read_wiki_overrides,
-    resolve,
-)
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _make_skill(skills_dir: Path, name: str, frontmatter: str = "") -> Path:
-    """Write a minimal SKILL.md under skills_dir/<name>/."""
-    d = skills_dir / name
-    d.mkdir(parents=True, exist_ok=True)
-    content = f"---\n{frontmatter}\n---\n# {name}\n" if frontmatter else f"# {name}\n"
-    p = d / "SKILL.md"
-    p.write_text(content, encoding="utf-8")
-    return p
-
-
-def _minimal_profile(frameworks=None, languages=None) -> dict:
-    return {
-        "repo_path": "/tmp/repo",
-        "languages": languages or [],
-        "frameworks": frameworks or [],
-        "infrastructure": [],
-        "data_stores": [],
-        "testing": [],
-        "ai_tooling": [],
-        "build_system": [],
-        "docs": [],
-    }
-
-
-def _detection(name: str, confidence: float = 0.9) -> dict:
-    return {"name": name, "confidence": confidence, "evidence": ["file.py"]}
-
-
-def _resolve_without_graph(
-    profile: dict,
-    available: dict,
-    overrides: dict,
-    **kwargs,
-) -> dict:
-    return resolve(profile, available, overrides, enable_graph=False, **kwargs)
-
-
-# ---------------------------------------------------------------------------
-# discover_available_skills
-# ---------------------------------------------------------------------------
-
-class TestDiscoverAvailableSkills:
-    def test_happy_path_single_skill(self, tmp_path):
-        _make_skill(tmp_path, "react", "tags: [javascript]\nversion: 1.0")
-        skills = discover_available_skills(str(tmp_path))
-        assert "react" in skills
-        assert skills["react"]["name"] == "react"
-        assert "path" in skills["react"]
-
-    def test_multiple_skills(self, tmp_path):
-        for name in ("react", "fastapi", "docker"):
-            _make_skill(tmp_path, name, f"tags: [{name}]")
-        skills = discover_available_skills(str(tmp_path))
-        assert set(skills.keys()) == {"react", "fastapi", "docker"}
-
-    def test_missing_directory_returns_empty(self, tmp_path):
-        skills = discover_available_skills(str(tmp_path / "nonexistent"))
-        assert skills == {}
-
-    def test_empty_skills_dir_returns_empty(self, tmp_path):
-        (tmp_path / "skills").mkdir()
-        skills = discover_available_skills(str(tmp_path / "skills"))
-        assert skills == {}
-
-    def test_malformed_frontmatter_still_registers_skill(self, tmp_path, capsys):
-        """A skill with unreadable frontmatter should still be indexed by name."""
-        d = tmp_path / "broken-skill"
-        d.mkdir()
-        (d / "SKILL.md").write_text("not---valid---frontmatter", encoding="utf-8")
-        skills = discover_available_skills(str(tmp_path))
-        # Should still contain the skill (minimal record)
-        assert "broken-skill" in skills
-
-    def test_nested_skill_discovered(self, tmp_path):
-        nested = tmp_path / "category" / "deep-skill"
-        nested.mkdir(parents=True)
-        (nested / "SKILL.md").write_text("# deep\n", encoding="utf-8")
-        skills = discover_available_skills(str(tmp_path))
-        assert "deep-skill" in skills
-
-
-# ---------------------------------------------------------------------------
-# read_wiki_overrides
-# ---------------------------------------------------------------------------
-
-class TestReadWikiOverrides:
-    def _make_override_page(self, wiki: Path, name: str, fields: dict) -> None:
-        entities = wiki / "entities" / "skills"
-        entities.mkdir(parents=True, exist_ok=True)
-        fm_lines = "\n".join(f"{k}: {v}" for k, v in fields.items())
-        page = f"---\n{fm_lines}\n---\n# {name}\n"
-        (entities / f"{name}.md").write_text(page, encoding="utf-8")
-
-    def test_always_load_true(self, tmp_path):
-        self._make_override_page(tmp_path, "react", {"always_load": "true", "use_count": "3"})
-        overrides = read_wiki_overrides(str(tmp_path))
-        assert overrides["react"]["always_load"] is True
-        assert overrides["react"]["use_count"] == 3
-
-    def test_never_load_true(self, tmp_path):
-        self._make_override_page(tmp_path, "legacy", {"never_load": "true", "use_count": "0"})
-        overrides = read_wiki_overrides(str(tmp_path))
-        assert overrides["legacy"]["never_load"] is True
-
-    def test_defaults_when_fields_absent(self, tmp_path):
-        # Provide at least one field so _parse_fm returns non-empty and the
-        # entry isn't skipped by the `if not meta: continue` guard.
-        self._make_override_page(tmp_path, "plain", {"status": "installed"})
-        overrides = read_wiki_overrides(str(tmp_path))
-        assert overrides["plain"]["always_load"] is False
-        assert overrides["plain"]["never_load"] is False
-        assert overrides["plain"]["use_count"] == 0
-
-    def test_missing_entities_dir_returns_empty(self, tmp_path):
-        overrides = read_wiki_overrides(str(tmp_path))
-        assert overrides == {}
-
-    def test_bad_use_count_defaults_to_zero(self, tmp_path):
-        self._make_override_page(tmp_path, "bad", {"use_count": "not-a-number"})
-        # Should not raise; int(str("not-a-number")) will raise, so it goes to except
-        overrides = read_wiki_overrides(str(tmp_path))
-        # Page with parse error is skipped (continue in except)
-        assert "bad" not in overrides
-
-    def test_page_without_frontmatter_skipped(self, tmp_path):
-        entities = tmp_path / "entities" / "skills"
-        entities.mkdir(parents=True)
-        (entities / "plain.md").write_text("# plain\nno frontmatter here", encoding="utf-8")
-        overrides = read_wiki_overrides(str(tmp_path))
-        assert "plain" not in overrides
-
-
-# ---------------------------------------------------------------------------
-# resolve
-# ---------------------------------------------------------------------------
-
-class TestResolve:
-    def test_graph_can_be_disabled_for_deterministic_unit_resolution(
-        self, tmp_path, monkeypatch
-    ):
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-
-        def fail_if_loaded():
-            raise AssertionError("unit resolver tests must not load the live graph")
-
-        monkeypatch.setattr(resolve_skills, "_load_graph", fail_if_loaded)
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-
-        manifest = _resolve_without_graph(profile, available, {})
-
-        assert "react" in [e["skill"] for e in manifest["load"]]
-        assert not any("graph walk skipped" in w for w in manifest["warnings"])
-
-    def test_basic_load_known_skill(self, tmp_path):
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = _resolve_without_graph(profile, available, {})
-        loaded_names = [e["skill"] for e in manifest["load"]]
-        assert "react" in loaded_names
-
-    def test_skill_not_available_goes_to_suggestions(self, tmp_path):
-        available = {}  # react not installed
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = _resolve_without_graph(profile, available, {})
-        suggestion_skills = [s["skill"] for s in manifest["suggestions"]]
-        assert "react" in suggestion_skills
-        # The unavailable react skill must NOT be in load. Graph-matched
-        # agents (e.g. react-specialist found via the live knowledge graph)
-        # may legitimately appear in load — the assertion targets the
-        # specific skill, not the entire load list, so this test stays
-        # robust against richer graph-driven recommendations.
-        loaded_skills = [
-            e.get("skill") for e in manifest["load"]
-            if e.get("entity_type", "skill") == "skill"
-        ]
-        assert "react" not in loaded_skills
-
-    def test_always_load_override_adds_skill(self, tmp_path):
-        available = {"docker": {"path": str(tmp_path / "docker/SKILL.md"), "name": "docker"}}
-        overrides = {"docker": {"always_load": True, "never_load": False, "use_count": 0, "last_used": "", "status": "installed"}}
-        profile = _minimal_profile()  # no detection for docker
-        manifest = _resolve_without_graph(profile, available, overrides)
-        loaded_names = [e["skill"] for e in manifest["load"]]
-        assert "docker" in loaded_names
-
-    def test_never_load_override_removes_skill(self, tmp_path):
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        overrides = {"react": {"always_load": False, "never_load": True, "use_count": 0, "last_used": "", "status": "installed"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = _resolve_without_graph(profile, available, overrides)
-        loaded_names = [e["skill"] for e in manifest["load"]]
-        assert "react" not in loaded_names
-
-    def test_conflict_resolution_keeps_higher_priority(self, tmp_path):
-        available = {
-            "fastapi": {"path": str(tmp_path / "fastapi/SKILL.md"), "name": "fastapi"},
-            "flask": {"path": str(tmp_path / "flask/SKILL.md"), "name": "flask"},
-        }
-        profile = _minimal_profile(frameworks=[
-            _detection("fastapi", confidence=0.95),
-            _detection("flask", confidence=0.6),
-        ])
-        manifest = _resolve_without_graph(profile, available, {})
-        loaded_names = [e["skill"] for e in manifest["load"]]
-        # fastapi has higher base priority (8) and higher confidence boost
-        assert "fastapi" in loaded_names
-        assert "flask" not in loaded_names
-        assert any("Conflict" in w for w in manifest["warnings"])
-
-    def test_max_skills_cap(self, tmp_path):
-        # Create 20 available skills each mapped from detections
-        skills_with_map = ["react", "docker", "fastapi", "django", "flask",
-                           "pytest", "jest", "langchain", "nextjs", "vue"]
-        available = {n: {"path": str(tmp_path / n / "SKILL.md"), "name": n} for n in skills_with_map}
-        profile = _minimal_profile(frameworks=[_detection(n, 0.9) for n in skills_with_map])
-        manifest = _resolve_without_graph(profile, available, {}, max_skills=3)
-        # At most 3 skill-mapped items (plus meta skills if available)
-        non_meta = [e for e in manifest["load"] if e["skill"] not in ("skill-router", "file-reading")]
-        assert len(non_meta) <= 3
-        assert any("Capped" in w for w in manifest["warnings"])
-
-    def test_meta_skills_added_if_available(self, tmp_path):
-        available = {"skill-router": {"path": str(tmp_path / "skill-router/SKILL.md"), "name": "skill-router"}}
-        profile = _minimal_profile()
-        manifest = _resolve_without_graph(profile, available, {})
-        loaded_names = [e["skill"] for e in manifest["load"]]
-        assert "skill-router" in loaded_names
-
-    def test_unloaded_skills_in_unload_list(self, tmp_path):
-        available = {
-            "react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"},
-            "docker": {"path": str(tmp_path / "docker/SKILL.md"), "name": "docker"},
-        }
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = _resolve_without_graph(profile, available, {})
-        unload_names = [e["skill"] for e in manifest["unload"]]
-        assert "docker" in unload_names
-
-    def test_empty_profile_no_crash(self):
-        manifest = _resolve_without_graph(_minimal_profile(), {}, {})
-        assert manifest["load"] == []
-        assert "generated_at" in manifest
-
-    def test_high_confidence_boost_applied(self, tmp_path):
-        """Skills with confidence >=0.9 should get priority +10."""
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        profile = _minimal_profile(frameworks=[_detection("react", confidence=0.95)])
-        manifest = _resolve_without_graph(profile, available, {})
-        entry = next(e for e in manifest["load"] if e["skill"] == "react")
-        # PRIORITY_BASE["react"] = 7, +10 for confidence, +0 no use_count
-        assert entry["priority"] >= 17
-
-
-class TestResolveMcpRecommendations:
-    """Phase 5 regression: graph-walk hits with type=='mcp-server' land
-    in manifest['mcp_servers'], NOT manifest['load'] (the skill bucket).
-    """
-
-    def _fake_graph(self, monkeypatch):
-        """Make resolve() think the graph is available and non-empty."""
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-
-        class _FakeGraph:
-            def number_of_nodes(self) -> int:
-                return 1
-
-        monkeypatch.setattr(
-            resolve_skills, "_load_graph", lambda: _FakeGraph()
-        )
-        monkeypatch.setattr(resolve_skills, "_GRAPH_AVAILABLE", True)
-
-    def test_mcp_graph_hit_lands_in_mcp_servers_not_load(
-        self, tmp_path, monkeypatch
-    ):
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-        self._fake_graph(monkeypatch)
-
-        # Synthetic graph hit: an MCP-type neighbor with score above the
-        # 1.5 noise floor.
-        def fake_resolve_by_seeds(graph, seeds, **kwargs):
-            return [
-                {
-                    "name": "github-mcp-server",
-                    "type": "mcp-server",
-                    "score": 3.0,
-                    "shared_tags": ["_t:github"],
-                    "via": ["react"],
-                },
-            ]
-
-        monkeypatch.setattr(
-            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
-        )
-
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-
-        mcp_names = [m["name"] for m in manifest["mcp_servers"]]
-        load_names = [e["skill"] for e in manifest["load"]]
-        assert "github-mcp-server" in mcp_names, (
-            f"MCP should appear in mcp_servers bucket; got {manifest['mcp_servers']}"
-        )
-        assert "github-mcp-server" not in load_names, (
-            "MCP must NOT land in manifest['load'] — that's the skill-loader bucket"
-        )
-
-    def test_mcp_entry_has_reason_score_and_shared_tags(
-        self, tmp_path, monkeypatch
-    ):
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-        self._fake_graph(monkeypatch)
-
-        def fake_resolve_by_seeds(graph, seeds, **kwargs):
-            return [
-                {
-                    "name": "fetch-mcp",
-                    "type": "mcp-server",
-                    "score": 2.5,
-                    "shared_tags": ["_t:fetch", "http"],
-                    "via": ["django"],
-                },
-            ]
-
-        monkeypatch.setattr(
-            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
-        )
-
-        available = {"django": {"path": str(tmp_path / "django/SKILL.md"), "name": "django"}}
-        profile = _minimal_profile(frameworks=[_detection("django")])
-        manifest = resolve(profile, available, {})
-
-        assert len(manifest["mcp_servers"]) == 1
-        entry = manifest["mcp_servers"][0]
-        assert entry["name"] == "fetch-mcp"
-        assert entry["score"] == 2.5
-        assert "graph neighbor of django" in entry["reason"]
-        assert "_t:fetch" in entry["shared_tags"]
-
-    def test_mcp_deduped_when_same_name_hit_twice(
-        self, tmp_path, monkeypatch
-    ):
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-        self._fake_graph(monkeypatch)
-
-        def fake_resolve_by_seeds(graph, seeds, **kwargs):
-            return [
-                {"name": "duped-mcp", "type": "mcp-server", "score": 2.0,
-                 "shared_tags": [], "via": ["a"]},
-                {"name": "duped-mcp", "type": "mcp-server", "score": 1.8,
-                 "shared_tags": [], "via": ["b"]},
-            ]
-
-        monkeypatch.setattr(
-            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
-        )
-
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-
-        assert sum(1 for m in manifest["mcp_servers"] if m["name"] == "duped-mcp") == 1
-
-    def test_mcp_below_noise_floor_dropped(
-        self, tmp_path, monkeypatch
-    ):
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-        self._fake_graph(monkeypatch)
-
-        def fake_resolve_by_seeds(graph, seeds, **kwargs):
-            # Post-P2.5 the resolver uses normalized_score (percentile
-            # in [0,1]) against the 0.20 MCP floor. A value of 0.1
-            # sits below the floor so the hit must be dropped.
-            return [
-                {"name": "weak-mcp", "type": "mcp-server",
-                 "score": 0.8, "normalized_score": 0.10,
-                 "shared_tags": [], "via": ["a"]},
-            ]
-
-        monkeypatch.setattr(
-            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
-        )
-
-        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-
-        assert manifest["mcp_servers"] == []
-
-    def test_skill_hits_still_route_to_load(
-        self, tmp_path, monkeypatch
-    ):
-        # Regression: mixing mcp-server hits and skill hits must not
-        # break the existing skill path.
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-        self._fake_graph(monkeypatch)
-
-        def fake_resolve_by_seeds(graph, seeds, **kwargs):
-            return [
-                {"name": "pytest-something", "type": "skill", "score": 3.0,
-                 "shared_tags": [], "via": ["django"]},
-                {"name": "fetch-mcp", "type": "mcp-server", "score": 2.0,
-                 "shared_tags": [], "via": ["django"]},
-            ]
-
-        monkeypatch.setattr(
-            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
-        )
-
-        available = {
-            "django": {"path": str(tmp_path / "django/SKILL.md"), "name": "django"},
-            "pytest-something": {
-                "path": str(tmp_path / "pytest-something/SKILL.md"),
-                "name": "pytest-something",
-            },
-        }
-        profile = _minimal_profile(frameworks=[_detection("django")])
-        manifest = resolve(profile, available, {})
-
-        mcp_names = [m["name"] for m in manifest["mcp_servers"]]
-        load_names = [e["skill"] for e in manifest["load"]]
-        assert "fetch-mcp" in mcp_names
-        assert "pytest-something" in load_names
-
-    def test_agent_graph_hit_lands_in_load_without_installed_skill(
-        self, tmp_path, monkeypatch
-    ):
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-        self._fake_graph(monkeypatch)
-
-        def fake_resolve_by_seeds(graph, seeds, **kwargs):
-            return [
-                {
-                    "name": "code-reviewer",
-                    "type": "agent",
-                    "score": 2.0,
-                    "normalized_score": 0.8,
-                    "shared_tags": ["review"],
-                    "via": ["django"],
-                },
-            ]
-
-        monkeypatch.setattr(
-            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
-        )
-
-        available = {"django": {"path": str(tmp_path / "django/SKILL.md"), "name": "django"}}
-        profile = _minimal_profile(frameworks=[_detection("django")])
-        manifest = resolve(profile, available, {})
-
-        agents = [
-            e for e in manifest["load"]
-            if e.get("entity_type") == "agent"
-        ]
-        assert [e["skill"] for e in agents] == ["code-reviewer"]
-        assert agents[0]["path"] == "/mnt/agents/unknown/code-reviewer.md"
-        assert not any("code-reviewer needed but not installed" in w for w in manifest["warnings"])
-
-    def test_real_graph_walk_routes_cross_type_hits(
-        self, tmp_path, monkeypatch
-    ):
-        import networkx as nx
-        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
-
-        G = nx.Graph()
-        G.add_node("skill:react", label="react", type="skill")
-        G.add_node("skill:pytest-something", label="pytest-something", type="skill")
-        G.add_node("agent:code-reviewer", label="code-reviewer", type="agent")
-        G.add_node("mcp-server:github-mcp-server", label="github-mcp-server", type="mcp-server")
-        G.add_edge(
-            "skill:react",
-            "skill:pytest-something",
-            weight=0.85,
-            shared_tags=["test"],
-        )
-        G.add_edge(
-            "skill:react",
-            "agent:code-reviewer",
-            weight=0.90,
-            shared_tags=["review"],
-        )
-        G.add_edge(
-            "skill:react",
-            "mcp-server:github-mcp-server",
-            weight=0.95,
-            shared_tags=["github"],
-        )
-        monkeypatch.setattr(resolve_skills, "_load_graph", lambda: G)
-        monkeypatch.setattr(resolve_skills, "_GRAPH_AVAILABLE", True)
-
-        available = {
-            "react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"},
-            "pytest-something": {
-                "path": str(tmp_path / "pytest-something/SKILL.md"),
-                "name": "pytest-something",
-            },
-        }
-        profile = _minimal_profile(frameworks=[_detection("react")])
-
-        manifest = resolve(profile, available, {})
-
-        load_by_name = {entry["skill"]: entry for entry in manifest["load"]}
-        assert load_by_name["pytest-something"]["entity_type"] == "skill"
-        assert load_by_name["code-reviewer"]["entity_type"] == "agent"
-        assert load_by_name["code-reviewer"]["path"] == "/mnt/agents/unknown/code-reviewer.md"
-        assert [entry["name"] for entry in manifest["mcp_servers"]] == [
-            "github-mcp-server",
-        ]
-        assert manifest["mcp_servers"][0]["shared_tags"] == ["github"]
-
-
-# ---------------------------------------------------------------------------
-# read_intent_signals
-# ---------------------------------------------------------------------------
-
-class TestReadIntentSignals:
-    def _write_log(self, path: Path, entries: list[dict]) -> None:
-        lines = [json.dumps(e) for e in entries]
-        path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-
-    def test_returns_empty_when_file_missing(self, tmp_path):
-        signals = read_intent_signals(str(tmp_path / "no-such.jsonl"))
-        assert signals == {}
-
-    def test_counts_todays_signals(self, tmp_path, monkeypatch):
-        from datetime import datetime, timezone
-        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        log = tmp_path / "intent.jsonl"
-        self._write_log(log, [
-            {"date": today, "signals": ["react", "docker"]},
-            {"date": today, "signals": ["react"]},
-        ])
-        signals = read_intent_signals(str(log))
-        assert signals["react"] == 2
-        assert signals["docker"] == 1
-
-    def test_ignores_other_dates(self, tmp_path):
-        log = tmp_path / "intent.jsonl"
-        self._write_log(log, [
-            {"date": "2020-01-01", "signals": ["react"]},
-        ])
-        signals = read_intent_signals(str(log))
-        # Today's date != 2020-01-01, so nothing counted
-        assert "react" not in signals
-
-    def test_skips_bad_json_lines(self, tmp_path):
-        from datetime import datetime, timezone
-        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        log = tmp_path / "intent.jsonl"
-        log.write_text(
-            'not json\n'
-            f'{json.dumps({"date": today, "signals": ["fastapi"]})}\n',
-            encoding="utf-8",
-        )
-        signals = read_intent_signals(str(log))
-        assert signals.get("fastapi") == 1
-
-    def test_empty_file_returns_empty(self, tmp_path):
-        log = tmp_path / "intent.jsonl"
-        log.write_text("", encoding="utf-8")
-        signals = read_intent_signals(str(log))
-        assert signals == {}
-
-
-# ---------------------------------------------------------------------------
-# apply_intent_boosts
-# ---------------------------------------------------------------------------
-
-class TestApplyIntentBoosts:
-    def _make_manifest(self) -> dict:
-        return {"suggestions": [], "warnings": []}
-
-    def test_boosts_existing_skill_in_needed(self):
-        needed = {"react": {"priority": 10, "reason": "detected", "confidence": 0.9}}
-        available = {}
-        manifest = self._make_manifest()
-        apply_intent_boosts(needed, {"react": 2}, available, manifest)
-        # boost = 5 * min(2, 3) = 10
-        assert needed["react"]["priority"] == 20
-
-    def test_boost_capped_at_three_signals(self):
-        needed = {"react": {"priority": 10, "reason": "detected", "confidence": 0.9}}
-        manifest = self._make_manifest()
-        apply_intent_boosts(needed, {"react": 10}, {}, manifest)
-        # boost = 5 * min(10, 3) = 15
-        assert needed["react"]["priority"] == 25
-
-    def test_available_not_in_needed_becomes_suggestion(self, tmp_path):
-        needed = {}
-        available = {"docker": {"path": str(tmp_path / "docker/SKILL.md")}}
-        manifest = self._make_manifest()
-        apply_intent_boosts(needed, {"docker": 1}, available, manifest)
-        suggestion_skills = [s["skill"] for s in manifest["suggestions"]]
-        assert "docker" in suggestion_skills
-
-    def test_unknown_signal_no_crash(self):
-        needed = {}
-        manifest = self._make_manifest()
-        apply_intent_boosts(needed, {"totally-unknown-signal": 5}, {}, manifest)
-        assert manifest["suggestions"] == []
-
-    def test_empty_signals_no_change(self):
-        needed = {"react": {"priority": 10, "reason": "x", "confidence": 0.9}}
-        manifest = self._make_manifest()
-        apply_intent_boosts(needed, {}, {}, manifest)
-        assert needed["react"]["priority"] == 10
-
-
-# ─────────────────────────────────────────────────────────────────────
-# P2.5 normalised noise-floor regression
-# ─────────────────────────────────────────────────────────────────────
-#
-# Pre-P2.5 the floors were absolute (1.5 / 1.0) and calibrated against
-# the v0.6 integer-weight graph. On v0.7's blended float-weight graph
-# a single edge is <=1.0, so absolute 1.5 dropped ALL single-seed
-# hits on any sparse/test graph — the suggestion arm silently produced
-# nothing. Post-fix the floors are percentile thresholds in [0,1],
-# scale-invariant.
-
-class TestNoiseFloorNormalized:
-
-    def _fake_graph(self, monkeypatch):
-        import networkx as nx
-        from ctx.core.resolve import resolve_skills
-
-        def fake_load_graph(_=None):
-            G = nx.Graph()
-            G.add_node("skill:foo", type="skill", label="foo")
-            return G
-
-        monkeypatch.setattr(resolve_skills, "_load_graph", fake_load_graph)
-
-    def test_normalized_score_at_top_survives(self, tmp_path, monkeypatch):
-        """A hit with normalized_score=1.0 (the top of its ranking)
-        always passes the floor — otherwise the top recommendation
-        gets silently dropped on small fixtures."""
-        from ctx.core.resolve import resolve_skills
-        from ctx.core.resolve.resolve_skills import resolve
-        self._fake_graph(monkeypatch)
-
-        def fake_hits(*a, **kw):
-            return [
-                {"name": "top-skill", "type": "skill",
-                 "score": 1.23, "normalized_score": 1.0,
-                 "shared_tags": ["x"], "via": ["react"]},
-            ]
-
-        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
-        available = {"react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
-                     "top-skill": {"path": str(tmp_path / "t/SKILL.md"), "name": "top-skill"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-        assert "top-skill" in {e["skill"] for e in manifest["load"]}
-
-    def test_skill_below_0_3_dropped(self, tmp_path, monkeypatch):
-        """Skill hits with normalized_score < 0.30 don't make the cut."""
-        from ctx.core.resolve import resolve_skills
-        from ctx.core.resolve.resolve_skills import resolve
-        self._fake_graph(monkeypatch)
-
-        def fake_hits(*a, **kw):
-            return [
-                {"name": "noisy", "type": "skill",
-                 "score": 0.12, "normalized_score": 0.10,
-                 "shared_tags": [], "via": ["react"]},
-            ]
-        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
-        available = {"react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
-                     "noisy": {"path": str(tmp_path / "n/SKILL.md"), "name": "noisy"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-        assert "noisy" not in {e["skill"] for e in manifest["load"]}
-
-    def test_mcp_floor_is_lower_than_skill_floor(self, tmp_path, monkeypatch):
-        """MCPs are historically sparser; a hit with normalized_score=0.25
-        passes the MCP floor (0.20) but NOT the skill floor (0.30).
-        Pinning this asymmetry so a future 'unify the floors' refactor
-        wipes out MCP recommendations without CI noticing."""
-        from ctx.core.resolve import resolve_skills
-        from ctx.core.resolve.resolve_skills import resolve
-        self._fake_graph(monkeypatch)
-
-        def fake_hits(*a, **kw):
-            return [
-                {"name": "mid-mcp", "type": "mcp-server",
-                 "score": 0.3, "normalized_score": 0.25,
-                 "shared_tags": ["x"], "via": ["react"]},
-                {"name": "mid-skill", "type": "skill",
-                 "score": 0.3, "normalized_score": 0.25,
-                 "shared_tags": ["x"], "via": ["react"]},
-            ]
-        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
-        available = {
-            "react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
-            "mid-skill": {"path": str(tmp_path / "s/SKILL.md"), "name": "mid-skill"},
-        }
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-        # Skill below 0.30 → dropped.
-        assert "mid-skill" not in {e["skill"] for e in manifest["load"]}
-        # MCP above 0.20 → kept.
-        mcp_names = {m["name"] for m in manifest["mcp_servers"]}
-        assert "mid-mcp" in mcp_names
-
-    def test_backward_compat_raw_score_fallback(self, tmp_path, monkeypatch):
-        """An older resolver output without normalized_score must
-        still work via raw-score fallback, so a stale cached graph
-        doesn't silently return [] after the P2.5 upgrade."""
-        from ctx.core.resolve import resolve_skills
-        from ctx.core.resolve.resolve_skills import resolve
-        self._fake_graph(monkeypatch)
-
-        def fake_hits(*a, **kw):
-            # No ``normalized_score`` key — pre-P2.5 shape.
-            return [
-                {"name": "legacy-hit", "type": "skill",
-                 "score": 2.5, "shared_tags": ["x"], "via": ["react"]},
-            ]
-        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
-        available = {"react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
-                     "legacy-hit": {"path": str(tmp_path / "l/SKILL.md"), "name": "legacy-hit"}}
-        profile = _minimal_profile(frameworks=[_detection("react")])
-        manifest = resolve(profile, available, {})
-        # Raw score 2.5 >> any old skill floor so legacy behaviour survives.
-        assert "legacy-hit" in {e["skill"] for e in manifest["load"]}
+"""
+tests/test_resolve_skills.py -- pytest suite for resolve_skills module.
+
+Covers:
+  - discover_available_skills   (happy path, empty dir, malformed frontmatter)
+  - read_wiki_overrides         (happy path, missing dir, bad use_count, boolean flags)
+  - resolve                     (basic load, conflict resolution, always/never_load, cap)
+  - read_intent_signals         (happy path, missing file, bad JSON lines, wrong date)
+  - apply_intent_boosts         (boost in needed, suggestion when available only)
+  - main()                      (via subprocess with --profile arg)
+"""
+
+import json
+import sys
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).parents[1]))
+
+from ctx.core.resolve.resolve_skills import (
+    apply_intent_boosts,
+    discover_available_skills,
+    read_intent_signals,
+    read_wiki_overrides,
+    resolve,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_skill(skills_dir: Path, name: str, frontmatter: str = "") -> Path:
+    """Write a minimal SKILL.md under skills_dir/<name>/."""
+    d = skills_dir / name
+    d.mkdir(parents=True, exist_ok=True)
+    content = f"---\n{frontmatter}\n---\n# {name}\n" if frontmatter else f"# {name}\n"
+    p = d / "SKILL.md"
+    p.write_text(content, encoding="utf-8")
+    return p
+
+
+def _minimal_profile(frameworks=None, languages=None) -> dict:
+    return {
+        "repo_path": "/tmp/repo",
+        "languages": languages or [],
+        "frameworks": frameworks or [],
+        "infrastructure": [],
+        "data_stores": [],
+        "testing": [],
+        "ai_tooling": [],
+        "build_system": [],
+        "docs": [],
+    }
+
+
+def _detection(name: str, confidence: float = 0.9) -> dict:
+    return {"name": name, "confidence": confidence, "evidence": ["file.py"]}
+
+
+def _resolve_without_graph(
+    profile: dict,
+    available: dict,
+    overrides: dict,
+    **kwargs,
+) -> dict:
+    return resolve(profile, available, overrides, enable_graph=False, **kwargs)
+
+
+# ---------------------------------------------------------------------------
+# discover_available_skills
+# ---------------------------------------------------------------------------
+
+class TestDiscoverAvailableSkills:
+    def test_happy_path_single_skill(self, tmp_path):
+        _make_skill(tmp_path, "react", "tags: [javascript]\nversion: 1.0")
+        skills = discover_available_skills(str(tmp_path))
+        assert "react" in skills
+        assert skills["react"]["name"] == "react"
+        assert "path" in skills["react"]
+
+    def test_multiple_skills(self, tmp_path):
+        for name in ("react", "fastapi", "docker"):
+            _make_skill(tmp_path, name, f"tags: [{name}]")
+        skills = discover_available_skills(str(tmp_path))
+        assert set(skills.keys()) == {"react", "fastapi", "docker"}
+
+    def test_missing_directory_returns_empty(self, tmp_path):
+        skills = discover_available_skills(str(tmp_path / "nonexistent"))
+        assert skills == {}
+
+    def test_empty_skills_dir_returns_empty(self, tmp_path):
+        (tmp_path / "skills").mkdir()
+        skills = discover_available_skills(str(tmp_path / "skills"))
+        assert skills == {}
+
+    def test_malformed_frontmatter_still_registers_skill(self, tmp_path, capsys):
+        """A skill with unreadable frontmatter should still be indexed by name."""
+        d = tmp_path / "broken-skill"
+        d.mkdir()
+        (d / "SKILL.md").write_text("not---valid---frontmatter", encoding="utf-8")
+        skills = discover_available_skills(str(tmp_path))
+        # Should still contain the skill (minimal record)
+        assert "broken-skill" in skills
+
+    def test_nested_skill_discovered(self, tmp_path):
+        nested = tmp_path / "category" / "deep-skill"
+        nested.mkdir(parents=True)
+        (nested / "SKILL.md").write_text("# deep\n", encoding="utf-8")
+        skills = discover_available_skills(str(tmp_path))
+        assert "deep-skill" in skills
+
+
+# ---------------------------------------------------------------------------
+# read_wiki_overrides
+# ---------------------------------------------------------------------------
+
+class TestReadWikiOverrides:
+    def _make_override_page(self, wiki: Path, name: str, fields: dict) -> None:
+        entities = wiki / "entities" / "skills"
+        entities.mkdir(parents=True, exist_ok=True)
+        fm_lines = "\n".join(f"{k}: {v}" for k, v in fields.items())
+        page = f"---\n{fm_lines}\n---\n# {name}\n"
+        (entities / f"{name}.md").write_text(page, encoding="utf-8")
+
+    def test_always_load_true(self, tmp_path):
+        self._make_override_page(tmp_path, "react", {"always_load": "true", "use_count": "3"})
+        overrides = read_wiki_overrides(str(tmp_path))
+        assert overrides["react"]["always_load"] is True
+        assert overrides["react"]["use_count"] == 3
+
+    def test_never_load_true(self, tmp_path):
+        self._make_override_page(tmp_path, "legacy", {"never_load": "true", "use_count": "0"})
+        overrides = read_wiki_overrides(str(tmp_path))
+        assert overrides["legacy"]["never_load"] is True
+
+    def test_defaults_when_fields_absent(self, tmp_path):
+        # Provide at least one field so _parse_fm returns non-empty and the
+        # entry isn't skipped by the `if not meta: continue` guard.
+        self._make_override_page(tmp_path, "plain", {"status": "installed"})
+        overrides = read_wiki_overrides(str(tmp_path))
+        assert overrides["plain"]["always_load"] is False
+        assert overrides["plain"]["never_load"] is False
+        assert overrides["plain"]["use_count"] == 0
+
+    def test_missing_entities_dir_returns_empty(self, tmp_path):
+        overrides = read_wiki_overrides(str(tmp_path))
+        assert overrides == {}
+
+    def test_bad_use_count_defaults_to_zero(self, tmp_path):
+        self._make_override_page(tmp_path, "bad", {"use_count": "not-a-number"})
+        # Should not raise; int(str("not-a-number")) will raise, so it goes to except
+        overrides = read_wiki_overrides(str(tmp_path))
+        # Page with parse error is skipped (continue in except)
+        assert "bad" not in overrides
+
+    def test_page_without_frontmatter_skipped(self, tmp_path):
+        entities = tmp_path / "entities" / "skills"
+        entities.mkdir(parents=True)
+        (entities / "plain.md").write_text("# plain\nno frontmatter here", encoding="utf-8")
+        overrides = read_wiki_overrides(str(tmp_path))
+        assert "plain" not in overrides
+
+
+# ---------------------------------------------------------------------------
+# resolve
+# ---------------------------------------------------------------------------
+
+class TestResolve:
+    def test_graph_can_be_disabled_for_deterministic_unit_resolution(
+        self, tmp_path, monkeypatch
+    ):
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+
+        def fail_if_loaded():
+            raise AssertionError("unit resolver tests must not load the live graph")
+
+        monkeypatch.setattr(resolve_skills, "_load_graph", fail_if_loaded)
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+
+        manifest = _resolve_without_graph(profile, available, {})
+
+        assert "react" in [e["skill"] for e in manifest["load"]]
+        assert not any("graph walk skipped" in w for w in manifest["warnings"])
+
+    def test_basic_load_known_skill(self, tmp_path):
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = _resolve_without_graph(profile, available, {})
+        loaded_names = [e["skill"] for e in manifest["load"]]
+        assert "react" in loaded_names
+
+    def test_skill_not_available_goes_to_suggestions(self, tmp_path):
+        available = {}  # react not installed
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = _resolve_without_graph(profile, available, {})
+        suggestion_skills = [s["skill"] for s in manifest["suggestions"]]
+        assert "react" in suggestion_skills
+        # The unavailable react skill must NOT be in load. Graph-matched
+        # agents (e.g. react-specialist found via the live knowledge graph)
+        # may legitimately appear in load — the assertion targets the
+        # specific skill, not the entire load list, so this test stays
+        # robust against richer graph-driven recommendations.
+        loaded_skills = [
+            e.get("skill") for e in manifest["load"]
+            if e.get("entity_type", "skill") == "skill"
+        ]
+        assert "react" not in loaded_skills
+
+    def test_always_load_override_adds_skill(self, tmp_path):
+        available = {"docker": {"path": str(tmp_path / "docker/SKILL.md"), "name": "docker"}}
+        overrides = {"docker": {"always_load": True, "never_load": False, "use_count": 0, "last_used": "", "status": "installed"}}
+        profile = _minimal_profile()  # no detection for docker
+        manifest = _resolve_without_graph(profile, available, overrides)
+        loaded_names = [e["skill"] for e in manifest["load"]]
+        assert "docker" in loaded_names
+
+    def test_never_load_override_removes_skill(self, tmp_path):
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        overrides = {"react": {"always_load": False, "never_load": True, "use_count": 0, "last_used": "", "status": "installed"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = _resolve_without_graph(profile, available, overrides)
+        loaded_names = [e["skill"] for e in manifest["load"]]
+        assert "react" not in loaded_names
+
+    def test_conflict_resolution_keeps_higher_priority(self, tmp_path):
+        available = {
+            "fastapi": {"path": str(tmp_path / "fastapi/SKILL.md"), "name": "fastapi"},
+            "flask": {"path": str(tmp_path / "flask/SKILL.md"), "name": "flask"},
+        }
+        profile = _minimal_profile(frameworks=[
+            _detection("fastapi", confidence=0.95),
+            _detection("flask", confidence=0.6),
+        ])
+        manifest = _resolve_without_graph(profile, available, {})
+        loaded_names = [e["skill"] for e in manifest["load"]]
+        # fastapi has higher base priority (8) and higher confidence boost
+        assert "fastapi" in loaded_names
+        assert "flask" not in loaded_names
+        assert any("Conflict" in w for w in manifest["warnings"])
+
+    def test_max_skills_cap(self, tmp_path):
+        # Create 20 available skills each mapped from detections
+        skills_with_map = ["react", "docker", "fastapi", "django", "flask",
+                           "pytest", "jest", "langchain", "nextjs", "vue"]
+        available = {n: {"path": str(tmp_path / n / "SKILL.md"), "name": n} for n in skills_with_map}
+        profile = _minimal_profile(frameworks=[_detection(n, 0.9) for n in skills_with_map])
+        manifest = _resolve_without_graph(profile, available, {}, max_skills=3)
+        # At most 3 skill-mapped items (plus meta skills if available)
+        non_meta = [e for e in manifest["load"] if e["skill"] not in ("skill-router", "file-reading")]
+        assert len(non_meta) <= 3
+        assert any("Capped" in w for w in manifest["warnings"])
+
+    def test_meta_skills_added_if_available(self, tmp_path):
+        available = {"skill-router": {"path": str(tmp_path / "skill-router/SKILL.md"), "name": "skill-router"}}
+        profile = _minimal_profile()
+        manifest = _resolve_without_graph(profile, available, {})
+        loaded_names = [e["skill"] for e in manifest["load"]]
+        assert "skill-router" in loaded_names
+
+    def test_unloaded_skills_in_unload_list(self, tmp_path):
+        available = {
+            "react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"},
+            "docker": {"path": str(tmp_path / "docker/SKILL.md"), "name": "docker"},
+        }
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = _resolve_without_graph(profile, available, {})
+        unload_names = [e["skill"] for e in manifest["unload"]]
+        assert "docker" in unload_names
+
+    def test_empty_profile_no_crash(self):
+        manifest = _resolve_without_graph(_minimal_profile(), {}, {})
+        assert manifest["load"] == []
+        assert "generated_at" in manifest
+
+    def test_high_confidence_boost_applied(self, tmp_path):
+        """Skills with confidence >=0.9 should get priority +10."""
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        profile = _minimal_profile(frameworks=[_detection("react", confidence=0.95)])
+        manifest = _resolve_without_graph(profile, available, {})
+        entry = next(e for e in manifest["load"] if e["skill"] == "react")
+        # PRIORITY_BASE["react"] = 7, +10 for confidence, +0 no use_count
+        assert entry["priority"] >= 17
+
+
+class TestResolveMcpRecommendations:
+    """Phase 5 regression: graph-walk hits with type=='mcp-server' land
+    in manifest['mcp_servers'], NOT manifest['load'] (the skill bucket).
+    """
+
+    def _fake_graph(self, monkeypatch):
+        """Make resolve() think the graph is available and non-empty."""
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+
+        class _FakeGraph:
+            def number_of_nodes(self) -> int:
+                return 1
+
+        monkeypatch.setattr(
+            resolve_skills, "_load_graph", lambda: _FakeGraph()
+        )
+        monkeypatch.setattr(resolve_skills, "_GRAPH_AVAILABLE", True)
+
+    def test_mcp_graph_hit_lands_in_mcp_servers_not_load(
+        self, tmp_path, monkeypatch
+    ):
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+        self._fake_graph(monkeypatch)
+
+        # Synthetic graph hit: an MCP-type neighbor with score above the
+        # 1.5 noise floor.
+        def fake_resolve_by_seeds(graph, seeds, **kwargs):
+            return [
+                {
+                    "name": "github-mcp-server",
+                    "type": "mcp-server",
+                    "score": 3.0,
+                    "shared_tags": ["_t:github"],
+                    "via": ["react"],
+                },
+            ]
+
+        monkeypatch.setattr(
+            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
+        )
+
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+
+        mcp_names = [m["name"] for m in manifest["mcp_servers"]]
+        load_names = [e["skill"] for e in manifest["load"]]
+        assert "github-mcp-server" in mcp_names, (
+            f"MCP should appear in mcp_servers bucket; got {manifest['mcp_servers']}"
+        )
+        assert "github-mcp-server" not in load_names, (
+            "MCP must NOT land in manifest['load'] — that's the skill-loader bucket"
+        )
+
+    def test_mcp_entry_has_reason_score_and_shared_tags(
+        self, tmp_path, monkeypatch
+    ):
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+        self._fake_graph(monkeypatch)
+
+        def fake_resolve_by_seeds(graph, seeds, **kwargs):
+            return [
+                {
+                    "name": "fetch-mcp",
+                    "type": "mcp-server",
+                    "score": 2.5,
+                    "shared_tags": ["_t:fetch", "http"],
+                    "via": ["django"],
+                },
+            ]
+
+        monkeypatch.setattr(
+            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
+        )
+
+        available = {"django": {"path": str(tmp_path / "django/SKILL.md"), "name": "django"}}
+        profile = _minimal_profile(frameworks=[_detection("django")])
+        manifest = resolve(profile, available, {})
+
+        assert len(manifest["mcp_servers"]) == 1
+        entry = manifest["mcp_servers"][0]
+        assert entry["name"] == "fetch-mcp"
+        assert entry["score"] == 2.5
+        assert "graph neighbor of django" in entry["reason"]
+        assert "_t:fetch" in entry["shared_tags"]
+
+    def test_mcp_deduped_when_same_name_hit_twice(
+        self, tmp_path, monkeypatch
+    ):
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+        self._fake_graph(monkeypatch)
+
+        def fake_resolve_by_seeds(graph, seeds, **kwargs):
+            return [
+                {"name": "duped-mcp", "type": "mcp-server", "score": 2.0,
+                 "shared_tags": [], "via": ["a"]},
+                {"name": "duped-mcp", "type": "mcp-server", "score": 1.8,
+                 "shared_tags": [], "via": ["b"]},
+            ]
+
+        monkeypatch.setattr(
+            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
+        )
+
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+
+        assert sum(1 for m in manifest["mcp_servers"] if m["name"] == "duped-mcp") == 1
+
+    def test_mcp_below_noise_floor_dropped(
+        self, tmp_path, monkeypatch
+    ):
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+        self._fake_graph(monkeypatch)
+
+        def fake_resolve_by_seeds(graph, seeds, **kwargs):
+            # Post-P2.5 the resolver uses normalized_score (percentile
+            # in [0,1]) against the 0.20 MCP floor. A value of 0.1
+            # sits below the floor so the hit must be dropped.
+            return [
+                {"name": "weak-mcp", "type": "mcp-server",
+                 "score": 0.8, "normalized_score": 0.10,
+                 "shared_tags": [], "via": ["a"]},
+            ]
+
+        monkeypatch.setattr(
+            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
+        )
+
+        available = {"react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+
+        assert manifest["mcp_servers"] == []
+
+    def test_skill_hits_still_route_to_load(
+        self, tmp_path, monkeypatch
+    ):
+        # Regression: mixing mcp-server hits and skill hits must not
+        # break the existing skill path.
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+        self._fake_graph(monkeypatch)
+
+        def fake_resolve_by_seeds(graph, seeds, **kwargs):
+            return [
+                {"name": "pytest-something", "type": "skill", "score": 3.0,
+                 "shared_tags": [], "via": ["django"]},
+                {"name": "fetch-mcp", "type": "mcp-server", "score": 2.0,
+                 "shared_tags": [], "via": ["django"]},
+            ]
+
+        monkeypatch.setattr(
+            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
+        )
+
+        available = {
+            "django": {"path": str(tmp_path / "django/SKILL.md"), "name": "django"},
+            "pytest-something": {
+                "path": str(tmp_path / "pytest-something/SKILL.md"),
+                "name": "pytest-something",
+            },
+        }
+        profile = _minimal_profile(frameworks=[_detection("django")])
+        manifest = resolve(profile, available, {})
+
+        mcp_names = [m["name"] for m in manifest["mcp_servers"]]
+        load_names = [e["skill"] for e in manifest["load"]]
+        assert "fetch-mcp" in mcp_names
+        assert "pytest-something" in load_names
+
+    def test_agent_graph_hit_lands_in_load_without_installed_skill(
+        self, tmp_path, monkeypatch
+    ):
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+        self._fake_graph(monkeypatch)
+
+        def fake_resolve_by_seeds(graph, seeds, **kwargs):
+            return [
+                {
+                    "name": "code-reviewer",
+                    "type": "agent",
+                    "score": 2.0,
+                    "normalized_score": 0.8,
+                    "shared_tags": ["review"],
+                    "via": ["django"],
+                },
+            ]
+
+        monkeypatch.setattr(
+            resolve_skills, "_resolve_by_seeds", fake_resolve_by_seeds
+        )
+
+        available = {"django": {"path": str(tmp_path / "django/SKILL.md"), "name": "django"}}
+        profile = _minimal_profile(frameworks=[_detection("django")])
+        manifest = resolve(profile, available, {})
+
+        agents = [
+            e for e in manifest["load"]
+            if e.get("entity_type") == "agent"
+        ]
+        assert [e["skill"] for e in agents] == ["code-reviewer"]
+        assert agents[0]["path"] == "/mnt/agents/unknown/code-reviewer.md"
+        assert not any("code-reviewer needed but not installed" in w for w in manifest["warnings"])
+
+    def test_real_graph_walk_routes_cross_type_hits(
+        self, tmp_path, monkeypatch
+    ):
+        import networkx as nx
+        from ctx.core.resolve import resolve_skills  # noqa: PLC0415
+
+        G = nx.Graph()
+        G.add_node("skill:react", label="react", type="skill")
+        G.add_node("skill:pytest-something", label="pytest-something", type="skill")
+        G.add_node("agent:code-reviewer", label="code-reviewer", type="agent")
+        G.add_node("mcp-server:github-mcp-server", label="github-mcp-server", type="mcp-server")
+        G.add_edge(
+            "skill:react",
+            "skill:pytest-something",
+            weight=0.85,
+            shared_tags=["test"],
+        )
+        G.add_edge(
+            "skill:react",
+            "agent:code-reviewer",
+            weight=0.90,
+            shared_tags=["review"],
+        )
+        G.add_edge(
+            "skill:react",
+            "mcp-server:github-mcp-server",
+            weight=0.95,
+            shared_tags=["github"],
+        )
+        monkeypatch.setattr(resolve_skills, "_load_graph", lambda: G)
+        monkeypatch.setattr(resolve_skills, "_GRAPH_AVAILABLE", True)
+
+        available = {
+            "react": {"path": str(tmp_path / "react/SKILL.md"), "name": "react"},
+            "pytest-something": {
+                "path": str(tmp_path / "pytest-something/SKILL.md"),
+                "name": "pytest-something",
+            },
+        }
+        profile = _minimal_profile(frameworks=[_detection("react")])
+
+        manifest = resolve(profile, available, {})
+
+        load_by_name = {entry["skill"]: entry for entry in manifest["load"]}
+        assert load_by_name["pytest-something"]["entity_type"] == "skill"
+        assert load_by_name["code-reviewer"]["entity_type"] == "agent"
+        assert load_by_name["code-reviewer"]["path"] == "/mnt/agents/unknown/code-reviewer.md"
+        assert [entry["name"] for entry in manifest["mcp_servers"]] == [
+            "github-mcp-server",
+        ]
+        assert manifest["mcp_servers"][0]["shared_tags"] == ["github"]
+
+
+# ---------------------------------------------------------------------------
+# read_intent_signals
+# ---------------------------------------------------------------------------
+
+class TestReadIntentSignals:
+    def _write_log(self, path: Path, entries: list[dict]) -> None:
+        lines = [json.dumps(e) for e in entries]
+        path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    def test_returns_empty_when_file_missing(self, tmp_path):
+        signals = read_intent_signals(str(tmp_path / "no-such.jsonl"))
+        assert signals == {}
+
+    def test_counts_todays_signals(self, tmp_path, monkeypatch):
+        from datetime import datetime, timezone
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        log = tmp_path / "intent.jsonl"
+        self._write_log(log, [
+            {"date": today, "signals": ["react", "docker"]},
+            {"date": today, "signals": ["react"]},
+        ])
+        signals = read_intent_signals(str(log))
+        assert signals["react"] == 2
+        assert signals["docker"] == 1
+
+    def test_ignores_other_dates(self, tmp_path):
+        log = tmp_path / "intent.jsonl"
+        self._write_log(log, [
+            {"date": "2020-01-01", "signals": ["react"]},
+        ])
+        signals = read_intent_signals(str(log))
+        # Today's date != 2020-01-01, so nothing counted
+        assert "react" not in signals
+
+    def test_skips_bad_json_lines(self, tmp_path):
+        from datetime import datetime, timezone
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        log = tmp_path / "intent.jsonl"
+        log.write_text(
+            'not json\n'
+            f'{json.dumps({"date": today, "signals": ["fastapi"]})}\n',
+            encoding="utf-8",
+        )
+        signals = read_intent_signals(str(log))
+        assert signals.get("fastapi") == 1
+
+    def test_empty_file_returns_empty(self, tmp_path):
+        log = tmp_path / "intent.jsonl"
+        log.write_text("", encoding="utf-8")
+        signals = read_intent_signals(str(log))
+        assert signals == {}
+
+
+# ---------------------------------------------------------------------------
+# apply_intent_boosts
+# ---------------------------------------------------------------------------
+
+class TestApplyIntentBoosts:
+    def _make_manifest(self) -> dict:
+        return {"suggestions": [], "warnings": []}
+
+    def test_boosts_existing_skill_in_needed(self):
+        needed = {"react": {"priority": 10, "reason": "detected", "confidence": 0.9}}
+        available = {}
+        manifest = self._make_manifest()
+        apply_intent_boosts(needed, {"react": 2}, available, manifest)
+        # boost = 5 * min(2, 3) = 10
+        assert needed["react"]["priority"] == 20
+
+    def test_boost_capped_at_three_signals(self):
+        needed = {"react": {"priority": 10, "reason": "detected", "confidence": 0.9}}
+        manifest = self._make_manifest()
+        apply_intent_boosts(needed, {"react": 10}, {}, manifest)
+        # boost = 5 * min(10, 3) = 15
+        assert needed["react"]["priority"] == 25
+
+    def test_available_not_in_needed_becomes_suggestion(self, tmp_path):
+        needed = {}
+        available = {"docker": {"path": str(tmp_path / "docker/SKILL.md")}}
+        manifest = self._make_manifest()
+        apply_intent_boosts(needed, {"docker": 1}, available, manifest)
+        suggestion_skills = [s["skill"] for s in manifest["suggestions"]]
+        assert "docker" in suggestion_skills
+
+    def test_unknown_signal_no_crash(self):
+        needed = {}
+        manifest = self._make_manifest()
+        apply_intent_boosts(needed, {"totally-unknown-signal": 5}, {}, manifest)
+        assert manifest["suggestions"] == []
+
+    def test_empty_signals_no_change(self):
+        needed = {"react": {"priority": 10, "reason": "x", "confidence": 0.9}}
+        manifest = self._make_manifest()
+        apply_intent_boosts(needed, {}, {}, manifest)
+        assert needed["react"]["priority"] == 10
+
+
+# ─────────────────────────────────────────────────────────────────────
+# P2.5 normalised noise-floor regression
+# ─────────────────────────────────────────────────────────────────────
+#
+# Pre-P2.5 the floors were absolute (1.5 / 1.0) and calibrated against
+# the v0.6 integer-weight graph. On v0.7's blended float-weight graph
+# a single edge is <=1.0, so absolute 1.5 dropped ALL single-seed
+# hits on any sparse/test graph — the suggestion arm silently produced
+# nothing. Post-fix the floors are percentile thresholds in [0,1],
+# scale-invariant.
+
+class TestNoiseFloorNormalized:
+
+    def _fake_graph(self, monkeypatch):
+        import networkx as nx
+        from ctx.core.resolve import resolve_skills
+
+        def fake_load_graph(_=None):
+            G = nx.Graph()
+            G.add_node("skill:foo", type="skill", label="foo")
+            return G
+
+        monkeypatch.setattr(resolve_skills, "_load_graph", fake_load_graph)
+
+    def test_normalized_score_at_top_survives(self, tmp_path, monkeypatch):
+        """A hit with normalized_score=1.0 (the top of its ranking)
+        always passes the floor — otherwise the top recommendation
+        gets silently dropped on small fixtures."""
+        from ctx.core.resolve import resolve_skills
+        from ctx.core.resolve.resolve_skills import resolve
+        self._fake_graph(monkeypatch)
+
+        def fake_hits(*a, **kw):
+            return [
+                {"name": "top-skill", "type": "skill",
+                 "score": 1.23, "normalized_score": 1.0,
+                 "shared_tags": ["x"], "via": ["react"]},
+            ]
+
+        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
+        available = {"react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
+                     "top-skill": {"path": str(tmp_path / "t/SKILL.md"), "name": "top-skill"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+        assert "top-skill" in {e["skill"] for e in manifest["load"]}
+
+    def test_skill_below_0_3_dropped(self, tmp_path, monkeypatch):
+        """Skill hits with normalized_score < 0.30 don't make the cut."""
+        from ctx.core.resolve import resolve_skills
+        from ctx.core.resolve.resolve_skills import resolve
+        self._fake_graph(monkeypatch)
+
+        def fake_hits(*a, **kw):
+            return [
+                {"name": "noisy", "type": "skill",
+                 "score": 0.12, "normalized_score": 0.10,
+                 "shared_tags": [], "via": ["react"]},
+            ]
+        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
+        available = {"react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
+                     "noisy": {"path": str(tmp_path / "n/SKILL.md"), "name": "noisy"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+        assert "noisy" not in {e["skill"] for e in manifest["load"]}
+
+    def test_mcp_floor_is_lower_than_skill_floor(self, tmp_path, monkeypatch):
+        """MCPs are historically sparser; a hit with normalized_score=0.25
+        passes the MCP floor (0.20) but NOT the skill floor (0.30).
+        Pinning this asymmetry so a future 'unify the floors' refactor
+        wipes out MCP recommendations without CI noticing."""
+        from ctx.core.resolve import resolve_skills
+        from ctx.core.resolve.resolve_skills import resolve
+        self._fake_graph(monkeypatch)
+
+        def fake_hits(*a, **kw):
+            return [
+                {"name": "mid-mcp", "type": "mcp-server",
+                 "score": 0.3, "normalized_score": 0.25,
+                 "shared_tags": ["x"], "via": ["react"]},
+                {"name": "mid-skill", "type": "skill",
+                 "score": 0.3, "normalized_score": 0.25,
+                 "shared_tags": ["x"], "via": ["react"]},
+            ]
+        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
+        available = {
+            "react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
+            "mid-skill": {"path": str(tmp_path / "s/SKILL.md"), "name": "mid-skill"},
+        }
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+        # Skill below 0.30 → dropped.
+        assert "mid-skill" not in {e["skill"] for e in manifest["load"]}
+        # MCP above 0.20 → kept.
+        mcp_names = {m["name"] for m in manifest["mcp_servers"]}
+        assert "mid-mcp" in mcp_names
+
+    def test_backward_compat_raw_score_fallback(self, tmp_path, monkeypatch):
+        """An older resolver output without normalized_score must
+        still work via raw-score fallback, so a stale cached graph
+        doesn't silently return [] after the P2.5 upgrade."""
+        from ctx.core.resolve import resolve_skills
+        from ctx.core.resolve.resolve_skills import resolve
+        self._fake_graph(monkeypatch)
+
+        def fake_hits(*a, **kw):
+            # No ``normalized_score`` key — pre-P2.5 shape.
+            return [
+                {"name": "legacy-hit", "type": "skill",
+                 "score": 2.5, "shared_tags": ["x"], "via": ["react"]},
+            ]
+        monkeypatch.setattr(resolve_skills, "_resolve_by_seeds", fake_hits)
+        available = {"react": {"path": str(tmp_path / "r/SKILL.md"), "name": "react"},
+                     "legacy-hit": {"path": str(tmp_path / "l/SKILL.md"), "name": "legacy-hit"}}
+        profile = _minimal_profile(frameworks=[_detection("react")])
+        manifest = resolve(profile, available, {})
+        # Raw score 2.5 >> any old skill floor so legacy behaviour survives.
+        assert "legacy-hit" in {e["skill"] for e in manifest["load"]}

src/tests/test_safe_name.py

@@ -1,228 +1,228 @@
-"""
-test_safe_name.py -- unit tests for _safe_name validators.
-
-Pins the security-auditor H-2 (relpath traversal) and H-3 (Windows drive-
-relative source name) findings. These validators are shared between
-mcp_canonical_index (relpath) and mcp_enrich / mcp_ingest (source name),
-so regressions here would reopen both attack surfaces simultaneously.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-import pytest
-
-from ctx.utils._safe_name import (
-    is_safe_relpath,
-    is_safe_source_name,
-    validate_relpath,
-    validate_source_name,
-)
-
-
-# ────────────────────────────────────────────────────────────────────
-# Source-name validator
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestIsSafeSourceName:
-    @pytest.mark.parametrize("name", [
-        "pulsemcp",
-        "awesome-mcp",
-        "glama",
-        "mcp-get",
-        "foo.v2",
-        "a",
-        "0",
-        "a" * 128,  # exactly the max length
-    ])
-    def test_accepts_valid_names(self, name: str):
-        assert is_safe_source_name(name)
-
-    @pytest.mark.parametrize("name", [
-        "",              # empty
-        "-pulsemcp",     # leading hyphen
-        ".pulsemcp",     # leading dot (hidden file)
-        "_pulsemcp",     # leading underscore (disallowed: first char must be [a-z0-9])
-        "PULSEMCP",      # uppercase (regex is lowercase)
-        "pulse mcp",     # space
-        "pulse$mcp",     # shell metachar
-        "a" * 129,       # too long
-    ])
-    def test_rejects_malformed(self, name: str):
-        assert not is_safe_source_name(name)
-
-    @pytest.mark.parametrize("name", [
-        "foo/bar",       # directory separator (posix)
-        "foo\\bar",      # directory separator (windows)
-        "../etc/passwd",
-        "..",
-        "/etc/passwd",
-        "\\windows\\system32",
-    ])
-    def test_rejects_path_separators(self, name: str):
-        """H-3 regression — traversal-shaped names must be blocked."""
-        assert not is_safe_source_name(name)
-
-    @pytest.mark.parametrize("name", [
-        "C:evil",         # Windows drive-relative (the H-3 exploit)
-        "C:",
-        "c:foo",
-        "C:\\Windows",    # drive-absolute
-        "Z:payload.json",
-    ])
-    def test_rejects_windows_drive_relative(self, name: str):
-        """H-3 regression — Windows drive-relative / absolute must be blocked.
-
-        Prior validator only checked ``/ \\ .``; ``C:evil`` passed through
-        and landed wherever drive C's CWD happened to be at the time.
-        """
-        assert not is_safe_source_name(name)
-
-    @pytest.mark.parametrize("name", [
-        "CON", "con", "Con",      # case-insensitive
-        "PRN",
-        "NUL",
-        "AUX",
-        "COM1", "COM9",
-        "LPT1", "LPT9",
-    ])
-    def test_rejects_windows_reserved_device_names(self, name: str):
-        """``NUL.json`` on Windows writes to the null device silently."""
-        assert not is_safe_source_name(name)
-
-    # Strix vuln-0003: Windows device-name reservation survives a suffix
-    # or trailing dot/space. `con.txt`, `aux.md`, `nul.`, `com1.log`, and
-    # `lpt1.txt` all still resolve to the device endpoint on Windows.
-    @pytest.mark.parametrize("name", [
-        "con.txt", "CON.TXT", "Con.Log",
-        "aux.md", "AUX.json",
-        "prn.bak",
-        "nul.",          # trailing dot — Windows strips it then matches NUL
-        "com1.log", "COM9.cfg",
-        "lpt1.txt", "lpt9.ini",
-    ])
-    def test_rejects_reserved_name_with_suffix_or_trailing_dot(
-        self, name: str,
-    ) -> None:
-        assert not is_safe_source_name(name), (
-            f"{name!r} slipped past the Windows reserved-name normalize"
-        )
-
-    def test_rejects_non_string(self):
-        assert not is_safe_source_name(None)              # type: ignore[arg-type]
-        assert not is_safe_source_name(123)               # type: ignore[arg-type]
-        assert not is_safe_source_name(["pulsemcp"])      # type: ignore[arg-type]
-
-
-class TestValidateSourceName:
-    def test_raises_on_invalid(self):
-        with pytest.raises(ValueError, match="invalid source name"):
-            validate_source_name("C:evil")
-
-    def test_custom_field_in_error_message(self):
-        with pytest.raises(ValueError, match="invalid mcp_source name"):
-            validate_source_name("../etc/passwd", field="mcp_source")
-
-    def test_silent_on_valid(self):
-        # Must not raise.
-        validate_source_name("pulsemcp")
-
-
-# ────────────────────────────��───────────────────────────────────────
-# Relpath validator — the H-2 attack surface
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestIsSafeRelpath:
-    @pytest.fixture()
-    def root(self, tmp_path: Path) -> Path:
-        (tmp_path / "a").mkdir()
-        (tmp_path / "a" / "foo.md").write_text("body", encoding="utf-8")
-        (tmp_path / "subdir" / "nested").mkdir(parents=True)
-        return tmp_path
-
-    @pytest.mark.parametrize("rel", [
-        "a/foo.md",                    # shallow
-        "subdir/nested/x.md",          # nested
-        "a/b/c/d/e/f/deep.md",         # very nested — no need to exist
-        "hooks/backup_on_change.py",
-    ])
-    def test_accepts_safe_relative_paths(self, root: Path, rel: str):
-        assert is_safe_relpath(root, rel)
-
-    @pytest.mark.parametrize("rel", [
-        "",
-        "../etc/passwd",
-        "../../../../tmp/evil",
-        "a/../../../outside",
-        "..",
-        "a/../..",
-    ])
-    def test_rejects_traversal(self, root: Path, rel: str):
-        """H-2 regression — ``..`` components in the stored relpath."""
-        assert not is_safe_relpath(root, rel)
-
-    @pytest.mark.parametrize("rel", [
-        "/etc/passwd",
-        "/foo",
-        "\\windows\\system32",
-        "\\foo",
-    ])
-    def test_rejects_absolute(self, root: Path, rel: str):
-        assert not is_safe_relpath(root, rel)
-
-    @pytest.mark.parametrize("rel", [
-        "C:evil",          # drive-relative: resolves against drive C's CWD
-        "C:/foo",
-        "C:\\foo",
-        "Z:payload.md",
-    ])
-    def test_rejects_windows_drive_relative(self, root: Path, rel: str):
-        """H-3 cousin — drive-relative in a stored relpath is always wrong."""
-        assert not is_safe_relpath(root, rel)
-
-    def test_rejects_non_string(self, root: Path):
-        assert not is_safe_relpath(root, None)            # type: ignore[arg-type]
-        assert not is_safe_relpath(root, 42)              # type: ignore[arg-type]
-
-    def test_empty_string_rejected(self, root: Path):
-        assert not is_safe_relpath(root, "")
-
-    @pytest.mark.skipif(os.name == "nt", reason="POSIX-only: symlink requires admin on Windows")
-    def test_rejects_symlink_escape(self, tmp_path: Path):
-        """A symlink INSIDE root that points OUTSIDE root must be caught.
-
-        Even with no ``..`` in the relpath, following a symlink to
-        /etc/passwd is traversal.
-        """
-        outside = tmp_path / "outside"
-        outside.mkdir()
-        (outside / "secret").write_text("sensitive", encoding="utf-8")
-
-        root = tmp_path / "root"
-        root.mkdir()
-        # Symlink root/escape -> outside
-        try:
-            (root / "escape").symlink_to(outside)
-        except (OSError, NotImplementedError):
-            pytest.skip("Platform does not support symlinks in this context")
-
-        # "escape/secret" is a relative path with no ``..``, but after
-        # symlink resolution it lands at outside/secret.
-        assert not is_safe_relpath(root, "escape/secret")
-
-
-class TestValidateRelpath:
-    def test_raises_on_traversal(self, tmp_path: Path):
-        with pytest.raises(ValueError, match="invalid relpath"):
-            validate_relpath(tmp_path, "../../etc/passwd")
-
-    def test_custom_field_in_error_message(self, tmp_path: Path):
-        with pytest.raises(ValueError, match="invalid entity_path"):
-            validate_relpath(tmp_path, "C:evil", field="entity_path")
-
-    def test_silent_on_valid(self, tmp_path: Path):
-        validate_relpath(tmp_path, "a/foo.md")
+"""
+test_safe_name.py -- unit tests for _safe_name validators.
+
+Pins the security-auditor H-2 (relpath traversal) and H-3 (Windows drive-
+relative source name) findings. These validators are shared between
+mcp_canonical_index (relpath) and mcp_enrich / mcp_ingest (source name),
+so regressions here would reopen both attack surfaces simultaneously.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+from ctx.utils._safe_name import (
+    is_safe_relpath,
+    is_safe_source_name,
+    validate_relpath,
+    validate_source_name,
+)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Source-name validator
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestIsSafeSourceName:
+    @pytest.mark.parametrize("name", [
+        "pulsemcp",
+        "awesome-mcp",
+        "glama",
+        "mcp-get",
+        "foo.v2",
+        "a",
+        "0",
+        "a" * 128,  # exactly the max length
+    ])
+    def test_accepts_valid_names(self, name: str):
+        assert is_safe_source_name(name)
+
+    @pytest.mark.parametrize("name", [
+        "",              # empty
+        "-pulsemcp",     # leading hyphen
+        ".pulsemcp",     # leading dot (hidden file)
+        "_pulsemcp",     # leading underscore (disallowed: first char must be [a-z0-9])
+        "PULSEMCP",      # uppercase (regex is lowercase)
+        "pulse mcp",     # space
+        "pulse$mcp",     # shell metachar
+        "a" * 129,       # too long
+    ])
+    def test_rejects_malformed(self, name: str):
+        assert not is_safe_source_name(name)
+
+    @pytest.mark.parametrize("name", [
+        "foo/bar",       # directory separator (posix)
+        "foo\\bar",      # directory separator (windows)
+        "../etc/passwd",
+        "..",
+        "/etc/passwd",
+        "\\windows\\system32",
+    ])
+    def test_rejects_path_separators(self, name: str):
+        """H-3 regression — traversal-shaped names must be blocked."""
+        assert not is_safe_source_name(name)
+
+    @pytest.mark.parametrize("name", [
+        "C:evil",         # Windows drive-relative (the H-3 exploit)
+        "C:",
+        "c:foo",
+        "C:\\Windows",    # drive-absolute
+        "Z:payload.json",
+    ])
+    def test_rejects_windows_drive_relative(self, name: str):
+        """H-3 regression — Windows drive-relative / absolute must be blocked.
+
+        Prior validator only checked ``/ \\ .``; ``C:evil`` passed through
+        and landed wherever drive C's CWD happened to be at the time.
+        """
+        assert not is_safe_source_name(name)
+
+    @pytest.mark.parametrize("name", [
+        "CON", "con", "Con",      # case-insensitive
+        "PRN",
+        "NUL",
+        "AUX",
+        "COM1", "COM9",
+        "LPT1", "LPT9",
+    ])
+    def test_rejects_windows_reserved_device_names(self, name: str):
+        """``NUL.json`` on Windows writes to the null device silently."""
+        assert not is_safe_source_name(name)
+
+    # Strix vuln-0003: Windows device-name reservation survives a suffix
+    # or trailing dot/space. `con.txt`, `aux.md`, `nul.`, `com1.log`, and
+    # `lpt1.txt` all still resolve to the device endpoint on Windows.
+    @pytest.mark.parametrize("name", [
+        "con.txt", "CON.TXT", "Con.Log",
+        "aux.md", "AUX.json",
+        "prn.bak",
+        "nul.",          # trailing dot — Windows strips it then matches NUL
+        "com1.log", "COM9.cfg",
+        "lpt1.txt", "lpt9.ini",
+    ])
+    def test_rejects_reserved_name_with_suffix_or_trailing_dot(
+        self, name: str,
+    ) -> None:
+        assert not is_safe_source_name(name), (
+            f"{name!r} slipped past the Windows reserved-name normalize"
+        )
+
+    def test_rejects_non_string(self):
+        assert not is_safe_source_name(None)              # type: ignore[arg-type]
+        assert not is_safe_source_name(123)               # type: ignore[arg-type]
+        assert not is_safe_source_name(["pulsemcp"])      # type: ignore[arg-type]
+
+
+class TestValidateSourceName:
+    def test_raises_on_invalid(self):
+        with pytest.raises(ValueError, match="invalid source name"):
+            validate_source_name("C:evil")
+
+    def test_custom_field_in_error_message(self):
+        with pytest.raises(ValueError, match="invalid mcp_source name"):
+            validate_source_name("../etc/passwd", field="mcp_source")
+
+    def test_silent_on_valid(self):
+        # Must not raise.
+        validate_source_name("pulsemcp")
+
+
+# ────────────────────────────────────────────────────────────────────
+# Relpath validator — the H-2 attack surface
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestIsSafeRelpath:
+    @pytest.fixture()
+    def root(self, tmp_path: Path) -> Path:
+        (tmp_path / "a").mkdir()
+        (tmp_path / "a" / "foo.md").write_text("body", encoding="utf-8")
+        (tmp_path / "subdir" / "nested").mkdir(parents=True)
+        return tmp_path
+
+    @pytest.mark.parametrize("rel", [
+        "a/foo.md",                    # shallow
+        "subdir/nested/x.md",          # nested
+        "a/b/c/d/e/f/deep.md",         # very nested — no need to exist
+        "hooks/backup_on_change.py",
+    ])
+    def test_accepts_safe_relative_paths(self, root: Path, rel: str):
+        assert is_safe_relpath(root, rel)
+
+    @pytest.mark.parametrize("rel", [
+        "",
+        "../etc/passwd",
+        "../../../../tmp/evil",
+        "a/../../../outside",
+        "..",
+        "a/../..",
+    ])
+    def test_rejects_traversal(self, root: Path, rel: str):
+        """H-2 regression — ``..`` components in the stored relpath."""
+        assert not is_safe_relpath(root, rel)
+
+    @pytest.mark.parametrize("rel", [
+        "/etc/passwd",
+        "/foo",
+        "\\windows\\system32",
+        "\\foo",
+    ])
+    def test_rejects_absolute(self, root: Path, rel: str):
+        assert not is_safe_relpath(root, rel)
+
+    @pytest.mark.parametrize("rel", [
+        "C:evil",          # drive-relative: resolves against drive C's CWD
+        "C:/foo",
+        "C:\\foo",
+        "Z:payload.md",
+    ])
+    def test_rejects_windows_drive_relative(self, root: Path, rel: str):
+        """H-3 cousin — drive-relative in a stored relpath is always wrong."""
+        assert not is_safe_relpath(root, rel)
+
+    def test_rejects_non_string(self, root: Path):
+        assert not is_safe_relpath(root, None)            # type: ignore[arg-type]
+        assert not is_safe_relpath(root, 42)              # type: ignore[arg-type]
+
+    def test_empty_string_rejected(self, root: Path):
+        assert not is_safe_relpath(root, "")
+
+    @pytest.mark.skipif(os.name == "nt", reason="POSIX-only: symlink requires admin on Windows")
+    def test_rejects_symlink_escape(self, tmp_path: Path):
+        """A symlink INSIDE root that points OUTSIDE root must be caught.
+
+        Even with no ``..`` in the relpath, following a symlink to
+        /etc/passwd is traversal.
+        """
+        outside = tmp_path / "outside"
+        outside.mkdir()
+        (outside / "secret").write_text("sensitive", encoding="utf-8")
+
+        root = tmp_path / "root"
+        root.mkdir()
+        # Symlink root/escape -> outside
+        try:
+            (root / "escape").symlink_to(outside)
+        except (OSError, NotImplementedError):
+            pytest.skip("Platform does not support symlinks in this context")
+
+        # "escape/secret" is a relative path with no ``..``, but after
+        # symlink resolution it lands at outside/secret.
+        assert not is_safe_relpath(root, "escape/secret")
+
+
+class TestValidateRelpath:
+    def test_raises_on_traversal(self, tmp_path: Path):
+        with pytest.raises(ValueError, match="invalid relpath"):
+            validate_relpath(tmp_path, "../../etc/passwd")
+
+    def test_custom_field_in_error_message(self, tmp_path: Path):
+        with pytest.raises(ValueError, match="invalid entity_path"):
+            validate_relpath(tmp_path, "C:evil", field="entity_path")
+
+    def test_silent_on_valid(self, tmp_path: Path):
+        validate_relpath(tmp_path, "a/foo.md")

src/tests/test_similarity_precision_recall.py

@@ -1,314 +1,314 @@
-"""
-test_similarity_precision_recall.py -- Integration test for the intake gate's
-similarity detection against a curated corpus.
-
-Purpose
--------
-The intake gate's usefulness depends on two numbers:
-
-  - **Recall** on near-duplicates: when two skills genuinely overlap, the
-    gate must flag at least 90% of them (``DUPLICATE`` or
-    ``NEAR_DUPLICATE``). Missed duplicates let redundant skills into the
-    corpus, which is the whole failure mode the gate exists to prevent.
-
-  - **Precision** against distinct and adversarial pairs: when two
-    skills are genuinely different, the gate must *not* flag them. False
-    positives block legitimate skills and train users to override the
-    gate — the worst failure mode.
-
-This test runs all three fixture sets (30 near-duplicates, 30 distinct,
-10 adversarial) through the real embedder and asserts precision/recall
-≥ 0.90.
-
-Tuning workflow
----------------
-Fixtures are hand-written under ``src/tests/fixtures/similarity/``. If
-the test fails:
-
-  1. Read the per-pair breakdown printed on failure — each misclassified
-     pair lists its cosine score and reasoning.
-  2. Adjust ``intake_dup_threshold`` / ``intake_near_dup_threshold`` in
-     ``config.json`` (documented as tunable in ``ctx_config.py``).
-  3. Re-run.
-
-If tuning thresholds cannot hit 0.9 on both axes, the bug is upstream —
-either ``compose_corpus_text`` is dropping signal, or the fixtures need
-revision. Do not lower the 0.9 bar without a plan.
-
-Markers
--------
-Marked ``@pytest.mark.integration`` because it loads the real MiniLM
-model (~100MB on first run). Skip in fast CI with ``-m 'not integration'``.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-import pytest
-
-SRC_DIR = Path(__file__).resolve().parents[1]
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
-
-from corpus_cache import CorpusCache  # noqa: E402
-from cosine_ranker import CosineRanker  # noqa: E402
-from ctx_config import cfg  # noqa: E402
-from intake_gate import compose_corpus_text, run_intake_gate  # noqa: E402
-
-
-FIXTURE_DIR = Path(__file__).parent / "fixtures" / "similarity"
-
-# Minimum precision and recall the gate must clear to be shipped.
-# Raising these is easy; lowering them requires a plan, not a fixup.
-_MIN_PRECISION = 0.90
-_MIN_RECALL = 0.90
-_REQUIRE_SIMILARITY_EVAL = os.environ.get("CTX_REQUIRE_SIMILARITY_EVAL") == "1"
-
-
-# ────────────────────────────────────────────────────────────────────
-# Fixture loading
-# ────────────────────────────────────────────────────────────────────
-
-
-@dataclass(frozen=True)
-class _Pair:
-    id: str
-    label: str  # "near_duplicate" | "distinct" | "adversarial"
-    a_md: str
-    b_md: str
-    note: str
-
-    @property
-    def should_flag(self) -> bool:
-        """A pair should be flagged iff its label is near_duplicate.
-
-        Distinct and adversarial pairs must pass unflagged — they exist
-        to prove the gate does not false-positive on legitimate skills.
-        """
-        return self.label == "near_duplicate"
-
-
-def _compose_md(entry: dict) -> str:
-    """Build a full markdown document from a fixture entry.
-
-    Fixture files store only the semantic content (name, description,
-    body) so they stay focused and editable. This helper assembles the
-    full markdown with frontmatter + H1 so structural checks pass.
-    """
-    name = entry["name"]
-    description = entry["description"]
-    body = entry["body"]
-    return (
-        "---\n"
-        f"name: {name}\n"
-        f"description: {description}\n"
-        "---\n"
-        f"# {name}\n\n"
-        f"{body}\n"
-    )
-
-
-def _load_pairs(filename: str) -> list[_Pair]:
-    path = FIXTURE_DIR / filename
-    if not path.exists():
-        pytest.fail(f"tracked fixture file missing: {path}")
-    pairs: list[_Pair] = []
-    for line_num, raw in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
-        raw = raw.strip()
-        if not raw or raw.startswith("#"):
-            continue
-        try:
-            entry = json.loads(raw)
-        except json.JSONDecodeError as exc:
-            pytest.fail(f"{path}:{line_num} invalid JSON: {exc}")
-        pairs.append(_Pair(
-            id=entry["id"],
-            label=entry["label"],
-            a_md=_compose_md(entry["a"]),
-            b_md=_compose_md(entry["b"]),
-            note=entry.get("note", ""),
-        ))
-    return pairs
-
-
-# ───────────────────────────────────────��────────────────────────────
-# Per-pair evaluation
-# ────────────────────────────────────────────────────────────────────
-
-
-@dataclass(frozen=True)
-class _Outcome:
-    pair: _Pair
-    flagged: bool
-    top_score: float
-    top_code: str  # "DUPLICATE" | "NEAR_DUPLICATE" | "" when not flagged
-
-
-def _evaluate_pair(pair: _Pair, embedder, cache_root: Path) -> _Outcome:
-    """Record A, check B, return whether B was flagged against A.
-
-    Each pair gets its own CorpusCache namespace so earlier pairs don't
-    leak into later ones. The embedder is reused across pairs — loading
-    MiniLM is the dominant cost, and it's immutable for this run.
-    """
-    cache = CorpusCache(f"fixture-{pair.id}", root=cache_root)
-
-    # Record A into the per-pair cache.
-    a_text = compose_corpus_text(pair.a_md)
-    a_vec = embedder.embed([a_text])[0]
-    cache.put(f"{pair.id}-a", a_text, a_vec)
-
-    # Rank B against the single-entry corpus.
-    ranker = CosineRanker.from_cache(cache)
-    config = cfg.build_intake_config()
-    decision = run_intake_gate(
-        pair.b_md,
-        embedder=embedder,
-        ranker=ranker,
-        config=config,
-    )
-
-    codes = {f.code for f in decision.findings}
-    flagged = "DUPLICATE" in codes or "NEAR_DUPLICATE" in codes
-    top_score = decision.nearest[0].score if decision.nearest else 0.0
-    top_code = (
-        "DUPLICATE" if "DUPLICATE" in codes
-        else "NEAR_DUPLICATE" if "NEAR_DUPLICATE" in codes
-        else ""
-    )
-    return _Outcome(pair=pair, flagged=flagged, top_score=float(top_score), top_code=top_code)
-
-
-# ────────────────────────────────────────────────────────────────────
-# Module-scoped setup — embedder loads once
-# ────────────────────────────────────────────────────────────────────
-
-
-@pytest.fixture(scope="module")
-def _embedder():
-    """Load the real configured embedder once per module run.
-
-    Local runs may skip when the embedding backend is unavailable. The
-    dedicated CI similarity gate sets CTX_REQUIRE_SIMILARITY_EVAL=1, in
-    which case dependency/model setup failures are hard failures.
-    """
-    try:
-        import sentence_transformers  # noqa: F401
-    except ImportError as exc:
-        message = f"sentence-transformers is required for similarity evaluation: {exc}"
-        if _REQUIRE_SIMILARITY_EVAL:
-            pytest.fail(message)
-        pytest.skip(message)
-    try:
-        return cfg.build_intake_embedder()
-    except Exception as exc:  # noqa: BLE001 - fail/skip policy depends on CI mode
-        message = f"cannot build intake embedder: {exc}"
-        if _REQUIRE_SIMILARITY_EVAL:
-            pytest.fail(message)
-        pytest.skip(message)
-
-
-@pytest.fixture
-def _tmp_cache_root(tmp_path, monkeypatch):
-    """Isolate cache writes so tests never touch ~/.claude."""
-    root = tmp_path / "intake-cache"
-    root.mkdir()
-    monkeypatch.setattr(cfg, "intake_cache_root", root)
-    return root
-
-
-# ────────────────────────────────────────────────────────────────────
-# The three fixture sets — evaluated together for precision/recall
-# ────────────────────────────────────────────────────────────────────
-
-
-@pytest.mark.integration
-def test_similarity_precision_and_recall(_embedder, _tmp_cache_root):
-    """Precision and recall across the full curated fixture set.
-
-    Confusion matrix:
-        TP = near_duplicate pairs correctly flagged
-        FN = near_duplicate pairs NOT flagged (missed duplicates)
-        FP = distinct or adversarial pairs incorrectly flagged
-        TN = distinct or adversarial pairs correctly passed
-
-    precision = TP / (TP + FP)
-    recall    = TP / (TP + FN)
-    """
-    near = _load_pairs("near_duplicates.jsonl")
-    distinct = _load_pairs("distinct_pairs.jsonl")
-    adversarial = _load_pairs("adversarial.jsonl")
-
-    # Sanity-check fixture counts so a truncated JSONL doesn't silently
-    # lower the bar the test claims to enforce.
-    assert len(near) == 30, f"expected 30 near-duplicate pairs, got {len(near)}"
-    assert len(distinct) == 30, f"expected 30 distinct pairs, got {len(distinct)}"
-    assert len(adversarial) == 10, f"expected 10 adversarial pairs, got {len(adversarial)}"
-
-    all_pairs = near + distinct + adversarial
-    outcomes = [_evaluate_pair(p, _embedder, _tmp_cache_root) for p in all_pairs]
-
-    tp = sum(1 for o in outcomes if o.pair.should_flag and o.flagged)
-    fn = sum(1 for o in outcomes if o.pair.should_flag and not o.flagged)
-    fp = sum(1 for o in outcomes if not o.pair.should_flag and o.flagged)
-    tn = sum(1 for o in outcomes if not o.pair.should_flag and not o.flagged)
-
-    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
-    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
-
-    # Per-pair breakdown in the failure message so tuning is data-driven.
-    misses = [o for o in outcomes if o.pair.should_flag and not o.flagged]
-    false_pos = [o for o in outcomes if not o.pair.should_flag and o.flagged]
-
-    failure_lines = [
-        f"precision={precision:.3f} (need >= {_MIN_PRECISION})",
-        f"recall={recall:.3f} (need >= {_MIN_RECALL})",
-        f"TP={tp} FN={fn} FP={fp} TN={tn}",
-        "",
-    ]
-    if misses:
-        failure_lines.append(f"Missed duplicates ({len(misses)}):")
-        for o in misses:
-            failure_lines.append(
-                f"  {o.pair.id}: top_score={o.top_score:.3f} label={o.pair.label}"
-            )
-    if false_pos:
-        failure_lines.append(f"False positives ({len(false_pos)}):")
-        for o in false_pos:
-            failure_lines.append(
-                f"  {o.pair.id}: top_score={o.top_score:.3f} "
-                f"flagged={o.top_code} label={o.pair.label}"
-            )
-    message = "\n".join(failure_lines)
-
-    assert recall >= _MIN_RECALL, message
-    assert precision >= _MIN_PRECISION, message
-
-
-def test_fixture_schema_integrity():
-    """Fail fast if any fixture file is malformed — catches JSONL typos
-    without having to load the embedder.
-    """
-    for filename, expected_label in [
-        ("near_duplicates.jsonl", "near_duplicate"),
-        ("distinct_pairs.jsonl", "distinct"),
-        ("adversarial.jsonl", "adversarial"),
-    ]:
-        pairs = _load_pairs(filename)
-        for p in pairs:
-            assert p.label == expected_label, (
-                f"{filename} contains pair {p.id!r} labeled "
-                f"{p.label!r}, expected {expected_label!r}"
-            )
-            # Structural minimum: description + H1 + H2 + enough body.
-            # If these fail the intake gate will reject on structure
-            # before similarity is even checked, poisoning recall.
-            assert "description:" in p.a_md
-            assert "description:" in p.b_md
-            assert "## " in p.a_md
-            assert "## " in p.b_md
+"""
+test_similarity_precision_recall.py -- Integration test for the intake gate's
+similarity detection against a curated corpus.
+
+Purpose
+-------
+The intake gate's usefulness depends on two numbers:
+
+  - **Recall** on near-duplicates: when two skills genuinely overlap, the
+    gate must flag at least 90% of them (``DUPLICATE`` or
+    ``NEAR_DUPLICATE``). Missed duplicates let redundant skills into the
+    corpus, which is the whole failure mode the gate exists to prevent.
+
+  - **Precision** against distinct and adversarial pairs: when two
+    skills are genuinely different, the gate must *not* flag them. False
+    positives block legitimate skills and train users to override the
+    gate — the worst failure mode.
+
+This test runs all three fixture sets (30 near-duplicates, 30 distinct,
+10 adversarial) through the real embedder and asserts precision/recall
+≥ 0.90.
+
+Tuning workflow
+---------------
+Fixtures are hand-written under ``src/tests/fixtures/similarity/``. If
+the test fails:
+
+  1. Read the per-pair breakdown printed on failure — each misclassified
+     pair lists its cosine score and reasoning.
+  2. Adjust ``intake_dup_threshold`` / ``intake_near_dup_threshold`` in
+     ``config.json`` (documented as tunable in ``ctx_config.py``).
+  3. Re-run.
+
+If tuning thresholds cannot hit 0.9 on both axes, the bug is upstream —
+either ``compose_corpus_text`` is dropping signal, or the fixtures need
+revision. Do not lower the 0.9 bar without a plan.
+
+Markers
+-------
+Marked ``@pytest.mark.integration`` because it loads the real MiniLM
+model (~100MB on first run). Skip in fast CI with ``-m 'not integration'``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+
+SRC_DIR = Path(__file__).resolve().parents[1]
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+from corpus_cache import CorpusCache  # noqa: E402
+from cosine_ranker import CosineRanker  # noqa: E402
+from ctx_config import cfg  # noqa: E402
+from intake_gate import compose_corpus_text, run_intake_gate  # noqa: E402
+
+
+FIXTURE_DIR = Path(__file__).parent / "fixtures" / "similarity"
+
+# Minimum precision and recall the gate must clear to be shipped.
+# Raising these is easy; lowering them requires a plan, not a fixup.
+_MIN_PRECISION = 0.90
+_MIN_RECALL = 0.90
+_REQUIRE_SIMILARITY_EVAL = os.environ.get("CTX_REQUIRE_SIMILARITY_EVAL") == "1"
+
+
+# ────────────────────────────────────────────────────────────────────
+# Fixture loading
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class _Pair:
+    id: str
+    label: str  # "near_duplicate" | "distinct" | "adversarial"
+    a_md: str
+    b_md: str
+    note: str
+
+    @property
+    def should_flag(self) -> bool:
+        """A pair should be flagged iff its label is near_duplicate.
+
+        Distinct and adversarial pairs must pass unflagged — they exist
+        to prove the gate does not false-positive on legitimate skills.
+        """
+        return self.label == "near_duplicate"
+
+
+def _compose_md(entry: dict) -> str:
+    """Build a full markdown document from a fixture entry.
+
+    Fixture files store only the semantic content (name, description,
+    body) so they stay focused and editable. This helper assembles the
+    full markdown with frontmatter + H1 so structural checks pass.
+    """
+    name = entry["name"]
+    description = entry["description"]
+    body = entry["body"]
+    return (
+        "---\n"
+        f"name: {name}\n"
+        f"description: {description}\n"
+        "---\n"
+        f"# {name}\n\n"
+        f"{body}\n"
+    )
+
+
+def _load_pairs(filename: str) -> list[_Pair]:
+    path = FIXTURE_DIR / filename
+    if not path.exists():
+        pytest.fail(f"tracked fixture file missing: {path}")
+    pairs: list[_Pair] = []
+    for line_num, raw in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+        raw = raw.strip()
+        if not raw or raw.startswith("#"):
+            continue
+        try:
+            entry = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            pytest.fail(f"{path}:{line_num} invalid JSON: {exc}")
+        pairs.append(_Pair(
+            id=entry["id"],
+            label=entry["label"],
+            a_md=_compose_md(entry["a"]),
+            b_md=_compose_md(entry["b"]),
+            note=entry.get("note", ""),
+        ))
+    return pairs
+
+
+# ────────────────────────────────────────────────────────────────────
+# Per-pair evaluation
+# ────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class _Outcome:
+    pair: _Pair
+    flagged: bool
+    top_score: float
+    top_code: str  # "DUPLICATE" | "NEAR_DUPLICATE" | "" when not flagged
+
+
+def _evaluate_pair(pair: _Pair, embedder, cache_root: Path) -> _Outcome:
+    """Record A, check B, return whether B was flagged against A.
+
+    Each pair gets its own CorpusCache namespace so earlier pairs don't
+    leak into later ones. The embedder is reused across pairs — loading
+    MiniLM is the dominant cost, and it's immutable for this run.
+    """
+    cache = CorpusCache(f"fixture-{pair.id}", root=cache_root)
+
+    # Record A into the per-pair cache.
+    a_text = compose_corpus_text(pair.a_md)
+    a_vec = embedder.embed([a_text])[0]
+    cache.put(f"{pair.id}-a", a_text, a_vec)
+
+    # Rank B against the single-entry corpus.
+    ranker = CosineRanker.from_cache(cache)
+    config = cfg.build_intake_config()
+    decision = run_intake_gate(
+        pair.b_md,
+        embedder=embedder,
+        ranker=ranker,
+        config=config,
+    )
+
+    codes = {f.code for f in decision.findings}
+    flagged = "DUPLICATE" in codes or "NEAR_DUPLICATE" in codes
+    top_score = decision.nearest[0].score if decision.nearest else 0.0
+    top_code = (
+        "DUPLICATE" if "DUPLICATE" in codes
+        else "NEAR_DUPLICATE" if "NEAR_DUPLICATE" in codes
+        else ""
+    )
+    return _Outcome(pair=pair, flagged=flagged, top_score=float(top_score), top_code=top_code)
+
+
+# ────────────────────────────────────────────────────────────────────
+# Module-scoped setup — embedder loads once
+# ────────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture(scope="module")
+def _embedder():
+    """Load the real configured embedder once per module run.
+
+    Local runs may skip when the embedding backend is unavailable. The
+    dedicated CI similarity gate sets CTX_REQUIRE_SIMILARITY_EVAL=1, in
+    which case dependency/model setup failures are hard failures.
+    """
+    try:
+        import sentence_transformers  # noqa: F401
+    except ImportError as exc:
+        message = f"sentence-transformers is required for similarity evaluation: {exc}"
+        if _REQUIRE_SIMILARITY_EVAL:
+            pytest.fail(message)
+        pytest.skip(message)
+    try:
+        return cfg.build_intake_embedder()
+    except Exception as exc:  # noqa: BLE001 - fail/skip policy depends on CI mode
+        message = f"cannot build intake embedder: {exc}"
+        if _REQUIRE_SIMILARITY_EVAL:
+            pytest.fail(message)
+        pytest.skip(message)
+
+
+@pytest.fixture
+def _tmp_cache_root(tmp_path, monkeypatch):
+    """Isolate cache writes so tests never touch ~/.claude."""
+    root = tmp_path / "intake-cache"
+    root.mkdir()
+    monkeypatch.setattr(cfg, "intake_cache_root", root)
+    return root
+
+
+# ────────────────────────────────────────────────────────────────────
+# The three fixture sets — evaluated together for precision/recall
+# ────────────────────────────────────────────────────────────────────
+
+
+@pytest.mark.integration
+def test_similarity_precision_and_recall(_embedder, _tmp_cache_root):
+    """Precision and recall across the full curated fixture set.
+
+    Confusion matrix:
+        TP = near_duplicate pairs correctly flagged
+        FN = near_duplicate pairs NOT flagged (missed duplicates)
+        FP = distinct or adversarial pairs incorrectly flagged
+        TN = distinct or adversarial pairs correctly passed
+
+    precision = TP / (TP + FP)
+    recall    = TP / (TP + FN)
+    """
+    near = _load_pairs("near_duplicates.jsonl")
+    distinct = _load_pairs("distinct_pairs.jsonl")
+    adversarial = _load_pairs("adversarial.jsonl")
+
+    # Sanity-check fixture counts so a truncated JSONL doesn't silently
+    # lower the bar the test claims to enforce.
+    assert len(near) == 30, f"expected 30 near-duplicate pairs, got {len(near)}"
+    assert len(distinct) == 30, f"expected 30 distinct pairs, got {len(distinct)}"
+    assert len(adversarial) == 10, f"expected 10 adversarial pairs, got {len(adversarial)}"
+
+    all_pairs = near + distinct + adversarial
+    outcomes = [_evaluate_pair(p, _embedder, _tmp_cache_root) for p in all_pairs]
+
+    tp = sum(1 for o in outcomes if o.pair.should_flag and o.flagged)
+    fn = sum(1 for o in outcomes if o.pair.should_flag and not o.flagged)
+    fp = sum(1 for o in outcomes if not o.pair.should_flag and o.flagged)
+    tn = sum(1 for o in outcomes if not o.pair.should_flag and not o.flagged)
+
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+
+    # Per-pair breakdown in the failure message so tuning is data-driven.
+    misses = [o for o in outcomes if o.pair.should_flag and not o.flagged]
+    false_pos = [o for o in outcomes if not o.pair.should_flag and o.flagged]
+
+    failure_lines = [
+        f"precision={precision:.3f} (need >= {_MIN_PRECISION})",
+        f"recall={recall:.3f} (need >= {_MIN_RECALL})",
+        f"TP={tp} FN={fn} FP={fp} TN={tn}",
+        "",
+    ]
+    if misses:
+        failure_lines.append(f"Missed duplicates ({len(misses)}):")
+        for o in misses:
+            failure_lines.append(
+                f"  {o.pair.id}: top_score={o.top_score:.3f} label={o.pair.label}"
+            )
+    if false_pos:
+        failure_lines.append(f"False positives ({len(false_pos)}):")
+        for o in false_pos:
+            failure_lines.append(
+                f"  {o.pair.id}: top_score={o.top_score:.3f} "
+                f"flagged={o.top_code} label={o.pair.label}"
+            )
+    message = "\n".join(failure_lines)
+
+    assert recall >= _MIN_RECALL, message
+    assert precision >= _MIN_PRECISION, message
+
+
+def test_fixture_schema_integrity():
+    """Fail fast if any fixture file is malformed — catches JSONL typos
+    without having to load the embedder.
+    """
+    for filename, expected_label in [
+        ("near_duplicates.jsonl", "near_duplicate"),
+        ("distinct_pairs.jsonl", "distinct"),
+        ("adversarial.jsonl", "adversarial"),
+    ]:
+        pairs = _load_pairs(filename)
+        for p in pairs:
+            assert p.label == expected_label, (
+                f"{filename} contains pair {p.id!r} labeled "
+                f"{p.label!r}, expected {expected_label!r}"
+            )
+            # Structural minimum: description + H1 + H2 + enough body.
+            # If these fail the intake gate will reject on structure
+            # before similarity is even checked, poisoning recall.
+            assert "description:" in p.a_md
+            assert "description:" in p.b_md
+            assert "## " in p.a_md
+            assert "## " in p.b_md

src/tests/test_skill_loader.py

@@ -1,372 +1,372 @@
-"""
-test_skill_loader.py -- Regression tests for path-traversal hardening in skill_loader.
-
-Covers Strix vuln-0001 (CWE-22): find_skill() must reject user-controlled names that
-contain path separators, traversal sequences, glob metacharacters, or absolute paths,
-and must confine resolved paths to SKILLS_DIR / AGENTS_DIR.
-"""
-
-from __future__ import annotations
-
-import json
-import importlib
-import subprocess
-import sys
-import textwrap
-from pathlib import Path
-
-import pytest
-
-_SRC_ROOT = Path(__file__).resolve().parents[1]
-_MANIFEST_DASHBOARD_WORKER = r"""
-from __future__ import annotations
-
-import os
-import sys
-import time
-from pathlib import Path
-
-sys.path.insert(0, sys.argv[3])
-
-home = Path(sys.argv[1])
-start_file = Path(sys.argv[2])
-mode = sys.argv[4]
-slug = sys.argv[5]
-
-os.environ["HOME"] = str(home)
-os.environ["USERPROFILE"] = str(home)
-
-deadline = time.monotonic() + 5.0
-while not start_file.exists():
-    if time.monotonic() > deadline:
-        raise TimeoutError("worker did not receive start signal")
-    time.sleep(0.005)
-
-if mode == "load":
-    from ctx.adapters.claude_code import skill_loader
-
-    original_write = skill_loader._atomic_write_text
-
-    def slow_write(path, text):
-        time.sleep(0.15)
-        original_write(path, text)
-
-    skill_loader._atomic_write_text = slow_write
-    skill_loader.update_manifest(slug, entity_type="skill")
-elif mode == "unload":
-    from ctx.adapters.claude_code.install import skill_unload
-
-    original_save = skill_unload.save_manifest
-
-    def slow_save(manifest):
-        time.sleep(0.15)
-        original_save(manifest)
-
-    skill_unload.save_manifest = slow_save
-    skill_unload.unload_from_session([slug])
-else:
-    raise ValueError(mode)
-"""
-
-
-def _run_dashboard_manifest_workers(
-    home: Path,
-    tmp_path: Path,
-    *,
-    mode: str,
-    slugs: list[str],
-) -> None:
-    start_file = tmp_path / f"{mode}.start"
-    code = textwrap.dedent(_MANIFEST_DASHBOARD_WORKER)
-    procs = [
-        subprocess.Popen(
-            [
-                sys.executable,
-                "-c",
-                code,
-                str(home),
-                str(start_file),
-                str(_SRC_ROOT),
-                mode,
-                slug,
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        for slug in slugs
-    ]
-    start_file.write_text("go", encoding="utf-8")
-    failures: list[str] = []
-    for proc in procs:
-        stdout, stderr = proc.communicate(timeout=20)
-        if proc.returncode:
-            failures.append(f"rc={proc.returncode}\nstdout={stdout}\nstderr={stderr}")
-    assert failures == []
-
-
-def test_dashboard_agent_unload_preserves_same_slug_skill(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    import ctx_monitor as cm
-    from ctx.adapters.claude_code.install import skill_unload
-
-    class _AuditLog:
-        @staticmethod
-        def log_skill_event(*args: object, **kwargs: object) -> None:
-            return None
-
-    claude_dir = tmp_path / ".claude"
-    manifest_path = claude_dir / "skill-manifest.json"
-    manifest_path.parent.mkdir(parents=True)
-    manifest_path.write_text(
-        json.dumps({
-            "load": [
-                {"skill": "debugger", "entity_type": "skill", "source": "seed"},
-                {"skill": "debugger", "entity_type": "agent", "source": "seed"},
-            ],
-            "unload": [],
-            "warnings": [],
-        }),
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(cm, "_claude_dir", lambda: claude_dir)
-    monkeypatch.setattr(skill_unload, "CLAUDE_DIR", claude_dir)
-    monkeypatch.setattr(skill_unload, "MANIFEST_PATH", manifest_path)
-    monkeypatch.setitem(sys.modules, "ctx_audit_log", _AuditLog)
-
-    ok, message = cm._perform_unload("debugger", entity_type="agent")
-
-    data = json.loads(manifest_path.read_text(encoding="utf-8"))
-    assert ok, message
-    assert data["load"] == [
-        {"skill": "debugger", "entity_type": "skill", "source": "seed"}
-    ]
-    assert data["unload"] == [
-        {"skill": "debugger", "entity_type": "agent", "source": "seed"}
-    ]
-
-
-@pytest.fixture()
-def fake_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    """Reload skill_loader with a throwaway HOME so module-level paths re-resolve."""
-    home = tmp_path / "home"
-    (home / ".claude" / "skills" / "goodskill").mkdir(parents=True)
-    (home / ".claude" / "skills" / "goodskill" / "SKILL.md").write_text("# good", encoding="utf-8")
-    (home / ".claude" / "skills").mkdir(parents=True, exist_ok=True)
-    (home / ".claude" / "outside-skill").mkdir(parents=True)
-    (home / ".claude" / "outside-skill" / "SKILL.md").write_text("# outside skill", encoding="utf-8")
-    (home / ".claude" / "agents").mkdir(parents=True, exist_ok=True)
-    (home / ".claude" / "agents" / "goodagent.md").write_text("# good agent", encoding="utf-8")
-    (home / ".claude" / "outside-agent.md").write_text("# outside agent", encoding="utf-8")
-
-    monkeypatch.setenv("HOME", str(home))
-    monkeypatch.setenv("USERPROFILE", str(home))  # Windows
-
-    from ctx.adapters.claude_code import skill_loader
-    importlib.reload(skill_loader)
-    monkeypatch.setattr(skill_loader, "SKILLS_DIR", home / ".claude" / "skills")
-    monkeypatch.setattr(skill_loader, "AGENTS_DIR", home / ".claude" / "agents")
-    monkeypatch.setattr(skill_loader, "WIKI_DIR", home / ".claude" / "skill-wiki")
-    monkeypatch.setattr(
-        skill_loader,
-        "PENDING_SKILLS",
-        home / ".claude" / "pending-skills.json",
-    )
-    monkeypatch.setattr(
-        skill_loader,
-        "MANIFEST_PATH",
-        home / ".claude" / "skill-manifest.json",
-    )
-    return skill_loader, home
-
-
-def test_valid_skill_name_resolves(fake_home):
-    loader, _ = fake_home
-    result = loader.find_skill("goodskill")
-    assert result is not None
-    assert result["type"] == "skill"
-    assert result["name"] == "goodskill"
-
-
-def test_valid_agent_name_resolves(fake_home):
-    loader, _ = fake_home
-    result = loader.find_skill("goodagent")
-    assert result is not None
-    assert result["type"] == "agent"
-
-
-@pytest.mark.parametrize(
-    "bad_name",
-    [
-        "../outside-skill",
-        "../outside-agent",
-        "..",
-        "../..",
-        "../../etc/passwd",
-        "foo/../bar",
-        "/absolute/path",
-        "C:/Windows/System32",
-        "**/outside-agent",
-        "*",
-        "**",
-        "?*",
-        "name\x00.md",
-        "name with space",
-        "name\nwith\nnewline",
-        "",
-        "name/",
-        "name\\windows",
-    ],
-)
-def test_traversal_and_metachars_rejected(fake_home, bad_name):
-    """Every traversal, glob metacharacter, separator, or absolute path must return None."""
-    loader, _ = fake_home
-    assert loader.find_skill(bad_name) is None, f"expected None for {bad_name!r}"
-
-
-def test_rglob_pattern_cannot_escape_agents_dir(fake_home):
-    """Strix's original rglob PoC: AGENTS_DIR.rglob('../outside-agent.md') used to match."""
-    loader, _ = fake_home
-    assert loader.find_skill("../outside-agent") is None
-
-
-def test_validate_skill_name_accepts_common_names(fake_home):
-    loader, _ = fake_home
-    from ctx.core.wiki.wiki_utils import validate_skill_name
-    for name in ("fastapi-pro", "docker_expert", "py3.11", "a", "Aa0._-"):
-        assert validate_skill_name(name) == name
-
-
-def test_validate_skill_name_rejects_bad(fake_home):
-    from ctx.core.wiki.wiki_utils import validate_skill_name
-    for bad in ("../x", "x/y", "*", "", "_leading", ".leading", "-leading"):
-        with pytest.raises(ValueError):
-            validate_skill_name(bad)
-
-
-# ─────────────────────────────────────────────────────────────────────
-# update_manifest: (slug, entity_type) tuple dedup contract
-# ─────────────────────────────────────────────────────────────────────
-#
-# Code-reviewer HIGH (P2.2). Prior impl deduped on slug alone and
-# wrote entries without an ``entity_type`` field. A same-slug
-# skill + agent collision silently dropped one of them.
-
-class TestUpdateManifestEntityType:
-
-    def test_writes_entity_type_field(self, fake_home):
-        loader, home = fake_home
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        loader.update_manifest("goodskill", entity_type="skill")
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        entries = [
-            e for e in data["load"]
-            if e.get("skill") == "goodskill"
-        ]
-        assert len(entries) == 1
-        assert entries[0].get("entity_type") == "skill"
-
-    def test_same_slug_skill_and_agent_coexist(self, fake_home):
-        """The regression: before the fix, adding an agent with the same
-        slug as an already-loaded skill was silently a no-op because
-        the slug-only dedup thought the agent was already loaded."""
-        loader, home = fake_home
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        loader.update_manifest("code-reviewer", entity_type="skill")
-        loader.update_manifest("code-reviewer", entity_type="agent")
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        pairs = {
-            (e.get("skill"), e.get("entity_type"))
-            for e in data["load"]
-        }
-        assert ("code-reviewer", "skill") in pairs
-        assert ("code-reviewer", "agent") in pairs
-
-    def test_idempotent_same_type(self, fake_home):
-        """Calling update_manifest twice with the same (slug, type)
-        must not append a duplicate entry."""
-        loader, home = fake_home
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        loader.update_manifest("goodskill", entity_type="skill")
-        loader.update_manifest("goodskill", entity_type="skill")
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        entries = [e for e in data["load"] if e.get("skill") == "goodskill"]
-        assert len(entries) == 1
-
-    def test_default_entity_type_is_skill(self, fake_home):
-        """Backward compat: call sites that don't pass entity_type
-        default to ``skill`` — the pre-fix implicit contract."""
-        loader, home = fake_home
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        loader.update_manifest("legacy-caller")
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        entry = next(e for e in data["load"] if e.get("skill") == "legacy-caller")
-        assert entry.get("entity_type") == "skill"
-
-    def test_legacy_pre_fix_manifest_entry_is_not_duplicated(self, fake_home):
-        """If the manifest already has a pre-fix entry (no ``entity_type``
-        key, slug == ``foo``), a new ``update_manifest("foo", "skill")``
-        call must recognise it as the same pair — the missing
-        ``entity_type`` in the old entry implicitly meant ``skill``."""
-        loader, home = fake_home
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        manifest_path.write_text(json.dumps({
-            "load": [{"skill": "foo", "source": "legacy"}],
-            "unload": [],
-            "warnings": [],
-        }), encoding="utf-8")
-        loader.update_manifest("foo", entity_type="skill")
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        foo_entries = [e for e in data["load"] if e.get("skill") == "foo"]
-        assert len(foo_entries) == 1, (
-            "legacy entry got duplicated — missing entity_type should "
-            "default to 'skill' for dedup purposes"
-        )
-
-    def test_concurrent_dashboard_loads_preserve_all_manifest_entries(
-        self,
-        tmp_path: Path,
-    ) -> None:
-        home = tmp_path / "home"
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        manifest_path.parent.mkdir(parents=True)
-        slugs = [f"skill-{i}" for i in range(8)]
-
-        _run_dashboard_manifest_workers(home, tmp_path, mode="load", slugs=slugs)
-
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        loaded = {entry["skill"] for entry in data["load"]}
-        assert loaded == set(slugs)
-
-    def test_concurrent_dashboard_unloads_preserve_all_manifest_removals(
-        self,
-        tmp_path: Path,
-    ) -> None:
-        home = tmp_path / "home"
-        manifest_path = home / ".claude" / "skill-manifest.json"
-        manifest_path.parent.mkdir(parents=True)
-        slugs = [f"skill-{i}" for i in range(8)]
-        manifest_path.write_text(
-            json.dumps({
-                "load": [
-                    {
-                        "skill": slug,
-                        "entity_type": "skill",
-                        "source": "seed",
-                    }
-                    for slug in slugs
-                ],
-                "unload": [],
-                "warnings": [],
-            }),
-            encoding="utf-8",
-        )
-
-        _run_dashboard_manifest_workers(home, tmp_path, mode="unload", slugs=slugs)
-
-        data = json.loads(manifest_path.read_text(encoding="utf-8"))
-        unloaded = {entry["skill"] for entry in data["unload"]}
-        assert data["load"] == []
-        assert unloaded == set(slugs)
+"""
+test_skill_loader.py -- Regression tests for path-traversal hardening in skill_loader.
+
+Covers Strix vuln-0001 (CWE-22): find_skill() must reject user-controlled names that
+contain path separators, traversal sequences, glob metacharacters, or absolute paths,
+and must confine resolved paths to SKILLS_DIR / AGENTS_DIR.
+"""
+
+from __future__ import annotations
+
+import json
+import importlib
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+import pytest
+
+_SRC_ROOT = Path(__file__).resolve().parents[1]
+_MANIFEST_DASHBOARD_WORKER = r"""
+from __future__ import annotations
+
+import os
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, sys.argv[3])
+
+home = Path(sys.argv[1])
+start_file = Path(sys.argv[2])
+mode = sys.argv[4]
+slug = sys.argv[5]
+
+os.environ["HOME"] = str(home)
+os.environ["USERPROFILE"] = str(home)
+
+deadline = time.monotonic() + 5.0
+while not start_file.exists():
+    if time.monotonic() > deadline:
+        raise TimeoutError("worker did not receive start signal")
+    time.sleep(0.005)
+
+if mode == "load":
+    from ctx.adapters.claude_code import skill_loader
+
+    original_write = skill_loader._atomic_write_text
+
+    def slow_write(path, text):
+        time.sleep(0.15)
+        original_write(path, text)
+
+    skill_loader._atomic_write_text = slow_write
+    skill_loader.update_manifest(slug, entity_type="skill")
+elif mode == "unload":
+    from ctx.adapters.claude_code.install import skill_unload
+
+    original_save = skill_unload.save_manifest
+
+    def slow_save(manifest):
+        time.sleep(0.15)
+        original_save(manifest)
+
+    skill_unload.save_manifest = slow_save
+    skill_unload.unload_from_session([slug])
+else:
+    raise ValueError(mode)
+"""
+
+
+def _run_dashboard_manifest_workers(
+    home: Path,
+    tmp_path: Path,
+    *,
+    mode: str,
+    slugs: list[str],
+) -> None:
+    start_file = tmp_path / f"{mode}.start"
+    code = textwrap.dedent(_MANIFEST_DASHBOARD_WORKER)
+    procs = [
+        subprocess.Popen(
+            [
+                sys.executable,
+                "-c",
+                code,
+                str(home),
+                str(start_file),
+                str(_SRC_ROOT),
+                mode,
+                slug,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        for slug in slugs
+    ]
+    start_file.write_text("go", encoding="utf-8")
+    failures: list[str] = []
+    for proc in procs:
+        stdout, stderr = proc.communicate(timeout=20)
+        if proc.returncode:
+            failures.append(f"rc={proc.returncode}\nstdout={stdout}\nstderr={stderr}")
+    assert failures == []
+
+
+def test_dashboard_agent_unload_preserves_same_slug_skill(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import ctx_monitor as cm
+    from ctx.adapters.claude_code.install import skill_unload
+
+    class _AuditLog:
+        @staticmethod
+        def log_skill_event(*args: object, **kwargs: object) -> None:
+            return None
+
+    claude_dir = tmp_path / ".claude"
+    manifest_path = claude_dir / "skill-manifest.json"
+    manifest_path.parent.mkdir(parents=True)
+    manifest_path.write_text(
+        json.dumps({
+            "load": [
+                {"skill": "debugger", "entity_type": "skill", "source": "seed"},
+                {"skill": "debugger", "entity_type": "agent", "source": "seed"},
+            ],
+            "unload": [],
+            "warnings": [],
+        }),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(cm, "_claude_dir", lambda: claude_dir)
+    monkeypatch.setattr(skill_unload, "CLAUDE_DIR", claude_dir)
+    monkeypatch.setattr(skill_unload, "MANIFEST_PATH", manifest_path)
+    monkeypatch.setitem(sys.modules, "ctx_audit_log", _AuditLog)
+
+    ok, message = cm._perform_unload("debugger", entity_type="agent")
+
+    data = json.loads(manifest_path.read_text(encoding="utf-8"))
+    assert ok, message
+    assert data["load"] == [
+        {"skill": "debugger", "entity_type": "skill", "source": "seed"}
+    ]
+    assert data["unload"] == [
+        {"skill": "debugger", "entity_type": "agent", "source": "seed"}
+    ]
+
+
+@pytest.fixture()
+def fake_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    """Reload skill_loader with a throwaway HOME so module-level paths re-resolve."""
+    home = tmp_path / "home"
+    (home / ".claude" / "skills" / "goodskill").mkdir(parents=True)
+    (home / ".claude" / "skills" / "goodskill" / "SKILL.md").write_text("# good", encoding="utf-8")
+    (home / ".claude" / "skills").mkdir(parents=True, exist_ok=True)
+    (home / ".claude" / "outside-skill").mkdir(parents=True)
+    (home / ".claude" / "outside-skill" / "SKILL.md").write_text("# outside skill", encoding="utf-8")
+    (home / ".claude" / "agents").mkdir(parents=True, exist_ok=True)
+    (home / ".claude" / "agents" / "goodagent.md").write_text("# good agent", encoding="utf-8")
+    (home / ".claude" / "outside-agent.md").write_text("# outside agent", encoding="utf-8")
+
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))  # Windows
+
+    from ctx.adapters.claude_code import skill_loader
+    importlib.reload(skill_loader)
+    monkeypatch.setattr(skill_loader, "SKILLS_DIR", home / ".claude" / "skills")
+    monkeypatch.setattr(skill_loader, "AGENTS_DIR", home / ".claude" / "agents")
+    monkeypatch.setattr(skill_loader, "WIKI_DIR", home / ".claude" / "skill-wiki")
+    monkeypatch.setattr(
+        skill_loader,
+        "PENDING_SKILLS",
+        home / ".claude" / "pending-skills.json",
+    )
+    monkeypatch.setattr(
+        skill_loader,
+        "MANIFEST_PATH",
+        home / ".claude" / "skill-manifest.json",
+    )
+    return skill_loader, home
+
+
+def test_valid_skill_name_resolves(fake_home):
+    loader, _ = fake_home
+    result = loader.find_skill("goodskill")
+    assert result is not None
+    assert result["type"] == "skill"
+    assert result["name"] == "goodskill"
+
+
+def test_valid_agent_name_resolves(fake_home):
+    loader, _ = fake_home
+    result = loader.find_skill("goodagent")
+    assert result is not None
+    assert result["type"] == "agent"
+
+
+@pytest.mark.parametrize(
+    "bad_name",
+    [
+        "../outside-skill",
+        "../outside-agent",
+        "..",
+        "../..",
+        "../../etc/passwd",
+        "foo/../bar",
+        "/absolute/path",
+        "C:/Windows/System32",
+        "**/outside-agent",
+        "*",
+        "**",
+        "?*",
+        "name\x00.md",
+        "name with space",
+        "name\nwith\nnewline",
+        "",
+        "name/",
+        "name\\windows",
+    ],
+)
+def test_traversal_and_metachars_rejected(fake_home, bad_name):
+    """Every traversal, glob metacharacter, separator, or absolute path must return None."""
+    loader, _ = fake_home
+    assert loader.find_skill(bad_name) is None, f"expected None for {bad_name!r}"
+
+
+def test_rglob_pattern_cannot_escape_agents_dir(fake_home):
+    """Strix's original rglob PoC: AGENTS_DIR.rglob('../outside-agent.md') used to match."""
+    loader, _ = fake_home
+    assert loader.find_skill("../outside-agent") is None
+
+
+def test_validate_skill_name_accepts_common_names(fake_home):
+    loader, _ = fake_home
+    from ctx.core.wiki.wiki_utils import validate_skill_name
+    for name in ("fastapi-pro", "docker_expert", "py3.11", "a", "Aa0._-"):
+        assert validate_skill_name(name) == name
+
+
+def test_validate_skill_name_rejects_bad(fake_home):
+    from ctx.core.wiki.wiki_utils import validate_skill_name
+    for bad in ("../x", "x/y", "*", "", "_leading", ".leading", "-leading"):
+        with pytest.raises(ValueError):
+            validate_skill_name(bad)
+
+
+# ─────────────────────────────────────────────────────────────────────
+# update_manifest: (slug, entity_type) tuple dedup contract
+# ─────────────────────────────────────────────────────────────────────
+#
+# Code-reviewer HIGH (P2.2). Prior impl deduped on slug alone and
+# wrote entries without an ``entity_type`` field. A same-slug
+# skill + agent collision silently dropped one of them.
+
+class TestUpdateManifestEntityType:
+
+    def test_writes_entity_type_field(self, fake_home):
+        loader, home = fake_home
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        loader.update_manifest("goodskill", entity_type="skill")
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        entries = [
+            e for e in data["load"]
+            if e.get("skill") == "goodskill"
+        ]
+        assert len(entries) == 1
+        assert entries[0].get("entity_type") == "skill"
+
+    def test_same_slug_skill_and_agent_coexist(self, fake_home):
+        """The regression: before the fix, adding an agent with the same
+        slug as an already-loaded skill was silently a no-op because
+        the slug-only dedup thought the agent was already loaded."""
+        loader, home = fake_home
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        loader.update_manifest("code-reviewer", entity_type="skill")
+        loader.update_manifest("code-reviewer", entity_type="agent")
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        pairs = {
+            (e.get("skill"), e.get("entity_type"))
+            for e in data["load"]
+        }
+        assert ("code-reviewer", "skill") in pairs
+        assert ("code-reviewer", "agent") in pairs
+
+    def test_idempotent_same_type(self, fake_home):
+        """Calling update_manifest twice with the same (slug, type)
+        must not append a duplicate entry."""
+        loader, home = fake_home
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        loader.update_manifest("goodskill", entity_type="skill")
+        loader.update_manifest("goodskill", entity_type="skill")
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        entries = [e for e in data["load"] if e.get("skill") == "goodskill"]
+        assert len(entries) == 1
+
+    def test_default_entity_type_is_skill(self, fake_home):
+        """Backward compat: call sites that don't pass entity_type
+        default to ``skill`` — the pre-fix implicit contract."""
+        loader, home = fake_home
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        loader.update_manifest("legacy-caller")
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        entry = next(e for e in data["load"] if e.get("skill") == "legacy-caller")
+        assert entry.get("entity_type") == "skill"
+
+    def test_legacy_pre_fix_manifest_entry_is_not_duplicated(self, fake_home):
+        """If the manifest already has a pre-fix entry (no ``entity_type``
+        key, slug == ``foo``), a new ``update_manifest("foo", "skill")``
+        call must recognise it as the same pair — the missing
+        ``entity_type`` in the old entry implicitly meant ``skill``."""
+        loader, home = fake_home
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        manifest_path.write_text(json.dumps({
+            "load": [{"skill": "foo", "source": "legacy"}],
+            "unload": [],
+            "warnings": [],
+        }), encoding="utf-8")
+        loader.update_manifest("foo", entity_type="skill")
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        foo_entries = [e for e in data["load"] if e.get("skill") == "foo"]
+        assert len(foo_entries) == 1, (
+            "legacy entry got duplicated — missing entity_type should "
+            "default to 'skill' for dedup purposes"
+        )
+
+    def test_concurrent_dashboard_loads_preserve_all_manifest_entries(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        home = tmp_path / "home"
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        manifest_path.parent.mkdir(parents=True)
+        slugs = [f"skill-{i}" for i in range(8)]
+
+        _run_dashboard_manifest_workers(home, tmp_path, mode="load", slugs=slugs)
+
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        loaded = {entry["skill"] for entry in data["load"]}
+        assert loaded == set(slugs)
+
+    def test_concurrent_dashboard_unloads_preserve_all_manifest_removals(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        home = tmp_path / "home"
+        manifest_path = home / ".claude" / "skill-manifest.json"
+        manifest_path.parent.mkdir(parents=True)
+        slugs = [f"skill-{i}" for i in range(8)]
+        manifest_path.write_text(
+            json.dumps({
+                "load": [
+                    {
+                        "skill": slug,
+                        "entity_type": "skill",
+                        "source": "seed",
+                    }
+                    for slug in slugs
+                ],
+                "unload": [],
+                "warnings": [],
+            }),
+            encoding="utf-8",
+        )
+
+        _run_dashboard_manifest_workers(home, tmp_path, mode="unload", slugs=slugs)
+
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        unloaded = {entry["skill"] for entry in data["unload"]}
+        assert data["load"] == []
+        assert unloaded == set(slugs)

src/tests/test_skill_mirror.py

@@ -1,322 +1,322 @@
-"""
-test_skill_mirror.py -- pins the short-skill mirror contract.
-
-The mirror exists because ctx-skill-install reads
-``<wiki>/converted/<slug>/SKILL.md`` and short skills (< line_threshold
-lines) skip the batch_convert pipeline that would create that file.
-Without the mirror, 835 of 1,791 skills are un-installable from the
-shipped tarball.
-
-Covers:
-  - short skill gets mirrored (creates converted/<slug>/SKILL.md)
-  - long skill is skipped (line_threshold guard)
-  - existing converted/<slug>/ dir is not overwritten without --force
-  - unchanged files skipped (idempotent re-run)
-  - --force overrides both guards
-  - invalid slugs rejected via validate_skill_name
-  - missing local source returns not-found
-  - prune removes short-skill mirrors whose local source vanished
-  - prune LEAVES long-skill pipeline dirs alone
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).parents[1]))
-
-import skill_mirror as _sm
-
-
-# ────────────────────────────────────────────────────────────────────
-# Fixtures
-# ────────────────────────────────────────────────────────────────────
-
-
-@pytest.fixture()
-def dirs(tmp_path: Path) -> tuple[Path, Path]:
-    """Return (skills_dir, wiki_dir) set up as empty roots."""
-    skills = tmp_path / "skills"
-    wiki = tmp_path / "wiki"
-    skills.mkdir()
-    wiki.mkdir()
-    return skills, wiki
-
-
-def _write_skill(skills: Path, slug: str, lines: int, content: str | None = None) -> Path:
-    """Create ~/.claude/skills/<slug>/SKILL.md with *lines* lines of body."""
-    body = content if content is not None else "\n".join(f"line {i}" for i in range(lines))
-    if content is None and not body.endswith("\n"):
-        body += "\n"
-    path = skills / slug / "SKILL.md"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(body, encoding="utf-8")
-    return path
-
-
-# ────────────────────────────────────────────────────────────────────
-# mirror_one
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestMirrorOne:
-    def test_short_skill_gets_mirrored(self, dirs):
-        skills, wiki = dirs
-        _write_skill(skills, "short-skill", lines=30)
-
-        r = _sm.mirror_one(
-            "short-skill", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180,
-        )
-
-        assert r.status == "mirrored"
-        assert (wiki / "converted" / "short-skill" / "SKILL.md").is_file()
-        assert r.body_lines == 30
-
-    def test_long_skill_skipped(self, dirs):
-        """Skills above line_threshold belong in the batch_convert
-        pipeline, not the mirror. Refusing here prevents a short-mirror
-        call from bypassing the pipeline's post-processing."""
-        skills, wiki = dirs
-        _write_skill(skills, "long-skill", lines=250)
-
-        r = _sm.mirror_one(
-            "long-skill", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180,
-        )
-
-        assert r.status == "skipped-too-long"
-        assert not (wiki / "converted" / "long-skill").exists()
-
-    def test_existing_pipeline_dir_not_overwritten(self, dirs):
-        """An existing converted/<slug>/ with SKILL.md + references/
-        is a pipeline artifact. Mirror must NOT overwrite it."""
-        skills, wiki = dirs
-        _write_skill(skills, "had-pipeline", lines=30)
-        pipeline_dir = wiki / "converted" / "had-pipeline"
-        pipeline_dir.mkdir(parents=True)
-        pipeline_file = pipeline_dir / "SKILL.md"
-        pipeline_file.write_text("PIPELINE-CONVERTED BODY\n", encoding="utf-8")
-        (pipeline_dir / "references").mkdir()
-
-        r = _sm.mirror_one(
-            "had-pipeline", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180,
-        )
-
-        assert r.status == "skipped-existing-pipeline"
-        assert pipeline_file.read_text(encoding="utf-8") == "PIPELINE-CONVERTED BODY\n"
-
-    def test_force_overwrites_existing(self, dirs):
-        """--force re-syncs after a local edit."""
-        skills, wiki = dirs
-        _write_skill(skills, "edited", lines=30, content="FRESH LOCAL BODY\n")
-        stale = wiki / "converted" / "edited" / "SKILL.md"
-        stale.parent.mkdir(parents=True)
-        stale.write_text("STALE WIKI BODY\n", encoding="utf-8")
-
-        r = _sm.mirror_one(
-            "edited", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180, force=True,
-        )
-
-        assert r.status == "mirrored"
-        assert stale.read_text(encoding="utf-8") == "FRESH LOCAL BODY\n"
-
-    def test_unchanged_is_idempotent(self, dirs):
-        """Second run on already-mirrored content reports `unchanged`,
-        not a rewrite."""
-        skills, wiki = dirs
-        _write_skill(skills, "same", lines=30, content="BODY\n")
-        # Pre-create the mirror with identical content. Because dest_dir
-        # already exists AND content matches, path returns `unchanged`.
-        mirror_path = wiki / "converted" / "same" / "SKILL.md"
-        mirror_path.parent.mkdir(parents=True)
-        mirror_path.write_text("BODY\n", encoding="utf-8")
-
-        r = _sm.mirror_one(
-            "same", skills_dir=skills, wiki_dir=wiki, line_threshold=180,
-        )
-        assert r.status == "unchanged"
-
-    def test_invalid_slug_rejected(self, dirs):
-        skills, wiki = dirs
-        r = _sm.mirror_one(
-            "../etc/passwd", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180,
-        )
-        assert r.status == "skipped-invalid"
-
-    def test_missing_local_returns_not_found(self, dirs):
-        skills, wiki = dirs
-        r = _sm.mirror_one(
-            "does-not-exist", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180,
-        )
-        assert r.status == "not-found"
-
-    def test_dry_run_does_not_write(self, dirs):
-        skills, wiki = dirs
-        _write_skill(skills, "dry", lines=30)
-
-        r = _sm.mirror_one(
-            "dry", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180, dry_run=True,
-        )
-
-        assert r.status == "mirrored"
-        assert "dry-run" in r.message
-        assert not (wiki / "converted" / "dry").exists()
-
-
-# ────────────────────────────────────────────────────────────────────
-# mirror_all
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestMirrorAll:
-    def test_mixed_corpus(self, dirs):
-        """Bulk run: short mirrors, long skips, existing-pipeline skips."""
-        skills, wiki = dirs
-        _write_skill(skills, "short-a", lines=20)
-        _write_skill(skills, "short-b", lines=50)
-        _write_skill(skills, "long", lines=300)
-        _write_skill(skills, "had-pipeline", lines=30)
-        # Pre-existing pipeline for had-pipeline:
-        (wiki / "converted" / "had-pipeline").mkdir(parents=True)
-        (wiki / "converted" / "had-pipeline" / "SKILL.md").write_text("X\n", encoding="utf-8")
-        (wiki / "converted" / "had-pipeline" / "references").mkdir()
-
-        results = _sm.mirror_all(
-            skills_dir=skills, wiki_dir=wiki, line_threshold=180,
-        )
-
-        by_status = {r.slug: r.status for r in results}
-        assert by_status["short-a"] == "mirrored"
-        assert by_status["short-b"] == "mirrored"
-        assert by_status["long"] == "skipped-too-long"
-        assert by_status["had-pipeline"] == "skipped-existing-pipeline"
-
-    def test_sort_is_stable(self, dirs):
-        """Order is deterministic across runs so log diffs are readable."""
-        skills, wiki = dirs
-        for slug in ("b-skill", "a-skill", "c-skill"):
-            _write_skill(skills, slug, lines=10)
-
-        results = _sm.mirror_all(
-            skills_dir=skills, wiki_dir=wiki, line_threshold=180,
-        )
-        assert [r.slug for r in results] == ["a-skill", "b-skill", "c-skill"]
-
-
-# ────────────────────────────────────────────────────────────────────
-# prune_orphans
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestPruneOrphans:
-    def test_prune_short_mirror_when_local_gone(self, dirs):
-        """Short mirror = converted/<slug>/ containing only SKILL.md.
-        If local source vanishes, prune drops the mirror."""
-        skills, wiki = dirs
-        mirror_dir = wiki / "converted" / "vanished"
-        mirror_dir.mkdir(parents=True)
-        (mirror_dir / "SKILL.md").write_text("orphan\n", encoding="utf-8")
-
-        results = _sm.prune_orphans(
-            skills_dir=skills, wiki_dir=wiki,
-        )
-
-        assert any(r.slug == "vanished" and r.status == "pruned" for r in results)
-        assert not mirror_dir.exists()
-
-    def test_prune_leaves_pipeline_dirs_alone(self, dirs):
-        """Long-skill pipeline dirs (SKILL.md + references/ + siblings)
-        must not be pruned — they hold converted content the local
-        source no longer needs to generate from."""
-        skills, wiki = dirs
-        pipeline_dir = wiki / "converted" / "pipelined"
-        pipeline_dir.mkdir(parents=True)
-        (pipeline_dir / "SKILL.md").write_text("body\n", encoding="utf-8")
-        (pipeline_dir / "references").mkdir()
-        (pipeline_dir / "check-gates.md").write_text("gates\n", encoding="utf-8")
-        # No local source for "pipelined" — but it has siblings, so keep it.
-
-        results = _sm.prune_orphans(skills_dir=skills, wiki_dir=wiki)
-
-        assert not any(r.slug == "pipelined" for r in results)
-        assert pipeline_dir.exists()
-
-    def test_prune_skips_present_sources(self, dirs):
-        """Mirror whose local source STILL exists is not pruned."""
-        skills, wiki = dirs
-        _write_skill(skills, "still-here", lines=20)
-        mirror_dir = wiki / "converted" / "still-here"
-        mirror_dir.mkdir(parents=True)
-        (mirror_dir / "SKILL.md").write_text("body\n", encoding="utf-8")
-
-        results = _sm.prune_orphans(skills_dir=skills, wiki_dir=wiki)
-
-        assert not any(r.slug == "still-here" for r in results)
-        assert mirror_dir.exists()
-
-    def test_prune_dry_run_reports_but_keeps(self, dirs):
-        skills, wiki = dirs
-        mirror_dir = wiki / "converted" / "to-prune"
-        mirror_dir.mkdir(parents=True)
-        (mirror_dir / "SKILL.md").write_text("x\n", encoding="utf-8")
-
-        results = _sm.prune_orphans(
-            skills_dir=skills, wiki_dir=wiki, dry_run=True,
-        )
-
-        assert any(r.status == "pruned" and "dry-run" in r.message for r in results)
-        assert mirror_dir.exists()
-
-
-# ────────────────────────────────────────────────────────────────────
-# Integration with skill_install
-# ────────────────────────────────────────────────────────────────────
-
-
-class TestIntegrationWithInstall:
-    def test_installed_after_mirror(self, dirs, tmp_path):
-        """End-to-end: a short local skill has no wiki content -> install
-        would fail with not-in-wiki -> run mirror -> install now works.
-
-        This is the exact regression the mirror exists to fix.
-        """
-        from ctx.adapters.claude_code.install.skill_install import install_skill
-
-        skills, wiki = dirs
-        _write_skill(
-            skills, "short-e2e", lines=10,
-            content="# short-e2e\n\nBody for a short skill.\n",
-        )
-        # Before mirror: install fails.
-        install_target = tmp_path / "install-target"
-        before = install_skill(
-            "short-e2e", wiki_dir=wiki, skills_dir=install_target,
-        )
-        assert before.status == "not-in-wiki"
-
-        # Run the mirror.
-        r = _sm.mirror_one(
-            "short-e2e", skills_dir=skills, wiki_dir=wiki,
-            line_threshold=180,
-        )
-        assert r.status == "mirrored"
-
-        # Install now succeeds with the mirrored body.
-        after = install_skill(
-            "short-e2e", wiki_dir=wiki, skills_dir=install_target,
-        )
-        assert after.status == "installed"
-        assert (install_target / "short-e2e" / "SKILL.md").is_file()
-        # Content matches the local body verbatim.
-        assert "Body for a short skill." in (
-            install_target / "short-e2e" / "SKILL.md"
-        ).read_text(encoding="utf-8")
+"""
+test_skill_mirror.py -- pins the short-skill mirror contract.
+
+The mirror exists because ctx-skill-install reads
+``<wiki>/converted/<slug>/SKILL.md`` and short skills (< line_threshold
+lines) skip the batch_convert pipeline that would create that file.
+Without the mirror, 835 of 1,791 skills are un-installable from the
+shipped tarball.
+
+Covers:
+  - short skill gets mirrored (creates converted/<slug>/SKILL.md)
+  - long skill is skipped (line_threshold guard)
+  - existing converted/<slug>/ dir is not overwritten without --force
+  - unchanged files skipped (idempotent re-run)
+  - --force overrides both guards
+  - invalid slugs rejected via validate_skill_name
+  - missing local source returns not-found
+  - prune removes short-skill mirrors whose local source vanished
+  - prune LEAVES long-skill pipeline dirs alone
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parents[1]))
+
+import skill_mirror as _sm
+
+
+# ────────────────────────────────────────────────────────────────────
+# Fixtures
+# ────���───────────────────────────────────────────────────────────────
+
+
+@pytest.fixture()
+def dirs(tmp_path: Path) -> tuple[Path, Path]:
+    """Return (skills_dir, wiki_dir) set up as empty roots."""
+    skills = tmp_path / "skills"
+    wiki = tmp_path / "wiki"
+    skills.mkdir()
+    wiki.mkdir()
+    return skills, wiki
+
+
+def _write_skill(skills: Path, slug: str, lines: int, content: str | None = None) -> Path:
+    """Create ~/.claude/skills/<slug>/SKILL.md with *lines* lines of body."""
+    body = content if content is not None else "\n".join(f"line {i}" for i in range(lines))
+    if content is None and not body.endswith("\n"):
+        body += "\n"
+    path = skills / slug / "SKILL.md"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(body, encoding="utf-8")
+    return path
+
+
+# ────────────────────────────────────────────────────────────────────
+# mirror_one
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestMirrorOne:
+    def test_short_skill_gets_mirrored(self, dirs):
+        skills, wiki = dirs
+        _write_skill(skills, "short-skill", lines=30)
+
+        r = _sm.mirror_one(
+            "short-skill", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180,
+        )
+
+        assert r.status == "mirrored"
+        assert (wiki / "converted" / "short-skill" / "SKILL.md").is_file()
+        assert r.body_lines == 30
+
+    def test_long_skill_skipped(self, dirs):
+        """Skills above line_threshold belong in the batch_convert
+        pipeline, not the mirror. Refusing here prevents a short-mirror
+        call from bypassing the pipeline's post-processing."""
+        skills, wiki = dirs
+        _write_skill(skills, "long-skill", lines=250)
+
+        r = _sm.mirror_one(
+            "long-skill", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180,
+        )
+
+        assert r.status == "skipped-too-long"
+        assert not (wiki / "converted" / "long-skill").exists()
+
+    def test_existing_pipeline_dir_not_overwritten(self, dirs):
+        """An existing converted/<slug>/ with SKILL.md + references/
+        is a pipeline artifact. Mirror must NOT overwrite it."""
+        skills, wiki = dirs
+        _write_skill(skills, "had-pipeline", lines=30)
+        pipeline_dir = wiki / "converted" / "had-pipeline"
+        pipeline_dir.mkdir(parents=True)
+        pipeline_file = pipeline_dir / "SKILL.md"
+        pipeline_file.write_text("PIPELINE-CONVERTED BODY\n", encoding="utf-8")
+        (pipeline_dir / "references").mkdir()
+
+        r = _sm.mirror_one(
+            "had-pipeline", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180,
+        )
+
+        assert r.status == "skipped-existing-pipeline"
+        assert pipeline_file.read_text(encoding="utf-8") == "PIPELINE-CONVERTED BODY\n"
+
+    def test_force_overwrites_existing(self, dirs):
+        """--force re-syncs after a local edit."""
+        skills, wiki = dirs
+        _write_skill(skills, "edited", lines=30, content="FRESH LOCAL BODY\n")
+        stale = wiki / "converted" / "edited" / "SKILL.md"
+        stale.parent.mkdir(parents=True)
+        stale.write_text("STALE WIKI BODY\n", encoding="utf-8")
+
+        r = _sm.mirror_one(
+            "edited", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180, force=True,
+        )
+
+        assert r.status == "mirrored"
+        assert stale.read_text(encoding="utf-8") == "FRESH LOCAL BODY\n"
+
+    def test_unchanged_is_idempotent(self, dirs):
+        """Second run on already-mirrored content reports `unchanged`,
+        not a rewrite."""
+        skills, wiki = dirs
+        _write_skill(skills, "same", lines=30, content="BODY\n")
+        # Pre-create the mirror with identical content. Because dest_dir
+        # already exists AND content matches, path returns `unchanged`.
+        mirror_path = wiki / "converted" / "same" / "SKILL.md"
+        mirror_path.parent.mkdir(parents=True)
+        mirror_path.write_text("BODY\n", encoding="utf-8")
+
+        r = _sm.mirror_one(
+            "same", skills_dir=skills, wiki_dir=wiki, line_threshold=180,
+        )
+        assert r.status == "unchanged"
+
+    def test_invalid_slug_rejected(self, dirs):
+        skills, wiki = dirs
+        r = _sm.mirror_one(
+            "../etc/passwd", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180,
+        )
+        assert r.status == "skipped-invalid"
+
+    def test_missing_local_returns_not_found(self, dirs):
+        skills, wiki = dirs
+        r = _sm.mirror_one(
+            "does-not-exist", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180,
+        )
+        assert r.status == "not-found"
+
+    def test_dry_run_does_not_write(self, dirs):
+        skills, wiki = dirs
+        _write_skill(skills, "dry", lines=30)
+
+        r = _sm.mirror_one(
+            "dry", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180, dry_run=True,
+        )
+
+        assert r.status == "mirrored"
+        assert "dry-run" in r.message
+        assert not (wiki / "converted" / "dry").exists()
+
+
+# ────────────────────────────────────────────────────────────────────
+# mirror_all
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestMirrorAll:
+    def test_mixed_corpus(self, dirs):
+        """Bulk run: short mirrors, long skips, existing-pipeline skips."""
+        skills, wiki = dirs
+        _write_skill(skills, "short-a", lines=20)
+        _write_skill(skills, "short-b", lines=50)
+        _write_skill(skills, "long", lines=300)
+        _write_skill(skills, "had-pipeline", lines=30)
+        # Pre-existing pipeline for had-pipeline:
+        (wiki / "converted" / "had-pipeline").mkdir(parents=True)
+        (wiki / "converted" / "had-pipeline" / "SKILL.md").write_text("X\n", encoding="utf-8")
+        (wiki / "converted" / "had-pipeline" / "references").mkdir()
+
+        results = _sm.mirror_all(
+            skills_dir=skills, wiki_dir=wiki, line_threshold=180,
+        )
+
+        by_status = {r.slug: r.status for r in results}
+        assert by_status["short-a"] == "mirrored"
+        assert by_status["short-b"] == "mirrored"
+        assert by_status["long"] == "skipped-too-long"
+        assert by_status["had-pipeline"] == "skipped-existing-pipeline"
+
+    def test_sort_is_stable(self, dirs):
+        """Order is deterministic across runs so log diffs are readable."""
+        skills, wiki = dirs
+        for slug in ("b-skill", "a-skill", "c-skill"):
+            _write_skill(skills, slug, lines=10)
+
+        results = _sm.mirror_all(
+            skills_dir=skills, wiki_dir=wiki, line_threshold=180,
+        )
+        assert [r.slug for r in results] == ["a-skill", "b-skill", "c-skill"]
+
+
+# ────────────────────────────────────────────────────────────────────
+# prune_orphans
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestPruneOrphans:
+    def test_prune_short_mirror_when_local_gone(self, dirs):
+        """Short mirror = converted/<slug>/ containing only SKILL.md.
+        If local source vanishes, prune drops the mirror."""
+        skills, wiki = dirs
+        mirror_dir = wiki / "converted" / "vanished"
+        mirror_dir.mkdir(parents=True)
+        (mirror_dir / "SKILL.md").write_text("orphan\n", encoding="utf-8")
+
+        results = _sm.prune_orphans(
+            skills_dir=skills, wiki_dir=wiki,
+        )
+
+        assert any(r.slug == "vanished" and r.status == "pruned" for r in results)
+        assert not mirror_dir.exists()
+
+    def test_prune_leaves_pipeline_dirs_alone(self, dirs):
+        """Long-skill pipeline dirs (SKILL.md + references/ + siblings)
+        must not be pruned — they hold converted content the local
+        source no longer needs to generate from."""
+        skills, wiki = dirs
+        pipeline_dir = wiki / "converted" / "pipelined"
+        pipeline_dir.mkdir(parents=True)
+        (pipeline_dir / "SKILL.md").write_text("body\n", encoding="utf-8")
+        (pipeline_dir / "references").mkdir()
+        (pipeline_dir / "check-gates.md").write_text("gates\n", encoding="utf-8")
+        # No local source for "pipelined" — but it has siblings, so keep it.
+
+        results = _sm.prune_orphans(skills_dir=skills, wiki_dir=wiki)
+
+        assert not any(r.slug == "pipelined" for r in results)
+        assert pipeline_dir.exists()
+
+    def test_prune_skips_present_sources(self, dirs):
+        """Mirror whose local source STILL exists is not pruned."""
+        skills, wiki = dirs
+        _write_skill(skills, "still-here", lines=20)
+        mirror_dir = wiki / "converted" / "still-here"
+        mirror_dir.mkdir(parents=True)
+        (mirror_dir / "SKILL.md").write_text("body\n", encoding="utf-8")
+
+        results = _sm.prune_orphans(skills_dir=skills, wiki_dir=wiki)
+
+        assert not any(r.slug == "still-here" for r in results)
+        assert mirror_dir.exists()
+
+    def test_prune_dry_run_reports_but_keeps(self, dirs):
+        skills, wiki = dirs
+        mirror_dir = wiki / "converted" / "to-prune"
+        mirror_dir.mkdir(parents=True)
+        (mirror_dir / "SKILL.md").write_text("x\n", encoding="utf-8")
+
+        results = _sm.prune_orphans(
+            skills_dir=skills, wiki_dir=wiki, dry_run=True,
+        )
+
+        assert any(r.status == "pruned" and "dry-run" in r.message for r in results)
+        assert mirror_dir.exists()
+
+
+# ────────────────────────────────────────────────────────────────────
+# Integration with skill_install
+# ────────────────────────────────────────────────────────────────────
+
+
+class TestIntegrationWithInstall:
+    def test_installed_after_mirror(self, dirs, tmp_path):
+        """End-to-end: a short local skill has no wiki content -> install
+        would fail with not-in-wiki -> run mirror -> install now works.
+
+        This is the exact regression the mirror exists to fix.
+        """
+        from ctx.adapters.claude_code.install.skill_install import install_skill
+
+        skills, wiki = dirs
+        _write_skill(
+            skills, "short-e2e", lines=10,
+            content="# short-e2e\n\nBody for a short skill.\n",
+        )
+        # Before mirror: install fails.
+        install_target = tmp_path / "install-target"
+        before = install_skill(
+            "short-e2e", wiki_dir=wiki, skills_dir=install_target,
+        )
+        assert before.status == "not-in-wiki"
+
+        # Run the mirror.
+        r = _sm.mirror_one(
+            "short-e2e", skills_dir=skills, wiki_dir=wiki,
+            line_threshold=180,
+        )
+        assert r.status == "mirrored"
+
+        # Install now succeeds with the mirrored body.
+        after = install_skill(
+            "short-e2e", wiki_dir=wiki, skills_dir=install_target,
+        )
+        assert after.status == "installed"
+        assert (install_target / "short-e2e" / "SKILL.md").is_file()
+        # Content matches the local body verbatim.
+        assert "Body for a short skill." in (
+            install_target / "short-e2e" / "SKILL.md"
+        ).read_text(encoding="utf-8")

src/tests/test_skill_quality_bench.py

@@ -1,141 +1,141 @@
-"""
-test_skill_quality_bench.py — P1-12 performance regression test.
-
-Creates 1,000 fake telemetry events spread across 100 slugs and asserts
-that ``recompute_all`` completes within the platform budget, confirming the
-O(M) single-scan behaviour (vs the previous O(N·M) per-slug rescan).
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-
-
-SRC_DIR = Path(__file__).resolve().parents[1]
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
-
-import skill_quality as sq  # noqa: E402
-
-
-# ────────────────────────────────────────────────────────────────────
-# Fixtures / helpers
-# ────────────────────────────────────────────────────────────────────
-
-_NUM_SLUGS = 100
-_EVENTS_PER_SLUG = 10  # 1,000 total events
-_NOW = datetime(2026, 4, 19, 12, 0, 0, tzinfo=timezone.utc)
-
-_SKILL_MD = (
-    "---\nname: {slug}\ndescription: Benchmark skill {slug}.\n---\n"
-    "# {slug}\n\n" + "Body content for the benchmark skill. " * 10 + "\n"
-)
-
-
-def _benchmark_budget_seconds() -> float:
-    if sys.platform == "win32" and os.environ.get("PYTEST_XDIST_WORKER"):
-        return 5.0
-    return 2.0
-
-
-def _make_bench_tree(tmp_path: Path) -> sq.SignalSources:
-    skills_dir = tmp_path / "skills"
-    agents_dir = tmp_path / "agents"
-    wiki_dir = tmp_path / "wiki"
-    events_path = tmp_path / "events.jsonl"
-
-    skills_dir.mkdir()
-    agents_dir.mkdir()
-    wiki_dir.mkdir()
-
-    slugs = [f"bench-skill-{i:03d}" for i in range(_NUM_SLUGS)]
-
-    # Create skill files.
-    for slug in slugs:
-        skill_dir = skills_dir / slug
-        skill_dir.mkdir()
-        (skill_dir / "SKILL.md").write_text(
-            _SKILL_MD.format(slug=slug), encoding="utf-8"
-        )
-
-    # Create JSONL with events spread evenly across slugs.
-    ts = _NOW.isoformat(timespec="seconds")
-    lines = []
-    for i in range(_NUM_SLUGS * _EVENTS_PER_SLUG):
-        slug = slugs[i % _NUM_SLUGS]
-        lines.append(json.dumps({"skill": slug, "event": "load", "timestamp": ts}))
-    events_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-
-    return sq.SignalSources(
-        skills_dir=skills_dir,
-        agents_dir=agents_dir,
-        wiki_dir=wiki_dir,
-        events_path=events_path,
-    )
-
-
-# ────────────────────────────────────────────────────────────────────
-# Tests
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_recompute_all_completes_within_budget(
-    tmp_path: Path,
-    monkeypatch,
-) -> None:
-    """recompute_all with 100 slugs / 1,000 events must stay fast."""
-    sources = _make_bench_tree(tmp_path)
-    sidecar_dir = tmp_path / "sidecars"
-    sidecar_dir.mkdir()
-
-    def fast_write(path: Path, text: str) -> None:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(text, encoding="utf-8")
-
-    monkeypatch.setattr(sq, "_atomic_write", fast_write)
-
-    start = time.monotonic()
-    successes, failures = sq.recompute_all(
-        sources=sources,
-        now=_NOW,
-        sidecar_dir=sidecar_dir,
-        update_frontmatter=False,
-    )
-    elapsed = time.monotonic() - start
-
-    assert failures == [], f"Unexpected failures: {failures}"
-    assert len(successes) == _NUM_SLUGS
-    budget = _benchmark_budget_seconds()
-    assert elapsed < budget, (
-        f"recompute_all took {elapsed:.2f}s for {_NUM_SLUGS} slugs / "
-        f"{_NUM_SLUGS * _EVENTS_PER_SLUG} events — expected < {budget:.1f}s"
-    )
-
-
-def test_events_index_used_single_read(tmp_path: Path) -> None:
-    """_build_events_index partitions events correctly by slug."""
-    sources = _make_bench_tree(tmp_path)
-
-    index = sq._build_events_index(sources.events_path)
-
-    assert len(index) == _NUM_SLUGS
-    for slug, events in index.items():
-        assert len(events) == _EVENTS_PER_SLUG, (
-            f"{slug} has {len(events)} events, expected {_EVENTS_PER_SLUG}"
-        )
-        assert all(e["skill"] == slug for e in events)
-
-
-def test_events_index_empty_file(tmp_path: Path) -> None:
-    """_build_events_index returns an empty dict for a missing or empty file."""
-    missing = tmp_path / "does_not_exist.jsonl"
-    assert sq._build_events_index(missing) == {}
-
-    empty = tmp_path / "empty.jsonl"
-    empty.write_text("", encoding="utf-8")
-    assert sq._build_events_index(empty) == {}
+"""
+test_skill_quality_bench.py — P1-12 performance regression test.
+
+Creates 1,000 fake telemetry events spread across 100 slugs and asserts
+that ``recompute_all`` completes within the platform budget, confirming the
+O(M) single-scan behaviour (vs the previous O(N·M) per-slug rescan).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+SRC_DIR = Path(__file__).resolve().parents[1]
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+import skill_quality as sq  # noqa: E402
+
+
+# ────────────────────────────────────────────────────────────────────
+# Fixtures / helpers
+# ────────────────────────────────────────────────────────────────────
+
+_NUM_SLUGS = 100
+_EVENTS_PER_SLUG = 10  # 1,000 total events
+_NOW = datetime(2026, 4, 19, 12, 0, 0, tzinfo=timezone.utc)
+
+_SKILL_MD = (
+    "---\nname: {slug}\ndescription: Benchmark skill {slug}.\n---\n"
+    "# {slug}\n\n" + "Body content for the benchmark skill. " * 10 + "\n"
+)
+
+
+def _benchmark_budget_seconds() -> float:
+    if sys.platform == "win32" and os.environ.get("PYTEST_XDIST_WORKER"):
+        return 5.0
+    return 2.0
+
+
+def _make_bench_tree(tmp_path: Path) -> sq.SignalSources:
+    skills_dir = tmp_path / "skills"
+    agents_dir = tmp_path / "agents"
+    wiki_dir = tmp_path / "wiki"
+    events_path = tmp_path / "events.jsonl"
+
+    skills_dir.mkdir()
+    agents_dir.mkdir()
+    wiki_dir.mkdir()
+
+    slugs = [f"bench-skill-{i:03d}" for i in range(_NUM_SLUGS)]
+
+    # Create skill files.
+    for slug in slugs:
+        skill_dir = skills_dir / slug
+        skill_dir.mkdir()
+        (skill_dir / "SKILL.md").write_text(
+            _SKILL_MD.format(slug=slug), encoding="utf-8"
+        )
+
+    # Create JSONL with events spread evenly across slugs.
+    ts = _NOW.isoformat(timespec="seconds")
+    lines = []
+    for i in range(_NUM_SLUGS * _EVENTS_PER_SLUG):
+        slug = slugs[i % _NUM_SLUGS]
+        lines.append(json.dumps({"skill": slug, "event": "load", "timestamp": ts}))
+    events_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    return sq.SignalSources(
+        skills_dir=skills_dir,
+        agents_dir=agents_dir,
+        wiki_dir=wiki_dir,
+        events_path=events_path,
+    )
+
+
+# ────────────────────────────────────────────────────────────────────
+# Tests
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_recompute_all_completes_within_budget(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    """recompute_all with 100 slugs / 1,000 events must stay fast."""
+    sources = _make_bench_tree(tmp_path)
+    sidecar_dir = tmp_path / "sidecars"
+    sidecar_dir.mkdir()
+
+    def fast_write(path: Path, text: str) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+
+    monkeypatch.setattr(sq, "_atomic_write", fast_write)
+
+    start = time.monotonic()
+    successes, failures = sq.recompute_all(
+        sources=sources,
+        now=_NOW,
+        sidecar_dir=sidecar_dir,
+        update_frontmatter=False,
+    )
+    elapsed = time.monotonic() - start
+
+    assert failures == [], f"Unexpected failures: {failures}"
+    assert len(successes) == _NUM_SLUGS
+    budget = _benchmark_budget_seconds()
+    assert elapsed < budget, (
+        f"recompute_all took {elapsed:.2f}s for {_NUM_SLUGS} slugs / "
+        f"{_NUM_SLUGS * _EVENTS_PER_SLUG} events — expected < {budget:.1f}s"
+    )
+
+
+def test_events_index_used_single_read(tmp_path: Path) -> None:
+    """_build_events_index partitions events correctly by slug."""
+    sources = _make_bench_tree(tmp_path)
+
+    index = sq._build_events_index(sources.events_path)
+
+    assert len(index) == _NUM_SLUGS
+    for slug, events in index.items():
+        assert len(events) == _EVENTS_PER_SLUG, (
+            f"{slug} has {len(events)} events, expected {_EVENTS_PER_SLUG}"
+        )
+        assert all(e["skill"] == slug for e in events)
+
+
+def test_events_index_empty_file(tmp_path: Path) -> None:
+    """_build_events_index returns an empty dict for a missing or empty file."""
+    missing = tmp_path / "does_not_exist.jsonl"
+    assert sq._build_events_index(missing) == {}
+
+    empty = tmp_path / "empty.jsonl"
+    empty.write_text("", encoding="utf-8")
+    assert sq._build_events_index(empty) == {}

src/tests/test_skill_telemetry.py

@@ -1,329 +1,329 @@
-"""
-test_skill_telemetry.py -- Regression tests for skill_telemetry.
-
-Covers the Phase 1 telemetry contract:
-
-  - event validation: type enum, skill-name sanitization, empty session_id
-  - round-trip: log_event -> read_events yields identical records
-  - malformed-line tolerance: partial/corrupt lines are skipped
-  - concurrent appends: two processes writing concurrently end up with
-    two well-formed lines (no interleaving corruption)
-  - retention window math: boundary and default-cap cases
-  - naive-timestamp handling: is_retained treats naive timestamps as UTC
-  - meta validation: rejects oversized, nested, or non-scalar values
-  - path containment: refuses caller-supplied paths that escape parents
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-import pytest
-
-SRC_DIR = Path(__file__).resolve().parents[1]
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
-
-import skill_telemetry as st  # noqa: E402
-
-
-def _iso(offset_seconds: float = 0.0) -> str:
-    return (
-        datetime.now(timezone.utc) + timedelta(seconds=offset_seconds)
-    ).isoformat(timespec="seconds")
-
-
-def _event(**overrides: object) -> st.TelemetryEvent:
-    defaults: dict[str, object] = {
-        "event": "load",
-        "skill": "x",
-        "timestamp": _iso(),
-        "session_id": "s1",
-        "event_id": "e-default",
-    }
-    defaults.update(overrides)
-    return st.TelemetryEvent(**defaults)  # type: ignore[arg-type]
-
-
-# ────────────────────────────────────────────────────────────────────
-# Event validation
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_event_accepts_all_defined_types() -> None:
-    for kind in ("load", "unload", "override", "switch_away"):
-        _event(event=kind)
-
-
-def test_event_rejects_unknown_type() -> None:
-    with pytest.raises(ValueError, match="invalid event type"):
-        _event(event="explode")
-
-
-@pytest.mark.parametrize(
-    "bad_name",
-    [
-        "",
-        "../etc/passwd",
-        "skill/with/slash",
-        "skill with space",
-        "-leading-dash",
-        "a" * 200,
-    ],
-)
-def test_event_rejects_unsafe_skill_name(bad_name: str) -> None:
-    with pytest.raises(ValueError, match="invalid skill name"):
-        _event(skill=bad_name)
-
-
-def test_event_rejects_empty_session_id() -> None:
-    with pytest.raises(ValueError, match="session_id"):
-        _event(session_id="")
-
-
-def test_event_rejects_empty_event_id() -> None:
-    with pytest.raises(ValueError, match="event_id"):
-        _event(event_id="")
-
-
-def test_event_rejects_non_iso_timestamp() -> None:
-    with pytest.raises(ValueError, match="timestamp must be ISO-8601"):
-        _event(timestamp="not-a-time")
-
-
-# ────────────────────────────────────────────────────────────────────
-# meta validation
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_log_event_rejects_oversized_meta(tmp_path: Path) -> None:
-    big = {f"k{i}": i for i in range(st._MAX_META_KEYS + 1)}
-    with pytest.raises(ValueError, match="max"):
-        st.log_event("load", "x", "s1", meta=big, path=tmp_path / "e.jsonl",
-                     trusted_root=tmp_path)
-
-
-def test_log_event_rejects_non_scalar_meta_value(tmp_path: Path) -> None:
-    with pytest.raises(TypeError, match="must be str/int/float/bool/None"):
-        st.log_event(
-            "load", "x", "s1", meta={"nested": {"a": 1}},
-            path=tmp_path / "e.jsonl", trusted_root=tmp_path,
-        )
-
-
-def test_log_event_rejects_oversized_meta_string(tmp_path: Path) -> None:
-    with pytest.raises(ValueError, match="exceeds"):
-        st.log_event(
-            "load", "x", "s1",
-            meta={"big": "a" * (st._MAX_META_VALUE_LEN + 1)},
-            path=tmp_path / "e.jsonl",
-            trusted_root=tmp_path,
-        )
-
-
-# ────────────────────────────────────────────────────────────────────
-# Round-trip
-# ───────────────────────────────────────────────────���────────────────
-
-
-def test_log_event_and_read_events_round_trip(tmp_path: Path) -> None:
-    events_path = tmp_path / "skill-events.jsonl"
-
-    rec_a = st.log_event(
-        "load", "python-patterns", "sess-1",
-        meta={"source": "unit-test"}, path=events_path, trusted_root=tmp_path,
-    )
-    rec_b = st.log_event(
-        "unload", "python-patterns", "sess-1", path=events_path,
-        trusted_root=tmp_path,
-    )
-    rec_c = st.log_event(
-        "override", "flask", "sess-1",
-        meta={"replaced_with": "fastapi"}, path=events_path, trusted_root=tmp_path,
-    )
-
-    got = list(st.read_events(path=events_path, trusted_root=tmp_path))
-    assert [e.event for e in got] == ["load", "unload", "override"]
-    assert got[0].event_id == rec_a.event_id
-    assert got[1].event_id == rec_b.event_id
-    assert got[2].event_id == rec_c.event_id
-    assert got[0].meta == {"source": "unit-test"}
-    assert got[2].meta == {"replaced_with": "fastapi"}
-
-
-def test_read_events_missing_file_yields_nothing(tmp_path: Path) -> None:
-    assert list(st.read_events(path=tmp_path / "nope.jsonl", trusted_root=tmp_path)) == []
-
-
-def test_read_events_skips_malformed_lines(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    events_path = tmp_path / "skill-events.jsonl"
-    # One valid event, one garbage line, one event missing a required key,
-    # one event missing event_id (now rejected), one blank line, one valid.
-    good1 = {
-        "event": "load", "skill": "x", "timestamp": _iso(),
-        "session_id": "s1", "event_id": "e1", "meta": {},
-    }
-    good2 = {
-        "event": "unload", "skill": "x", "timestamp": _iso(),
-        "session_id": "s1", "event_id": "e2", "meta": {},
-    }
-    missing_session = {
-        "event": "load", "skill": "x", "timestamp": _iso(), "event_id": "ex",
-    }
-    missing_event_id = {
-        "event": "load", "skill": "x", "timestamp": _iso(), "session_id": "s1",
-    }
-    events_path.write_text(
-        json.dumps(good1) + "\n"
-        + "not-json-at-all\n"
-        + json.dumps(missing_session) + "\n"
-        + json.dumps(missing_event_id) + "\n"
-        + "\n"
-        + json.dumps(good2) + "\n",
-        encoding="utf-8",
-    )
-
-    got = list(st.read_events(path=events_path, trusted_root=tmp_path))
-    assert [e.event_id for e in got] == ["e1", "e2"]
-    captured = capsys.readouterr()
-    # Warning is sanitised — no raw line content, no file path.
-    assert "skipping malformed event at line" in captured.err
-    assert "not-json-at-all" not in captured.err
-    assert str(events_path) not in captured.err
-
-
-def test_read_events_rejects_path_that_escapes_parent(tmp_path: Path) -> None:
-    # ``tmp_path / ".."`` resolves outside its own parent — must be refused.
-    bad = tmp_path / ".." / "evil.jsonl"
-    with pytest.raises(ValueError, match="escapes"):
-        list(st.read_events(path=bad))
-
-
-# ────────────────────────────────────────────────────────────────────
-# Concurrency
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_concurrent_appends_produce_wellformed_lines(tmp_path: Path) -> None:
-    events_path = tmp_path / "skill-events.jsonl"
-    N = 32
-
-    def worker(i: int) -> None:
-        st.log_event("load", f"skill{i:03d}", f"sess-{i}", path=events_path,
-                     trusted_root=tmp_path)
-
-    with ThreadPoolExecutor(max_workers=8) as pool:
-        list(pool.map(worker, range(N)))
-
-    lines = events_path.read_text(encoding="utf-8").splitlines()
-    assert len(lines) == N
-    for line in lines:
-        obj = json.loads(line)
-        assert obj["event"] == "load"
-        assert obj["session_id"].startswith("sess-")
-
-
-# ────────────────────────────────────────────────────────────────────
-# Retention window
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_retention_window_floor_applies_below_threshold() -> None:
-    assert st.retention_window_seconds(30 * 60) == pytest.approx(20 * 60)
-
-
-def test_retention_window_fraction_applies_above_threshold() -> None:
-    assert st.retention_window_seconds(4 * 3600) == pytest.approx(48 * 60)
-
-
-def test_retention_window_rejects_negative_session() -> None:
-    with pytest.raises(ValueError):
-        st.retention_window_seconds(-1)
-
-
-def test_retention_window_rejects_bad_fraction() -> None:
-    with pytest.raises(ValueError):
-        st.retention_window_seconds(60, fraction=1.5)
-
-
-def test_is_retained_true_at_and_above_window() -> None:
-    t0 = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
-    t1 = t0 + timedelta(minutes=20)
-    assert st.is_retained(t0.isoformat(), t1.isoformat(), session_seconds=600) is True
-
-
-def test_is_retained_false_below_window() -> None:
-    t0 = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
-    t1 = t0 + timedelta(minutes=19, seconds=59)
-    assert st.is_retained(t0.isoformat(), t1.isoformat(), session_seconds=600) is False
-
-
-def test_is_retained_rejects_reversed_timestamps() -> None:
-    t0 = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
-    t1 = t0 - timedelta(minutes=1)
-    with pytest.raises(ValueError):
-        st.is_retained(t0.isoformat(), t1.isoformat(), session_seconds=600)
-
-
-def test_is_retained_treats_naive_timestamps_as_utc() -> None:
-    # Naive load_ts (no tz) mixed with aware unload_ts must not raise.
-    load_ts = "2026-04-18T12:00:00"
-    unload_ts = "2026-04-18T12:30:00+00:00"
-    assert st.is_retained(load_ts, unload_ts, session_seconds=600) is True
-
-
-def test_is_retained_both_naive_ok() -> None:
-    load_ts = "2026-04-18T12:00:00"
-    unload_ts = "2026-04-18T12:30:00"
-    assert st.is_retained(load_ts, unload_ts, session_seconds=600) is True
-
-
-# ────────────────────────────────────────────────────────────────────
-# Default path resolution
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_default_events_path_resolves_under_claude_dir(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    # Simpler than reloading the module: just monkeypatch the constant
-    # the tests care about.
-    target = tmp_path / ".claude" / "skill-events.jsonl"
-    monkeypatch.setattr(st, "DEFAULT_EVENTS_PATH", target)
-    assert st.DEFAULT_EVENTS_PATH == target
-
-
-# ────────────────────────────────────────────────────────────────────
-# Trusted-root path containment (regression for Strix LOW finding)
-# ────────────────────────────────────────────────────────────────────
-
-
-def test_resolve_events_path_rejects_etc_passwd() -> None:
-    """Absolute path outside any trusted root must raise ValueError."""
-    with pytest.raises(ValueError, match="escapes trusted root"):
-        st._resolve_events_path(Path("/etc/passwd"))
-
-
-def test_resolve_events_path_rejects_windows_temp() -> None:
-    """Windows absolute path outside trusted root must raise ValueError."""
-    with pytest.raises(ValueError, match="escapes trusted root"):
-        st._resolve_events_path(Path("C:/Windows/Temp/x"))
-
-
-def test_resolve_events_path_none_returns_default() -> None:
-    """None path must return DEFAULT_EVENTS_PATH unchanged."""
-    result = st._resolve_events_path(None)
-    assert result == st.DEFAULT_EVENTS_PATH
-
-
-def test_resolve_events_path_tmp_path_with_trusted_root(tmp_path: Path) -> None:
-    """A path inside tmp_path succeeds when trusted_root=tmp_path."""
-    target = tmp_path / "x.jsonl"
-    result = st._resolve_events_path(target, trusted_root=tmp_path)
-    assert result == target
+"""
+test_skill_telemetry.py -- Regression tests for skill_telemetry.
+
+Covers the Phase 1 telemetry contract:
+
+  - event validation: type enum, skill-name sanitization, empty session_id
+  - round-trip: log_event -> read_events yields identical records
+  - malformed-line tolerance: partial/corrupt lines are skipped
+  - concurrent appends: two processes writing concurrently end up with
+    two well-formed lines (no interleaving corruption)
+  - retention window math: boundary and default-cap cases
+  - naive-timestamp handling: is_retained treats naive timestamps as UTC
+  - meta validation: rejects oversized, nested, or non-scalar values
+  - path containment: refuses caller-supplied paths that escape parents
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+
+SRC_DIR = Path(__file__).resolve().parents[1]
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+import skill_telemetry as st  # noqa: E402
+
+
+def _iso(offset_seconds: float = 0.0) -> str:
+    return (
+        datetime.now(timezone.utc) + timedelta(seconds=offset_seconds)
+    ).isoformat(timespec="seconds")
+
+
+def _event(**overrides: object) -> st.TelemetryEvent:
+    defaults: dict[str, object] = {
+        "event": "load",
+        "skill": "x",
+        "timestamp": _iso(),
+        "session_id": "s1",
+        "event_id": "e-default",
+    }
+    defaults.update(overrides)
+    return st.TelemetryEvent(**defaults)  # type: ignore[arg-type]
+
+
+# ────────────────────────────────────────────────────────────────────
+# Event validation
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_event_accepts_all_defined_types() -> None:
+    for kind in ("load", "unload", "override", "switch_away"):
+        _event(event=kind)
+
+
+def test_event_rejects_unknown_type() -> None:
+    with pytest.raises(ValueError, match="invalid event type"):
+        _event(event="explode")
+
+
+@pytest.mark.parametrize(
+    "bad_name",
+    [
+        "",
+        "../etc/passwd",
+        "skill/with/slash",
+        "skill with space",
+        "-leading-dash",
+        "a" * 200,
+    ],
+)
+def test_event_rejects_unsafe_skill_name(bad_name: str) -> None:
+    with pytest.raises(ValueError, match="invalid skill name"):
+        _event(skill=bad_name)
+
+
+def test_event_rejects_empty_session_id() -> None:
+    with pytest.raises(ValueError, match="session_id"):
+        _event(session_id="")
+
+
+def test_event_rejects_empty_event_id() -> None:
+    with pytest.raises(ValueError, match="event_id"):
+        _event(event_id="")
+
+
+def test_event_rejects_non_iso_timestamp() -> None:
+    with pytest.raises(ValueError, match="timestamp must be ISO-8601"):
+        _event(timestamp="not-a-time")
+
+
+# ────────────────────────────────────────────────────────────────────
+# meta validation
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_log_event_rejects_oversized_meta(tmp_path: Path) -> None:
+    big = {f"k{i}": i for i in range(st._MAX_META_KEYS + 1)}
+    with pytest.raises(ValueError, match="max"):
+        st.log_event("load", "x", "s1", meta=big, path=tmp_path / "e.jsonl",
+                     trusted_root=tmp_path)
+
+
+def test_log_event_rejects_non_scalar_meta_value(tmp_path: Path) -> None:
+    with pytest.raises(TypeError, match="must be str/int/float/bool/None"):
+        st.log_event(
+            "load", "x", "s1", meta={"nested": {"a": 1}},
+            path=tmp_path / "e.jsonl", trusted_root=tmp_path,
+        )
+
+
+def test_log_event_rejects_oversized_meta_string(tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="exceeds"):
+        st.log_event(
+            "load", "x", "s1",
+            meta={"big": "a" * (st._MAX_META_VALUE_LEN + 1)},
+            path=tmp_path / "e.jsonl",
+            trusted_root=tmp_path,
+        )
+
+
+# ────────────────────────────────────────────────────────────────────
+# Round-trip
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_log_event_and_read_events_round_trip(tmp_path: Path) -> None:
+    events_path = tmp_path / "skill-events.jsonl"
+
+    rec_a = st.log_event(
+        "load", "python-patterns", "sess-1",
+        meta={"source": "unit-test"}, path=events_path, trusted_root=tmp_path,
+    )
+    rec_b = st.log_event(
+        "unload", "python-patterns", "sess-1", path=events_path,
+        trusted_root=tmp_path,
+    )
+    rec_c = st.log_event(
+        "override", "flask", "sess-1",
+        meta={"replaced_with": "fastapi"}, path=events_path, trusted_root=tmp_path,
+    )
+
+    got = list(st.read_events(path=events_path, trusted_root=tmp_path))
+    assert [e.event for e in got] == ["load", "unload", "override"]
+    assert got[0].event_id == rec_a.event_id
+    assert got[1].event_id == rec_b.event_id
+    assert got[2].event_id == rec_c.event_id
+    assert got[0].meta == {"source": "unit-test"}
+    assert got[2].meta == {"replaced_with": "fastapi"}
+
+
+def test_read_events_missing_file_yields_nothing(tmp_path: Path) -> None:
+    assert list(st.read_events(path=tmp_path / "nope.jsonl", trusted_root=tmp_path)) == []
+
+
+def test_read_events_skips_malformed_lines(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    events_path = tmp_path / "skill-events.jsonl"
+    # One valid event, one garbage line, one event missing a required key,
+    # one event missing event_id (now rejected), one blank line, one valid.
+    good1 = {
+        "event": "load", "skill": "x", "timestamp": _iso(),
+        "session_id": "s1", "event_id": "e1", "meta": {},
+    }
+    good2 = {
+        "event": "unload", "skill": "x", "timestamp": _iso(),
+        "session_id": "s1", "event_id": "e2", "meta": {},
+    }
+    missing_session = {
+        "event": "load", "skill": "x", "timestamp": _iso(), "event_id": "ex",
+    }
+    missing_event_id = {
+        "event": "load", "skill": "x", "timestamp": _iso(), "session_id": "s1",
+    }
+    events_path.write_text(
+        json.dumps(good1) + "\n"
+        + "not-json-at-all\n"
+        + json.dumps(missing_session) + "\n"
+        + json.dumps(missing_event_id) + "\n"
+        + "\n"
+        + json.dumps(good2) + "\n",
+        encoding="utf-8",
+    )
+
+    got = list(st.read_events(path=events_path, trusted_root=tmp_path))
+    assert [e.event_id for e in got] == ["e1", "e2"]
+    captured = capsys.readouterr()
+    # Warning is sanitised — no raw line content, no file path.
+    assert "skipping malformed event at line" in captured.err
+    assert "not-json-at-all" not in captured.err
+    assert str(events_path) not in captured.err
+
+
+def test_read_events_rejects_path_that_escapes_parent(tmp_path: Path) -> None:
+    # ``tmp_path / ".."`` resolves outside its own parent — must be refused.
+    bad = tmp_path / ".." / "evil.jsonl"
+    with pytest.raises(ValueError, match="escapes"):
+        list(st.read_events(path=bad))
+
+
+# ────────────────────────────────────────────────────────────────────
+# Concurrency
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_concurrent_appends_produce_wellformed_lines(tmp_path: Path) -> None:
+    events_path = tmp_path / "skill-events.jsonl"
+    N = 32
+
+    def worker(i: int) -> None:
+        st.log_event("load", f"skill{i:03d}", f"sess-{i}", path=events_path,
+                     trusted_root=tmp_path)
+
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        list(pool.map(worker, range(N)))
+
+    lines = events_path.read_text(encoding="utf-8").splitlines()
+    assert len(lines) == N
+    for line in lines:
+        obj = json.loads(line)
+        assert obj["event"] == "load"
+        assert obj["session_id"].startswith("sess-")
+
+
+# ────────────────────────────────────────────────────────────────────
+# Retention window
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_retention_window_floor_applies_below_threshold() -> None:
+    assert st.retention_window_seconds(30 * 60) == pytest.approx(20 * 60)
+
+
+def test_retention_window_fraction_applies_above_threshold() -> None:
+    assert st.retention_window_seconds(4 * 3600) == pytest.approx(48 * 60)
+
+
+def test_retention_window_rejects_negative_session() -> None:
+    with pytest.raises(ValueError):
+        st.retention_window_seconds(-1)
+
+
+def test_retention_window_rejects_bad_fraction() -> None:
+    with pytest.raises(ValueError):
+        st.retention_window_seconds(60, fraction=1.5)
+
+
+def test_is_retained_true_at_and_above_window() -> None:
+    t0 = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
+    t1 = t0 + timedelta(minutes=20)
+    assert st.is_retained(t0.isoformat(), t1.isoformat(), session_seconds=600) is True
+
+
+def test_is_retained_false_below_window() -> None:
+    t0 = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
+    t1 = t0 + timedelta(minutes=19, seconds=59)
+    assert st.is_retained(t0.isoformat(), t1.isoformat(), session_seconds=600) is False
+
+
+def test_is_retained_rejects_reversed_timestamps() -> None:
+    t0 = datetime(2026, 4, 18, 12, 0, 0, tzinfo=timezone.utc)
+    t1 = t0 - timedelta(minutes=1)
+    with pytest.raises(ValueError):
+        st.is_retained(t0.isoformat(), t1.isoformat(), session_seconds=600)
+
+
+def test_is_retained_treats_naive_timestamps_as_utc() -> None:
+    # Naive load_ts (no tz) mixed with aware unload_ts must not raise.
+    load_ts = "2026-04-18T12:00:00"
+    unload_ts = "2026-04-18T12:30:00+00:00"
+    assert st.is_retained(load_ts, unload_ts, session_seconds=600) is True
+
+
+def test_is_retained_both_naive_ok() -> None:
+    load_ts = "2026-04-18T12:00:00"
+    unload_ts = "2026-04-18T12:30:00"
+    assert st.is_retained(load_ts, unload_ts, session_seconds=600) is True
+
+
+# ─────────────────────────────────────────────────���──────────────────
+# Default path resolution
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_default_events_path_resolves_under_claude_dir(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    # Simpler than reloading the module: just monkeypatch the constant
+    # the tests care about.
+    target = tmp_path / ".claude" / "skill-events.jsonl"
+    monkeypatch.setattr(st, "DEFAULT_EVENTS_PATH", target)
+    assert st.DEFAULT_EVENTS_PATH == target
+
+
+# ────────────────────────────────────────────────────────────────────
+# Trusted-root path containment (regression for Strix LOW finding)
+# ────────────────────────────────────────────────────────────────────
+
+
+def test_resolve_events_path_rejects_etc_passwd() -> None:
+    """Absolute path outside any trusted root must raise ValueError."""
+    with pytest.raises(ValueError, match="escapes trusted root"):
+        st._resolve_events_path(Path("/etc/passwd"))
+
+
+def test_resolve_events_path_rejects_windows_temp() -> None:
+    """Windows absolute path outside trusted root must raise ValueError."""
+    with pytest.raises(ValueError, match="escapes trusted root"):
+        st._resolve_events_path(Path("C:/Windows/Temp/x"))
+
+
+def test_resolve_events_path_none_returns_default() -> None:
+    """None path must return DEFAULT_EVENTS_PATH unchanged."""
+    result = st._resolve_events_path(None)
+    assert result == st.DEFAULT_EVENTS_PATH
+
+
+def test_resolve_events_path_tmp_path_with_trusted_root(tmp_path: Path) -> None:
+    """A path inside tmp_path succeeds when trusted_root=tmp_path."""
+    target = tmp_path / "x.jsonl"
+    result = st._resolve_events_path(target, trusted_root=tmp_path)
+    assert result == target

src/tests/test_update_repo_stats.py

@@ -1,338 +1,391 @@
-from __future__ import annotations
-
-import io
-import json
-import sys
-import tarfile
-from pathlib import Path
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-import update_repo_stats as urs  # noqa: E402
-
-
-def _add_bytes(tf: tarfile.TarFile, name: str, body: bytes) -> None:
-    info = tarfile.TarInfo(name)
-    info.size = len(body)
-    tf.addfile(info, io.BytesIO(body))
-
-
-def _add_json(tf: tarfile.TarFile, name: str, body: object) -> None:
-    _add_bytes(tf, name, json.dumps(body).encode("utf-8"))
-
-
-def _write_graph_tarball(root: Path, entries: list[tuple[str, object | bytes]]) -> None:
-    graph_dir = root / "graph"
-    graph_dir.mkdir()
-    with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
-        for name, body in entries:
-            if isinstance(body, bytes):
-                _add_bytes(tf, name, body)
-            else:
-                _add_json(tf, name, body)
-
-
-def test_tarball_stats_only_trust_safe_regular_members(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    _write_graph_tarball(
-        tmp_path,
-        [
-            ("./graphify-out/graph.json", {"nodes": [{}, {}], "edges": [{}, {}, {}]}),
-            ("./graphify-out/communities.json", {"total_communities": 4}),
-            ("./entities/skills/good.md", b"# skill"),
-            ("entities/agents/good.md", b"# agent"),
-            ("entities/mcp-servers/a/good.md", b"# mcp"),
-            ("entities/harnesses/good.md", b"# harness"),
-            ("shadow/entities/skills/ignored.md", b"# ignored"),
-            ("entities/skills/../ignored.md", b"# ignored"),
-        ],
-    )
-
-    assert urs._read_graph_from_tarball() == {
-        "nodes": 2,
-        "edges": 3,
-        "skills": 1,
-        "agents": 1,
-        "mcps": 1,
-        "harnesses": 1,
-        "communities": 4,
-    }
-
-
-def test_tarball_stats_reject_suffix_impersonation(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    _write_graph_tarball(
-        tmp_path,
-        [
-            ("evil/graphify-out/graph.json", {"nodes": [{}], "edges": []}),
-            ("entities/skills/good.md", b"# skill"),
-        ],
-    )
-
-    assert urs._read_graph_from_tarball() is None
-
-
-def test_tarball_stats_reject_non_regular_json_member(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    graph_dir = tmp_path / "graph"
-    graph_dir.mkdir()
-    with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
-        info = tarfile.TarInfo("graphify-out/graph.json")
-        info.type = tarfile.DIRTYPE
-        tf.addfile(info)
-        _add_bytes(tf, "entities/skills/good.md", b"# skill")
-
-    assert urs._read_graph_from_tarball() is None
-
-
-def test_tarball_stats_reject_oversized_json_member(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    monkeypatch.setattr(urs, "_MAX_TAR_JSON_BYTES", 8)
-    _write_graph_tarball(
-        tmp_path,
-        [
-            ("graphify-out/graph.json", {"nodes": [{}], "edges": []}),
-            ("entities/skills/good.md", b"# skill"),
-        ],
-    )
-
-    assert urs._read_graph_from_tarball() is None
-
-
-def test_tarball_stats_uses_report_when_graph_json_is_large(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    monkeypatch.setattr(urs, "_MAX_TAR_JSON_BYTES", 8)
-    _write_graph_tarball(
-        tmp_path,
-        [
-            (
-                "graphify-out/graph-report.md",
-                b"# Graph Report\n\n> Nodes: 104078 | Edges: 2881027 | Communities: 50\n",
-            ),
-            ("graphify-out/graph.json", {"nodes": [{}], "edges": []}),
-            ("entities/skills/good.md", b"# skill"),
-            ("entities/agents/good.md", b"# agent"),
-            ("entities/mcp-servers/a/good.md", b"# mcp"),
-            ("entities/harnesses/good.md", b"# harness"),
-        ],
-    )
-
-    stats = urs._read_graph_from_tarball()
-    assert stats is not None
-    assert {
-        key: stats[key]
-        for key in ("nodes", "edges", "skills", "agents", "mcps", "harnesses", "communities")
-    } == {
-        "nodes": 104078,
-        "edges": 2881027,
-        "skills": 1,
-        "agents": 1,
-        "mcps": 1,
-        "harnesses": 1,
-        "communities": 50,
-    }
-
-
-def test_test_badge_is_labeled_collected_not_passing() -> None:
-    text = "[![Tests](https://img.shields.io/badge/Tests-12_passing-brightgreen.svg)](#)"
-    stats = {
-        "nodes": None,
-        "edges": None,
-        "skills": None,
-        "agents": None,
-        "mcps": None,
-        "harnesses": None,
-        "communities": None,
-    }
-    patched = text
-    for pattern, replacement in urs.build_replacements(stats, tests=34, converted=None):
-        patched = pattern.sub(replacement, patched)
-
-    assert "Tests-34_collected" in patched
-    assert "_passing" not in patched
-
-
-def test_docs_landing_test_count_is_updated() -> None:
-    text = "CI-matrixed, 3,617 tests collected. Ships console scripts."
-    stats = {
-        "nodes": None,
-        "edges": None,
-        "skills": None,
-        "agents": None,
-        "mcps": None,
-        "harnesses": None,
-        "communities": None,
-    }
-    patched = text
-    for pattern, replacement in urs.build_docs_replacements(
-        stats=stats,
-        tests=3619,
-        converted=None,
-    ):
-        patched = pattern.sub(replacement, patched)
-
-    assert "3,619 tests collected" in patched
-    assert "3,617 tests collected" not in patched
-
-
-def test_knowledge_graph_counts_are_updated() -> None:
-    text = "\n".join([
-        "| Total nodes | **102,925** |",
-        "| Curated core nodes | **13,460** (1,998 skills + 467 agents + 10,788 MCP servers + 207 harnesses) |",
-        "| Body-backed skill nodes | **89,463** hydrated installable skill entries |",
-        "| Total edges | **2,913,930** |",
-        "| Hydrated skill incident edges | **2,605,000** |",
-        "| Hydrated skill semantic incident edges | **1,500,000** |",
-        "| Edge sources (overlap-deduped) | semantic 1,683,163 - tag 897,754 - token 433,245 |",
-        "| Cross-type edges (skill <-> agent) | ~67K |",
-        "| Cross-type edges (skill <-> MCP) | ~41K |",
-        "| Cross-type edges (agent <-> MCP) | ~223 |",
-        "| Harness edges | **6,571** |",
-    ])
-    stats = {
-        "nodes": 102928,
-        "edges": 2913960,
-        "skills": 91464,
-        "agents": 467,
-        "mcps": 10790,
-        "harnesses": 207,
-        "communities": 52,
-        "skills_sh_entries": 89465,
-        "skills_sh_bodies": 89465,
-        "semantic_edges": 1683193,
-        "tag_edges": 897784,
-        "token_edges": 433245,
-        "hydrated_incident_edges": 2605721,
-        "hydrated_semantic_incident_edges": 1500648,
-        "cross_skill_agent_edges": 66799,
-        "cross_skill_mcp_edges": 41521,
-        "cross_agent_mcp_edges": 229,
-        "harness_edges": 6576,
-    }
-    patched = text
-    for pattern, replacement in urs.build_replacements(stats, tests=None, converted=None):
-        patched = pattern.sub(replacement, patched)
-
-    assert "| Total nodes | **102,928** |" in patched
-    assert "| Curated core nodes | **13,463** (1,999 skills + 467 agents + 10,790 MCP servers + 207 harnesses) |" in patched
-    assert "| Body-backed skill nodes | **89,465** hydrated installable skill entries |" in patched
-    assert "| Total edges | **2,913,960** |" in patched
-    assert "semantic 1,683,193 - tag 897,784 - token 433,245" in patched
-    assert "| Cross-type edges (skill <-> agent) | ~66,799 |" in patched
-    assert "| Cross-type edges (skill <-> MCP) | ~41,521 |" in patched
-    assert "| Cross-type edges (agent <-> MCP) | ~229 |" in patched
-    assert "| Harness edges | **6,576** |" in patched
-
-
-def test_harness_aware_readme_prose_is_updated() -> None:
-    text = (
-        "walks a **1,000 skills, 20 agents, 30 MCP servers, "
-        "and 4 cataloged harnesses** graph"
-    )
-    stats = {
-        "nodes": None,
-        "edges": None,
-        "skills": 92815,
-        "agents": 464,
-        "mcps": 10787,
-        "harnesses": 13,
-        "communities": None,
-    }
-    patched = text
-    for pattern, replacement in urs.build_replacements(stats, tests=None, converted=None):
-        patched = pattern.sub(replacement, patched)
-
-    assert "**92,815 skills, 464 agents, 10,787 MCP servers, and 13 harnesses**" in patched
-
-
-def test_patch_readme_checks_knowledge_graph_doc(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    readme = tmp_path / "README.md"
-    docs = tmp_path / "docs"
-    docs.mkdir()
-    docs_index = docs / "index.md"
-    docs_knowledge = docs / "knowledge-graph.md"
-    readme.write_text("Graph has 10 nodes and 20 edges\n", encoding="utf-8")
-    docs_index.write_text("3 tests collected\n", encoding="utf-8")
-    docs_knowledge.write_text("| Total nodes | **10** |\n", encoding="utf-8")
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    monkeypatch.setattr(urs, "README", readme)
-    monkeypatch.setattr(urs, "DOCS_INDEX", docs_index)
-    monkeypatch.setattr(urs, "DOCS_KNOWLEDGE_GRAPH", docs_knowledge)
-    monkeypatch.setattr(
-        urs,
-        "read_graph_stats",
-        lambda: {
-            "nodes": 11,
-            "edges": 21,
-            "skills": None,
-            "agents": None,
-            "mcps": None,
-            "harnesses": None,
-            "communities": 1,
-        },
-    )
-    monkeypatch.setattr(urs, "read_test_count", lambda: None)
-    monkeypatch.setattr(urs, "read_converted_count", lambda: None)
-
-    assert urs.patch_readme(check_only=True) == 1
-
-
-def test_read_test_count_prefers_project_python(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    calls: list[str] = []
-
-    def _collect(candidate: str) -> int | None:
-        calls.append(candidate)
-        return 34 if candidate == "python" else 30
-
-    monkeypatch.setattr(urs.sys, "executable", "python3")
-    monkeypatch.setattr(urs, "_pytest_collect", _collect)
-
-    assert urs.read_test_count() == 34
-    assert calls == ["python"]
-
-
-def test_uncollected_importorskip_tests_are_added_to_collection_count(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
-    tests_dir = tmp_path / "src" / "tests"
-    tests_dir.mkdir(parents=True)
-    (tests_dir / "test_browser.py").write_text(
-        "import pytest\n"
-        "pytest.importorskip('playwright.sync_api')\n"
-        "def test_one(): pass\n"
-        "def test_two(): pass\n",
-        encoding="utf-8",
-    )
-    (tests_dir / "test_present.py").write_text(
-        "import pytest\n"
-        "pytest.importorskip('already.available')\n"
-        "def test_present(): pass\n",
-        encoding="utf-8",
-    )
-
-    stdout = "src/tests/test_present.py::test_present\n1 test collected\n"
-    assert urs._uncollected_importorskip_test_count(stdout) == 2
+from __future__ import annotations
+
+import io
+import json
+import sys
+import tarfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+import update_repo_stats as urs  # noqa: E402
+
+
+def _add_bytes(tf: tarfile.TarFile, name: str, body: bytes) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(body)
+    tf.addfile(info, io.BytesIO(body))
+
+
+def _add_json(tf: tarfile.TarFile, name: str, body: object) -> None:
+    _add_bytes(tf, name, json.dumps(body).encode("utf-8"))
+
+
+def _write_graph_tarball(root: Path, entries: list[tuple[str, object | bytes]]) -> None:
+    graph_dir = root / "graph"
+    graph_dir.mkdir()
+    with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
+        for name, body in entries:
+            if isinstance(body, bytes):
+                _add_bytes(tf, name, body)
+            else:
+                _add_json(tf, name, body)
+
+
+def test_tarball_stats_only_trust_safe_regular_members(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    _write_graph_tarball(
+        tmp_path,
+        [
+            ("./graphify-out/graph.json", {"nodes": [{}, {}], "edges": [{}, {}, {}]}),
+            ("./graphify-out/communities.json", {"total_communities": 4}),
+            ("./entities/skills/good.md", b"# skill"),
+            ("entities/agents/good.md", b"# agent"),
+            ("entities/mcp-servers/a/good.md", b"# mcp"),
+            ("entities/harnesses/good.md", b"# harness"),
+            ("shadow/entities/skills/ignored.md", b"# ignored"),
+            ("entities/skills/../ignored.md", b"# ignored"),
+        ],
+    )
+
+    assert urs._read_graph_from_tarball() == {
+        "nodes": 2,
+        "edges": 3,
+        "skills": 1,
+        "agents": 1,
+        "mcps": 1,
+        "harnesses": 1,
+        "communities": 4,
+    }
+
+
+def test_tarball_stats_reject_suffix_impersonation(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    _write_graph_tarball(
+        tmp_path,
+        [
+            ("evil/graphify-out/graph.json", {"nodes": [{}], "edges": []}),
+            ("entities/skills/good.md", b"# skill"),
+        ],
+    )
+
+    assert urs._read_graph_from_tarball() is None
+
+
+def test_tarball_stats_reject_non_regular_json_member(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    graph_dir = tmp_path / "graph"
+    graph_dir.mkdir()
+    with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
+        info = tarfile.TarInfo("graphify-out/graph.json")
+        info.type = tarfile.DIRTYPE
+        tf.addfile(info)
+        _add_bytes(tf, "entities/skills/good.md", b"# skill")
+
+    assert urs._read_graph_from_tarball() is None
+
+
+def test_tarball_stats_reject_oversized_json_member(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    monkeypatch.setattr(urs, "_MAX_TAR_JSON_BYTES", 8)
+    _write_graph_tarball(
+        tmp_path,
+        [
+            ("graphify-out/graph.json", {"nodes": [{}], "edges": []}),
+            ("entities/skills/good.md", b"# skill"),
+        ],
+    )
+
+    assert urs._read_graph_from_tarball() is None
+
+
+def test_tarball_stats_uses_report_when_graph_json_is_large(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    monkeypatch.setattr(urs, "_MAX_TAR_JSON_BYTES", 8)
+    _write_graph_tarball(
+        tmp_path,
+        [
+            (
+                "graphify-out/graph-report.md",
+                b"# Graph Report\n\n> Nodes: 104078 | Edges: 2881027 | Communities: 50\n",
+            ),
+            ("graphify-out/graph.json", {"nodes": [{}], "edges": []}),
+            ("entities/skills/good.md", b"# skill"),
+            ("entities/agents/good.md", b"# agent"),
+            ("entities/mcp-servers/a/good.md", b"# mcp"),
+            ("entities/harnesses/good.md", b"# harness"),
+        ],
+    )
+
+    stats = urs._read_graph_from_tarball()
+    assert stats is not None
+    assert {
+        key: stats[key]
+        for key in ("nodes", "edges", "skills", "agents", "mcps", "harnesses", "communities")
+    } == {
+        "nodes": 104078,
+        "edges": 2881027,
+        "skills": 1,
+        "agents": 1,
+        "mcps": 1,
+        "harnesses": 1,
+        "communities": 50,
+    }
+
+
+def test_test_badge_is_labeled_collected_not_passing() -> None:
+    text = "[![Tests](https://img.shields.io/badge/Tests-12_passing-brightgreen.svg)](#)"
+    stats = {
+        "nodes": None,
+        "edges": None,
+        "skills": None,
+        "agents": None,
+        "mcps": None,
+        "harnesses": None,
+        "communities": None,
+    }
+    patched = text
+    for pattern, replacement in urs.build_replacements(stats, tests=34, converted=None):
+        patched = pattern.sub(replacement, patched)
+
+    assert "Tests-34_collected" in patched
+    assert "_passing" not in patched
+
+
+def test_docs_landing_test_count_is_updated() -> None:
+    text = "CI-matrixed, 3,617 tests collected. Ships console scripts."
+    stats = {
+        "nodes": None,
+        "edges": None,
+        "skills": None,
+        "agents": None,
+        "mcps": None,
+        "harnesses": None,
+        "communities": None,
+    }
+    patched = text
+    for pattern, replacement in urs.build_docs_replacements(
+        stats=stats,
+        tests=3619,
+        converted=None,
+    ):
+        patched = pattern.sub(replacement, patched)
+
+    assert "3,619 tests collected" in patched
+    assert "3,617 tests collected" not in patched
+
+
+def test_knowledge_graph_counts_are_updated() -> None:
+    text = "\n".join([
+        "| Total nodes | **102,925** |",
+        "| Curated core nodes | **13,460** (1,998 skills + 467 agents + 10,788 MCP servers + 207 harnesses) |",
+        "| Body-backed skill nodes | **89,463** hydrated installable skill entries |",
+        "| Total edges | **2,913,930** |",
+        "| Hydrated skill incident edges | **2,605,000** |",
+        "| Hydrated skill semantic incident edges | **1,500,000** |",
+        "| Edge sources (overlap-deduped) | semantic 1,683,163 - tag 897,754 - token 433,245 |",
+        "| Cross-type edges (skill <-> agent) | ~67K |",
+        "| Cross-type edges (skill <-> MCP) | ~41K |",
+        "| Cross-type edges (agent <-> MCP) | ~223 |",
+        "| Harness edges | **6,571** |",
+    ])
+    stats = {
+        "nodes": 102928,
+        "edges": 2913960,
+        "skills": 91464,
+        "agents": 467,
+        "mcps": 10790,
+        "harnesses": 207,
+        "communities": 52,
+        "skills_sh_entries": 89465,
+        "skills_sh_bodies": 89465,
+        "semantic_edges": 1683193,
+        "tag_edges": 897784,
+        "token_edges": 433245,
+        "hydrated_incident_edges": 2605721,
+        "hydrated_semantic_incident_edges": 1500648,
+        "cross_skill_agent_edges": 66799,
+        "cross_skill_mcp_edges": 41521,
+        "cross_agent_mcp_edges": 229,
+        "harness_edges": 6576,
+    }
+    patched = text
+    for pattern, replacement in urs.build_replacements(stats, tests=None, converted=None):
+        patched = pattern.sub(replacement, patched)
+
+    assert "| Total nodes | **102,928** |" in patched
+    assert "| Curated core nodes | **13,463** (1,999 skills + 467 agents + 10,790 MCP servers + 207 harnesses) |" in patched
+    assert "| Body-backed skill nodes | **89,465** hydrated installable skill entries |" in patched
+    assert "| Total edges | **2,913,960** |" in patched
+    assert "semantic 1,683,193 - tag 897,784 - token 433,245" in patched
+    assert "| Cross-type edges (skill <-> agent) | ~66,799 |" in patched
+    assert "| Cross-type edges (skill <-> MCP) | ~41,521 |" in patched
+    assert "| Cross-type edges (agent <-> MCP) | ~229 |" in patched
+    assert "| Harness edges | **6,576** |" in patched
+
+
+def test_harness_aware_readme_prose_is_updated() -> None:
+    text = (
+        "walks a **1,000 skills, 20 agents, 30 MCP servers, "
+        "and 4 cataloged harnesses** graph"
+    )
+    stats = {
+        "nodes": None,
+        "edges": None,
+        "skills": 92815,
+        "agents": 464,
+        "mcps": 10787,
+        "harnesses": 13,
+        "communities": None,
+    }
+    patched = text
+    for pattern, replacement in urs.build_replacements(stats, tests=None, converted=None):
+        patched = pattern.sub(replacement, patched)
+
+    assert "**92,815 skills, 464 agents, 10,787 MCP servers, and 13 harnesses**" in patched
+
+
+def test_readme_entity_badges_are_updated() -> None:
+    text = "\n".join([
+        "[![Graph](https://img.shields.io/badge/Graph-1_nodes_/_2_edges-red.svg)](graph/)",
+        "[![Skills](https://img.shields.io/badge/Skills-1-blue.svg)](graph/)",
+        "[![Agents](https://img.shields.io/badge/Agents-2-purple.svg)](graph/)",
+        "[![MCPs](https://img.shields.io/badge/MCPs-3-pink.svg)](graph/)",
+        "[![Harnesses](https://img.shields.io/badge/Harnesses-4-orange.svg)](graph/)",
+    ])
+    stats = {
+        "nodes": None,
+        "edges": None,
+        "skills": 91464,
+        "agents": 467,
+        "mcps": 10790,
+        "harnesses": 207,
+        "communities": None,
+    }
+    patched = text
+    for pattern, replacement in urs.build_replacements(stats, tests=None, converted=None):
+        patched = pattern.sub(replacement, patched)
+
+    assert "badge/Skills-91%2C464-blue" in patched
+    assert "badge/Agents-467-purple" in patched
+    assert "badge/MCPs-10%2C790-pink" in patched
+    assert "badge/Harnesses-207-orange" in patched
+    assert "](https://stevesolun.github.io/ctx/knowledge-graph/)" in patched
+    assert (
+        patched.count("](https://stevesolun.github.io/ctx/dashboard/#catalog-badge-links)")
+        == 4
+    )
+    assert "127.0.0.1" not in patched
+
+
+def test_github_about_description_uses_current_entity_counts() -> None:
+    stats = {
+        "nodes": 102928,
+        "edges": 2_900_000,
+        "skills": 91464,
+        "agents": 467,
+        "mcps": 10790,
+        "harnesses": 207,
+        "communities": 52,
+    }
+
+    description = urs.build_github_about_description(stats)
+
+    assert "102,928-node LLM-wiki graph" in description
+    assert "91,464 skills" in description
+    assert "467 agents" in description
+    assert "10,790 MCPs" in description
+    assert "207 harnesses" in description
+
+
+def test_patch_readme_checks_knowledge_graph_doc(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    readme = tmp_path / "README.md"
+    docs = tmp_path / "docs"
+    docs.mkdir()
+    docs_index = docs / "index.md"
+    docs_knowledge = docs / "knowledge-graph.md"
+    readme.write_text("Graph has 10 nodes and 20 edges\n", encoding="utf-8")
+    docs_index.write_text("3 tests collected\n", encoding="utf-8")
+    docs_knowledge.write_text("| Total nodes | **10** |\n", encoding="utf-8")
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    monkeypatch.setattr(urs, "README", readme)
+    monkeypatch.setattr(urs, "DOCS_INDEX", docs_index)
+    monkeypatch.setattr(urs, "DOCS_KNOWLEDGE_GRAPH", docs_knowledge)
+    monkeypatch.setattr(
+        urs,
+        "read_graph_stats",
+        lambda: {
+            "nodes": 11,
+            "edges": 21,
+            "skills": None,
+            "agents": None,
+            "mcps": None,
+            "harnesses": None,
+            "communities": 1,
+        },
+    )
+    monkeypatch.setattr(urs, "read_test_count", lambda: None)
+    monkeypatch.setattr(urs, "read_converted_count", lambda: None)
+
+    assert urs.patch_readme(check_only=True) == 1
+
+
+def test_read_test_count_prefers_project_python(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[str] = []
+
+    def _collect(candidate: str) -> int | None:
+        calls.append(candidate)
+        return 34 if candidate == "python" else 30
+
+    monkeypatch.setattr(urs.sys, "executable", "python3")
+    monkeypatch.setattr(urs, "_pytest_collect", _collect)
+
+    assert urs.read_test_count() == 34
+    assert calls == ["python"]
+
+
+def test_uncollected_importorskip_tests_are_added_to_collection_count(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(urs, "REPO_ROOT", tmp_path)
+    tests_dir = tmp_path / "src" / "tests"
+    tests_dir.mkdir(parents=True)
+    (tests_dir / "test_browser.py").write_text(
+        "import pytest\n"
+        "pytest.importorskip('playwright.sync_api')\n"
+        "def test_one(): pass\n"
+        "def test_two(): pass\n",
+        encoding="utf-8",
+    )
+    (tests_dir / "test_present.py").write_text(
+        "import pytest\n"
+        "pytest.importorskip('already.available')\n"
+        "def test_present(): pass\n",
+        encoding="utf-8",
+    )
+
+    stdout = "src/tests/test_present.py::test_present\n1 test collected\n"
+    assert urs._uncollected_importorskip_test_count(stdout) == 2

src/tests/test_validate_graph_artifacts.py

@@ -1,1192 +1,1193 @@
-from __future__ import annotations
-
-import gzip
-import json
-import sqlite3
-import tarfile
-import zlib
-from io import BytesIO
-from pathlib import Path
-from typing import Any
-
-import pytest
-import yaml  # type: ignore[import-untyped]
-
-from validate_graph_artifacts import (
-    DEFAULT_HARNESSES,
-    GraphArtifactError,
-    _validate_root_entity_overlay,
-    _safe_tar_name,
-    _scan_graph_json,
-    validate_graph_artifacts,
-)
-
-_PREVIEW_HTML_FILES = (
-    "sample-top60.html",
-    "viz-ai-agents.html",
-    "viz-overview.html",
-    "viz-python.html",
-    "viz-security.html",
-)
-
-
-def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
-    payload = text.encode("utf-8")
-    info = tarfile.TarInfo(name)
-    info.size = len(payload)
-    info.mode = 0o644
-    tf.addfile(info, BytesIO(payload))
-
-
-def _add_bytes(tf: tarfile.TarFile, name: str, payload: bytes) -> None:
-    info = tarfile.TarInfo(name)
-    info.size = len(payload)
-    info.mode = 0o644
-    tf.addfile(info, BytesIO(payload))
-
-
-def _dashboard_index_bytes(graph_dir: Path, *, export_id: str) -> bytes:
-    path = graph_dir / f"dashboard-index-{export_id}.sqlite3"
-    if path.exists():
-        path.unlink()
-    conn = sqlite3.connect(path)
-    try:
-        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
-        conn.execute(
-            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
-            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
-        )
-        conn.execute(
-            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
-            "PRIMARY KEY(slug,type,node_id))"
-        )
-        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
-        conn.executemany(
-            "INSERT INTO meta VALUES(?,?)",
-            [
-                ("version", "1"),
-                ("export_id", json.dumps(export_id)),
-                ("nodes_count", "2"),
-                ("edges_count", "1"),
-                ("max_degree", "1"),
-                ("top_k", "40"),
-            ],
-        )
-        conn.executemany(
-            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
-            [
-                ("skill:skills-sh-example-skill", "skills-sh-example-skill", "skill", "[]", "", None, None, 1),
-                ("harness:langgraph", "langgraph", "harness", "[]", "", None, None, 1),
-            ],
-        )
-        conn.executemany(
-            "INSERT INTO slug_index VALUES(?,?,?)",
-            [
-                ("skills-sh-example-skill", "skill", "skill:skills-sh-example-skill"),
-                ("langgraph", "harness", "harness:langgraph"),
-            ],
-        )
-        conn.executemany(
-            "INSERT INTO neighbors VALUES(?,?)",
-            [
-                ("skill:skills-sh-example-skill", zlib.compress(json.dumps([{"target": "harness:langgraph"}]).encode("utf-8"))),
-                ("harness:langgraph", zlib.compress(json.dumps([{"target": "skill:skills-sh-example-skill"}]).encode("utf-8"))),
-            ],
-        )
-        conn.commit()
-    finally:
-        conn.close()
-    payload = path.read_bytes()
-    path.unlink()
-    return payload
-
-
-def _write_catalog(graph_dir: Path, *, converted_path: str | None = None) -> None:
-    skill = {
-        "ctx_slug": "skills-sh-example-skill",
-        "graph_node_id": "skill:skills-sh-example-skill",
-        "entity_path": "entities/skills/skills-sh-example-skill.md",
-        "body_available": converted_path is not None,
-        "converted_path": converted_path,
-    }
-    catalog = {
-        "observed_unique_skills": 1,
-        "body_available_count": 1 if converted_path else 0,
-        "skills": [skill],
-    }
-    with gzip.open(graph_dir / "skills-sh-catalog.json.gz", "wt", encoding="utf-8") as f:
-        json.dump(catalog, f)
-
-
-def _write_entity_overlay(graph_dir: Path) -> None:
-    payload = {
-        "overlay_id": "test-overlay",
-        "nodes": [
-            {
-                "id": "harness:langgraph",
-                "label": "langgraph",
-                "type": "harness",
-            }
-        ],
-        "edges": [
-            {
-                "source": "skill:skills-sh-example-skill",
-                "target": "harness:langgraph",
-                "weight": 0.5,
-                "final_weight": 0.5,
-                "similarity_score": 0.5,
-            }
-        ],
-    }
-    (graph_dir / "entity-overlays.jsonl").write_text(
-        json.dumps(payload) + "\n",
-        encoding="utf-8",
-    )
-
-
-def _write_runtime_archive(
-    graph_dir: Path,
-    *,
-    graph: dict[str, Any],
-    include_queue: bool = False,
-    include_delta: bool = True,
-    include_report: bool = True,
-    include_manifest: bool = True,
-    delta_export_id: str = "export-test",
-    communities_export_id: str = "export-test",
-    report_export_id: str = "export-test",
-    manifest_export_id: str = "export-test",
-) -> None:
-    with tarfile.open(graph_dir / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
-        _add_text(tf, "index.md", "# Wiki\n")
-        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
-        if include_delta:
-            _add_text(
-                tf,
-                "graphify-out/graph-delta.json",
-                json.dumps({"export_id": delta_export_id, "nodes": [], "edges": []}),
-            )
-        _add_text(
-            tf,
-            "graphify-out/communities.json",
-            json.dumps({"export_id": communities_export_id, "total_communities": 1}),
-        )
-        if include_report:
-            _add_text(
-                tf,
-                "graphify-out/graph-report.md",
-                f"# Graph Report\n\n> Export ID: {report_export_id}\n",
-            )
-        if include_manifest:
-            _add_text(
-                tf,
-                "graphify-out/graph-export-manifest.json",
-                json.dumps({
-                    "version": 1,
-                    "export_id": manifest_export_id,
-                    "artifacts": {
-                        "graph": "graph.json",
-                        "delta": "graph-delta.json",
-                        "communities": "communities.json",
-                        "report": "graph-report.md",
-                    },
-                    "counts": {"nodes": 2, "edges": 1, "communities": 1},
-                }),
-            )
-        _add_bytes(
-            tf,
-            "graphify-out/dashboard-neighborhoods.sqlite3",
-            _dashboard_index_bytes(graph_dir, export_id=manifest_export_id),
-        )
-        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
-        if include_queue:
-            _add_text(tf, ".ctx/wiki-queue.sqlite3", "not a shipped artifact\n")
-        for slug in sorted(DEFAULT_HARNESSES):
-            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
-
-
-def _write_archive(
-    graph_dir: Path,
-    *,
-    include_converted: bool = True,
-    converted_skill_text: str = "# Example\n",
-    include_original: bool = False,
-    include_lock: bool = False,
-    include_queue: bool = False,
-    include_delta: bool = True,
-    include_report: bool = True,
-    include_manifest: bool = True,
-    graph_export_id: str = "export-test",
-    delta_export_id: str = "export-test",
-    communities_export_id: str | None = None,
-    report_export_id: str | None = None,
-    manifest_export_id: str | None = None,
-) -> None:
-    _write_entity_overlay(graph_dir)
-    communities_export_id = communities_export_id or graph_export_id
-    report_export_id = report_export_id or graph_export_id
-    manifest_export_id = manifest_export_id or graph_export_id
-    graph = {
-        "graph": {"export_id": graph_export_id},
-        "nodes": [
-            {
-                "id": "skill:skills-sh-example-skill",
-                "type": "skill",
-                "source_catalog": "skills.sh",
-            },
-            {"id": "harness:langgraph", "type": "harness"},
-        ],
-        "edges": [
-            {
-                "source": "skill:skills-sh-example-skill",
-                "target": "harness:langgraph",
-                "semantic_sim": 0.91,
-            },
-        ],
-    }
-    with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
-        _add_text(tf, "./index.md", "# Wiki\n")
-        _add_text(tf, "./graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
-        if include_delta:
-            _add_text(
-                tf,
-                "./graphify-out/graph-delta.json",
-                json.dumps({"export_id": delta_export_id, "nodes": [], "edges": []}),
-            )
-        _add_text(
-            tf,
-            "./graphify-out/communities.json",
-            json.dumps({"export_id": communities_export_id, "total_communities": 1}),
-        )
-        if include_report:
-            _add_text(
-                tf,
-                "./graphify-out/graph-report.md",
-                f"# Graph Report\n\n> Export ID: {report_export_id}\n",
-            )
-        if include_manifest:
-            _add_text(
-                tf,
-                "./graphify-out/graph-export-manifest.json",
-                json.dumps({
-                    "version": 1,
-                    "export_id": manifest_export_id,
-                    "artifacts": {
-                        "graph": "graph.json",
-                        "delta": "graph-delta.json",
-                        "communities": "communities.json",
-                        "report": "graph-report.md",
-                    },
-                    "counts": {"nodes": 2, "edges": 1, "communities": 1},
-                }),
-            )
-        _add_bytes(
-            tf,
-            "./graphify-out/dashboard-neighborhoods.sqlite3",
-            _dashboard_index_bytes(graph_dir, export_id=manifest_export_id),
-        )
-        _add_text(tf, "./external-catalogs/skills-sh/catalog.json", "{}")
-        _add_text(tf, "./entities/skills/skills-sh-example-skill.md", "# Example\n")
-        _add_text(tf, "./entities/harnesses/langgraph.md", "# LangGraph\n")
-        if include_converted:
-            _add_text(tf, "./converted/skills-sh-example-skill/SKILL.md", converted_skill_text)
-            _add_text(tf, "./converted/skills-sh-example-skill/references/01-scope.md", "# Scope\n")
-        if include_original:
-            _add_text(tf, "./converted/skills-sh-example-skill/SKILL.md.original", "# Raw\n")
-        if include_lock:
-            _add_text(tf, "./index.md.lock", "")
-        if include_queue:
-            _add_text(tf, "./.ctx/wiki-queue.sqlite3", "not a shipped artifact\n")
-    for preview in _PREVIEW_HTML_FILES:
-        (graph_dir / preview).write_text(
-            "\n".join([
-                "<!DOCTYPE html>",
-                "<html><head>",
-                f'<meta name="ctx-graph-export-id" content="{manifest_export_id}">',
-                "</head><body>",
-                "const CTX_GRAPH_METADATA = "
-                + json.dumps({
-                    "export_id": manifest_export_id,
-                    "source_graph_nodes": 2,
-                    "source_graph_edges": 1,
-                }),
-                "</body></html>",
-            ]),
-            encoding="utf-8",
-        )
-    _write_runtime_archive(
-        graph_dir,
-        graph=graph,
-        include_delta=include_delta,
-        include_report=include_report,
-        include_manifest=include_manifest,
-        delta_export_id=delta_export_id,
-        communities_export_id=communities_export_id,
-        report_export_id=report_export_id,
-        manifest_export_id=manifest_export_id,
-    )
-    (graph_dir / "communities.json").write_text(
-        json.dumps({"export_id": communities_export_id, "total_communities": 1}),
-        encoding="utf-8",
-    )
-
-
-def test_validate_graph_artifacts_checks_catalog_paths_and_deep_graph_stats(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text(
-        json.dumps({"total_communities": 1}),
-        encoding="utf-8",
-    )
-    _write_archive(tmp_path)
-
-    stats = validate_graph_artifacts(
-        tmp_path,
-        deep=True,
-        min_nodes=2,
-        min_edges=1,
-        min_skills_sh_nodes=1,
-        min_semantic_edges=1,
-        expected_harnesses={"langgraph"},
-        line_threshold=180,
-        max_stage_lines=40,
-        expected_nodes=2,
-        expected_edges=1,
-        expected_semantic_edges=1,
-        expected_harness_nodes=1,
-        expected_skills_sh_nodes=1,
-        expected_skills_sh_catalog_entries=1,
-        expected_skills_sh_converted=1,
-        expected_skill_pages=1,
-        expected_agent_pages=0,
-        expected_mcp_pages=0,
-        expected_harness_pages=1,
-    )
-
-    assert stats.graph_nodes == 2
-    assert stats.graph_edges == 1
-    assert stats.harness_nodes == 1
-    assert stats.skills_sh_catalog_entries == 1
-    assert stats.skills_sh_converted == 1
-    assert stats.harness_pages == 1
-
-    with pytest.raises(GraphArtifactError, match="graph_edges exact count mismatch"):
-        validate_graph_artifacts(
-            tmp_path,
-            deep=True,
-            min_nodes=2,
-            min_edges=1,
-            min_skills_sh_nodes=1,
-            min_semantic_edges=1,
-            expected_harnesses={"langgraph"},
-            expected_edges=2,
-        )
-
-    with pytest.raises(GraphArtifactError, match="deep=True is required"):
-        validate_graph_artifacts(
-            tmp_path,
-            expected_harnesses={"langgraph"},
-            expected_nodes=2,
-        )
-
-
-def test_validate_graph_artifacts_rejects_mixed_export_generation(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, graph_export_id="new-export", delta_export_id="old-export")
-
-    with pytest.raises(GraphArtifactError, match="export_id mismatch"):
-        validate_graph_artifacts(
-            tmp_path,
-            deep=True,
-            min_nodes=2,
-            min_edges=1,
-            min_skills_sh_nodes=1,
-            min_semantic_edges=1,
-            expected_harnesses={"langgraph"},
-        )
-
-
-def test_validate_graph_artifacts_rejects_runtime_full_export_split(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path, graph_export_id="full-export")
-    runtime_graph = {
-        "graph": {"export_id": "runtime-export"},
-        "nodes": [
-            {"id": "skill:skills-sh-example-skill", "type": "skill"},
-            {"id": "harness:langgraph", "type": "harness"},
-        ],
-        "edges": [
-            {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
-        ],
-    }
-    _write_runtime_archive(
-        tmp_path,
-        graph=runtime_graph,
-        delta_export_id="runtime-export",
-        communities_export_id="runtime-export",
-        report_export_id="runtime-export",
-        manifest_export_id="runtime-export",
-    )
-
-    with pytest.raises(GraphArtifactError, match="runtime graph archive export_id mismatch"):
-        validate_graph_artifacts(
-            tmp_path,
-            deep=True,
-            min_nodes=2,
-            min_edges=1,
-            min_skills_sh_nodes=1,
-            min_semantic_edges=1,
-            expected_harnesses={"langgraph"},
-        )
-
-
-def test_validate_graph_artifacts_rejects_corrupt_dashboard_index(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path)
-    with tarfile.open(tmp_path / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
-        graph = {
-            "graph": {"export_id": "export-test"},
-            "nodes": [
-                {"id": "skill:skills-sh-example-skill", "type": "skill"},
-                {"id": "harness:langgraph", "type": "harness"},
-            ],
-            "edges": [
-                {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
-            ],
-        }
-        _add_text(tf, "index.md", "# Wiki\n")
-        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
-        _add_text(tf, "graphify-out/graph-delta.json", json.dumps({"export_id": "export-test"}))
-        _add_text(tf, "graphify-out/communities.json", json.dumps({"export_id": "export-test"}))
-        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n\n> Export ID: export-test\n")
-        _add_text(
-            tf,
-            "graphify-out/graph-export-manifest.json",
-            json.dumps({
-                "version": 1,
-                "export_id": "export-test",
-                "artifacts": {
-                    "graph": "graph.json",
-                    "delta": "graph-delta.json",
-                    "communities": "communities.json",
-                    "report": "graph-report.md",
-                },
-                "counts": {"nodes": 2, "edges": 1, "communities": 1},
-            }),
-        )
-        _add_text(tf, "graphify-out/dashboard-neighborhoods.sqlite3", "not sqlite\n")
-        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
-        for slug in sorted(DEFAULT_HARNESSES):
-            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
-
-    with pytest.raises(GraphArtifactError, match="dashboard index"):
-        validate_graph_artifacts(
-            tmp_path,
-            deep=True,
-            min_nodes=2,
-            min_edges=1,
-            min_skills_sh_nodes=1,
-            min_semantic_edges=1,
-            expected_harnesses={"langgraph"},
-        )
-
-
-def test_validate_graph_artifacts_rejects_stale_dashboard_index(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path, graph_export_id="new-export", manifest_export_id="new-export")
-    with tarfile.open(tmp_path / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
-        graph = {
-            "graph": {"export_id": "new-export"},
-            "nodes": [
-                {"id": "skill:skills-sh-example-skill", "type": "skill"},
-                {"id": "harness:langgraph", "type": "harness"},
-            ],
-            "edges": [
-                {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
-            ],
-        }
-        _add_text(tf, "index.md", "# Wiki\n")
-        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
-        _add_text(tf, "graphify-out/graph-delta.json", json.dumps({"export_id": "new-export"}))
-        _add_text(tf, "graphify-out/communities.json", json.dumps({"export_id": "new-export"}))
-        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n\n> Export ID: new-export\n")
-        _add_text(
-            tf,
-            "graphify-out/graph-export-manifest.json",
-            json.dumps({
-                "version": 1,
-                "export_id": "new-export",
-                "artifacts": {
-                    "graph": "graph.json",
-                    "delta": "graph-delta.json",
-                    "communities": "communities.json",
-                    "report": "graph-report.md",
-                },
-                "counts": {"nodes": 2, "edges": 1, "communities": 1},
-            }),
-        )
-        _add_bytes(
-            tf,
-            "graphify-out/dashboard-neighborhoods.sqlite3",
-            _dashboard_index_bytes(tmp_path, export_id="old-export"),
-        )
-        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
-        for slug in sorted(DEFAULT_HARNESSES):
-            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
-
-    with pytest.raises(GraphArtifactError, match="dashboard index export_id mismatch"):
-        validate_graph_artifacts(
-            tmp_path,
-            deep=True,
-            min_nodes=2,
-            min_edges=1,
-            min_skills_sh_nodes=1,
-            min_semantic_edges=1,
-            expected_harnesses={"langgraph"},
-        )
-
-
-def test_validate_graph_artifacts_rejects_stale_preview_html(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text(
-        json.dumps({"total_communities": 1}),
-        encoding="utf-8",
-    )
-    _write_archive(tmp_path)
-    (tmp_path / "viz-overview.html").write_text(
-        '<meta name="ctx-graph-export-id" content="old-export">',
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match="stale graph preview"):
-        validate_graph_artifacts(
-            tmp_path,
-            deep=True,
-            min_nodes=2,
-            min_edges=1,
-            min_skills_sh_nodes=1,
-            min_semantic_edges=1,
-            expected_harnesses={"langgraph"},
-        )
-
-
-def test_validate_graph_artifacts_rejects_stale_root_communities(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path)
-    (tmp_path / "communities.json").write_text(
-        json.dumps({"export_id": "old-export", "total_communities": 1}),
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match="stale graph/communities.json"):
-        validate_graph_artifacts(
-            tmp_path,
-            expected_harnesses={"langgraph"},
-        )
-
-
-@pytest.mark.parametrize(
-    ("archive_kwargs", "missing_name"),
-    [
-        ({"include_delta": False}, "graph-delta.json"),
-        ({"include_report": False}, "graph-report.md"),
-        ({"include_manifest": False}, "graph-export-manifest.json"),
-    ],
-)
-def test_validate_graph_artifacts_rejects_missing_graph_export_files(
-    tmp_path: Path,
-    archive_kwargs: dict[str, Any],
-    missing_name: str,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, **archive_kwargs)
-
-    with pytest.raises(GraphArtifactError, match=missing_name):
-        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
-
-
-@pytest.mark.parametrize(
-    "archive_kwargs",
-    [
-        {"graph_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
-        {"delta_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
-        {
-            "communities_export_id": "artifact-export",
-            "manifest_export_id": "manifest-export",
-        },
-        {"report_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
-    ],
-)
-def test_validate_graph_artifacts_rejects_artifact_export_id_mismatch(
-    tmp_path: Path,
-    archive_kwargs: dict[str, Any],
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, **archive_kwargs)
-
-    with pytest.raises(GraphArtifactError, match="export_id mismatch"):
-        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
-
-
-def test_validate_graph_artifacts_rejects_missing_converted_catalog_path(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, include_converted=False)
-
-    with pytest.raises(GraphArtifactError, match="missing converted Skills.sh body"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_missing_skill_bundle_reference(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(
-        tmp_path,
-        converted_skill_text=(
-            "# Example\n\n"
-            "Use `resources/implementation-playbook.md` for the implementation flow.\n"
-        ),
-    )
-
-    with pytest.raises(GraphArtifactError, match="missing bundled skill file"):
-        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
-
-
-def test_validate_graph_artifacts_rejects_body_unavailable_catalog_records(
-    tmp_path: Path,
-) -> None:
-    _write_catalog(tmp_path, converted_path=None)
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, include_converted=False)
-
-    with pytest.raises(GraphArtifactError, match="body-unavailable records"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_missing_entity_overlay(tmp_path: Path) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path)
-    (tmp_path / "entity-overlays.jsonl").unlink()
-
-    with pytest.raises(GraphArtifactError, match="entity-overlays.jsonl"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_invalid_entity_overlay(tmp_path: Path) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path)
-    (tmp_path / "entity-overlays.jsonl").write_text(
-        json.dumps({
-            "overlay_id": "bad-overlay",
-            "nodes": [{"id": "skill:bad"}],
-            "edges": [{"source": "skill:bad", "target": "skill:other", "weight": 2}],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match="weight must be 0..1"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_original_backup_members(tmp_path: Path) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, include_original=True)
-
-    with pytest.raises(GraphArtifactError, match="raw backup"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_lock_members(tmp_path: Path) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
-    _write_archive(tmp_path, include_lock=True)
-
-    with pytest.raises(GraphArtifactError, match="lock member"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_transient_queue_state(tmp_path: Path) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path, include_queue=True)
-
-    with pytest.raises(GraphArtifactError, match="transient queue state"):
-        validate_graph_artifacts(tmp_path)
-
-
-def test_validate_graph_artifacts_rejects_runtime_queue_state(tmp_path: Path) -> None:
-    _write_catalog(
-        tmp_path,
-        converted_path="converted/skills-sh-example-skill/SKILL.md",
-    )
-    _write_archive(tmp_path)
-    graph = {
-        "graph": {"export_id": "export-test"},
-        "nodes": [
-            {"id": "skill:skills-sh-example-skill", "type": "skill"},
-            {"id": "harness:langgraph", "type": "harness"},
-        ],
-        "edges": [],
-    }
-    _write_runtime_archive(tmp_path, graph=graph, include_queue=True)
-
-    with pytest.raises(GraphArtifactError, match="transient queue state"):
-        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
-
-
-@pytest.mark.parametrize(
-    "raw_name",
-    [
-        "../graphify-out/graph.json",
-        "./../graphify-out/graph.json",
-        "entities/../graphify-out/graph.json",
-        "/graphify-out/graph.json",
-        r"C:\tmp\graph.json",
-        "entities//skills/example.md",
-    ],
-)
-def test_safe_tar_name_rejects_unsafe_members(raw_name: str) -> None:
-    with pytest.raises(GraphArtifactError, match="unsafe archive member path"):
-        _safe_tar_name(raw_name)
-
-
-def test_safe_tar_name_strips_only_exact_current_dir_prefix() -> None:
-    assert _safe_tar_name("./graphify-out/graph.json") == "graphify-out/graph.json"
-
-
-def test_scan_graph_json_handles_pretty_printed_graph() -> None:
-    graph = {
-        "nodes": [
-            {
-                "id": "skill:skills-sh-example-skill",
-                "type": "skill",
-                "source_catalog": "skills.sh",
-            },
-            {
-                "id": "harness:text-to-cad",
-                "type": "harness",
-            },
-        ],
-        "edges": [
-            {
-                "source": "skill:skills-sh-example-skill",
-                "target": "harness:text-to-cad",
-                "semantic_sim": 0.0,
-            },
-            {
-                "source": "skill:skills-sh-example-skill",
-                "target": "harness:text-to-cad",
-                "semantic_sim": 0.82,
-            },
-        ],
-    }
-    payload = json.dumps(graph, indent=2).encode("utf-8")
-
-    assert _scan_graph_json(BytesIO(payload)) == (2, 2, 1, 1, 1, None)
-
-
-def test_scan_graph_json_rejects_out_of_range_edge_scores() -> None:
-    graph = {
-        "nodes": [{"id": "skill:a", "type": "skill"}],
-        "edges": [
-            {
-                "source": "skill:a",
-                "target": "skill:b",
-                "semantic_sim": 2.0,
-                "tag_sim": 0.0,
-                "token_sim": 0.0,
-                "weight": 0.5,
-                "final_weight": 0.5,
-            },
-        ],
-    }
-    payload = json.dumps(graph).encode("utf-8")
-
-    with pytest.raises(GraphArtifactError, match="semantic_sim must be 0..1"):
-        _scan_graph_json(BytesIO(payload))
-
-
-@pytest.mark.parametrize("raw", ["NaN", "Infinity", "-Infinity"])
-def test_scan_graph_json_rejects_non_finite_edge_scores(raw: str) -> None:
-    payload = (
-        b'{"nodes":[{"id":"skill:a","type":"skill"}],"edges":['
-        b'{"source":"skill:a","target":"skill:b","semantic_sim":'
-        + raw.encode("ascii")
-        + b',"tag_sim":0.0,"token_sim":0.0,"weight":0.5,"final_weight":0.5}'
-        b"]}"
-    )
-
-    with pytest.raises(GraphArtifactError, match="semantic_sim must be finite"):
-        _scan_graph_json(BytesIO(payload))
-
-
-def test_scan_graph_json_rejects_weight_final_weight_drift() -> None:
-    graph = {
-        "nodes": [{"id": "skill:a", "type": "skill"}],
-        "edges": [
-            {
-                "source": "skill:a",
-                "target": "skill:b",
-                "semantic_sim": 0.8,
-                "tag_sim": 0.0,
-                "token_sim": 0.0,
-                "weight": 0.7,
-                "final_weight": 0.5,
-            },
-        ],
-    }
-    payload = json.dumps(graph).encode("utf-8")
-
-    with pytest.raises(GraphArtifactError, match="weight must equal final_weight"):
-        _scan_graph_json(BytesIO(payload))
-
-
-def test_scan_graph_json_rejects_weight_drift_with_nested_score_components() -> None:
-    graph = {
-        "nodes": [{"id": "skill:a", "type": "skill"}],
-        "edges": [
-            {
-                "source": "skill:a",
-                "target": "skill:b",
-                "semantic_sim": 0.8,
-                "tag_sim": 0.0,
-                "token_sim": 0.0,
-                "weight": 0.7,
-                "final_weight": 0.5,
-                "score_components": {
-                    "semantic": 0.8,
-                    "tag": 0.0,
-                    "token": 0.0,
-                },
-            },
-        ],
-    }
-    payload = json.dumps(graph).encode("utf-8")
-
-    with pytest.raises(GraphArtifactError, match="weight must equal final_weight"):
-        _scan_graph_json(BytesIO(payload))
-
-
-def test_scan_graph_json_rejects_score_component_drift() -> None:
-    graph = {
-        "nodes": [{"id": "skill:a", "type": "skill"}],
-        "edges": [
-            {
-                "source": "skill:a",
-                "target": "skill:b",
-                "semantic_sim": 0.8,
-                "tag_sim": 0.0,
-                "token_sim": 0.0,
-                "weight": 0.8,
-                "final_weight": 0.8,
-                "score_components": {
-                    "semantic": 0.4,
-                    "type_affinity": 0.1,
-                },
-            },
-        ],
-    }
-    payload = json.dumps(graph).encode("utf-8")
-
-    with pytest.raises(GraphArtifactError, match="score_components must sum"):
-        _scan_graph_json(BytesIO(payload))
-
-
-@pytest.mark.parametrize("value", [-0.1, 1.1])
-def test_scan_graph_json_rejects_out_of_range_score_components(value: float) -> None:
-    graph = {
-        "nodes": [{"id": "skill:a", "type": "skill"}],
-        "edges": [
-            {
-                "source": "skill:a",
-                "target": "skill:b",
-                "weight": 0.5,
-                "final_weight": 0.5,
-                "score_components": {
-                    "semantic": value,
-                    "tag": 0.5 - value,
-                },
-            },
-        ],
-    }
-    payload = json.dumps(graph).encode("utf-8")
-
-    with pytest.raises(GraphArtifactError, match="score_components must be 0..1"):
-        _scan_graph_json(BytesIO(payload))
-
-
-@pytest.mark.parametrize("field", ["semantic_sim", "tag_sim", "token_sim"])
-def test_overlay_validation_rejects_out_of_range_similarity_fields(
-    tmp_path: Path,
-    field: str,
-) -> None:
-    (tmp_path / "entity-overlays.jsonl").write_text(
-        json.dumps({
-            "nodes": [{"id": "skill:a"}],
-            "edges": [
-                {
-                    "source": "skill:a",
-                    "target": "skill:b",
-                    "weight": 0.5,
-                    "final_weight": 0.5,
-                    field: 2.0,
-                },
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match=f"{field} must be 0..1"):
-        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
-
-
-def test_overlay_validation_rejects_weight_final_weight_drift(tmp_path: Path) -> None:
-    (tmp_path / "entity-overlays.jsonl").write_text(
-        json.dumps({
-            "nodes": [{"id": "skill:a"}],
-            "edges": [
-                {
-                    "source": "skill:a",
-                    "target": "skill:b",
-                    "weight": 0.7,
-                    "final_weight": 0.5,
-                },
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match="weight must equal final_weight"):
-        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
-
-
-def test_overlay_validation_rejects_score_component_drift(tmp_path: Path) -> None:
-    (tmp_path / "entity-overlays.jsonl").write_text(
-        json.dumps({
-            "nodes": [{"id": "skill:a"}],
-            "edges": [
-                {
-                    "source": "skill:a",
-                    "target": "skill:b",
-                    "weight": 0.8,
-                    "final_weight": 0.8,
-                    "score_components": {
-                        "semantic": 0.4,
-                        "type_affinity": 0.1,
-                    },
-                },
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match="score_components must sum"):
-        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
-
-
-@pytest.mark.parametrize("value", [-0.1, 1.1])
-def test_overlay_validation_rejects_out_of_range_score_components(
-    tmp_path: Path,
-    value: float,
-) -> None:
-    (tmp_path / "entity-overlays.jsonl").write_text(
-        json.dumps({
-            "nodes": [{"id": "skill:a"}],
-            "edges": [
-                {
-                    "source": "skill:a",
-                    "target": "skill:b",
-                    "weight": 0.5,
-                    "final_weight": 0.5,
-                    "score_components": {
-                        "semantic": value,
-                        "tag": 0.5 - value,
-                    },
-                },
-            ],
-        })
-        + "\n",
-        encoding="utf-8",
-    )
-
-    with pytest.raises(GraphArtifactError, match="score_components must be 0..1"):
-        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
-
-
-def test_scan_graph_json_extracts_top_level_graph_export_id() -> None:
-    graph = {
-        "directed": False,
-        "graph": {
-            "source_catalog_nodes": {"skills.sh": 1},
-            "source_catalog_edges": {"skills.sh": 0},
-            "export_id": "graph-export",
-        },
-        "nodes": [
-            {
-                "id": "skill:skills-sh-example-skill",
-                "type": "skill",
-                "source_catalog": "skills.sh",
-            },
-        ],
-        "edges": [],
-    }
-    payload = json.dumps(graph, separators=(",", ":")).encode("utf-8")
-
-    assert _scan_graph_json(BytesIO(payload)) == (1, 0, 0, 1, 0, "graph-export")
-
-
-def test_scan_graph_json_ignores_node_level_export_id() -> None:
-    graph = {
-        "nodes": [
-            {
-                "id": "skill:skills-sh-example-skill",
-                "type": "skill",
-                "source_catalog": "skills.sh",
-                "export_id": "node-export",
-            },
-        ],
-        "edges": [],
-    }
-    payload = json.dumps(graph, separators=(",", ":")).encode("utf-8")
-
-    assert _scan_graph_json(BytesIO(payload)) == (1, 0, 0, 1, 0, None)
-
-
-def test_graph_only_workflow_uses_exact_release_counts() -> None:
-    workflow = yaml.safe_load(Path(".github/workflows/test.yml").read_text(
-        encoding="utf-8"
-    ))
-    steps = workflow["jobs"]["graph-check"]["steps"]
-    validate_step = next(
-        step for step in steps if step.get("name") == "Validate shipped graph artifacts"
-    )
-    command = " ".join(
-        line.rstrip("\\").strip()
-        for line in validate_step["run"].splitlines()
-        if line.strip()
-    )
-    argv = command.split()
-
-    script_index = argv.index("src/validate_graph_artifacts.py")
-    args = argv[script_index + 1:]
-    parsed: dict[str, str | bool] = {}
-    i = 0
-    while i < len(args):
-        flag = args[i]
-        if i + 1 >= len(args) or args[i + 1].startswith("--"):
-            parsed[flag] = True
-            i += 1
-        else:
-            parsed[flag] = args[i + 1]
-            i += 2
-
-    assert argv[:script_index + 1] == ["python", "src/validate_graph_artifacts.py"]
-    assert parsed == {
-        "--graph-dir": "graph",
-        "--deep": True,
-        "--min-nodes": "100000",
-        "--min-edges": "2000000",
-        "--min-skills-sh-nodes": "89000",
-        "--min-semantic-edges": "1000000",
-        "--expected-nodes": "102928",
-        "--expected-edges": "2913960",
-        "--expected-semantic-edges": "1683193",
-        "--expected-harness-nodes": "207",
-        "--expected-skills-sh-nodes": "89471",
-        "--expected-skills-sh-catalog-entries": "89465",
-        "--expected-skills-sh-converted": "89465",
-        "--expected-skill-pages": "91464",
-        "--expected-agent-pages": "467",
-        "--expected-mcp-pages": "10790",
-        "--expected-harness-pages": "207",
-        "--line-threshold": "180",
-        "--max-stage-lines": "40",
-    }
-
-
-def test_graph_only_workflow_waits_for_release_asset_upload() -> None:
-    workflow = yaml.safe_load(Path(".github/workflows/test.yml").read_text(
-        encoding="utf-8"
-    ))
-    steps = workflow["jobs"]["graph-check"]["steps"]
-    resolve_step = next(
-        step for step in steps if step.get("name") == "Resolve graph LFS artifacts"
-    )
-    script = resolve_step["run"]
-
-    assert "release_asset_wait_seconds = 300" in script
-    assert "while True:" in script
-    assert "Waiting for matching release asset" in script
-    assert "time.sleep(release_asset_poll_seconds)" in script
+from __future__ import annotations
+
+import gzip
+import json
+import sqlite3
+import tarfile
+import zlib
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+import pytest
+import yaml  # type: ignore[import-untyped]
+
+from validate_graph_artifacts import (
+    DEFAULT_HARNESSES,
+    GraphArtifactError,
+    _validate_root_entity_overlay,
+    _safe_tar_name,
+    _scan_graph_json,
+    validate_graph_artifacts,
+)
+
+_PREVIEW_HTML_FILES = (
+    "sample-top60.html",
+    "viz-ai-agents.html",
+    "viz-overview.html",
+    "viz-python.html",
+    "viz-security.html",
+)
+
+
+def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
+    payload = text.encode("utf-8")
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    info.mode = 0o644
+    tf.addfile(info, BytesIO(payload))
+
+
+def _add_bytes(tf: tarfile.TarFile, name: str, payload: bytes) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    info.mode = 0o644
+    tf.addfile(info, BytesIO(payload))
+
+
+def _dashboard_index_bytes(graph_dir: Path, *, export_id: str) -> bytes:
+    path = graph_dir / f"dashboard-index-{export_id}.sqlite3"
+    if path.exists():
+        path.unlink()
+    conn = sqlite3.connect(path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("version", "1"),
+                ("export_id", json.dumps(export_id)),
+                ("nodes_count", "2"),
+                ("edges_count", "1"),
+                ("max_degree", "1"),
+                ("top_k", "40"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            [
+                ("skill:skills-sh-example-skill", "skills-sh-example-skill", "skill", "[]", "", None, None, 1),
+                ("harness:langgraph", "langgraph", "harness", "[]", "", None, None, 1),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            [
+                ("skills-sh-example-skill", "skill", "skill:skills-sh-example-skill"),
+                ("langgraph", "harness", "harness:langgraph"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO neighbors VALUES(?,?)",
+            [
+                ("skill:skills-sh-example-skill", zlib.compress(json.dumps([{"target": "harness:langgraph"}]).encode("utf-8"))),
+                ("harness:langgraph", zlib.compress(json.dumps([{"target": "skill:skills-sh-example-skill"}]).encode("utf-8"))),
+            ],
+        )
+        conn.commit()
+    finally:
+        conn.close()
+    payload = path.read_bytes()
+    path.unlink()
+    return payload
+
+
+def _write_catalog(graph_dir: Path, *, converted_path: str | None = None) -> None:
+    skill = {
+        "ctx_slug": "skills-sh-example-skill",
+        "graph_node_id": "skill:skills-sh-example-skill",
+        "entity_path": "entities/skills/skills-sh-example-skill.md",
+        "body_available": converted_path is not None,
+        "converted_path": converted_path,
+    }
+    catalog = {
+        "observed_unique_skills": 1,
+        "body_available_count": 1 if converted_path else 0,
+        "skills": [skill],
+    }
+    with gzip.open(graph_dir / "skills-sh-catalog.json.gz", "wt", encoding="utf-8") as f:
+        json.dump(catalog, f)
+
+
+def _write_entity_overlay(graph_dir: Path) -> None:
+    payload = {
+        "overlay_id": "test-overlay",
+        "nodes": [
+            {
+                "id": "harness:langgraph",
+                "label": "langgraph",
+                "type": "harness",
+            }
+        ],
+        "edges": [
+            {
+                "source": "skill:skills-sh-example-skill",
+                "target": "harness:langgraph",
+                "weight": 0.5,
+                "final_weight": 0.5,
+                "similarity_score": 0.5,
+            }
+        ],
+    }
+    (graph_dir / "entity-overlays.jsonl").write_text(
+        json.dumps(payload) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _write_runtime_archive(
+    graph_dir: Path,
+    *,
+    graph: dict[str, Any],
+    include_queue: bool = False,
+    include_delta: bool = True,
+    include_report: bool = True,
+    include_manifest: bool = True,
+    delta_export_id: str = "export-test",
+    communities_export_id: str = "export-test",
+    report_export_id: str = "export-test",
+    manifest_export_id: str = "export-test",
+) -> None:
+    with tarfile.open(graph_dir / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        if include_delta:
+            _add_text(
+                tf,
+                "graphify-out/graph-delta.json",
+                json.dumps({"export_id": delta_export_id, "nodes": [], "edges": []}),
+            )
+        _add_text(
+            tf,
+            "graphify-out/communities.json",
+            json.dumps({"export_id": communities_export_id, "total_communities": 1}),
+        )
+        if include_report:
+            _add_text(
+                tf,
+                "graphify-out/graph-report.md",
+                f"# Graph Report\n\n> Export ID: {report_export_id}\n",
+            )
+        if include_manifest:
+            _add_text(
+                tf,
+                "graphify-out/graph-export-manifest.json",
+                json.dumps({
+                    "version": 1,
+                    "export_id": manifest_export_id,
+                    "artifacts": {
+                        "graph": "graph.json",
+                        "delta": "graph-delta.json",
+                        "communities": "communities.json",
+                        "report": "graph-report.md",
+                    },
+                    "counts": {"nodes": 2, "edges": 1, "communities": 1},
+                }),
+            )
+        _add_bytes(
+            tf,
+            "graphify-out/dashboard-neighborhoods.sqlite3",
+            _dashboard_index_bytes(graph_dir, export_id=manifest_export_id),
+        )
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        if include_queue:
+            _add_text(tf, ".ctx/wiki-queue.sqlite3", "not a shipped artifact\n")
+        for slug in sorted(DEFAULT_HARNESSES):
+            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
+
+
+def _write_archive(
+    graph_dir: Path,
+    *,
+    include_converted: bool = True,
+    converted_skill_text: str = "# Example\n",
+    include_original: bool = False,
+    include_lock: bool = False,
+    include_queue: bool = False,
+    include_delta: bool = True,
+    include_report: bool = True,
+    include_manifest: bool = True,
+    graph_export_id: str = "export-test",
+    delta_export_id: str = "export-test",
+    communities_export_id: str | None = None,
+    report_export_id: str | None = None,
+    manifest_export_id: str | None = None,
+) -> None:
+    _write_entity_overlay(graph_dir)
+    communities_export_id = communities_export_id or graph_export_id
+    report_export_id = report_export_id or graph_export_id
+    manifest_export_id = manifest_export_id or graph_export_id
+    graph = {
+        "graph": {"export_id": graph_export_id},
+        "nodes": [
+            {
+                "id": "skill:skills-sh-example-skill",
+                "type": "skill",
+                "source_catalog": "skills.sh",
+            },
+            {"id": "harness:langgraph", "type": "harness"},
+        ],
+        "edges": [
+            {
+                "source": "skill:skills-sh-example-skill",
+                "target": "harness:langgraph",
+                "semantic_sim": 0.91,
+            },
+        ],
+    }
+    with tarfile.open(graph_dir / "wiki-graph.tar.gz", "w:gz") as tf:
+        _add_text(tf, "./index.md", "# Wiki\n")
+        _add_text(tf, "./graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        if include_delta:
+            _add_text(
+                tf,
+                "./graphify-out/graph-delta.json",
+                json.dumps({"export_id": delta_export_id, "nodes": [], "edges": []}),
+            )
+        _add_text(
+            tf,
+            "./graphify-out/communities.json",
+            json.dumps({"export_id": communities_export_id, "total_communities": 1}),
+        )
+        if include_report:
+            _add_text(
+                tf,
+                "./graphify-out/graph-report.md",
+                f"# Graph Report\n\n> Export ID: {report_export_id}\n",
+            )
+        if include_manifest:
+            _add_text(
+                tf,
+                "./graphify-out/graph-export-manifest.json",
+                json.dumps({
+                    "version": 1,
+                    "export_id": manifest_export_id,
+                    "artifacts": {
+                        "graph": "graph.json",
+                        "delta": "graph-delta.json",
+                        "communities": "communities.json",
+                        "report": "graph-report.md",
+                    },
+                    "counts": {"nodes": 2, "edges": 1, "communities": 1},
+                }),
+            )
+        _add_bytes(
+            tf,
+            "./graphify-out/dashboard-neighborhoods.sqlite3",
+            _dashboard_index_bytes(graph_dir, export_id=manifest_export_id),
+        )
+        _add_text(tf, "./external-catalogs/skills-sh/catalog.json", "{}")
+        _add_text(tf, "./entities/skills/skills-sh-example-skill.md", "# Example\n")
+        _add_text(tf, "./entities/harnesses/langgraph.md", "# LangGraph\n")
+        if include_converted:
+            _add_text(tf, "./converted/skills-sh-example-skill/SKILL.md", converted_skill_text)
+            _add_text(tf, "./converted/skills-sh-example-skill/references/01-scope.md", "# Scope\n")
+        if include_original:
+            _add_text(tf, "./converted/skills-sh-example-skill/SKILL.md.original", "# Raw\n")
+        if include_lock:
+            _add_text(tf, "./index.md.lock", "")
+        if include_queue:
+            _add_text(tf, "./.ctx/wiki-queue.sqlite3", "not a shipped artifact\n")
+    for preview in _PREVIEW_HTML_FILES:
+        (graph_dir / preview).write_text(
+            "\n".join([
+                "<!DOCTYPE html>",
+                "<html><head>",
+                f'<meta name="ctx-graph-export-id" content="{manifest_export_id}">',
+                "</head><body>",
+                "const CTX_GRAPH_METADATA = "
+                + json.dumps({
+                    "export_id": manifest_export_id,
+                    "source_graph_nodes": 2,
+                    "source_graph_edges": 1,
+                }),
+                "</body></html>",
+            ]),
+            encoding="utf-8",
+        )
+    _write_runtime_archive(
+        graph_dir,
+        graph=graph,
+        include_delta=include_delta,
+        include_report=include_report,
+        include_manifest=include_manifest,
+        delta_export_id=delta_export_id,
+        communities_export_id=communities_export_id,
+        report_export_id=report_export_id,
+        manifest_export_id=manifest_export_id,
+    )
+    (graph_dir / "communities.json").write_text(
+        json.dumps({"export_id": communities_export_id, "total_communities": 1}),
+        encoding="utf-8",
+    )
+
+
+def test_validate_graph_artifacts_checks_catalog_paths_and_deep_graph_stats(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text(
+        json.dumps({"total_communities": 1}),
+        encoding="utf-8",
+    )
+    _write_archive(tmp_path)
+
+    stats = validate_graph_artifacts(
+        tmp_path,
+        deep=True,
+        min_nodes=2,
+        min_edges=1,
+        min_skills_sh_nodes=1,
+        min_semantic_edges=1,
+        expected_harnesses={"langgraph"},
+        line_threshold=180,
+        max_stage_lines=40,
+        expected_nodes=2,
+        expected_edges=1,
+        expected_semantic_edges=1,
+        expected_harness_nodes=1,
+        expected_skills_sh_nodes=1,
+        expected_skills_sh_catalog_entries=1,
+        expected_skills_sh_converted=1,
+        expected_skill_pages=1,
+        expected_agent_pages=0,
+        expected_mcp_pages=0,
+        expected_harness_pages=1,
+    )
+
+    assert stats.graph_nodes == 2
+    assert stats.graph_edges == 1
+    assert stats.harness_nodes == 1
+    assert stats.skills_sh_catalog_entries == 1
+    assert stats.skills_sh_converted == 1
+    assert stats.harness_pages == 1
+
+    with pytest.raises(GraphArtifactError, match="graph_edges exact count mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+            expected_edges=2,
+        )
+
+    with pytest.raises(GraphArtifactError, match="deep=True is required"):
+        validate_graph_artifacts(
+            tmp_path,
+            expected_harnesses={"langgraph"},
+            expected_nodes=2,
+        )
+
+
+def test_validate_graph_artifacts_rejects_mixed_export_generation(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, graph_export_id="new-export", delta_export_id="old-export")
+
+    with pytest.raises(GraphArtifactError, match="export_id mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_runtime_full_export_split(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path, graph_export_id="full-export")
+    runtime_graph = {
+        "graph": {"export_id": "runtime-export"},
+        "nodes": [
+            {"id": "skill:skills-sh-example-skill", "type": "skill"},
+            {"id": "harness:langgraph", "type": "harness"},
+        ],
+        "edges": [
+            {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
+        ],
+    }
+    _write_runtime_archive(
+        tmp_path,
+        graph=runtime_graph,
+        delta_export_id="runtime-export",
+        communities_export_id="runtime-export",
+        report_export_id="runtime-export",
+        manifest_export_id="runtime-export",
+    )
+
+    with pytest.raises(GraphArtifactError, match="runtime graph archive export_id mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_corrupt_dashboard_index(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path)
+    with tarfile.open(tmp_path / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
+        graph = {
+            "graph": {"export_id": "export-test"},
+            "nodes": [
+                {"id": "skill:skills-sh-example-skill", "type": "skill"},
+                {"id": "harness:langgraph", "type": "harness"},
+            ],
+            "edges": [
+                {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
+            ],
+        }
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        _add_text(tf, "graphify-out/graph-delta.json", json.dumps({"export_id": "export-test"}))
+        _add_text(tf, "graphify-out/communities.json", json.dumps({"export_id": "export-test"}))
+        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n\n> Export ID: export-test\n")
+        _add_text(
+            tf,
+            "graphify-out/graph-export-manifest.json",
+            json.dumps({
+                "version": 1,
+                "export_id": "export-test",
+                "artifacts": {
+                    "graph": "graph.json",
+                    "delta": "graph-delta.json",
+                    "communities": "communities.json",
+                    "report": "graph-report.md",
+                },
+                "counts": {"nodes": 2, "edges": 1, "communities": 1},
+            }),
+        )
+        _add_text(tf, "graphify-out/dashboard-neighborhoods.sqlite3", "not sqlite\n")
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        for slug in sorted(DEFAULT_HARNESSES):
+            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
+
+    with pytest.raises(GraphArtifactError, match="dashboard index"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_stale_dashboard_index(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path, graph_export_id="new-export", manifest_export_id="new-export")
+    with tarfile.open(tmp_path / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
+        graph = {
+            "graph": {"export_id": "new-export"},
+            "nodes": [
+                {"id": "skill:skills-sh-example-skill", "type": "skill"},
+                {"id": "harness:langgraph", "type": "harness"},
+            ],
+            "edges": [
+                {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
+            ],
+        }
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        _add_text(tf, "graphify-out/graph-delta.json", json.dumps({"export_id": "new-export"}))
+        _add_text(tf, "graphify-out/communities.json", json.dumps({"export_id": "new-export"}))
+        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n\n> Export ID: new-export\n")
+        _add_text(
+            tf,
+            "graphify-out/graph-export-manifest.json",
+            json.dumps({
+                "version": 1,
+                "export_id": "new-export",
+                "artifacts": {
+                    "graph": "graph.json",
+                    "delta": "graph-delta.json",
+                    "communities": "communities.json",
+                    "report": "graph-report.md",
+                },
+                "counts": {"nodes": 2, "edges": 1, "communities": 1},
+            }),
+        )
+        _add_bytes(
+            tf,
+            "graphify-out/dashboard-neighborhoods.sqlite3",
+            _dashboard_index_bytes(tmp_path, export_id="old-export"),
+        )
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        for slug in sorted(DEFAULT_HARNESSES):
+            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
+
+    with pytest.raises(GraphArtifactError, match="dashboard index export_id mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_stale_preview_html(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text(
+        json.dumps({"total_communities": 1}),
+        encoding="utf-8",
+    )
+    _write_archive(tmp_path)
+    (tmp_path / "viz-overview.html").write_text(
+        '<meta name="ctx-graph-export-id" content="old-export">',
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="stale graph preview"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_stale_root_communities(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path)
+    (tmp_path / "communities.json").write_text(
+        json.dumps({"export_id": "old-export", "total_communities": 1}),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="stale graph/communities.json"):
+        validate_graph_artifacts(
+            tmp_path,
+            expected_harnesses={"langgraph"},
+        )
+
+
+@pytest.mark.parametrize(
+    ("archive_kwargs", "missing_name"),
+    [
+        ({"include_delta": False}, "graph-delta.json"),
+        ({"include_report": False}, "graph-report.md"),
+        ({"include_manifest": False}, "graph-export-manifest.json"),
+    ],
+)
+def test_validate_graph_artifacts_rejects_missing_graph_export_files(
+    tmp_path: Path,
+    archive_kwargs: dict[str, Any],
+    missing_name: str,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, **archive_kwargs)
+
+    with pytest.raises(GraphArtifactError, match=missing_name):
+        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
+
+
+@pytest.mark.parametrize(
+    "archive_kwargs",
+    [
+        {"graph_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
+        {"delta_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
+        {
+            "communities_export_id": "artifact-export",
+            "manifest_export_id": "manifest-export",
+        },
+        {"report_export_id": "artifact-export", "manifest_export_id": "manifest-export"},
+    ],
+)
+def test_validate_graph_artifacts_rejects_artifact_export_id_mismatch(
+    tmp_path: Path,
+    archive_kwargs: dict[str, Any],
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, **archive_kwargs)
+
+    with pytest.raises(GraphArtifactError, match="export_id mismatch"):
+        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
+
+
+def test_validate_graph_artifacts_rejects_missing_converted_catalog_path(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, include_converted=False)
+
+    with pytest.raises(GraphArtifactError, match="missing converted Skills.sh body"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_missing_skill_bundle_reference(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(
+        tmp_path,
+        converted_skill_text=(
+            "# Example\n\n"
+            "Use `resources/implementation-playbook.md` for the implementation flow.\n"
+        ),
+    )
+
+    with pytest.raises(GraphArtifactError, match="missing bundled skill file"):
+        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
+
+
+def test_validate_graph_artifacts_rejects_body_unavailable_catalog_records(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(tmp_path, converted_path=None)
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, include_converted=False)
+
+    with pytest.raises(GraphArtifactError, match="body-unavailable records"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_missing_entity_overlay(tmp_path: Path) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path)
+    (tmp_path / "entity-overlays.jsonl").unlink()
+
+    with pytest.raises(GraphArtifactError, match="entity-overlays.jsonl"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_invalid_entity_overlay(tmp_path: Path) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path)
+    (tmp_path / "entity-overlays.jsonl").write_text(
+        json.dumps({
+            "overlay_id": "bad-overlay",
+            "nodes": [{"id": "skill:bad"}],
+            "edges": [{"source": "skill:bad", "target": "skill:other", "weight": 2}],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="weight must be 0..1"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_original_backup_members(tmp_path: Path) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, include_original=True)
+
+    with pytest.raises(GraphArtifactError, match="raw backup"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_lock_members(tmp_path: Path) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    (tmp_path / "communities.json").write_text("{}", encoding="utf-8")
+    _write_archive(tmp_path, include_lock=True)
+
+    with pytest.raises(GraphArtifactError, match="lock member"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_transient_queue_state(tmp_path: Path) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path, include_queue=True)
+
+    with pytest.raises(GraphArtifactError, match="transient queue state"):
+        validate_graph_artifacts(tmp_path)
+
+
+def test_validate_graph_artifacts_rejects_runtime_queue_state(tmp_path: Path) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path)
+    graph = {
+        "graph": {"export_id": "export-test"},
+        "nodes": [
+            {"id": "skill:skills-sh-example-skill", "type": "skill"},
+            {"id": "harness:langgraph", "type": "harness"},
+        ],
+        "edges": [],
+    }
+    _write_runtime_archive(tmp_path, graph=graph, include_queue=True)
+
+    with pytest.raises(GraphArtifactError, match="transient queue state"):
+        validate_graph_artifacts(tmp_path, expected_harnesses={"langgraph"})
+
+
+@pytest.mark.parametrize(
+    "raw_name",
+    [
+        "../graphify-out/graph.json",
+        "./../graphify-out/graph.json",
+        "entities/../graphify-out/graph.json",
+        "/graphify-out/graph.json",
+        r"C:\tmp\graph.json",
+        "entities//skills/example.md",
+    ],
+)
+def test_safe_tar_name_rejects_unsafe_members(raw_name: str) -> None:
+    with pytest.raises(GraphArtifactError, match="unsafe archive member path"):
+        _safe_tar_name(raw_name)
+
+
+def test_safe_tar_name_strips_only_exact_current_dir_prefix() -> None:
+    assert _safe_tar_name("./graphify-out/graph.json") == "graphify-out/graph.json"
+
+
+def test_scan_graph_json_handles_pretty_printed_graph() -> None:
+    graph = {
+        "nodes": [
+            {
+                "id": "skill:skills-sh-example-skill",
+                "type": "skill",
+                "source_catalog": "skills.sh",
+            },
+            {
+                "id": "harness:text-to-cad",
+                "type": "harness",
+            },
+        ],
+        "edges": [
+            {
+                "source": "skill:skills-sh-example-skill",
+                "target": "harness:text-to-cad",
+                "semantic_sim": 0.0,
+            },
+            {
+                "source": "skill:skills-sh-example-skill",
+                "target": "harness:text-to-cad",
+                "semantic_sim": 0.82,
+            },
+        ],
+    }
+    payload = json.dumps(graph, indent=2).encode("utf-8")
+
+    assert _scan_graph_json(BytesIO(payload)) == (2, 2, 1, 1, 1, None)
+
+
+def test_scan_graph_json_rejects_out_of_range_edge_scores() -> None:
+    graph = {
+        "nodes": [{"id": "skill:a", "type": "skill"}],
+        "edges": [
+            {
+                "source": "skill:a",
+                "target": "skill:b",
+                "semantic_sim": 2.0,
+                "tag_sim": 0.0,
+                "token_sim": 0.0,
+                "weight": 0.5,
+                "final_weight": 0.5,
+            },
+        ],
+    }
+    payload = json.dumps(graph).encode("utf-8")
+
+    with pytest.raises(GraphArtifactError, match="semantic_sim must be 0..1"):
+        _scan_graph_json(BytesIO(payload))
+
+
+@pytest.mark.parametrize("raw", ["NaN", "Infinity", "-Infinity"])
+def test_scan_graph_json_rejects_non_finite_edge_scores(raw: str) -> None:
+    payload = (
+        b'{"nodes":[{"id":"skill:a","type":"skill"}],"edges":['
+        b'{"source":"skill:a","target":"skill:b","semantic_sim":'
+        + raw.encode("ascii")
+        + b',"tag_sim":0.0,"token_sim":0.0,"weight":0.5,"final_weight":0.5}'
+        b"]}"
+    )
+
+    with pytest.raises(GraphArtifactError, match="semantic_sim must be finite"):
+        _scan_graph_json(BytesIO(payload))
+
+
+def test_scan_graph_json_rejects_weight_final_weight_drift() -> None:
+    graph = {
+        "nodes": [{"id": "skill:a", "type": "skill"}],
+        "edges": [
+            {
+                "source": "skill:a",
+                "target": "skill:b",
+                "semantic_sim": 0.8,
+                "tag_sim": 0.0,
+                "token_sim": 0.0,
+                "weight": 0.7,
+                "final_weight": 0.5,
+            },
+        ],
+    }
+    payload = json.dumps(graph).encode("utf-8")
+
+    with pytest.raises(GraphArtifactError, match="weight must equal final_weight"):
+        _scan_graph_json(BytesIO(payload))
+
+
+def test_scan_graph_json_rejects_weight_drift_with_nested_score_components() -> None:
+    graph = {
+        "nodes": [{"id": "skill:a", "type": "skill"}],
+        "edges": [
+            {
+                "source": "skill:a",
+                "target": "skill:b",
+                "semantic_sim": 0.8,
+                "tag_sim": 0.0,
+                "token_sim": 0.0,
+                "weight": 0.7,
+                "final_weight": 0.5,
+                "score_components": {
+                    "semantic": 0.8,
+                    "tag": 0.0,
+                    "token": 0.0,
+                },
+            },
+        ],
+    }
+    payload = json.dumps(graph).encode("utf-8")
+
+    with pytest.raises(GraphArtifactError, match="weight must equal final_weight"):
+        _scan_graph_json(BytesIO(payload))
+
+
+def test_scan_graph_json_rejects_score_component_drift() -> None:
+    graph = {
+        "nodes": [{"id": "skill:a", "type": "skill"}],
+        "edges": [
+            {
+                "source": "skill:a",
+                "target": "skill:b",
+                "semantic_sim": 0.8,
+                "tag_sim": 0.0,
+                "token_sim": 0.0,
+                "weight": 0.8,
+                "final_weight": 0.8,
+                "score_components": {
+                    "semantic": 0.4,
+                    "type_affinity": 0.1,
+                },
+            },
+        ],
+    }
+    payload = json.dumps(graph).encode("utf-8")
+
+    with pytest.raises(GraphArtifactError, match="score_components must sum"):
+        _scan_graph_json(BytesIO(payload))
+
+
+@pytest.mark.parametrize("value", [-0.1, 1.1])
+def test_scan_graph_json_rejects_out_of_range_score_components(value: float) -> None:
+    graph = {
+        "nodes": [{"id": "skill:a", "type": "skill"}],
+        "edges": [
+            {
+                "source": "skill:a",
+                "target": "skill:b",
+                "weight": 0.5,
+                "final_weight": 0.5,
+                "score_components": {
+                    "semantic": value,
+                    "tag": 0.5 - value,
+                },
+            },
+        ],
+    }
+    payload = json.dumps(graph).encode("utf-8")
+
+    with pytest.raises(GraphArtifactError, match="score_components must be 0..1"):
+        _scan_graph_json(BytesIO(payload))
+
+
+@pytest.mark.parametrize("field", ["semantic_sim", "tag_sim", "token_sim"])
+def test_overlay_validation_rejects_out_of_range_similarity_fields(
+    tmp_path: Path,
+    field: str,
+) -> None:
+    (tmp_path / "entity-overlays.jsonl").write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.5,
+                    "final_weight": 0.5,
+                    field: 2.0,
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match=f"{field} must be 0..1"):
+        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
+
+
+def test_overlay_validation_rejects_weight_final_weight_drift(tmp_path: Path) -> None:
+    (tmp_path / "entity-overlays.jsonl").write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.7,
+                    "final_weight": 0.5,
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="weight must equal final_weight"):
+        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
+
+
+def test_overlay_validation_rejects_score_component_drift(tmp_path: Path) -> None:
+    (tmp_path / "entity-overlays.jsonl").write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.8,
+                    "final_weight": 0.8,
+                    "score_components": {
+                        "semantic": 0.4,
+                        "type_affinity": 0.1,
+                    },
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="score_components must sum"):
+        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
+
+
+@pytest.mark.parametrize("value", [-0.1, 1.1])
+def test_overlay_validation_rejects_out_of_range_score_components(
+    tmp_path: Path,
+    value: float,
+) -> None:
+    (tmp_path / "entity-overlays.jsonl").write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.5,
+                    "final_weight": 0.5,
+                    "score_components": {
+                        "semantic": value,
+                        "tag": 0.5 - value,
+                    },
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(GraphArtifactError, match="score_components must be 0..1"):
+        _validate_root_entity_overlay(tmp_path / "entity-overlays.jsonl")
+
+
+def test_scan_graph_json_extracts_top_level_graph_export_id() -> None:
+    graph = {
+        "directed": False,
+        "graph": {
+            "source_catalog_nodes": {"skills.sh": 1},
+            "source_catalog_edges": {"skills.sh": 0},
+            "export_id": "graph-export",
+        },
+        "nodes": [
+            {
+                "id": "skill:skills-sh-example-skill",
+                "type": "skill",
+                "source_catalog": "skills.sh",
+            },
+        ],
+        "edges": [],
+    }
+    payload = json.dumps(graph, separators=(",", ":")).encode("utf-8")
+
+    assert _scan_graph_json(BytesIO(payload)) == (1, 0, 0, 1, 0, "graph-export")
+
+
+def test_scan_graph_json_ignores_node_level_export_id() -> None:
+    graph = {
+        "nodes": [
+            {
+                "id": "skill:skills-sh-example-skill",
+                "type": "skill",
+                "source_catalog": "skills.sh",
+                "export_id": "node-export",
+            },
+        ],
+        "edges": [],
+    }
+    payload = json.dumps(graph, separators=(",", ":")).encode("utf-8")
+
+    assert _scan_graph_json(BytesIO(payload)) == (1, 0, 0, 1, 0, None)
+
+
+def test_graph_only_workflow_uses_exact_release_counts() -> None:
+    workflow = yaml.safe_load(Path(".github/workflows/test.yml").read_text(
+        encoding="utf-8"
+    ))
+    steps = workflow["jobs"]["graph-check"]["steps"]
+    validate_step = next(
+        step for step in steps if step.get("name") == "Validate shipped graph artifacts"
+    )
+    command = " ".join(
+        line.rstrip("\\").strip()
+        for line in validate_step["run"].splitlines()
+        if line.strip()
+    )
+    argv = command.split()
+
+    script_index = argv.index("src/validate_graph_artifacts.py")
+    args = argv[script_index + 1:]
+    parsed: dict[str, str | bool] = {}
+    i = 0
+    while i < len(args):
+        flag = args[i]
+        if i + 1 >= len(args) or args[i + 1].startswith("--"):
+            parsed[flag] = True
+            i += 1
+        else:
+            parsed[flag] = args[i + 1]
+            i += 2
+
+    assert argv[:script_index + 1] == ["python", "src/validate_graph_artifacts.py"]
+    assert parsed == {
+        "--graph-dir": "graph",
+        "--deep": True,
+        "--min-nodes": "100000",
+        "--min-edges": "2000000",
+        "--min-skills-sh-nodes": "89000",
+        "--min-semantic-edges": "1000000",
+        "--expected-nodes": "102928",
+        "--expected-edges": "2913960",
+        "--expected-semantic-edges": "1683193",
+        "--expected-harness-nodes": "207",
+        "--expected-skills-sh-nodes": "89471",
+        "--expected-skills-sh-catalog-entries": "89465",
+        "--expected-skills-sh-converted": "89465",
+        "--expected-skill-pages": "91464",
+        "--expected-agent-pages": "467",
+        "--expected-mcp-pages": "10790",
+        "--expected-harness-pages": "207",
+        "--line-threshold": "180",
+        "--max-stage-lines": "40",
+    }
+
+
+def test_graph_only_workflow_waits_for_release_asset_upload() -> None:
+    workflow = yaml.safe_load(Path(".github/workflows/test.yml").read_text(
+        encoding="utf-8"
+    ))
+    steps = workflow["jobs"]["graph-check"]["steps"]
+    resolve_step = next(
+        step for step in steps
+        if step.get("name") == "Resolve graph artifacts from release assets"
+    )
+    script = resolve_step["run"]
+
+    assert "release_asset_wait_seconds = 300" in script
+    assert "while True:" in script
+    assert "Waiting for matching release asset" in script
+    assert "time.sleep(release_asset_poll_seconds)" in script