@diottodev/runic 1.0.0 → 1.1.0

package/engineering/llm-wiki/commands/wiki-query.md

@@ -0,0 +1,58 @@
+---
+name: wiki-query
+description: Query the LLM Wiki — reads index.md first, drills into 3-10 relevant pages, synthesizes an answer with inline [[wikilink]] citations, and offers to file the answer back as a new comparison or synthesis page. Usage /wiki-query "<question>"
+---
+
+# /wiki-query
+
+Ask the wiki a question. The librarian reads `index.md` first, picks relevant pages across categories, synthesizes an answer with citations, and offers to file the answer back into the wiki so your explorations compound.
+
+## Usage
+
+```
+/wiki-query "<your question>"
+/wiki-query "what does the wiki say about sparse autoencoders?"
+/wiki-query "compare monosemanticity and polysemanticity across my sources"
+/wiki-query "which sources disagree on scaling laws?"
+/wiki-query "give me a comparison table of SAE vs linear probing"
+```
+
+## What happens
+
+1. **Index-first read** — reads `wiki/index.md` to find relevant pages
+2. **Drill-in** — reads 3-10 pages in full (synthesis + concepts + sources + entities)
+3. **Follow links** — opportunistically follows wikilinks between pages
+4. **Fallback search** — if the index isn't enough, runs `scripts/wiki_search.py` (BM25)
+5. **Synthesize** — composes a direct answer + supporting detail + inline `[[sources/xxx]]` citations + "Related pages" section
+6. **Offer to file back** — asks whether to save this as a new wiki page (usually in `comparisons/` or `synthesis/`)
+
+## Output formats
+
+The answer's format follows the question:
+
+| Question shape | Output |
+|---|---|
+| "What is X?" | Markdown explanation with citations |
+| "A vs B" | Comparison table |
+| "Give me a slide deck on X" | Markdown synthesis → `/wiki-marp` to render |
+| "Chart the trend in X" | Python script + saved chart in `wiki/assets/charts/` |
+
+## Sub-agent
+
+This command dispatches the `wiki-librarian` sub-agent. See `agents/wiki-librarian.md`.
+
+## Scripts
+
+- `engineering/llm-wiki/scripts/wiki_search.py` — BM25 fallback search
+- `engineering/llm-wiki/scripts/append_log.py` — log filed answers
+
+## Rules
+
+- **Read the index first.** No grep-everything.
+- **Every claim cites a page** with a `[[wikilink]]`.
+- **Offer to file the answer back** — but only for substantive answers worth keeping.
+
+## Skill Reference
+
+→ `engineering/llm-wiki/SKILL.md`
+→ `engineering/llm-wiki/references/query-workflow.md`

