LLM Wiki Manager

LLM wiki kit

Created by sametbrr

Published in sametbrr/llm-wiki-manager. Publisher page

73 GitHub starsUpdated 2026-11-02

What it is

Agent Skills plugin for a persistent LLM-managed markdown wiki — ingest, cross-reference, cited queries and lint with 5 stdlib scripts

— the description by sametbrr

AutoGineer overview, from the brain’s own files

LLM Wiki Manager is an agent skill and plugin designed to implement the Karpathy LLM Wiki pattern. It shifts the paradigm from traditional RAG—where an LLM re-reads raw documents on every query—to a persistent, compounding knowledge base. The system maintains a clear division of labor: the user curates raw source files in a dedicated folder, while the agent manages the wiki layer, handling synthesis, cross-referencing, indexing, and bookkeeping. It includes idempotent Python scripts for maintenance tasks like linting, logging, and schema evolution, ensuring that knowledge remains structured and traceable over time.

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

The system organizes data into a three-layer model: a schema file for conventions, a raw folder for immutable source documents, and a wiki folder for synthesized content. The agent uses a set of Python scripts to manage this structure. When a user provides a source, the agent ingests it, summarizes the content, updates entity and concept pages, and logs the action. It supports advanced operations like semantic updates to propagate changes across multiple pages, automated health checks that generate dated reports, and multi-wiki routing to bridge project-specific and global knowledge bases.

Folders
Folder	Role	Files
.github	agent-config	2
skills	agent-instructions	27
tests	tests	1
.claude-plugin	folder	1
.codex-plugin	folder	1

The agent reads

CLAUDE.md evidence: README.md

The agent writes

Requirements

Works with: Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Kiro, OpenCode, Amp, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

Download the brain as a ZIP and unzip it where you keep your notes or project: https://mp-staging.autogineer.com/agent-brains/sametbrr/llm-wiki-manager/download
Claude Code reads CLAUDE.md from this folder automatically.
cd llm-wiki-manager && claude
AutoGineer scanned these files at commit 28ad285.
Created by sametbrr. Published in sametbrr/llm-wiki-manager. Licence: MIT License.

Usage

AutoGineer overview, from the brain’s own files

Bootstrap a new wiki environment in a research folder.
Ingest PDF or text documents into the wiki.
Query the wiki for synthesized answers with citations.
Perform semantic updates to propagate information changes across the wiki.
Run automated health checks to identify broken links or orphan pages.
Route knowledge between project-specific and global wikis.

“Set up an LLM wiki here. Topic: history of nutrition science.”: The agent scaffolds the raw/ and wiki/ folders and initializes the schema file.
“Add this PDF to the wiki.”: The agent reads the source, writes a summary, updates relevant entity pages, and logs the ingestion.
“Smith 2024 supersedes Keys 1980, update the wiki.”: The agent performs a semantic sweep across all pages to update the superseded claim and logs the change.
“Lint the wiki.”: The agent runs a health check, generates a dated report in the reports folder, and updates the index.

Documentation by sametbrr

Image: Release Image: License: MIT Image: Agent Skills

Quick Start • Installation • Usage • Update mode • Multi-wiki • Compatibility

LLM Wiki Manager

An Agent Skill and plugin for Claude Code and Codex for building and maintaining a personal LLM-managed wiki — a persistent, compounding knowledge base where the LLM does all the writing, cross-referencing, and bookkeeping while you curate sources and ask questions.

🇹🇷 Türkçe için README.tr.md

Quick Start

claude plugin marketplace add sametbrr/skill-hub && claude plugin install llm-wiki-manager@skill-hub   # Claude Code
codex plugin marketplace add sametbrr/skill-hub && codex plugin add llm-wiki-manager@skill-hub         # Codex

Start a new session in your research folder:

mkdir ~/research/my-topic && cd ~/research/my-topic && claude   # or: codex
> "Set up an LLM wiki here. Topic: history of nutrition science."

