Generated banner for Zissa Wiki
Generated logo for Zissa Wiki

Zissa Wiki

LLM wiki kit

First committed by MetamusicX

Published in MetamusicX/zissa-wiki. Publisher page

62 GitHub stars

What it is

Zissa Wiki — an LLM-maintained research knowledge base in plain markdown, maintained by any AI agent (Claude, Codex, Gemini, DeepSeek, Kimi, Grok, Mistral or any chat app). Implements Karpathy's LLM Wiki pattern; checks every quote against its source.
— the description by MetamusicX

AutoGineer overview, from the brain’s own files

Zissa Wiki is a research-oriented knowledge base designed to compound knowledge over time. It implements the LLM Wiki pattern, where an AI agent maintains a structured, interlinked set of markdown files rather than relying on transient RAG. The system separates immutable source material in raw/ from the agent-maintained wiki/ layer. It includes deterministic tooling for quote verification, link checking, and graph visualization, ensuring that the knowledge base remains accurate and verifiable. It is designed to be model-agnostic, working with any AI agent capable of following the provided schema.

How it works

Memory model: LLM wiki

AutoGineer overview, from the brain’s own files

The system organizes information into three layers: raw sources (immutable files like PDFs or transcripts), the wiki (agent-maintained markdown pages including concepts, authors, and syntheses), and the schema (templates and rules). When a user adds a source to the raw/ folder, the agent ingests it, creates a source note, and updates relevant wiki pages. The system uses a Python script to perform deterministic checks, such as verifying that every direct quote in the wiki matches the source text exactly, checking for broken links, and ensuring frontmatter consistency.

Folders
FolderRoleFiles
.claudeagent-config5
.githubagent-config5
archivearchive1
rawraw-sources8
scriptsscripts2
templatestemplates8
teststests1
wikiwiki8
.githooksfolder1
conversationsfolder1
outputsfolder4

The agent reads

The agent writes

Requirements

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

Set it up

  1. This brain runs code automatically: 1 hook (claude-code), 1 script. Review .claude/settings.json, .githooks/pre-commit before opening the folder in Claude Code. No step below turns a hook on for you.

    • .claude/settings.json: python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/lint_gate.py"
    • .githooks/pre-commit: runs on git pre-commit
  2. Clone the repository at the commit AutoGineer scanned:

    git clone https://github.com/MetamusicX/zissa-wiki.git && cd zissa-wiki && git checkout 8119876380f3f6971b321ecf56a7ee347d3b3268
  3. Claude Code reads CLAUDE.md from this folder automatically.

  4. cd zissa-wiki && claude

  5. AutoGineer scanned these files at commit 8119876.

  6. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/MetamusicX/zissa-wiki/blob/8119876380f3f6971b321ecf56a7ee347d3b3268/README.md#quickstart
  7. First committed by MetamusicX. Published in MetamusicX/zissa-wiki. Licence: MIT License.

Usage

AutoGineer overview, from the brain’s own files

  • Ingesting new research papers or notes to update the knowledge base.
  • Querying the wiki to synthesize information across multiple sources.
  • Linting the wiki to ensure structural integrity and link validity.
  • Visualizing the research graph to identify connections between concepts and authors.
  • Generating research deliverables like essays or slides from wiki content.
“ingest raw/articles/smith-2020.pdf”
The agent reads the source, discusses key claims, creates a source note, updates related concept pages, and runs a verification check.
“python3 scripts/wiki.py graph --around individuation”
Generates a Mermaid diagram showing the connections between the concept 'Individuation' and related authors, sources, and syntheses.

Documentation by MetamusicX

Zissa Wiki

A research wiki that writes itself as you read, and checks its own quotes.

Image: wiki checks Image: release Image: license: MIT Image: python 3.9+ Image: works with any LLM agent

Zissa Wiki is a personal knowledge base for academic research, kept in plain markdown and maintained by the AI agent of your choice: Claude Code, Codex, Gemini CLI, Cursor, an open-source agent running DeepSeek, Kimi, Qwen or Mistral, or a plain chat window in ChatGPT, Grok, Le Chat or DeepSeek. You drop a source into raw/ and say ingest. The agent reads it, writes a source note, and updates every concept, author, debate and project page the source touches. Every direct quote is then checked, word for word, against the file it came from.

It implements Andrej Karpathy's LLM Wiki pattern: rather than re-deriving knowledge from raw documents on every question (RAG), the model builds a persistent, interlinked wiki that compounds with each source. No database, no embeddings, no plugins.

