/graph

name: graph
description: Use when the user wants to build, refresh, or visualize the repo's knowledge graph — code structure plus the committed wiki/ — via graphify. Produces an interactive graph + a GRAPH_REPORT.md of God Nodes, surprising connections, and suggested questions. Trigger on "/graph", "build the knowledge graph", "graph the repo", "map the codebase", "refresh the graph", "visualize the second brain".

Knowledge Graph (graphify)

Build a map of how this AIOS actually fits together — which code files and which wiki notes depend on, reference, and cluster with each other — so you can see the structure instead of guessing it. Powered by **graphify** (a knowledge-graph builder), scoped hard to what's safe to graph.

When to run

• The user asks to see how the repo / second brain hangs together ("map the codebase", "graph the repo").
• After meaningful structural change — new skills, tools, SOPs, or a `/wiki` loop that added entries — to refresh the picture.
• As a thinking aid before a refactor, an audit, or a `/weekly` review: *what's load-bearing, what's orphaned, what's surprisingly connected.*
• Before exploring with `/graph-query` (this builds/refreshes the graph it queries).

The output (always this shape)

graphify writes everything to **`graphify-out/`** (git-ignored — a derived artifact, never committed):

## Knowledge graph — <date>
**Built from** — code (local AST) + committed wiki/. Excluded: raw/, .tmp/, .env, secrets.
**Artifacts** — graphify-out/graph.html (interactive) · graph.json · GRAPH_REPORT.md

**God Nodes** — the most-connected hubs (what everything leans on):
1. <node> — <why it's central, in a phrase>
2. … 3. …
**Surprising Connections** — edges you wouldn't expect (cross-domain links worth a look):
- <A> ↔ <B> — <what the link is>
**Suggested Questions** — what the graph invites you to ask next:
- <question> → run `/graph-query "<question>"`

Every edge carries graphify's honesty label — **EXTRACTED** (read directly), **INFERRED** (reasoned), or **AMBIGUOUS** — so claims about the graph cite their basis (cite-don't-invent).

Process

1. **Ensure graphify is installed.** Run `python tools/graphify_setup.py check`. If missing, offer to install (`uv tool install graphifyy`, fallback `pipx install graphifyy` / `pip install graphifyy`, then `graphify install --platform claude`). No account or signup is needed. **Gate:** don't proceed until `graphify --version` resolves. 2. **Set the build scope — code + committed `wiki/` ONLY.** This is the hard line:

• **Include:** source code (Python in `tools/`, etc.) and the committed `wiki/`.
• **EXCLUDE always:** `raw/` (may hold raw PHI/PII/financials before de-identification), `.tmp/`, `.env`, `graphify-out/`, and any sensitive/secret path. **Never** point graphify's document extraction at `raw/`.
• Why this is safe: code is parsed locally by tree-sitter AST (no LLM, nothing leaves the machine); document extraction is limited to `wiki/`, which is already de-identified and non-confidential per the wiki admission policy. graphify also auto-skips sensitive files during detection — but scope, not that fallback, is your guardrail.

3. **Build the graph.**

• **Full build (code + wiki):** the heavy document pass runs through graphify's own pipeline using the host IDE session — invoke `/graphify .` (graphify's global skill), having confirmed scope. Non-code text in `wiki/` is extracted by *this* session; graphify does not call any third party or read `ANTHROPIC_API_KEY` in-IDE.
• **Code-only refresh (no LLM, fast):** run `graphify update <path>` — re-extracts the code AST deterministically, no model call. Prefer this when only code changed.
• **Gate:** confirm `graphify-out/graph.json` and `GRAPH_REPORT.md` were written before reporting.

4. **Surface the highlights.** Read `graphify-out/GRAPH_REPORT.md` and summarize into the output shape above — God Nodes, Surprising Connections, Suggested Questions — keeping the EXTRACTED/INFERRED/AMBIGUOUS labels. Point the user at `graphify-out/graph.html` for the interactive view. 5. **Offer the next move.** Propose `/graph-query "<question>"` to explore (shortest paths, neighbors, communities), and — if the user wants it standing — `graphify hook install` for auto-rebuild on commit (a Cadence touch) or `--watch` for continuous rebuild while working.

Autonomy

**L2 — drafts/refreshes the graph; the human reads it.** Building is reversible and lands only in git-ignored `graphify-out/`, so it's safe to run on request. A **code-only `graphify update`** (deterministic, no LLM, no document pass) can run at **L3** — e.g. via the commit hook — once trusted. Never commit `graphify-out/`; never widen scope beyond code + `wiki/` without explicit approval.

Guardrails (from CLAUDE.md)

• **Never extract `raw/`** (or `.env`, `.tmp/`, secrets) — `raw/` can hold pre-de-identified PHI/PII/financials. Document extraction is limited to the committed, de-identified `wiki/`. (Guardrails #1, #2, #7)
• **`graphify-out/` is git-ignored** — a derived artifact. No secrets, confidential figures, or sensitive data enter git via the graph.
• **Cite, don't invent.** Carry graphify's honesty audit trail (EXTRACTED / INFERRED / AMBIGUOUS) into any claim about the graph. (Guardrail #6)
• Code AST is parsed locally; the wiki document pass uses this host session only — no third-party call, no `ANTHROPIC_API_KEY` read.