Features

Instead of RAG — where the LLM rediscovers answers from raw documents on every query — this pattern has the LLM compile raw sources into a persistent, interlinked markdown wiki. Each new source enriches existing pages. Cross-references are built eagerly. Contradictions are flagged. Knowledge compounds over time.

Implements Karpathy's LLM Wiki pattern as a full agent skill with 9 operating modes (including multi-wiki routing and migrate), 5 idempotent Python scripts, 8 page templates, and 11 reference documents.

Without this pattern          With this pattern
────────────────────          ──────────────────
Query 1 → re-read 50 docs     Query 1 → read compiled wiki (already synthesized)
Query 2 → re-read 50 docs     Query 2 → read updated wiki (cross-refs already there)
Query 3 → re-read 50 docs     Query 3 → read updated wiki (contradictions already flagged)

Requirements

Claude Code, OpenAI Codex, or any agentskills.io-compatible agent
Python 3.9+ (stdlib only, for the 5 included scripts — no pip install needed)

Installation

Option 1 — Claude Code plugin (recommended)

claude plugin marketplace add sametbrr/skill-hub
claude plugin install llm-wiki-manager@skill-hub

Option 2 — Codex plugin

codex plugin marketplace add sametbrr/skill-hub
codex plugin add llm-wiki-manager@skill-hub

Option 3 — GitHub CLI, any agent (gh CLI with gh skill)

gh skill install sametbrr/llm-wiki-manager llm-wiki-manager --agent claude-code --scope user   # or --agent codex

Option 4 — manual copy: copy skills/llm-wiki-manager/ into ~/.claude/skills/ or ~/.agents/skills/.

After installing, start a new session. The skill loads automatically when relevant.

Usage

The skill auto-detects which mode applies from natural language. No slash commands needed.

> "Set up an LLM wiki here"                             # Bootstrap: scaffold raw/, wiki/ and the schema file
> "Add this PDF to the wiki"                            # Ingest: summarize, cross-reference, index, log
> "What does the wiki say about X?"                     # Query: answer with citations, offer to file back
> "Smith 2024 supersedes Keys 1980, update the wiki"    # Update: sweep every page that paraphrases the claim
> "Lint the wiki"                                       # Lint: dated health report in wiki/reports/
> "We should always do X going forward"                 # Schema-evolve: record a convention for future sessions
> "Add this to my global wiki"                          # Multi-wiki: route between project and global wiki
> "How does this pattern work?"                         # Teach: explain the pattern and compare it with RAG

Modes

Mode	Trigger examples	What happens
Bootstrap	"Set up a wiki", "start a knowledge base here"	Scaffolds `raw/`, `wiki/` and the schema file (`AGENTS.md` + a `CLAUDE.md` pointer) from templates
Ingest	"Add this PDF to the wiki", "I just read X, file it"	Reads source → writes summary → updates entity/concept pages → indexes → logs
Query	"What does the wiki say about X?", "Compare X and Y"	Reads index → candidate pages → synthesizes answer with citations → offers to file back
Update	"Smith 2024 supersedes Keys 1980, update the wiki"	Semantic sweep across all pages → diff-before-write per page → single log entry
Lint	"Health check the wiki", "anything broken?"	Runs `lint_wiki.py` → auto-saves `wiki/reports/lint-YYYY-MM-DD.md` → auto-tracks in index and log
Schema-evolve	"We should always do X going forward"	Updates the schema file (`AGENTS.md` / `CLAUDE.md`) so future sessions inherit the convention
Multi-wiki	"Add this to my global wiki", "promote this page to global"	Routes between project wiki and global wiki using the `External Wiki:` declaration in project `CLAUDE.md`
Teach	"How does this pattern work?", "explain the LLM wiki idea"	Explains the pattern, compares with RAG, walks through a concrete example

Full walkthrough

# 1. Go to your research folder
mkdir ~/research/my-topic && cd ~/research/my-topic && claude