Part of the Zissa family of open, agent-driven tooling, a sibling to Zissa Agent Orchestra. (Formerly llm-research-wiki; old links still redirect.)

Quickstart

git clone https://github.com/MetamusicX/zissa-wiki.git my-wiki
cd my-wiki
git config core.hooksPath .githooks     # optional: refuse commits that break links or misquote

Then open the folder in your agent (claude, codex, gemini, Cursor…), or use a chat app as described below.

  1. Fill in the Domain Context at the end of AGENTS.md: your research areas and key thinkers.

  2. Write a 2–3 page research map in your own words, save it as raw/notes/research-map.md, and say "ingest raw/notes/research-map.md". This seeds the wiki with your conceptual framework.

  3. Add real sources one at a time ("ingest raw/articles/<file>.pdf"), and supervise the first 5–10 closely.

  4. Ask research questions in plain language, and say "lint" every 10–15 ingests.

Works with any model

The schema lives in AGENTS.md, the cross-tool convention for agent instructions. Nothing in it depends on one vendor, and scripts/wiki.py never calls a model: it only reads and checks files. So the wiki is portable. Switch models whenever you like, and the pages, rules and checks stay the same.

You useStart withIt reads the schema from
Claude Codeclaude, then /ingest, /query, /lintCLAUDE.md, which imports AGENTS.md
Codex CLI (OpenAI)codex, then "ingest raw/…"AGENTS.md
Gemini CLIgemini, then "ingest raw/…"GEMINI.md, which imports AGENTS.md
Cursor, GitHub Copilot agent and other IDE agentsthe agent chat, "ingest raw/…"AGENTS.md
Any model through an open-source agent, e.g. OpenCode with DeepSeek, Kimi, Qwen, Grok, Mistral or a local modelthe agent, "ingest raw/…"AGENTS.md
A chat app: ChatGPT, Grok, Le Chat, DeepSeek, Kimi, Claude.ai…wiki.py prompt, paste, then wiki.py applythe prompt itself

Tested end to end with Claude Code, Codex CLI and, through the chat-app route, a Mistral model: each ingest produced well-formed pages that passed wiki.py check.

In any chat app

A chat app can't open your files, so wiki.py carries them across. prompt bundles the schema, the page templates, index.md, the relevant wiki pages and the full source text into one message. apply writes the model's reply back into the wiki and checks it:

python3 scripts/wiki.py prompt ingest raw/articles/smith-2020.pdf | pbcopy   # 1. copy the prompt
#   2. paste it into the chat, discuss the takeaways, say "go",
#      then copy the one code block the model replies with
pbpaste | python3 scripts/wiki.py apply                                     # 3. write the pages, then check

If apply finds a broken link or a misquote, paste its report back into the chat, ask for corrected files, and apply again. prompt query "…" and prompt lint work the same way. When the wiki outgrows the model's context window, prompt includes the pages most relevant to the source or question: set the size with --budget, and force a page in with --include. On Linux use xclip -selection clipboard (and xclip -o); on Windows, clip and Get-Clipboard.

How it works

%%{init: {"flowchart": {"wrappingWidth": 400}}}%%
flowchart LR
    you(["You"])
    agent["<b>Your agent</b><br/>Claude · Codex · Gemini · any chat app<br/>follows AGENTS.md"]
    tool["<b>scripts/wiki.py</b><br/>check · lint · quotes · graph · move"]

    subgraph RAW["raw/ · you add"]
        src[("Sources<br/>PDF · EPUB · notes<br/>transcripts · images")]
    end
    subgraph WIKI["wiki/ · the agent writes"]
        sn["Source notes"]
        pages["Concepts · Authors · Debates<br/>Methods · Themes · Projects"]
        syn["Syntheses"]
    end
    subgraph NAV["navigation"]
        idx["index.md<br/>concept clusters"]
        log["log.md<br/>every change"]
    end

    you -- "add a source" --> src
    you -- "ask" --> agent
    src -. "read, never modified" .-> agent
    agent --> sn & pages & syn
    agent --> idx & log
    agent -- "check before finishing" --> tool
    tool -. "errors to fix" .-> agent

    classDef ai fill:#fbe7df,stroke:#d97757,color:#1f2328
    classDef det fill:#e2e8f0,stroke:#475569,color:#1f2328
    class agent ai
    class tool det
LayerContentsWho writes it
raw/Immutable sources: articles, books, chapters, notes, transcripts, annotations, imagesYou
wiki/Interlinked markdown pages: source notes, concepts, authors, debates, syntheses, projectsThe agent
schemaAGENTS.md (the rules), templates/ (one per page type), index.md (clusters), log.md (history)You and the agent

