LLM Wiki Newsroom

See the output before installing — the example corpus shipped in this repo is published as a browsable GitHub Wiki (no clone needed). It's a rendered static snapshot of the wiki/ folder; the interactive graph below runs locally.

!The interactive knowledge graph browser — every page a node, every wikilink an edge, auto-grouped into color-coded clusters with relationship-typed links

_{The interactive knowledge graph (graph/graph.html) — every page a node, every wikilink an edge, color-coded by auto-detected cluster, with a live physics layout and filter/search built in. Shown here on a larger private deployment (~2,300 nodes) to convey how it scales; this repo ships a deliberately small example corpus you can browse the exact same way. (Interface shown in the optional Korean WIKI_LANG=ko mode.)}

The concept

This project is one question worked into a running system: how far can you trust knowledge an AI wrote? Two ideas organize everything below.

1. The product is an LLM Wiki — Andrej Karpathy's three-layer pattern. The original documents you collect (Layer 1, raw/), the cross-linked wiki the agent maintains (Layer 2, wiki/), and the operating rules the agent follows (Layer 3, CLAUDE.md + .claude/) are kept strictly separate, so humans and AI don't trespass into each other's territory. As the operator you do exactly two things — feed Layer 1 and tune Layer 3; only the agent writes Layer 2. And ingesting one document doesn't just add a page: it refreshes the ~10–15 existing pages that mention the same entities and concepts, which is what makes the wiki compound instead of just piling up.

2. The factory is a newsroom running four loops. The wiki is produced by five roles modeled on a newspaper staff — and the agent that writes a page is never the one that reviews it:

| Role | What it does | |---|---| | Reporter | gathers material and drafts source pages + entity/concept stubs | | Columnist | writes the deep cross-source analyses | | Copy Editor | rule-based Python checks — not an LLM at all | | Desk | re-reads finished drafts with fresh eyes; the only independent qualitative judgment in the system | | Editor-in-Chief | routes work and gates publication — orchestration, not evaluation |

Four loops turn that division of labor into trust. The first three nest inside one another; only the fourth sits outside, feeding published pages back in:

%%{init: {"flowchart": {"wrappingWidth": 700}}}%%
flowchart BT
    subgraph meta["Meta loop — mistakes become new rules"]
        subgraph outer["Outer loop — two gates before publication"]
            inner["Inner loop — the writer self-checks while drafting"]
        end
    end
    %% the   padding keeps this box as wide as the Meta loop box above
    reground["  Reground loop — pages that go stale or inconsistent come back as input  "]
    reground -.-> meta
    style meta fill:transparent,stroke:#58a6ff,stroke-width:2px
    style outer fill:transparent,stroke:#3fb950,stroke-width:2px
    style inner fill:transparent,stroke:#d29922,stroke-width:2px
    style reground fill:transparent,stroke:#bc8cff,stroke-width:2px,stroke-dasharray:4 4

| Loop | When it runs | What it does | |---|---|---| | Inner | while drafting | the writer self-checks against the same yardstick the review gates will use later, and hands off instead of grinding | | Outer | at publication | two gates — deterministic lint (Copy Editor), then a six-lens qualitative review (Desk) — and both must pass | | Meta | when mistakes recur | repeat failures become proposals to amend the authoring rules themselves — blind measurement where it applies, operator sign-off always | | Reground | after publication | published pages that have gone stale or inconsistent come back around as factory input |

One piece of the machinery is deliberately not a loop. A loop is feedback — something exists, gets checked, gets corrected. Before any loop runs, a GROUND Ladder governs the input side: how much the writer reads before drafting, widening from the page's declared dependencies toward the whole corpus only on a named signal that the evidence so far is insufficient. The loops correct what came out; the ladder disciplines what goes in — every authoring cycle enters through it. (Details under Key Features.)

The first three loops mirror the "software factory" playbook for AI-assisted coding; the fourth exists because knowledge, unlike code, keeps decaying after you ship it. The full argument for this design is in the companion article: The Knowledge Factory.

Everything else in this README — the commands, the tools, the feature list — hangs off this map.

What makes this different

There are plenty of takes on Karpathy's LLM Wiki idea now. After reading the popular implementations, three things here are genuinely rare — and they are the bet:

• Authoring guidelines that evolve themselves (the meta loop) — something I haven't found in the other implementations. When the same review failure keeps recurring, the system drafts a fix to its own writing rules. The idea is borrowed from Self-Harness and Microsoft SkillOpt. Where the fix touches prose an LLM judge scores, it has to clear a blind A/B against a regression set first; tool code, fact corrections and structural moves are verified deterministically instead, and I can waive the A/B by directing a change myself, with the reason recorded. So it isn't only the wiki that improves over time, but the rules that build it. (Thirteen weeks of that ledger on a private instance: 107 amendments adopted, 72 rejected, 18 deferred. Of the 107, 16 cite a measurement, 40 were adopted on a recorded waiver, and 51 are changes the A/B doesn't cover or that record no measurement. Over the same window, 44 of the 70 defect classes that ever got a fix came back afterwards, and five of them produced 451 of the 823 recurrences (55%); the rule amended most often has been rewritten 19 times and still fires. The loop is still experimental; I'm measuring whether it earns its keep rather than claiming it's solved.)
• A full newsroom, not just "an agent" (the outer loop) — plenty of tools wrap one agent around your notes, and a few add a verifier. Here authoring and review sit in different hands, the review is held to an editorial rubric drawn from real craft (journalism, consulting, encyclopedic forms) so a different person or session reproduces the same bar, and a two-sided gate means the deterministic lint and the qualitative review must both pass.
• Memex-style associative discovery — saved reading trails and "unexpected connection" surfacing that the other implementations don't carry.

Installation

git clone https://github.com/alfadur7/llm-wiki-newsroom.git
cd llm-wiki-newsroom
pip install -r requirements.txt

No API keys, no accounts — the dependencies are the whole setup. If igraph/leidenalg have no wheels for your platform (e.g. Termux/Android), delete those two lines from requirements.txt: everything else still installs, and tools/build.py falls back to a pure-Python partition.

Or click "Use this template" to create your own wiki repo from this scaffold. To start from a clean slate, delete the example pages under wiki/ (keep the folders and graph/cluster_labels.json), then ingest your own sources with /wiki-ingest.

This project assumes an environment where the AI agent reads and edits files and invokes tools on its own. Support levels by agent:

| Agent | Config file | Support level | |----------|----------|----------| | Claude Code (primary) | CLAUDE.md + .claude/commands/ | All 9 slash commands + advanced features (cascading updates, associative discovery, etc.) | | Codex | AGENTS.md | Basic workflow only (drive it with natural language) | | Gemini CLI | GEMINI.md | Basic workflow only (drive it with natural language) |

Claude Code-only features include cascading updates that refresh related existing pages whenever a new document is added, a backlink index across all pages, automatic contradiction tracking, and associative discovery that follows connected concepts. AGENTS.md and GEMINI.md carry only the basic workflow from the original SamurAIGPT project. The Python tools used to build the wiki run locally with no external API keys.

Slash Commands (Claude Code)

In Claude Code, typing a /-prefixed command like /wiki-ingest runs the matching workflow. The table below gives each command's role in one line; the Key Features section explains how they work. Argument notation follows , [optional], and a | b | c (pick one); invoking a command with no required argument prints usage and stops.

Core workflow

| Command | Arguments | Description | Example | |--------|------|------|------| | /wiki-ingest | | Absorb one document into the wiki while also refreshing related existing pages. inbox processes the mobile share-sheet queue in a batch | /wiki-ingest raw/NewsScrap/article.md | | /wiki-query | | Find pages related to the question via the graph and answer with supporting evidence | /wiki-query open source AI definition | | /wiki-lint | [--fix] | Health-check for broken links, missing pages, contradictions, etc. (--fix auto-repairs) | /wiki-lint --fix | | /wiki-graph | — | Compute the connections between pages and generate an interactive graph | /wiki-graph |

News & sharing

| Command | Arguments | Description | Example | |--------|------|------|------| | /wiki-news | [cluster\|keyword] | Search the web for the latest news related to the wiki's topics and recommend only new articles | /wiki-news open-source-ai-definition | | /wiki-export | — | Merge the entire wiki into files for upload to a Claude.ai project | /wiki-export |

Associative discovery

"Associative discovery" is inspired by the Memex proposed by Vannevar Bush in 1945 — an exploration style that follows connected concepts to surface unexpected relationships without a fixed search term.

| Command | Arguments | Description | Example | |--------|------|------|------| | /wiki-discover | ]> | Unexpected connections within 2 hops from a seed (or random seed), or auto-ranking of hubs that bridge clusters | /wiki-discover Meta | | /wiki-trail | [args] | Build and save a 5–12 step page path that follows a single topic | /wiki-trail create open source AI definition | | /wiki-timeline | [year] | A chronological storyline of a person's or company's events sorted by year | /wiki-timeline Meta 2024 |