# 2. Bootstrap the wiki
> "Set up an LLM wiki here. Topic: history of nutrition science."

# 3. Drop a source
cp ~/Downloads/pollan-2008.pdf raw/

# 4. Ingest it
> "Ingest Pollan's In Defense of Food"

# 5. Ask questions
> "What does the wiki say about nutritionism?"

# 6. Health check (auto-saves dated report to wiki/reports/)
> "Lint the wiki"

The three-layer model

your-wiki/
├── AGENTS.md          # Schema — conventions for this wiki (co-evolved over time)
├── CLAUDE.md          # One line: @AGENTS.md (Claude Code reads CLAUDE.md, Codex reads AGENTS.md)
├── raw/               # YOUR layer — immutable sources you curate. LLM reads, never writes.
└── wiki/              # LLM layer — all pages written and maintained by the LLM
    ├── index.md       # Content catalog (updated on every ingest)
    ├── log.md         # Append-only operation log (greppable)
    ├── hot.md         # Hot cache — most recently ingested sources and active references
    ├── sources/       # One summary page per ingested source
    ├── entities/      # People, organizations, places, products
    ├── concepts/      # Ideas, theories, frameworks, terms
    ├── notes/         # Filed-back query answers and loose pages
    └── reports/       # Auto-generated dated lint reports (wiki/reports/lint-YYYY-MM-DD.md)

Division of labor:

You do	The LLM does
Curate sources (decide what to read)	Read sources end-to-end
Ask questions, steer direction	Write summaries, entity and concept pages
Review the wiki, follow links	Update cross-references in-place
Decide what matters	Maintain index.md and log.md
Own `raw/`	Flag contradictions, surface gaps

You almost never write wiki pages by hand. The LLM does the bookkeeping — that's what makes the wiki compound instead of collapse.

Core disciplines

LLM owns wiki/. You own raw/. No exceptions.
Every operation logs to log.md via append_log.py. Greppable: grep "^## \[" log.md | tail -20
Every new or updated page touches index.md via update_index.py. Stale index = wiki that feels lost.
Cross-reference aggressively. When a source mentions an entity that already has a page, update that page. Don't leave connections implicit.
Cite back to raw/. Every claim is traceable to a specific source file.
Flag contradictions, don't overwrite. New source disagrees with old claim? Both stay, marked with their source, with a > [!warning] Sources disagree callout.
Schema lives in CLAUDE.md. When a convention works, write it down. The next session starts informed.

What's inside

Scripts (Python stdlib, no dependencies, all idempotent)

Script	Purpose
`scripts/init_wiki.py`	Scaffold a new wiki — creates `raw/`, `wiki/`, the schema file (`AGENTS.md` + `CLAUDE.md` pointer, or keeps an existing one), `index.md`, `log.md`, and `hot.md`. Idempotent.
`scripts/append_log.py`	Append a `## [YYYY-MM-DD] action \| title` entry to `log.md`. Supports flexible log path detection.
`scripts/update_index.py`	Add or update an entry under a category in `index.md`. Case-insensitive categories, keeps section order and content, follows the index link style (markdown or `[[wikilinks]]`), new categories go before `## Meta`.
`scripts/lint_wiki.py`	Health check. Detects orphan pages, broken links and index drift in both standard markdown and Obsidian wiki-link format (`[[page#heading]]`, `![[embed.png]]` included). Default: writes `wiki/reports/lint-<today>.md` and auto-tracks. Run `--stdout` for terminal output.
`scripts/migrate_wiki.py`	Schema upgrade (v1 → v2). Deduplicates `index.md`, moves dated changelog blocks from `hot.md` into `log.md`, stamps the schema version. Idempotent.

Templates