Raw sources are read once and never modified. The wiki is the layer that answers questions.

The three workflows

The rules live in AGENTS.md, which your agent loads at the start of every session. You start each workflow in plain language ("ingest …", a question, "lint"). In Claude Code they are also slash commands.

Ingest: one source in, 10–15 pages updated
sequenceDiagram
    actor You
    participant C as Your agent
    participant W as wiki/ · index · log
    participant T as wiki.py

    You->>C: ingest raw/articles/smith-2020.pdf
    C->>C: read the source in full
    C-->>You: central argument, key claims, pages it will touch
    You->>C: go ahead
    C->>W: write the source note
    C->>T: quotes smith-2020-….md
    T-->>C: p. 45 — the source reads "tensions", not "energies"
    C->>W: fix the quote against the source
    par one subagent per page
        C->>W: concept, author, debate and project pages
    end
    C->>W: index.md and log.md
    C->>T: check (lint + quotes)
    T-->>C: 0 errors
    C-->>You: 12 pages created or updated

The agent discusses the source with you before writing anything. It reads each page template only when it is about to write that kind of page. If your tool supports subagents, a large ingest can hand independent page updates to them in parallel.

Query: answers from the wiki, at constant cost
%%{init: {"flowchart": {"wrappingWidth": 400}}}%%
flowchart LR
    q(["Your question"]) --> idx["index.md<br/>find the cluster"]
    idx --> has{"Synthesis for<br/>this cluster?"}
    has -- yes --> syn["Read the synthesis"]
    has -- no --> core["Read the core pages"]
    syn --> rel["Follow <code>related:</code><br/>to neighbours"]
    core --> rel
    rel --> ans(["Answer, citing<br/>wiki pages"])
    ans -. "worth keeping?" .-> save["Save as a<br/>new synthesis"]

A flat index gets slow past ~50 pages. So queries run a three-step cascade:

  1. Concept clusters. index.md groups concepts into 4–6 thematic clusters per domain, and a query picks its cluster first.

  2. Synthesis pages. A cluster's pre-digested overview in wiki/syntheses/. One page read instead of six.

  3. related: fields. Every concept and author page lists its 3–5 closest neighbours, so the agent can move between pages without re-scanning the index.

Each step narrows the reading set, which keeps query cost roughly constant at 100+ pages.

Lint: the tool is the hands, the agent is the head

Mechanical checks run as deterministic Python; judgement checks are left to the agent. The result is one prioritised list, and nothing is fixed without your say.

wiki.py checks, exactly and for freeThe agent judges, by reading
broken links, orphan pages, index driftduplicate pages
missing or invalid frontmattercontradictions between pages
oversize pages, thin source supportstale pages that new sources should have touched
misquotes against the raw file, and wrong page numbersweak or generic pages

Quotes you can trust

AGENTS.md tells the agent never to invent a citation. wiki.py quotes enforces it. For each source note it finds the linked raw file (PDF, EPUB, DOCX, HTML, markdown, text) and checks that every quote appears in it. Only the letters are compared, so PDF extraction noise, ligatures and line-end hyphens don't count as differences. When a quote has drifted, it tells you exactly where:

✗ ERROR (1)
  wiki/source-notes/x-2020.md:14  [quote-differs] departs from the source at
  “…ndividual is a reservoir of energies”; the source reads “…dividual is a reservoir of tensions.”

It also catches omissions made without an ellipsis, dropped in-text citations, and page numbers that don't hold the passage. It reads the page numbers printed in the PDF, so book pages and PDF pages don't get confused.

See your wiki

wiki.py graph draws the wiki, or the neighbourhood of one page, as a Mermaid diagram. That renders on GitHub, in Obsidian, and inside any wiki page:

python3 scripts/wiki.py graph --around individuation
flowchart LR
    n0(["Gilbert Simondon"])
    n1(["Gilles Deleuze"])
    n2("Difference in itself")
    n3("Individuation")
    n4("Metastability")
    n5("Preindividual")
    n6("Transduction")
    n7[["Deleuze 1968 — Difference and Repetition"]]
    n8[["Simondon — L'individuation"]]
    n9[/"Individuation from Simondon to Deleuze"/]
    n0 --> n3
    n2 --> n3
    n3 --> n5
    n3 <--> n6
    n3 <--> n7
    n3 <--> n8
    n9 --> n3
    n1 -.- n3
    n4 -.- n3
    classDef author fill:#fce7f3,stroke:#db2777,color:#1f2328
    class n0,n1 author
    classDef concept fill:#dbeafe,stroke:#3b82f6,color:#1f2328
    class n2,n3,n4,n5,n6 concept
    classDef source_note fill:#f1f5f9,stroke:#64748b,color:#1f2328
    class n7,n8 source_note
    classDef synthesis fill:#dcfce7,stroke:#16a34a,color:#1f2328
    class n9 synthesis
    style n3 stroke-width:3px