You don't have to memorize the slash commands — you can request the same tasks in natural language, and Claude Code figures out the intent and maps it to the right command.

"Ingest this file: raw/NewsScrap/article.md"
"What's the relationship between open weights and the OSI definition?"
"Check the wiki for contradictions and auto-fix them"
"Start from Meta and find unexpected connections"

Key Features

Grouped by where each feature sits in the concept above: first the product (the wiki itself and the ways to explore it), then the reading discipline that feeds it, then the loops that make it trustworthy.

The wiki itself

Persistent wiki

Cascading updates

Automatic duplicate-document skip

PDF ingest (multimodal)

• Download: Put the PDF URL in the inbox queue (raw/_inbox.md) and run /wiki-ingest inbox to save it as a binary under raw/PDF/. Just the .pdf lands, with no separate meta file.
• URL management inside the wiki page: Record the URL in the source_url: frontmatter of wiki/sources/.md generated at ingest, so dedup works even if the same document is re-downloaded. Even if you manually drop just a PDF with no URL, duplicates are filtered by file path.

Contradiction detection · 3-layer tracking

1. wiki/contradiction.md — global aggregation of contradictions. The editor's tension-axis narrative + theme summaries.
2. wiki/contradictions/.md — per-theme deep analysis (e.g., whether an "open source" model must release its training data). Which themes exist and which raw issues belong to which theme is defined by _contradictions_themes.json as the mapping SoT.
3. wiki/contradictions/_contradictions.json — source DB of auto-detected individual issues.

Automatic topic clustering

Leiden is the successor to the better-known Louvain algorithm, solving Louvain's limitation (the modularity-local-maxima trap) where cluster boundaries swing wildly under small graph changes, via a refinement stage and connectivity guarantees. In the larger corpus this engine was built for, as the wiki grew to ~470 hubs Louvain hit an unstable regime where adding just 7 new sources would make the cluster count jump from 7 to 10; after adopting Leiden, the same change was measured to stay stable at 8→8. (The small example corpus shipped here has only 3 clusters, so the instability doesn't show up — but the algorithm choice still matters as a wiki grows.)

{
  "slug": "licensing-open-washing",
  "name": "Licensing & Open-Washing",
  "anchor_members": [
    "concepts/ModelLicensing.md",
    "concepts/OpenWashing.md",
    "entities/Meta.md"
  ],
  "paired_with": ["open-source-ai-definition"]
}

Knowledge graph visualization

Serve the graph/ folder over a local web server (e.g. python -m http.server) and open graph.html — it fetches its data, so a file:// double-click is unsupported — and these interactions are available right in the browser:

• Live physics simulation — nodes find their place by spring, gravity, and repulsion, and stop automatically when motion settles
• Drag to rearrange — drop a node and it pins there; surrounding nodes respond physically to adjust the layout
• Domain filter — toggle on/off by clicking in the sidebar; hovering a domain row wraps that region in color
• Relationship filter — classify edges into 5 types (contradicts·defines·cites·references·inferred) and toggle, e.g., "I want to see only contradiction relationships in this graph"
• Search — search by node name for automatic camera move + top-match highlight
• Select and explore surroundings — clicking a node highlights its connected edges and shows neighbor labels; a local view mode that keeps only the 1·2·3-hop range to focus on nearby relationships
• Fragile-bridge highlight — mark connection points that link two domains by a single edge in orange (sidebar toggle)
• Analysis overlay — overlay a saved associative trail or a contradiction's opposing camps in color on top of the graph, to see a path's flow or a confrontation structure within the overall terrain
• Shareable link — filter, local-view, and highlight state are all recorded in the URL, so the same view can be shared as-is

Two-level index

Exploring and sharing the wiki

Search/traversal queries (tools/query.py)

Graph traversal (python tools/query.py graph ...) — structural queries using link relationships:

• graph path Meta OpenSourceInitiative — shows the shortest path connecting two pages and why each link was formed ([[X]] — connection reason explanation). You can trace the logical flow from "Meta" to "OpenSourceInitiative" without a single click.
• graph explain OpenWeights — summarizes which cluster a page belongs to, which pages reference it, and what it points to.
• graph neighbors Meta — groups directly connected pages by cluster to see "what's around" at a glance.