Template	Used for
`wiki-CLAUDE.md.tmpl`	The schema file dropped into a fresh wiki
`source-summary.md.tmpl`	One ingested source — claims, methodology, cross-links, open questions
`entity-page.md.tmpl`	People, organizations, places, products
`concept-page.md.tmpl`	Ideas, frameworks, theories, terms
`comparison-page.md.tmpl`	"X vs Y" pages, often filed-back query answers
`index.md.tmpl`	Initial content catalog
`log.md.tmpl`	Initial log with bootstrap entry
`hot.md.tmpl`	Initial hot cache — rewritten after each ingest with latest sources and active references

Reference docs

Eleven detailed workflow documents in references/: philosophy.md · architecture.md · bootstrap-workflow.md · ingest-workflow.md · query-workflow.md · update-workflow.md · lint-workflow.md · migrate-workflow.md · schema-design-guide.md · multi-wiki-routing.md · teaching-mode.md

The skill reads these selectively — you don't need to. They're there to give the LLM depth on each mode.

Update mode

Standard ingest already handles contradictions on a single page (Disputes section). Update mode is for when a new source supersedes a claim that's paraphrased across multiple pages — the same idea written four different ways in four different files.

Scenario: Smith 2024 reanalysis shows Keys 1980's seven-countries study cherry-picked data.
The Keys r=0.87 claim appears as:
  concepts/saturated-fat.md     → "Keys found r=0.87 across seven countries"
  entities/ancel-keys.md        → "famous for showing strong correlation"
  concepts/heart-disease.md     → "saturated fat is a primary driver per Keys"
  concepts/dietary-policy.md    → "the saturated fat hypothesis drove decades of policy"