<sub>Shapes and colours by page type: concepts rounded blue, authors pill-shaped pink, source notes grey, syntheses green. Solid arrows are links; dotted lines are related: entries. --depth 2 goes a hop further; --all-edges adds the links between neighbours. Illustrative demo pages.</sub>

The wiki is plain markdown with relative links, so the folder also opens as an Obsidian vault as it is, graph view included.

Tools

scripts/wiki.py is a single-file, zero-dependency Python tool (3.9+). Full reference: scripts/README.md.

CommandWhat it does
python3 scripts/wiki.py checkThe finishing check: lint errors, plus quotes in every changed source note.
python3 scripts/wiki.py lintLinks, orphans, index drift, frontmatter, size, thin support. Exits nonzero on any error.
python3 scripts/wiki.py quotes [NOTE]Every direct quote against its raw file, plus page numbers.
python3 scripts/wiki.py graph [--around PAGE]The wiki's link graph as a Mermaid diagram.
python3 scripts/wiki.py move OLD NEWRenames a page and rewrites every link and related: entry pointing to it.
python3 scripts/wiki.py prompt ingest|query|lintBundles a workflow into one message for any chat app.
python3 scripts/wiki.py applyWrites a chat model's reply into the wiki, then runs check.

The finishing check runs whichever agent you use:

  • Every agent runs wiki.py check as the last step of each ingest; AGENTS.md requires it.

  • A git pre-commit hook (.githooks/pre-commit) refuses any commit whose wiki changes break a link or misquote a source, no matter which agent (or person) made them. Turn it on once per clone with git config core.hooksPath .githooks.

  • GitHub Actions (.github/workflows/wiki.yml) checks every push to your fork.

  • wiki.py apply checks everything a chat model sends back.

  • In Claude Code, a Stop hook (.claude/hooks/lint_gate.py) runs the check before Claude finishes a task and sends it back to fix what fails.

Folder structure

raw/                  your sources — immutable
  articles/  books/  chapters/  notes/  annotations/  transcripts/  images/  _staging/
wiki/                 written by the agent
  concepts/  authors/  debates/  themes/  methods/  syntheses/  source-notes/  projects/
templates/            one template per page type, read on demand
outputs/              finished deliverables: essays/  slides/  handouts/  tables/
archive/              superseded pages
conversations/        saved sessions
.githooks/            pre-commit: the finishing check on every commit
.claude/              Claude Code extras: /ingest /query /lint, the Stop hook
scripts/wiki.py       check · lint · quotes · graph · move · prompt · apply
conventions.toml      the machine-checkable rules the tool reads
AGENTS.md             the schema — "the law of the wiki", for every agent
CLAUDE.md, GEMINI.md  one-line imports of AGENTS.md for Claude Code and Gemini CLI
index.md · log.md     navigation and history

Page types

TypeLocationPurpose
Source notewiki/source-notes/One per ingested source: summary, key claims, verified quotes, connections
Conceptwiki/concepts/Definition, key thinkers, related concepts, source support
Authorwiki/authors/Bio, key works, concepts, relevance to your research
Debatewiki/debates/Framed positions, key texts, current state
Synthesiswiki/syntheses/Evolving argumentative overview of a cluster
Projectwiki/projects/<name>/Your active research or writing projects
Method · Themewiki/methods/ · wiki/themes/Research methods; clusters that exceed one concept

Optionally, every claim can carry an epistemic marker: [W] for the wiki's own synthesis across sources, [P] for your research position, [?] for the uncertain, and none for a claim a named source makes. The markers keep "what the source says" apart from "what I argue". They are off by default; see Epistemic Markers in AGENTS.md to switch them on.

Each type has a template in templates/ with YAML frontmatter (title, type, tags, related, created, updated). The agent reads a template only when it is about to write that kind of page, so the always-loaded AGENTS.md stays lean.

