Consolidate 4 skills into 1 with progressive disclosure

Merge codebase-memory-exploring, codebase-memory-tracing,
codebase-memory-quality, and codebase-memory-reference into a single
codebase-memory skill with a references/ directory.

Motivation:
- Each skill registered a separate description entry that Claude scans
  at session startup. 4 skills = 4 description entries consuming listing
  space when 1 would suffice with a broader trigger phrase set.
- The 4 skills had overlapping content (gotchas, tips) scattered across
  files with no single source of truth.
- Per Anthropic's Agent Skills best practices and official spec
  (agentskills.io), skills should use progressive disclosure: a concise
  SKILL.md (<500 lines, <5000 tokens) loaded on activation, with
  detailed reference material in separate files loaded on demand.

What changed:
- assets/skills/: 4 separate skill directories replaced by 1
  codebase-memory/ directory with references/ subdirectory
- SKILL.md (54 lines): decision matrix, quick workflows, consolidated
  gotchas section — everything an agent needs to pick the right tool
- references/exploring.md: codebase exploration workflows
- references/tracing.md: call chain tracing, impact analysis, cross-service
- references/quality.md: dead code, fan-out/fan-in, change coupling
- references/tool-reference.md: all 14 tools, edge types, Cypher syntax,
  regex patterns
- cli.c: embedded skill content consolidated into single string with
  decision matrix, all workflows, and gotchas
- cli.h: CBM_SKILL_COUNT 4 → 1
- test_cli.c: updated to test single consolidated skill covering all
  capabilities

The consolidated gotchas section surfaces the 5 most common mistakes
(search_graph vs query_graph for edges, 200-row cap, exact name
requirement, direction="both" for cross-service, pagination) in the
main SKILL.md where the agent reads them before encountering issues.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: gdilla

cmd/codebase-memory-mcp/assets/skills/codebase-memory-exploring/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: codebase-memory
+description: >
+  Use the codebase knowledge graph for structural code queries. Triggers on: "explore the codebase",
+  "understand the architecture", "what functions exist", "show me the structure", "who calls this function",
+  "what does X call", "trace the call chain", "find callers of", "show dependencies", "impact analysis",
+  "dead code", "unused functions", "high fan-out", "refactor candidates", "code quality audit",
+  "graph query syntax", "Cypher query examples", "edge types", "how to use search_graph".
+---
+
+# Codebase Memory — Knowledge Graph Tools
+
+Graph tools return precise structural results in ~500 tokens vs ~80K for grep-based exploration.
+
+## Step 1: Check if project is indexed
+
+```
+list_projects
+```
+
+If the project is missing: `index_repository(repo_path="/path/to/project")`. If already indexed, skip — auto-sync keeps the graph fresh.
+
+## What do you want to do?
+
+| Goal | Read |
+|------|------|
+| **Explore codebase structure** — find functions, classes, routes, understand architecture | [references/exploring.md](references/exploring.md) |
+| **Trace call chains** — who calls X, what does X call, impact analysis, cross-service calls | [references/tracing.md](references/tracing.md) |
+| **Code quality analysis** — dead code, high fan-out, hidden coupling, refactor candidates | [references/quality.md](references/quality.md) |
+| **Tool reference** — all 14 tools, edge types, node labels, Cypher syntax, regex patterns | [references/tool-reference.md](references/tool-reference.md) |
+
+## Quick Decision Matrix
+
+| Question | Tool call |
+|----------|-----------|
+| Who calls X? | `trace_call_path(direction="inbound")` |
+| What does X call? | `trace_call_path(direction="outbound")` |
+| Full call context | `trace_call_path(direction="both")` |
+| Find by name pattern | `search_graph(name_pattern="...")` |
+| Dead code | `search_graph(max_degree=0, exclude_entry_points=true)` |
+| Cross-service edges | `query_graph` with Cypher |
+| Impact of local changes | `detect_changes()` |
+| Risk-classified trace | `trace_call_path(risk_labels=true)` |
+| Text search | `search_code` or Grep |
+
+## Gotchas
+
+1. **`search_graph(relationship="HTTP_CALLS")` does NOT return edges** — it filters nodes by degree. Use `query_graph` with Cypher to see actual edge properties (url_path, confidence).
+2. **`query_graph` has a 200-row cap** before aggregation — COUNT queries silently undercount on large codebases. Use `search_graph` with `min_degree`/`max_degree` for counting.
+3. **`trace_call_path` needs exact names** — use `search_graph(name_pattern=".*Partial.*")` first to discover the exact function name.
+4. **`direction="outbound"` misses cross-service callers** — always use `direction="both"` for complete context. Cross-service HTTP_CALLS appear as inbound edges.
+5. **Results default to 10 per page** — check `has_more` and use `offset` to paginate.
+6. **Dead code detection requires entry point exclusion** — without `exclude_entry_points=true`, route handlers and `main()` show as false positives.
+7. **`search_graph` with degree filters has no row cap** (unlike `query_graph`). Use it for counting, not `query_graph`.

cmd/codebase-memory-mcp/assets/skills/codebase-memory-tracing/SKILL.md

@@ -0,0 +1,61 @@
+# Codebase Exploration
+
+## Get a structural overview
+
+```
+get_graph_schema
+```
+
+Returns node label counts (functions, classes, routes), edge type counts, and relationship patterns. Use it to understand what's in the graph before querying.
+
+## Find specific code elements
+
+Find functions by name pattern:
+```
+search_graph(label="Function", name_pattern=".*Handler.*")
+```
+
+Find classes:
+```
+search_graph(label="Class", name_pattern=".*Service.*")
+```
+
+Find all REST routes:
+```
+search_graph(label="Route")
+```
+
+Find modules/packages:
+```
+search_graph(label="Module")
+```
+
+Scope to a specific directory:
+```
+search_graph(label="Function", qn_pattern=".*services\\.order\\..*")
+```
+
+## Read source code
+
+After finding a function via search, read its source:
+```
+get_code_snippet(qualified_name="project.path.to.FunctionName")
+```
+
+## File/directory exploration
+
+```
+list_directory(path="src/services")
+```
+
+## When to Use Grep Instead
+
+- Searching for **string literals** or error messages → `search_code` or Grep
+- Finding a file by exact name → Glob
+- The graph indexes structural elements, not text content
+
+## Tips
+
+- Use `project` parameter when multiple repos are indexed.
+- Route nodes have a `properties.handler` field with the handler function name.
+- `exclude_labels` removes noise (e.g., `exclude_labels=["Route"]` when searching by name pattern).