• qmd hybrid "open weights vs open source" — recommendation search combining keyword, meaning, and reranking.
• qmd search "OpenAI" — BM25 keyword matching (fastest).
• qmd vsearch "models that are open in name only" — vector-based semantic similarity (finds it by context even when the exact keyword isn't in the body — here, surfacing the open-washing pages).

Associative discovery — finding unexpected connections

• Seed exploration: starting from a specific page like /wiki-discover Meta, it follows backlinks and co-references 2 hops to present pages not directly linked to the seed but unexpectedly close (e.g., "model licensing terms → training-data disclosure"). Giving --random picks a random hub in the mid-range of backlink counts and runs the same exploration.

• Bridge-hub ranking (--surprising): automatically selects the pages that most bridge different topic clusters. The score rises the more often it appears on shortest paths, the more its neighbors span multiple clusters, and the less it's so famous as to seem "obvious." The "unexpected centers" are output as a top N even with no seed input.

Associative trails (Memex Trail)

Timeline

Wiki-based latest-news search

Claude.ai mobile integration

So that answers understand the wiki structure and attach links to the graph, paste the entire wiki-export/README.md that export also produces (an instruction document covering file structure, answer rules, and the deep-link convention) once into the custom instructions box of the Claude.ai project. Then, when citing a hub the answer links to that page, and when pinning a specific claim's source it links straight to the original.

Before the loops — the GROUND Ladder

The four loops are all feedback: something exists, gets checked, gets corrected. The newest mechanism governs the input side instead — how much the writer reads before drafting, as a ladder climbed only as far as the evidence demands.

• The rungs — start from the target page's declared dependencies (R0), then widen to the index (R1), the links the build has already computed (R2), content search for the relations no link declares (R3), and, while the corpus still fits in one read, an exhaustive pass over everything (R4).
• The signal to climb — widening happens only on a named insufficiency signal: a claim with no evidence span secured, an unresolved wikilink, consecutive empty searches. The signal also picks the rung, so an unresolved link jumps straight to R2 instead of stepping through R1.
• The recorded rung — every hand-off notes where the writer stopped (grounded_at), and the defect corpus stores it alongside which review surface caught the defect. That second coordinate is the point: without it, a defect born from under-reading is indistinguishable from bad writing, so the meta loop's only possible prescription was "fix the writing rules." Recording the pair is what makes "widen the reading earlier" available as a diagnosis at all — drawing it is a separate step, and not built.

The inner and outer loops — how a page earns publication

Dual automation

• Deterministic automation: Python scripts generate mechanical outputs like links, rankings, and catalogs
• Probabilistic automation: Claude writes narrative prose following authoring guidelines and an evaluation rubric, self-verifying and rewriting against /wiki-lint's automated metrics — the inner loop at work

Separation of authoring and review

The probabilistic automation above doesn't have one Claude do everything. The Claude that writes the body and the Claude that re-reads and reviews it are split into different instances, reducing self-bias. Just as a newspaper divides labor among reporters, columnists, and the desk, authoring and verification are placed in different hands.

• Two-sided verification gate — deterministic lint (quantitative metrics like link/citation/structure consistency) and qualitative review with fresh reader's eyes (areas like bias, narrative flow, argument quality) operate as one unit. Passing the quantitative side alone can still be blocked on the qualitative side, and vice versa.
• Verification failure count — if the same criterion fails 1st, 2nd, 3rd in a row, the count is tracked automatically, and a 3rd failure for the same reason is escalated to human-operator review to prevent infinite self-repetition.
• Common 4-stage skeleton — every workflow (ingest, query, health-check, rewrite, etc.) shares an "observe → write → verify → adapt" 4-stage structure, so new tasks are understood by the same pattern.
• Two isomorphic verification ladders — wiki content climbs a Content Verification Ladder (post-edit hook → self-lint → batch lint → qualitative desk review → publish gate), and changes to the writing rules themselves climb a matching Guideline Verification Ladder (deterministic lint → minimal-edit check → blind review → an effect-measurement gate, where the change is of a kind that gate covers). The same "cheapest deterministic check first" principle governs both layers.

Editorial-form-based quality evaluation

Forms it draws on:

• Per-domain overview: journalism's nut graph · inverted pyramid (NN/g) · PAGE framing; consulting's McKinsey SCR (Situation-Complication-Resolution) · BCG Bold-bullet; Wikipedia's Summary style · Coatrack avoidance
• Contradiction analysis: Wikipedia NPOV · ASF (attribute sources) · DUE (due weight); Toulmin argument (claim-grounds-rebuttal-qualifier); Hegelian thesis-antithesis-synthesis; BBC Due Impartiality
• Common to both axes: Wikipedia MoS link density · first-mention principle · broken-link avoidance

Health-check · auto-fix

Hard-to-reverse operations like creating a new page or deleting an existing one first show which files are affected and then ask for confirmation — preventing unintended changes even without Git. If the data that synchronization is keyed on (cluster definitions, contradiction theme mapping) is stale, auto-fix pauses briefly and first tells you which command to refresh with.

The meta loop — rules that learn from their own failures

When the same review failure recurs, the system doesn't stop at fixing individual cases; it collects those failures and drafts a proposal to fix the authoring guidelines themselves. So not only the wiki body but the rules that build the wiki learn from their own mistakes.

• Proposals aren't applied immediately. Where a change touches the prose an LLM judge scores, it must show a measured effect: the same task is rewritten side-by-side with and without the change and scored blind, and a held-out regression set confirms nothing else got worse. That covers a minority of changes — the rest are verified deterministically, or adopted on an operator directive that waives the measurement and records why.
• Guideline edits are reviewed blind — a reviewer who never saw the deliberation reads only the diff and classifies each change as substantive or invariant, so wording churn can't masquerade as improvement.
• Every accepted or rejected proposal lands in a transition ledger, and defects that recur after a fix are ranked first in the next review round — the loop learns from its own failed fixes, not just from new defects.
• Recurring findings can also be hardened into code — promoted into a deterministic lint rule or hook, moving the problem out of the judgment layer entirely so the qualitative review stays pointed at problems nobody has seen before.
• Adoption always ends at the operator gate: the loop proposes and measures; it never adopts on its own.

The reground loop — published pages come back as input

Once code ships it stays put until the spec changes; knowledge doesn't — it drifts away from reality as the world moves. So this system feeds published pages back in as factory input, on three triggers, each an old newsroom practice:

• Update — an upstream source changed. /wiki-lint staleness surfaces derived pages that lag the sources they were built from; a Columnist re-reads the sources and rewrites. (A follow-up story.)
• Follow-up — one of the wiki's own claims carries an unresolved marker or a deadline that has now passed. The Desk re-adjudicates, ending at operator confirmation. (Circling back on a story you promised to follow.)
• Correction — the wiki's own pages disagree with each other or with a generated artifact. The Desk re-reads a published cluster as one bundle, catching the mismatches that reading one page at a time can't reveal. (A correction notice.)

Architecture

The three layers from the concept live in raw/ (Layer 1), wiki/ (Layer 2), and CLAUDE.md + .claude/ (Layer 3). The Layer 2 wiki is further formalized into four sub-layers. Knowing which slash command produces or updates each sub-layer makes the workflow intuitive to follow.

| Sub-layer | Role | Producing/updating command | Output location | |------|------|----------------|---------| | L2-1 Source reflection | Reflect one source into summary, claims, quotes, and connection sections | /wiki-ingest | wiki/sources/.md | | L2-2 Abstraction | Extract and update the entities, concepts, and timelines mentioned in sources | /wiki-ingest's cascading update · /wiki-timeline | wiki/entities/, wiki/concepts/, wiki/timelines/ | | L2-3 Per-domain analysis | Cluster overviews · issue (contradiction) analyses · query answers · discovery trails | Skeletons auto-generated (the full tools/build.py rebuild via /wiki-ingest · /wiki-lint overview --fix; /wiki-lint contradiction --fix for issue analyses) → Claude writes the body against an evaluation rubric. Plus: /wiki-query · /wiki-trail | wiki/overviews/.md, wiki/contradictions/.md, wiki/syntheses/.md, wiki/trails/.md | | L2-4 Global aggregation | Restate each per-domain overview and per-theme contradiction analysis one paragraph at a time + cross-domain narrative | Claude rewrites periodically | wiki/overview.md, wiki/contradiction.md |

For example, ingesting one article with /wiki-ingest creates L2-1 and L2-2 at the same time. When the next full rebuild recomputes clusters, the relevant per-domain overviews (L2-3) are automatically affected, and Claude rewrites them against the evaluation rubric as needed. The global overview (L2-4) is rewritten periodically once the per-domain overviews stabilize, keeping it current. Each sub-layer is responsible only for its own axis (per-domain overview or issue/contradiction), so editing one page leaves the other axis's files untouched.

raw/                       # Layer 1: original sources (immutable)
  NewsScrap/               #   HTML article clippings (Obsidian Web Clipper-compatible md)
  PDF/                     #   centrally managed PDF documents (drop *.pdf only)
  AiChat/                  #   topic notes excerpted from AI conversations
  _inbox.md                #   mobile share-sheet URL queue (auto-managed)
  _archive.md              #   accumulated inbox processing results (auto-managed)
wiki/                      # Layer 2: agent-managed wiki
  index.md                 #   full page catalog + drill-down entry point (auto-generated)
  overview.md              #   per-domain overview global aggregation — landscape axis (auto skeleton + agent-written narrative)
  contradiction.md         #   per-theme contradiction analysis global aggregation — conflict axis (auto skeleton + agent-written narrative)
  _backlinks.json          #   backlink index (auto-generated)
  sources/                 #   individual source pages + catalog
    _source_map.json       #   ingest deduplication map (auto-generated)
    _catalog.md            #   full source catalog (auto-generated)
    _catalog-<slug>.md     #   per-cluster catalog (auto-generated)
  entities/                #   companies, institutions, people
  concepts/                #   technology, strategy, regulation concepts
  timelines/               #   per-entity chronological timelines
  overviews/               #   per-domain overviews (landscape per cluster)
  contradictions/          #   per-theme contradiction analyses (conflict per theme)
    _contradictions.json        #     contradiction source DB — per claim (auto-generated)
    _contradictions_themes.json #     theme ↔ claim mapping SoT (Claude-generated)
    <theme>.md                  #     per-theme deep analysis (auto skeleton + agent-written narrative)
  syntheses/               #   saved query answers (Q-A)
  trails/                  #   associative trails (Memex)
wiki-export/               # merged files for Claude.ai Project Knowledge (auto-generated)
graph/                     # knowledge graph + clusters
  _graph.json              #   node/edge data (auto-generated)
  _clusters.json           #   Leiden clusters + source assignment (auto-generated)
  cluster_labels.json      #   ★ stable cluster labels — manually edited config file
  graph.html               #   interactive graph visualization (open in browser)
CLAUDE.md                  # Layer 3: schema (evolved jointly by humans and the LLM)
log.md                     # chronological operations log (append-only)
lint-report.md             # health-check results (auto-generated)
tools/                     # Python tools (no API key required)

raw/NewsScrap/article.md  or  raw/PDF/report.pdf  (folder argument scans both .md and .pdf)
  1) Dedup: check whether it was already ingested, by both URL and file path
  2) Read the body: markdown as-is; for PDFs the Read tool interprets the binary directly
  3) Write the source page: wiki/sources/<slug>.md with summary, claims, quotes, connection sections
     · For PDFs, the original URL is recorded in this page's source_url field (for dedup)
  4) Cascading update: append new facts to the entity/concept pages that appear in the source and refresh their reference lists
  5) Link enrichment: propose [[wikilink]] candidates for existing page names that appear as plain text in the body
  6) Full rebuild: graph/visualization → clusters/catalogs/per-domain overviews → contradiction source DB → index → dependency index,
     updated in that order (a single tools/build.py run)
  7) Auto-validation: check broken links, filename convention, missing tags
  8) Cluster health diagnosis: surface new topic clusters that need a label (graph/cluster_labels.json)
  9) Append one line to log.md

1) Classify the question by type (entity description / relationship between two pages / topic survey / short-fact / wiki overview / contradiction comparison)
2) Narrow candidates by type (the agent checks the "map" before reading full bodies):
     tools/query.py graph explain <page>   → summarize a page's in/out links, cluster, and connection reasons
     tools/query.py graph neighbors <page>  → group adjacent pages by topic
     tools/query.py graph path <A> <B>      → shortest path between two pages and the reason for each hop
     tools/query.py qmd hybrid "topic"       → body search combining keyword, meaning, and reranking
     tools/query.py qmd search "keyword"     → BM25 keyword matching (fastest)
     tools/query.py qmd vsearch "context sentence" → vector-based semantic similarity
3) Read in full only the ≤10 pages selected above
4) Produce a markdown answer with supporting [[wikilinks]]
5) (Optional) Save the answer to wiki/syntheses/<slug>.md to reuse as material for later queries