Scaling advice

  • Start with your own research map as the first ingest. It seeds the wiki with your framework.

  • Ingest one source at a time for the first 10–15, and supervise the quality.

  • Don't ingest your whole library, only what matters to your active projects. raw/_staging/ is a holding pen: review it weekly.

  • Lint every 10–15 ingests.

  • Create the first synthesis when a cluster has 4+ sources and keeps coming up in queries.

  • At ~50 sources the wiki becomes a genuine research tool; at ~100 it's indispensable.

Template vs. live wiki

This repository is the template, the unspecialised seed: placeholder Domain Context, empty raw/ and wiki/. Fork it and make it yours. Please keep your own research content in your fork rather than opening PRs with it here; see CONTRIBUTING.

My own working wiki is a separate version specialised to my research (Continental philosophy of science, new music studies, posthuman music). It uses the same schema, workflows and templates, plus a populated Domain Context and project folders.

Two adjacent systems in my setup share this DNA but serve other ends. The MetamusicX wiki builds atomic entities from research-meeting transcripts, and Alluvium turns daily journals into PARA-organised atomic notes. This template is the academic-research variant.

Requirements

  • An AI agent: any from the table above, or just a chat app

  • Python 3.9+ for scripts/wiki.py: recommended for the checks, and required for the chat-app route (the wiki itself is pure markdown)

  • poppler's pdftotext so wiki quotes can read PDFs (optional; brew install poppler / apt install poppler-utils)

Credits

See CHANGELOG for what's new. MIT licensed.

AGENTS.md

AGENTS.md — Research Wiki Schema

This file is the operational backbone of the Research Wiki. Read it in full at the start of every session. It defines who you are, how this wiki is structured, and exactly how to behave.

It is written for any AI agent: Claude, GPT/Codex, Gemini, Grok, Mistral, DeepSeek, Kimi, Qwen, a local model. Nothing here depends on one vendor. Where a tool offers extras (slash commands, hooks), they only automate what this file already asks for.


Identity

You are the Research Wiki agent. Your job is to maintain, grow, and query a structured knowledge base for the researcher who owns this wiki. You are not a general-purpose assistant in this context — you are a dedicated research intelligence system. You read sources, extract knowledge, build and update wiki pages, synthesize across them, and answer research questions from accumulated knowledge rather than from general training.

You are precise, thorough, and consistent. You never invent citations. You never paraphrase in ways that distort meaning. When you are uncertain, you say so. When a source says something surprising or important, you flag it.


Architecture

The wiki has three layers:

Layer 1: raw/ — Immutable source material. Files here are never modified or deleted by the agent. They are the ground truth. All ingested documents live here.

Layer 2: wiki/ — LLM-written markdown. This is the active knowledge base. Every page here is created or updated by the agent. Pages are interlinked, cross-referenced, and kept current as new sources are ingested. This is the primary answer source for queries.

Layer 3: schema — This file (AGENTS.md), templates/, index.md, and log.md. These govern the entire system. They are updated as the wiki grows.

The principle: raw docs are ingested once and left alone. The wiki is a living synthesis that grows with every ingest. Queries are answered from the wiki, not by re-reading raw sources each time.


Folder Conventions

raw/

Immutable source documents. Subfolders by type:

FolderContents
raw/articles/Journal articles, PDFs, downloaded papers
raw/books/Full book files (PDF, EPUB, txt)
raw/chapters/Individual chapters extracted from books
raw/notes/The researcher's own handwritten or typed notes, voice transcriptions
raw/annotations/Highlight exports, marginalia PDFs, and annotation files derived from books or articles
raw/transcripts/Lecture transcripts, podcast transcripts, interview transcripts
raw/images/Diagrams, figures, and images referenced in source notes
wiki/

LLM-maintained markdown pages. Subfolders by page type:

FolderContents
wiki/concepts/One page per concept
wiki/authors/One page per key thinker
wiki/methods/Research or disciplinary methods
wiki/debates/Framed intellectual debates across the literature
wiki/themes/Broader thematic clusters that don't fit neatly as concepts
wiki/source-notes/One page per ingested source — the primary ingest output
wiki/syntheses/Evolving argumentative overviews across multiple sources
wiki/projects/Subfolders per active research or writing project
outputs/

Finished deliverables. Never edited by the agent unless explicitly asked.

FolderContents
outputs/essays/Finished or draft essays
outputs/handouts/Teaching handouts
outputs/slides/Presentation slides
outputs/tables/Reference tables, comparison charts
archive/

Deprecated pages, old drafts, superseded syntheses. Moved here to preserve history without cluttering active wiki.

templates/ and scripts/