Update mode:
  1. Semantic sweep — finds all four (grep won't, LLM will)
  2. Shows scope: "4 pages affected. Proceed?"
  3. Diff-before-write per page — y/n/skip/edit per change
  4. Per-page strategy: revise / disputes / annotate (not one-size-fits-all)
  5. One log entry tying all four edits to Smith 2024

This is change propagation, not change tracking. The log and frontmatter track what was edited. Update mode ensures the edit reaches everywhere it should.

Auto-dated lint reports

lint_wiki.py with no flags:

Writes wiki/reports/lint-YYYY-MM-DD.md (overwrites same-day run — idempotent daily)
Adds a Reports index entry automatically
Appends a lint | Health check log entry automatically
Exits with code 1 if any block-severity issue found (useful for CI)

Reports accumulate as a longitudinal health record. git log wiki/reports/ shows how wiki quality evolved over time.

Override flags: --stdout (terminal, no tracking), --no-track (write file, skip index/log), --report PATH (custom path).

Multi-wiki

Most users start with one wiki. Once you have two — say, a per-project wiki at the working directory plus a long-lived global "second brain" (often an existing Obsidian vault) — the skill routes writes between them based on a single declaration in the project's CLAUDE.md.

~/projects/x-project/          ← active project (current working directory)
├── CLAUDE.md                  ← project schema — declares the global wiki path
├── raw/                       ← project sources
└── wiki/                      ← project wiki

~/Documents/obsidian/          ← global wiki (long-lived, exists across projects)
├── CLAUDE.md                  ← global schema
├── raw/
└── wiki/

One-time setup

Add this to the project's CLAUDE.md (or ask the agent to do it):

## External Wiki

Global knowledge base: ~/Documents/obsidian/

### Routing rules
- Project-specific code decisions, architecture, bugs, configuration → this project's `wiki/`
- Concepts, frameworks, patterns, ideas applicable beyond this project → global wiki
- When in doubt, ask before writing
- Scripts always need `--path` flag pointing to the right wiki root

### Cross-wiki links
- Use absolute paths (`~/...`) when linking from one wiki to the other.
- Never use relative paths that cross wiki boundaries.

Four canonical scenarios

#	Scenario	Trigger	What the agent does
A	Write to global while in a project	"Add JWT refresh rotation to my global wiki"	Reads project `CLAUDE.md` → resolves global path → writes to global, project wiki untouched
B	Pull from global into a project	"What does the global wiki say about rate limiting? Apply it to /api/search"	Reads global pages → synthesizes recommendation → writes a project-specific page that links to the global one (never copies)
C	Promote a page from project to global	"concepts/event-sourcing.md has matured, promote it"	Moves content to global → leaves a one-line redirect stub at the project path → updates both indexes and logs
D	Lint both wikis at once	"Lint both wikis"	Runs `lint_wiki.py --path` against each → reads both reports → returns one summary

Full walkthroughs of all four scenarios in references/multi-wiki-routing.md.

Compatibility

Tool	Install	Schema file it reads
Claude Code	plugin (`claude plugin install llm-wiki-manager@skill-hub`) or `~/.claude/skills/`	`CLAUDE.md`
OpenAI Codex	plugin (`codex plugin add llm-wiki-manager@skill-hub`) or `~/.agents/skills/`	`AGENTS.md`
GitHub Copilot, Cursor, Gemini CLI, …	`gh skill install … --agent <name>`	usually `AGENTS.md`

A wiki that keeps its schema in AGENTS.md with a one-line CLAUDE.md (@AGENTS.md) works in all of them; init_wiki.py sets that up.

Karpathy's LLM Wiki gist — the original idea
agentskills.io — open standard spec

Contributing

Questions and ideas: Discussions
Bugs: issue tracker
Pull requests: read the contribution guide first
Security reports: follow the security policy, not a public issue

License

MIT — see LICENSE.

Report Bug · Request Feature

</div>

skills/llm-wiki-manager/references/lint-workflow.md

Lint Workflow

Use this when the user wants a health check on the wiki. Triggers: "audit the wiki", "lint", "anything broken", "what's stale", or after a long break ("I haven't touched this in a month, what's the state").

Linting is preventive maintenance. Wikis decay quietly — broken links from renamed files, orphan pages no one links to, claims contradicted by later sources but never updated, gaps where a page should exist. The script catches the mechanical problems; the LLM has to spot the substantive ones.

Goal

Produce a short report of issues, organized by severity. Propose fixes. With user approval, apply them. Append a single log entry summarizing the pass.

The full loop

1. Run the lint script

python scripts/lint_wiki.py --path .

By default this writes the report to wiki/reports/lint-<today>.md, then auto-tracks it: adds an entry under the Reports category in wiki/index.md, and appends a single lint | Health check entry to wiki/log.md. Re-running on the same day overwrites the day's report file (idempotent daily) — but each run logs a new entry, so you can see "I lint-checked twice today" in the log.

Useful flags:

--stdout — print to terminal, don't write a file, don't auto-track. For one-off inspection.
--report /custom/path.md — custom path. If the path is outside wiki/, auto-tracking is skipped (treated as one-off external snapshot).
--no-track — write the report file but skip the index/log updates.
--stub-words 30 — change the threshold for stub detection (default 50).
--log-gap-days 60 — change the threshold for log-gap warnings (default 30).
--hot-max-words 900 — change the hot.md bloat threshold (default 700).
--max-tags 5 — change the per-page frontmatter tag limit (default 4).

The report is markdown, organized by severity (block / quality / suggestion). Past reports accumulate in wiki/reports/, giving you a longitudinal view of wiki health — "how was the wiki last month vs now". Git history of wiki/reports/ is the audit trail.

2. Layer in the substantive checks

The script can't see semantics. The LLM has to read the report and add:

Stale claims — pages whose latest cited source is much older than the most recent ingest. The world may have moved.
Unflagged contradictions — pages where two cited sources clearly disagree but no "Disputes" section exists.
Missing pages — entities or concepts mentioned across multiple sources that don't have their own page yet.
Over-thin pages — pages that have one source citation and no synthesis. Often candidates for deletion or merge.
Wiki schema drift — CLAUDE.md says one convention, recent pages use another. Either update CLAUDE.md or fix the pages.

To find these, skim recent source-summary pages and check whether their contents have actually been integrated upstream. Skim the index categories and check that they still match the actual contents.

3. Triage by severity

Organize the report into three buckets:

Block bug — something is actively broken (broken links, index pointing to dead files). Fix without asking.
Quality issue — orphan pages, missing index entries, unflagged contradictions, empty pages. Propose fixes; apply with user approval.
Suggestion — stale claims, missing pages worth creating, schema drift. Surface but don't pressure.

4. Present and propose

Show the user a tight summary, not the full report:

Lint pass over wiki/ (47 pages):
2 broken links in concepts/nutritionism.md (auto-fix incoming)
3 orphan pages — likely belong under concepts/. Want me to link them from related pages?
1 contradiction between sources/keys-1980.md and sources/teicholz-2014.md — concepts/saturated-fat.md doesn't have a "Disputes" section yet. Want me to add one?
Suggestion: entities/marion-nestle.md is mentioned in 4 source summaries but has no page. Want me to create one?

Wait for direction before applying anything beyond the block bugs.

5. Apply approved fixes

Apply changes one bucket at a time. Show what changed. For substantive changes (creating a new page, adding a Disputes section), draft and confirm before saving.

6. Update index and log

After fixes:

# Update index for any new or substantially-changed pages
python scripts/update_index.py --path . --category ... --title ... --page-path ... --summary ...

# One log entry summarizing the pass
python scripts/append_log.py --action lint \
  --title "Health check pass" \
  --details "Fixed 2 broken links. Linked 3 orphans. Added Disputes section to concepts/saturated-fat.md. Created entities/marion-nestle.md (4 sources)."

Cadence

After every 5-10 ingests is reasonable.
After a long break (more than a month).
Before sharing the wiki with someone else.
Whenever the wiki "feels" off — usually a sign it actually is.

The user will rarely ask for it on schedule. It's worth proactively suggesting after a few ingests if it hasn't happened: "Your wiki has grown by ~12 pages since the last lint. Want me to do a pass?"

What the lint script catches

scripts/lint_wiki.py is intentionally conservative — it only flags things that are mechanically clear. The full check list:

Check	What it does	Severity
`broken_links`	Markdown links and `[[wiki-links]]` to non-existent files within the wiki	block
`index_missing`	Pages that exist but aren't in `wiki/index.md` (reads both `[markdown](links)` and `[[wiki-links]]` in the index)	quality
`index_dead`	Index entries pointing to deleted files	block
`orphans`	Pages with zero inbound links (checks both `[markdown](links)` and `[[wiki-links]]`)	quality
`stub_pages`	Pages under ~50 words	quality
`raw_missing`	Wiki pages citing `raw/` files that don't exist	block
`log_gaps`	Stretches of >30 days with no log entry, in an otherwise active wiki	suggestion
`slug_mismatch`	Filenames not conforming to `CLAUDE.md` slug convention	quality
`index_duplicates`	The same page listed more than once in the index (one page = one entry)	quality
`hot_health`	`hot.md` over the word threshold or accumulating dated `## [...]` changelog blocks	quality
`overtagged`	Pages with more frontmatter tags than the limit	quality
`single_use_tags`	Tags appearing on exactly one page (keywords, not classifiers)	suggestion
`wikilink_collisions`	`[[slugs]]` matching more than one file (silent ambiguity)	quality
`schema_version`	Wiki's `schema_version` stamp behind what the skill expects — points to `migrate_wiki.py`	suggestion

The thresholds (50 words, 30 days, 700 hot words, 4 tags) are tunable via flags — see --help.

Consciously ignored findings: if the wiki's CLAUDE.md has a "Lint exceptions" section, findings on the files/slugs listed there are expected — report them but don't propose fixes. When the user repeatedly dismisses the same finding, propose adding it to that section (schema-evolve).

What the lint script does not catch

Anything semantic. The LLM is responsible for:

Stale claims
Unflagged contradictions
Missing pages on cross-cutting entities
Schema drift between CLAUDE.md and actual practice
Pages that exist but say nothing useful

These require reading the wiki. The lint script just gives you a starting point.

Heuristics

Block bugs first, fix without asking. Broken links and dead index entries are pure damage.
Don't auto-fix orphans. An orphan page might genuinely be unused (delete) or a future-relevant page (link from somewhere). Ask.
Don't create suggested pages on autopilot. The user might have reasons for not wanting them.
Suggest schema updates when patterns emerge. If three lint passes in a row found the same kind of problem, the schema needs to evolve.

Common mistakes

Treating the script's output as the whole job. The script is the floor, not the ceiling. Layer in semantic checks.
Skipping user approval on substantive changes. Autonomous edits to substantive content erodes trust. Block bugs only.
Logging the lint as if nothing happened. The log entry should say what was found and what was fixed — that becomes useful audit trail later.

40 files

Advantages

Compounding knowledge base that synthesizes information rather than re-reading raw documents on every query. evidence: README.md
Automated bookkeeping and cross-referencing reduce manual maintenance effort. evidence: README.md
Idempotent scripts ensure reliable operations without external dependencies. evidence: README.md

Limitations

Requires strict adherence to the division of labor between the raw source folder and the LLM-managed wiki folder. evidence: README.md
Multi-wiki routing requires manual configuration of paths in the schema file. evidence: README.md

Security

Risk level: No risk found

This brain runs

Agent instructions that run or fetch something (8)

AGENTS.md: `tests/test_scripts.py`: functional tests that run every script against temp wikis.
AGENTS.md: `python3 -m unittest discover -s tests`
AGENTS.md: Codex: install from a local marketplace in an isolated `CODEX_HOME`;
skills/llm-wiki-manager/SKILL.md: Run them by path relative to this skill's directory, and always pass `--path <wiki-root>`.
skills/llm-wiki-manager/SKILL.md: If it is lower than the version this skill expects, offer one sentence before starting the requested work: *"This wiki is at schema v1, the skill expects v2 — run `scripts/migrate_wiki.py` first?"* Don't block the requested operation if the user declines;
skills/llm-wiki-manager/SKILL.md: If the section is missing and a multi-wiki operation is requested, **run Schema-evolve first** to add it, then proceed.
skills/llm-wiki-manager/SKILL.md: Some users run two wikis: a per-project wiki at the working directory and a long-lived global wiki (often an existing Obsidian vault) at a fixed path.
skills/llm-wiki-manager/SKILL.md: unstamped = v1), shows a **dry-run** of the mechanical steps plus the manual (LLM) steps, applies with `--apply` only.