package/engineering/llm-wiki/skills/llm-wiki/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: llm-wiki
+description: Use when building or maintaining a persistent personal knowledge base (second brain) in Obsidian where an LLM incrementally ingests sources, updates entity/concept pages, maintains cross-references, and keeps a synthesis current. Triggers include "second brain", "Obsidian wiki", "personal knowledge management", "ingest this paper/article/book", "build a research wiki", "compound knowledge", "Memex", or whenever the user wants knowledge to accumulate across sessions instead of being re-derived by RAG on every query.
+context: fork
+version: 2.9.0
+author: claude-code-skills
+license: MIT
+tags: [knowledge-management, obsidian, second-brain, pkm, rag-alternative, wiki, karpathy, memex]
+compatible_tools: [claude-code, codex-cli, cursor, antigravity, opencode, gemini-cli]
+---
+
+# LLM Wiki — Second Brain for Claude Code + Obsidian
+
+Inspired by Andrej Karpathy's LLM Wiki pattern ([gist](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f)). This skill turns Claude Code (or any agent CLI) into a disciplined wiki maintainer that **incrementally builds and maintains** a persistent, interlinked Obsidian vault as you feed it sources. The knowledge compounds — cross-references, contradictions, and synthesis are already there when you query.
+
+## Core principle
+
+Most LLM+docs workflows are **RAG**: retrieve fragments at query time, synthesize from scratch, forget. The wiki is **compounding**: sources are read once, integrated into a persistent markdown knowledge base, and kept current. You curate and ask; the LLM reads, files, cross-references, and maintains.
+
+> Obsidian is the IDE. The LLM is the programmer. The wiki is the codebase.
+
+## When to use
+
+- **Personal**: track goals, health, psychology, journaling, self-improvement
+- **Research**: deep dives over weeks on a topic — papers, articles, reports, evolving thesis
+- **Book companion**: file chapters as you read; build a fan-wiki-style companion for characters, themes, plot threads
+- **Business/team**: internal wiki fed by Slack, meeting notes, calls — LLM does maintenance nobody else wants to do
+- **Competitive analysis, due diligence, trip planning, course notes, hobby deep-dives**
+
+**Do NOT use when:** you need one-shot Q&A over a fixed document (use RAG), you don't plan to add sources over time, or you don't want Obsidian in the loop.
+
+## Architecture (three layers)
+
+```
+vault/
+├── raw/                    # Layer 1 — IMMUTABLE source of truth
+│   ├── <source files>      # Articles, papers, PDFs, images, data
+│   └── assets/             # Downloaded images from clipped articles
+├── wiki/                   # Layer 2 — LLM-owned knowledge base
+│   ├── index.md            # Content catalog (LLM updates every ingest)
+│   ├── log.md              # Append-only timeline (## [YYYY-MM-DD] <op> | <title>)
+│   ├── entities/           # Person/Org/Place pages
+│   ├── concepts/           # Ideas, theories, frameworks
+│   ├── sources/            # One summary page per ingested source
+│   ├── comparisons/        # Cross-source analysis pages
+│   └── synthesis/          # High-level syntheses, theses, overviews
+├── CLAUDE.md               # Schema + conventions (Claude Code)
+└── AGENTS.md               # Same content, for Codex/Cursor/Antigravity
+```
+
+- **Layer 1 (raw/)** — you own. LLM only reads; never writes.
+- **Layer 2 (wiki/)** — LLM owns. It creates, updates, and cross-references pages. You read it.
+- **Layer 3 (CLAUDE.md / AGENTS.md)** — the *schema*. Conventions, workflows, frontmatter rules. Co-evolved by you and the LLM.
+
+## Three core operations
+
+1. **Ingest** — LLM reads a source, discusses takeaways with you, writes a source summary, updates 10-15 relevant pages, updates index, appends to log. See `references/ingest-workflow.md`.
+2. **Query** — LLM reads `index.md` first, drills into relevant pages, synthesizes with citations. Good answers get **filed back into the wiki** so explorations compound. See `references/query-workflow.md`.
+3. **Lint** — Health check: contradictions, stale claims, orphan pages, missing cross-refs, concepts mentioned but lacking their own page, data gaps to fill with web search. See `references/lint-workflow.md`.
+
+## Quick start
+
+```bash
+# 1. Initialize a vault (in Obsidian's vault directory)
+python scripts/init_vault.py --path ~/vaults/research --topic "LLM interpretability"
+
+# 2. Drop a source into raw/, then ingest
+/wiki-ingest ~/vaults/research/raw/anthropic-monosemanticity.pdf
+
+# 3. Ask questions (answers can be re-filed into the wiki)
+/wiki-query "how does monosemanticity compare to mechanistic interpretability?"
+
+# 4. Periodic health check
+/wiki-lint
+
+# 5. See the timeline
+/wiki-log --last 10
+```
+
+## Slash commands (this plugin ships)
+
+| Command | Purpose |
+|---|---|
+| `/wiki-init` | Bootstrap a fresh vault with schema files + starter structure |
+| `/wiki-ingest <path>` | Read a source, discuss, update wiki, log it |
+| `/wiki-query <question>` | Search wiki, synthesize answer, offer to file back |
+| `/wiki-lint` | Run health check — contradictions, orphans, stale claims, gaps |
+| `/wiki-log` | Show recent log entries (uses unix tools on `log.md`) |
+
+## Sub-agents (this plugin ships)
+
+| Agent | When dispatched |
+|---|---|
+| `wiki-ingestor` | Delegated ingest flow — reads source, proposes updates, applies after your approval |
+| `wiki-linter` | Runs the health-check workflow independently, reports findings |
+| `wiki-librarian` | Answers queries using index-first search, synthesizes with citations |
+
+## Python tools (`scripts/`)
+
+All tools are **standard library only** (no pip installs). Run with `python scripts/<tool>.py --help`.
+
+| Script | Purpose |
+|---|---|
+| `init_vault.py` | Create folder structure + seed CLAUDE.md, AGENTS.md, index.md, log.md |
+| `ingest_source.py` | Helper: extract text/frontmatter from a source file, ready for LLM review |
+| `update_index.py` | Regenerate `index.md` from wiki page frontmatter (category, date, source count) |
+| `append_log.py` | Append a standardized log entry `## [YYYY-MM-DD] <op> \| <title>` |
+| `wiki_search.py` | BM25 search over wiki pages (standalone fallback when index.md isn't enough) |
+| `lint_wiki.py` | Find orphans (no inbound links), stale pages, missing cross-refs, broken links |
+| `graph_analyzer.py` | Compute link graph stats — hubs, orphans, clusters, disconnected components |
+| `export_marp.py` | Render a wiki page (or subtree) to a Marp slide deck |
+
+## Cross-tool compatibility
+
+The vault's **schema** lives in CLAUDE.md (Claude Code) or AGENTS.md (Codex/Cursor/Antigravity/OpenCode). The same content works in both. This plugin ships both templates. For per-tool setup instructions see `references/cross-tool-setup.md`.
+
+```
+CLAUDE.md       → Claude Code
+AGENTS.md       → Codex CLI, Cursor, Antigravity, OpenCode, Gemini CLI
+.cursorrules    → legacy Cursor (pre-AGENTS.md)
+```
+
+The scripts are pure Python stdlib → run identically everywhere. Only the loader file changes per tool.
+
+## Obsidian setup (recommended)
+
+- **Obsidian Web Clipper** — browser extension; converts web articles to markdown and drops them in `raw/`
+- **Download images locally** — Settings → Files and links → Attachment folder path = `raw/assets/`. Settings → Hotkeys → bind "Download attachments for current file" to `Ctrl+Shift+D`
+- **Graph view** — see hubs/orphans; essential for spotting structural problems
+- **Marp plugin** — Markdown-based slide decks directly from wiki pages
+- **Dataview plugin** — dynamic tables/lists over page frontmatter (tags, dates, source counts)
+- **Git** — the vault is a plain markdown repo; version it
+
+Full setup walkthrough: `references/obsidian-setup.md`
+
+## Why this works (vs plain RAG)
+
+| Plain RAG | LLM Wiki |
+|---|---|
+| Rediscover knowledge each query | Knowledge accumulates |
+| Cross-references re-computed every time | Cross-references pre-written and maintained |
+| Contradictions surface only if you ask | Contradictions flagged during ingest |
+| Exploration disappears into chat history | Good answers re-filed as new pages |
+| Scales by embeddings infrastructure | Scales by markdown + `index.md` + optional local search |
+
+At ~100 sources / hundreds of pages, `index.md` + filesystem search is enough. Past that, layer in a local search tool like [qmd](https://github.com/tobi/qmd) or use `scripts/wiki_search.py`.
+
+## Related skills (chains via `context: fork`)
+
+This skill is marked `context: fork` so other skills can chain into it:
+
+- **`para-memory-files`** — PARA-method memory; complementary as long-term personal memory that feeds sources into the wiki
+- **`obsidian-vault`** (mattpocock) — lightweight Obsidian note helper; this skill is the maintained-wiki layer on top
+- **`rag-design`** — when wiki outgrows ~500 pages, use rag-design to bolt on a retrieval layer
+- **`mcp-design`** — expose the wiki as an MCP tool
+- **`agent-communication`** — for multi-agent wiki maintenance (ingestor + linter + librarian)
+
+## Reference docs
+
+- `references/wiki-schema.md` — full vault layout, page frontmatter, naming conventions
+- `references/page-formats.md` — entity, concept, source, comparison, synthesis templates
+- `references/ingest-workflow.md` — the detailed ingest flow the wiki-ingestor agent follows
+- `references/query-workflow.md` — query patterns, citation format, re-filing answers
+- `references/lint-workflow.md` — health-check heuristics
+- `references/obsidian-setup.md` — Obsidian plugins, hotkeys, vault config
+- `references/cross-tool-setup.md` — per-tool setup (Codex, Cursor, Antigravity, etc.)
+- `references/memex-principles.md` — Bush's Memex, why the LLM changes the maintenance math
+
+## Templates (`assets/`)
+
+- `CLAUDE.md.template`, `AGENTS.md.template`, `.cursorrules.template` — schema loaders per tool
+- `index.md.template`, `log.md.template` — starter index and log
+- `page-templates/` — entity, concept, source-summary, comparison, synthesis
+- `example-vault/` — small worked example you can study or copy
+
+## Iron rule
+
+**The LLM never edits files in `raw/`.** Ever. Sources are immutable. All LLM writes go to `wiki/`. If you need to correct a source, do it in `raw/` yourself — then re-ingest.

package/engineering/llm-wiki/skills/llm-wiki/assets/AGENTS.md.template

@@ -0,0 +1,140 @@
+# {{VAULT_NAME}} — LLM Wiki
+
+> **Topic:** {{TOPIC}}
+> **Initialized:** {{DATE}}
+> **Tool:** Any AGENTS.md-aware CLI (Codex, Cursor, Antigravity, OpenCode, Gemini CLI, etc.). Claude Code uses `CLAUDE.md`, which is identical.
+
+You are the maintainer of this wiki. You read from `raw/`, you write to `wiki/`. You never edit `raw/`.
+
+## The three layers
+
+```
+raw/     → sources (articles, papers, notes). IMMUTABLE. You only read.
+wiki/    → the knowledge base. You own this. Create, update, cross-reference.
+AGENTS.md → schema (this file). Co-evolved with the user.
+```
+
+## Vault structure
+
+```
+raw/
+├── <sources>              # articles, papers, notes — IMMUTABLE
+└── assets/                # downloaded images from clipped articles
+
+wiki/
+├── index.md               # content catalog — update every ingest
+├── log.md                 # append-only timeline
+├── entities/              # people, orgs, places, products
+├── concepts/              # ideas, theories, frameworks
+├── sources/               # one summary page per ingested source
+├── comparisons/           # cross-source analysis
+├── synthesis/             # high-level overviews and theses
+└── .templates/            # page templates (reference only)
+```
+
+## Page frontmatter (required on every wiki page)
+
+```yaml
+---
+title: <Title>
+category: entity | concept | source | comparison | synthesis
+summary: <one-line summary>
+tags: [tag1, tag2]
+sources: <count of sources referencing this page>
+updated: YYYY-MM-DD
+---
+```
+
+For `source` pages, also include:
+```yaml
+source_path: raw/<path>
+source_date: YYYY-MM
+authors: [author1, author2]
+ingested: YYYY-MM-DD
+```
+
+## The three operations
+
+### Ingest
+
+When the user says "ingest this source" or points you at a file in `raw/`:
+
+1. Read the source directly with your file-reading tool
+2. **Discuss with the user first** — TL;DR, key claims, pages you'll touch, contradictions
+3. Wait for confirmation
+4. Create/merge the summary page at `wiki/sources/<slug>.md`
+5. Update every relevant entity and concept page (typically 5-15 pages)
+6. Flag contradictions with `> ⚠️ Contradiction:` callouts on both sides
+7. Update `wiki/index.md`
+8. Append a log entry: `## [YYYY-MM-DD] ingest | <title>` with touched pages in the body
+9. Report back with a bulleted list of touched pages
+
+If Python is available, use the helpers:
+```bash
+python <plugin-path>/scripts/ingest_source.py --vault . --source <path> --json
+python <plugin-path>/scripts/append_log.py --vault . --op ingest --title "<title>"
+python <plugin-path>/scripts/update_index.py --vault .
+```
+
+### Query
+
+When the user asks a question:
+
+1. Read `wiki/index.md` first
+2. Pick 3-10 relevant pages across categories
+3. Read them in full
+4. Follow wikilinks opportunistically
+5. Fall back to `wiki_search.py --query <terms>` if needed
+6. Synthesize: direct answer → supporting detail → inline `[[sources/xxx]]` citations → "Related pages"
+7. **Offer to file the answer back** as a new page
+
+### Lint
+
+When the user says "check the wiki" or periodically:
+
+1. Run `lint_wiki.py` + `graph_analyzer.py`
+2. Do semantic checks (contradictions, stale claims, concept gaps)
+3. Present a report with suggested actions
+4. Append a `lint` entry to `log.md`
+
+## Iron rules
+
+1. **`raw/` is immutable.** You read from it; you never write to it.
+2. **All writes go to `wiki/`.** No exceptions.
+3. **Every wiki page has YAML frontmatter** with `title`, `category`, `summary`, `updated`.
+4. **Every ingest touches ≥5 files.**
+5. **Every claim has a citation.**
+6. **Contradictions get flagged inline.** Both pages.
+7. **Good answers get filed back.** Explorations compound.
+
+## Log format
+
+```
+## [YYYY-MM-DD] <op> | <title>
+<optional detail>
+```
+
+Ops: `ingest`, `query`, `lint`, `create`, `update`, `delete`, `note`.
+
+## Tools
+
+Python scripts live wherever you installed the plugin. Standard library only.
+
+- `init_vault.py`
+- `ingest_source.py`
+- `update_index.py`
+- `append_log.py`
+- `wiki_search.py`
+- `lint_wiki.py`
+- `graph_analyzer.py`
+- `export_marp.py`
+
+Run any of them with `--help`.
+
+## Style
+
+- Concise. Wiki pages are read, not generated.
+- Short paragraphs. Bulleted lists where appropriate.
+- Cite aggressively with `[[wikilinks]]`.
+- Say "I don't know" when you don't. Don't invent content.
+- Update `updated:` whenever you touch a page.

package/engineering/llm-wiki/skills/llm-wiki/assets/CLAUDE.md.template

@@ -0,0 +1,133 @@
+# {{VAULT_NAME}} — LLM Wiki
+
+> **Topic:** {{TOPIC}}
+> **Initialized:** {{DATE}}
+> **Tool:** Claude Code (this file). A parallel `AGENTS.md` exists for Codex/Cursor/Antigravity.
+
+You are the maintainer of this wiki. You read from `raw/`, you write to `wiki/`. You never edit `raw/`.
+
+## The three layers
+
+```
+raw/     → sources (articles, papers, notes). IMMUTABLE. You only read.
+wiki/    → the knowledge base. You own this. Create, update, cross-reference.
+CLAUDE.md / AGENTS.md → schema (this file). Co-evolved with the user.
+```
+
+## Vault structure
+
+```
+raw/
+├── <sources>              # articles, papers, notes — IMMUTABLE
+└── assets/                # downloaded images from clipped articles
+
+wiki/
+├── index.md               # content catalog — update every ingest
+├── log.md                 # append-only timeline
+├── entities/              # people, orgs, places, products
+├── concepts/              # ideas, theories, frameworks
+├── sources/               # one summary page per ingested source
+├── comparisons/           # cross-source analysis
+├── synthesis/             # high-level overviews and theses
+└── .templates/            # page templates (reference only)
+```
+
+## Page frontmatter (required on every wiki page)
+
+```yaml
+---
+title: <Title>
+category: entity | concept | source | comparison | synthesis
+summary: <one-line summary>
+tags: [tag1, tag2]
+sources: <count of sources referencing this page>
+updated: YYYY-MM-DD
+---
+```
+
+For `source` pages, also include:
+```yaml
+source_path: raw/<path>
+source_date: YYYY-MM (original publication)
+authors: [author1, author2]
+ingested: YYYY-MM-DD
+```
+
+## The three operations
+
+### Ingest (`/wiki-ingest <path>`)
+
+1. Run `python scripts/ingest_source.py --vault . --source <path> --json` to get the brief
+2. Read the source directly
+3. **Discuss with the user first** — TL;DR, key claims, which pages will be touched, contradictions
+4. Wait for confirmation
+5. Create or merge the summary page at `wiki/sources/<slug>.md`
+6. Update every relevant entity and concept page (typically 5-15 pages)
+7. Flag contradictions with `> ⚠️ Contradiction:` callouts on both sides
+8. Update `wiki/index.md` (run `update_index.py` or edit inline)
+9. Run `append_log.py --op ingest --title "<title>" --detail "<touched pages>"`
+10. Report back with a bulleted list of touched pages
+
+### Query (`/wiki-query <question>`)
+
+1. Read `wiki/index.md` first
+2. Pick 3-10 relevant pages across categories (synthesis + concepts + sources + entities)
+3. Read them in full
+4. Follow wikilinks opportunistically
+5. Fall back to `wiki_search.py --query <terms>` if the index doesn't surface the answer
+6. Synthesize: direct answer (1-3 sentences) → supporting detail → inline `[[sources/xxx]]` citations → "Related pages" section
+7. **Offer to file the answer back** as a new page in `comparisons/` or `synthesis/`
+
+### Lint (`/wiki-lint`)
+
+1. Run `python scripts/lint_wiki.py --vault .` for mechanical checks
+2. Run `python scripts/graph_analyzer.py --vault .` for structural stats
+3. Semantic checks: look for contradictions, stale claims, concepts mentioned without their own page, cross-reference gaps
+4. Present findings as a markdown report with suggested actions
+5. Append a `lint` entry to `log.md`
+
+## Iron rules
+
+1. **`raw/` is immutable.** You read from it; you never write to it.
+2. **All writes go to `wiki/`.** No exceptions.
+3. **Every wiki page has YAML frontmatter** with `title`, `category`, `summary`, `updated`.
+4. **Every ingest touches ≥5 files.** The source summary, 2-4 entity/concept pages, `index.md`, `log.md`.
+5. **Every claim has a citation.** Link back to the `sources/<slug>` page.
+6. **Contradictions get flagged inline.** Both pages get the callout.
+7. **Good answers get filed back.** Explorations compound.
+
+## Log format
+
+```
+## [YYYY-MM-DD] <op> | <title>
+<optional detail — which pages touched, what changed>
+```
+
+Valid ops: `ingest`, `query`, `lint`, `create`, `update`, `delete`, `note`.
+
+Grep the log: `grep "^## \[" wiki/log.md | tail -10`
+
+## Tools
+
+All scripts live at `~/.claude/skills/llm-wiki/scripts/` (or wherever you installed the plugin). Standard library only.
+
+- `init_vault.py` — bootstrap a vault
+- `ingest_source.py` — prep a source for ingest (metadata + preview)
+- `update_index.py` — regenerate `wiki/index.md` from page frontmatter
+- `append_log.py` — append a standardized log entry
+- `wiki_search.py` — BM25 search fallback
+- `lint_wiki.py` — mechanical health check
+- `graph_analyzer.py` — link graph stats
+- `export_marp.py` — render a page as a Marp slide deck
+
+## Obsidian
+
+The user opens this vault in Obsidian. They watch the graph view while you edit. Useful plugins: Graph view, Backlinks, Dataview, Marp, Templates, Git.
+
+## Style
+
+- Be concise. Wiki pages are read, not generated.
+- Prefer short paragraphs. Bulleted lists where appropriate.
+- Cite aggressively with `[[wikilinks]]`.
+- When you're not sure, say so in the page. Don't invent content.
+- Update `updated:` frontmatter whenever you touch a page.

package/engineering/llm-wiki/skills/llm-wiki/assets/cursorrules.template

@@ -0,0 +1,30 @@
+# Cursor rules for {{VAULT_NAME}} LLM Wiki
+
+You are the maintainer of this wiki. You read from `raw/` and write only to `wiki/`.
+You never edit files in `raw/`. Full schema is in `AGENTS.md` — read it first.
+
+Topic: {{TOPIC}}
+Initialized: {{DATE}}
+
+Core rules:
+1. `raw/` is immutable. Read only.
+2. All writes go to `wiki/`.
+3. Every wiki page has YAML frontmatter with: title, category, summary, updated.
+4. Every ingest touches at least 5 files: source summary + 2-4 entity/concept pages + index.md + log.md.
+5. Every claim has a wikilink citation to its source page.
+6. Contradictions get `> ⚠️ Contradiction:` callouts on both sides.
+7. Good query answers get filed back into the wiki as new pages.
+
+Operations: ingest / query / lint. Full workflows in AGENTS.md.
+
+Log format: `## [YYYY-MM-DD] <op> | <title>`
+Valid ops: ingest, query, lint, create, update, delete, note.
+
+Scripts (Python stdlib) in `<plugin-path>/scripts/`:
+- ingest_source.py, update_index.py, append_log.py
+- lint_wiki.py, graph_analyzer.py, wiki_search.py, export_marp.py
+
+Run any with `--help`. Use them when helpful — they're fast and deterministic.
+
+Style: concise. Cite with `[[wikilinks]]`. Say "I don't know" when you don't.
+Update `updated:` frontmatter on every touch.

package/engineering/llm-wiki/skills/llm-wiki/assets/example-vault/README.md

@@ -0,0 +1,35 @@
+# Example Vault — "LLM Interpretability"
+
+A minimal worked example to study before initializing your own.
+
+**Not** a runnable vault — it's missing most files. The goal is to show what a healthy small vault looks like after ingesting 2-3 sources on one topic.
+
+## Layout
+
+```
+example-vault/
+├── raw/
+│   └── assets/
+├── wiki/
+│   ├── index.md
+│   ├── log.md
+│   ├── entities/
+│   │   └── anthropic.md
+│   ├── concepts/
+│   │   └── sparse-autoencoder.md
+│   ├── sources/
+│   │   └── monosemanticity.md
+│   └── synthesis/
+│       └── interpretability-overview.md
+├── CLAUDE.md
+└── AGENTS.md
+```
+
+## What to notice
+
+1. **Every page has frontmatter.** This is what makes the index + lint scripts work.
+2. **The source page is the single source of truth** for claims from that paper. Other pages cite it rather than duplicating content.
+3. **`index.md` is organized by category**, not chronologically.
+4. **`log.md` uses the standardized header format** `## [YYYY-MM-DD] <op> | <title>`.
+5. **Cross-references are wikilinks**, not prose references. `[[sources/monosemanticity]]`, not "see the Monosemanticity paper".
+6. **The synthesis page has a `How this synthesis has changed` section.** Append-only history so you can see the thesis evolve.

package/engineering/llm-wiki/skills/llm-wiki/assets/example-vault/wiki/concepts/sparse-autoencoder.md

@@ -0,0 +1,33 @@
+---
+title: Sparse Autoencoder
+category: concept
+summary: Dictionary-learning method for decomposing polysemantic neurons into monosemantic features
+tags: [interpretability, sparse-autoencoders, dictionary-learning]
+sources: 1
+updated: 2026-04-10
+---
+
+# Sparse Autoencoder
+
+## Definition
+A neural-network-based dictionary-learning method that decomposes the activations of a target model's layer into a larger set of sparsely-active features, each of which is hoped to be monosemantic (interpretable as a single concept).
+
+## Origin
+Introduced to LLM interpretability by [[entities/anthropic]] in the Transformer Circuits thread. The specific form used in [[sources/monosemanticity]] is a wide, sparse autoencoder trained on the residual stream activations of a one-layer transformer.
+
+## Key claims
+- SAEs extract features that are *more* monosemantic than raw neurons — cited from [[sources/monosemanticity]]
+- The resulting feature dictionary is larger than the original layer width (overcomplete)
+- Features come in interpretable families (specific tokens, contexts, circuits)
+
+## Contrasts with
+- **Linear probing** — supervised; requires you to know what feature to look for
+- **Direct neuron inspection** — limited by polysemanticity
+
+## Open questions
+- Does it scale beyond one-layer models?
+- Are the features truly monosemantic or just more monosemantic?
+
+## Used in
+- [[synthesis/interpretability-overview]]
+- [[sources/monosemanticity]]

package/engineering/llm-wiki/skills/llm-wiki/assets/example-vault/wiki/entities/anthropic.md

@@ -0,0 +1,31 @@
+---
+title: Anthropic
+category: entity
+summary: AI safety company, developer of Claude; major contributor to interpretability research
+tags: [company, ai-safety, interpretability]
+sources: 1
+updated: 2026-04-10
+---
+
+# Anthropic
+
+## What it is
+AI safety company founded in 2021 by former OpenAI researchers. Builds the Claude family of large language models and publishes research on AI safety, alignment, and interpretability.
+
+## Why it matters
+Primary source of modern mechanistic interpretability work, including the sparse-autoencoder line of research that this wiki is tracking.
+
+## Key facts
+- Founded 2021 — cited from [[sources/monosemanticity]]
+- Publishes the Transformer Circuits thread (interpretability research)
+- Runs the [[concepts/sparse-autoencoder]] line of work
+
+## Related
+- [[concepts/sparse-autoencoder]]
+- [[synthesis/interpretability-overview]]
+
+## Appears in
+- [[sources/monosemanticity]] — primary SAE paper
+
+## Open questions
+- Has the SAE approach scaled beyond one-layer models as of late 2024?

package/engineering/llm-wiki/skills/llm-wiki/assets/example-vault/wiki/index.md

@@ -0,0 +1,18 @@
+# Index — example-vault
+
+_Updated 2026-04-10 • 4 pages_
+
+> Content catalog. Read this first when answering queries.
+> Topic: **LLM Interpretability**
+
+## Synthesis (1)
+- [[synthesis/interpretability-overview|Interpretability Overview]] — current thesis on mechanistic interpretability in LLMs _(1 source · upd 2026-04-10)_
+
+## Concept (1)
+- [[concepts/sparse-autoencoder|Sparse Autoencoder]] — dictionary-learning method for decomposing polysemantic neurons into monosemantic features _(1 source · upd 2026-04-10)_
+
+## Entity (1)
+- [[entities/anthropic|Anthropic]] — AI safety company, developer of Claude; major contributor to interpretability research _(1 source · upd 2026-04-10)_
+
+## Source (1)
+- [[sources/monosemanticity|Towards Monosemanticity]] — Anthropic 2024 paper using sparse autoencoders to extract interpretable features from a one-layer transformer _(upd 2026-04-10)_

package/engineering/llm-wiki/skills/llm-wiki/assets/example-vault/wiki/log.md

@@ -0,0 +1,11 @@
+# Log — example-vault
+
+> Append-only timeline. Grep recent: `grep "^## \[" log.md | tail -10`
+
+## [2026-04-10] note | Vault initialized
+Topic: **LLM Interpretability**. Layers created.
+
+## [2026-04-10] ingest | Towards Monosemanticity
+Added sources/monosemanticity.md. Created entities/anthropic.md,
+concepts/sparse-autoencoder.md. Started synthesis/interpretability-overview.md.
+No contradictions (first source).