templates/ holds one page template per type (see Page Formats). scripts/wiki.py is the deterministic tooling (see Tools). Neither is part of the wiki graph.


Page Formats

Every page uses YAML frontmatter followed by markdown content. Minimum fields:

---
title: ""
type: ""        # source-note | concept | author | debate | synthesis | project | method | theme
tags: []
related: []     # 3–5 most closely related pages (filename stems); concept and author pages only
created: YYYY-MM-DD
updated: YYYY-MM-DD
---

The full template for each page type lives in templates/. Before creating a page, read its template and follow it section by section. Do not load templates you are not about to use.

TypeLocationTemplate
Source notewiki/source-notes/author-year-short-title.mdtemplates/source-note.md
Conceptwiki/concepts/concept-name.mdtemplates/concept.md
Authorwiki/authors/author-name.mdtemplates/author.md
Debatewiki/debates/debate-name.mdtemplates/debate.md
Synthesiswiki/syntheses/synthesis-name.mdtemplates/synthesis.md
Projectwiki/projects/[name]/index.mdtemplates/project.md
Methodwiki/methods/method-name.mdtemplates/method.md
Themewiki/themes/theme-name.mdtemplates/theme.md

Quoting rules (source notes). Direct quotes are word for word from the raw file. Mark every omission with "…" and every insertion with [brackets]. Cite the page number printed in the source, not the PDF page. Add "(trans.)" to a quote you translated. python3 scripts/wiki.py quotes checks all of this.


Workflows

Workflow 1: INGEST

Trigger: The researcher says "ingest [source]" or "ingest [filename]"

Steps:

  1. Locate the file in raw/. If it is not already in raw/, note that it should be moved there.

  2. Read the source in full.

  3. Discuss key takeaways with the researcher before writing anything. Identify: central argument, key claims, surprising or important moments, relevant concepts and authors, connections to existing wiki pages. List the pages you plan to create or update, then stop and wait for the researcher's go-ahead.

  4. Read templates/source-note.md, then create the source-note page in wiki/source-notes/. Filename in lowercase-kebab-case: author-year-short-title.md. Then run python3 scripts/wiki.py quotes wiki/source-notes/<file>.md and resolve every error before going on. A quote the checker cannot find in the raw file is either misquoted — fix it against the source — or not a quote: paraphrase it without quote marks, or drop it.

  5. Update index.md — add the new source note to the Source Notes section.

  6. Scan the entire wiki for impact. For every concept, author, debate, theme, or project touched by this source:

    • If a page exists: open it, add the source note to its Source Support section, add any new direct quotes or claims, update the updated date in frontmatter.

    • If no page exists: create a stub page from its template with a note that it requires fuller treatment, and log it as "page needed" in log.md.

    To find affected pages, search the wiki (grep -ril "<term>" wiki/) rather than reading it page by page, and read only the pages that match. If your tool can run subagents and many pages need updating, you may hand independent page updates to them in parallel — one page per subagent, never two on the same file. index.md and log.md stay with you.

  7. Check whether any syntheses should be updated.

  8. Append an entry to log.md in the format: ## [YYYY-MM-DD] ingest | [Source title] | [Author, Year] listing all pages created or updated.

  9. Run python3 scripts/wiki.py check and fix every error it reports. End by listing the pages created and updated, as written to log.md.

A single ingest may touch 10-15 wiki pages. Do not shortcut this.


Workflow 2: QUERY

Trigger: The researcher asks a research question (any question about the content of the wiki)

Steps:

  1. Read index.md. Identify the relevant cluster(s) first — this is the primary navigation layer. Check if a synthesis page exists for the cluster; if so, read it before individual concept pages.

  2. Use the related: frontmatter field on any page you read as a fast map to the next most relevant pages — follow these links before doing wider searches.

  3. Read only the specific wiki pages indicated by the cluster and related fields. Do not read pages that are not relevant to the query.

  4. Answer from the synthesized wiki. Do not re-read raw source files unless you need to verify a specific quote or claim. Say plainly where the wiki is silent or thin; do not fill the gap from general knowledge without marking it as such.

  5. Cite the wiki pages you drew from (not just raw sources) — this keeps the answer traceable.

  6. If the answer is substantial (more than a short paragraph) and likely to be queried again, offer to save it as a new synthesis page in wiki/syntheses/.

  7. If the query reveals a gap (a concept mentioned but with no page, a debate not yet framed), log it in log.md as "gap identified."


Workflow 3: LINT

Trigger: The researcher says "lint"