Attribution and licence

Created by

sametbrr

Declared authors

sametbrr (declared in .claude-plugin/plugin.json)

Publisher

Samet Birer (Community)

Source

sametbrr/llm-wiki-manager · commit 28ad285

Licence

MIT License (files served here)

ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-12

AutoGineer is not affiliated with or endorsed by sametbrr.

Download

The ZIP holds the files AutoGineer serves, with ATTRIBUTION.md and the licence. Download llm-wiki-manager.zip

What it is

How it works

Requirements

Set it up

Usage

Documentation by sametbrr

LLM Wiki Manager

Quick Start

Features

Requirements

Installation

Usage

Modes

Full walkthrough

The three-layer model

Core disciplines

What's inside

Scripts (Python stdlib, no dependencies, all idempotent)

Templates

Reference docs

Update mode

Auto-dated lint reports

Multi-wiki

One-time setup

Four canonical scenarios

Compatibility

Related

Contributing

License

Lint Workflow

Goal

The full loop

1. Run the lint script

2. Layer in the substantive checks

3. Triage by severity

4. Present and propose

5. Apply approved fixes

6. Update index and log

Cadence

What the lint script catches

What the lint script does not catch

Heuristics

Common mistakes

Advantages

Limitations

Security

This brain runs

Attribution and licence

Download