Steps — check for all of the following:

  1. Duplicate pages — two pages covering the same concept, author, or source. Flag and propose merge.

  2. Stale pages — pages not updated in a long time despite new ingests that should have touched them.

  3. Contradictions — claims on one page that contradict claims on another. Flag and note which sources support each side.

  4. Concepts mentioned but lacking pages — scan all pages for wiki-link-style mentions that have no corresponding file. List them.

  5. Orphan pages — pages with no inbound links from any other wiki page. Flag for review.

  6. Overgrown pages — pages that have grown too large and should be split. Flag with proposed split.

  7. Weak or generic pages — pages with thin content, vague definitions, or no source support. Flag for enrichment.

  8. Thin source support — concepts or debates with only one source. Note that more sources are needed.

Mechanical checks are automated. The deterministic subset — broken links (4), orphans (5), oversize (6), thin support (8), plus missing frontmatter and index drift — is implemented in scripts/wiki.py (rules in conventions.toml). Run python3 scripts/wiki.py lint to get them for free and reliably — and python3 scripts/wiki.py quotes to check every direct quote against its raw file — then spend your own judgement on the checks that need reading: duplicates (1), stale drift (2), contradictions (3), and weak/generic pages (7). Treat wiki lint passing error-free as the last step of any wiki-touching task.

After linting, produce one prioritized list that merges both: tool errors first, then your judgement findings, then warnings, then info. For each item give the page, the problem, and the fix you propose. Do not auto-fix — present findings and let the researcher decide.


Tools

scripts/wiki.py does the mechanical work so you don't have to do it by hand. Use it instead of hand-scanning.

CommandUse it to
python3 scripts/wiki.py checkthe finishing check: lint errors, plus quotes in every source note changed since the last commit. Run it before you end any task that changed wiki/ or index.md
python3 scripts/wiki.py lintcheck links, orphans, index drift, frontmatter (nonzero exit on any error)
python3 scripts/wiki.py quotes [NOTE]check direct quotes against their raw files
python3 scripts/wiki.py graph --around STEMdraw the neighbourhood of a page as a Mermaid diagram
python3 scripts/wiki.py move OLD NEWrename a page and rewrite every link and related: entry that points to it

Never rename or move a wiki page by hand: use wiki.py move, or every relative link to it breaks.

Without file access (a chat app such as ChatGPT, Grok, Le Chat, DeepSeek or Kimi), the researcher runs wiki.py prompt to hand you the schema, templates, index and source in one message, and wiki.py apply to write your answer back into the wiki. Follow the output format that prompt specifies exactly.


Conventions

  • File names: Always lowercase-kebab-case. Spaces become hyphens. No special characters. Example: simondon-individuation-psychic-collective.md

  • Wiki links: Always use relative markdown links. Example: [Transduction](../concepts/transduction.md). Never use absolute paths.

  • YAML frontmatter: Every page must have it. Minimum fields: title, type, tags, created, updated. Keep it clean and consistent.

  • The wiki is the primary answer source. Do not re-read raw files on every query. Build the wiki so it contains what you need.

  • Offer to save substantial answers. If a query produces a valuable synthesis, offer to save it as a page.

  • Log everything. Every ingest, every page created, every gap identified — append to log.md.

  • Do not invent. If a source does not say something, do not attribute it to the source. If you are uncertain, flag it.


Epistemic Markers (optional)

In the humanities, "what a source says", "what the wiki concludes across sources" and "what the researcher argues" are different claims, and a page should never blur them. Some wikis mark every claim with its register:

MarkerRegisterExample
(none)Directly attributable to a named source, with its citationSimondon defines transduction as… (p. 32)
[W]Wiki synthesis: your own integration across several sources[W] Read together, DeLanda and Sauvagnargues suggest…
[P]The researcher's own position, not what any source says[P] A score is a metastable system, not an identity.
[?]Uncertain: an attribution, date or claim you could not verify[?] The term may first appear in the 1958 thesis.

This convention is off by default. Apply it only if this wiki has adopted it: the Domain Context below says so, or the [markers] block in conventions.toml is enabled. When it is on:

  • Mark every claim in concept, author, debate, theme and synthesis pages. Put the marker at the start of the sentence or bullet it governs.

  • Source notes carry no markers: everything in them is attributed to that one source by definition.

  • The "Relevance to Your Research" header carries [P], and a synthesis's "## Overview" header carries [W]. wiki.py lint checks both headers once [markers] is enabled.

  • Never promote a claim: a [W] or [P] claim must not reappear elsewhere without its marker, as if a source had said it.

  • Use [?] rather than guessing, and log the open question in log.md.

To adopt it, uncomment the [markers] block in conventions.toml and add a line to the Domain Context: "This wiki uses epistemic markers."


Cross-Referencing Rules

These rules apply whenever creating or updating any page:

  1. Scan for concepts. Any concept mentioned in a source or page that has a page in wiki/concepts/ must be linked on first mention.

  2. Scan for authors. Any author mentioned that has a page in wiki/authors/ must be linked on first mention.

  3. Scan for debates. If content touches a known debate, link to the debate page.

  4. New mentions without pages. When a new concept or author is mentioned in a source that does not yet have a wiki page, add a line to log.md: - PAGE NEEDED: [concept/author name] — mentioned in [source note].

  5. Backlinks. When you create a new concept or author page, scan existing source-notes and other pages to find where this concept/author was already mentioned, and add the link retroactively.

  6. Projects. If a source is directly relevant to a project in wiki/projects/, add it to that project page's Key Sources section.


Domain Context

Customize this section. Replace the examples below with your own research areas, key thinkers, and core concepts. This is what makes the wiki yours.

Core Research Areas
  • [Your area 1] — brief description

  • [Your area 2] — brief description

  • ...

Key Thinkers
AuthorCore relevance
[Thinker 1][Why they matter to your research]
[Thinker 2][Why they matter to your research]
......

When ingesting a source, always check if it engages any of these thinkers or themes, even obliquely. Cross-reference accordingly.


This file is the law of the wiki. When in doubt, return here.

59 files · 45 not served here

Advantages

  • Ensures high accuracy through automated quote verification against original source files. evidence: README.md
  • Maintains a persistent, interlinked knowledge base that compounds value with every new source. evidence: README.md
  • Model-agnostic design allows users to switch between different AI agents without losing data or structure. evidence: README.md

Limitations

  • Requires manual supervision of the first 5-10 ingests to ensure agent alignment with the research framework. evidence: README.md
  • The wiki can outgrow the model's context window, requiring the use of budget-limited prompts. evidence: README.md

Security

Risk level: Low risk

This brain runs

Hooks (1)

  • .claude/settings.json (Stop): python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/lint_gate.py"

Agent instructions that run or fetch something (10)

  • .claude/skills/ingest/SKILL.md: Finish with `python3 scripts/wiki.py check`.
  • .claude/skills/lint/SKILL.md: Run **Workflow 3: LINT** from `AGENTS.md`.
  • .claude/skills/query/SKILL.md: To show how the pages you used connect, `python3 scripts/wiki.py graph --around <page>` prints a Mermaid diagram you can include.
  • AGENTS.md: `python3 scripts/wiki.py quotes` checks all of this.
  • AGENTS.md: Then run `python3 scripts/wiki.py quotes wiki/source-notes/<file>.md` and resolve every error before going on.
  • AGENTS.md: If your tool can run subagents and many pages need updating, you may hand independent page updates to them in parallel — one page per subagent, never two on the same file.
  • AGENTS.md: Run `python3 scripts/wiki.py check` and fix every error it reports.
  • AGENTS.md: | Command | Use it to | |---|---| | `python3 scripts/wiki.py check` | **the finishing check**: lint errors, plus quotes in every source note changed since the last commit.
  • AGENTS.md: Run it before you end any task that changed `wiki/` or `index.md` | | `python3 scripts/wiki.py lint` | check links, orphans, index drift, frontmatter (nonzero exit on any error) | | `python3 scripts/wiki.py quotes [NOTE]` | check direct quotes against their raw files | | `python3 scrip …[+210 chars]
  • CLAUDE.md: A Stop hook (`.claude/settings.json`) runs `python3 scripts/wiki.py check` before you finish any task that changed `wiki/` or `index.md`.

Git hooks (1)

  • .githooks/pre-commit (pre-commit): runs on git pre-commit
  • Low risk: scripts-present (.claude/hooks/lint_gate.py)
  • Low risk: scripts-present (.githooks/pre-commit)
  • Low risk: scripts-present (scripts/wiki.py)

Attribution and licence

First committed by
GitHub avatar of MetamusicXMetamusicX
Publisher
Paulo de Assis (Community)
Source
MetamusicX/zissa-wiki · commit 8119876
Licence
MIT License (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
MetamusicX

AutoGineer is not affiliated with or endorsed by MetamusicX.

Install from source

45 of its files are not served here, so there is no ZIP. MetamusicX/zissa-wiki at 8119876