One repo, every kind of knowledge, no lock-in.

How to query

• MCP: search_memories, read_memory, write_memory, edit_memory, build_context
• App: ⌘K search, the Memories tier in the sidebar
• Files: plain markdown — grep, awk, your editor of choice

When to write here

Atomic, durable facts that should outlive the session. A decision you made and why. A constraint you discovered. A relationship between two parts of the system. If it would make a future-you grep, it belongs in Memories.

How it's organized

• Filenames: dashed (Architecture-Overview.md)
• Links: [Title](Page-Name) — Memophant resolves them in-app
• Home.md is the landing page; _Sidebar.md groups the nav
• In-app GitHub Wiki publishing — optional auto-publish on every wiki commit

When to write here

Anything where the reader needs the throughline. How a subsystem fits together. The walkthrough of a complex flow. The runbook for an incident. Wiki pages are where you'd send a new collaborator; memories are what they'd grep when stuck.

What makes it different

• Hex tokens render inline as live color swatches
• Fenced blocks → type scale, spacing bars, radius + elevation samples
• Generate Design System — distills your notes + repo into a design.md that renders itself
• The live render is gated to the design tier — code, wiki, and memory stay plain text

When to write here

Before you build a new UI component, write the spec. Before you change a token, document the why. The design tier is what stops the design system from drifting from a coherent voice into a soup of one-off choices — and the live render means you actually see it.

CLI verbs

• memophant code find <Symbol> — where is it defined?
• memophant code refs <Symbol> — what references it?
• memophant code outline <path> — symbol tree of one file
• memophant code imports <path> — what a file imports (importers = the reverse)
• memophant code search "<text>" — FTS over indexed symbols
• memophant code status — index health

Why it exists

Memories and wiki capture what the code means. The code tier captures where the code is. Together they let an AI session resolve “fix the auth middleware” without re-reading every Swift file — the symbol query goes straight to the file, the memory query goes straight to the decision.

What you can do with it

• Drag to move between Todo / Doing / Done / Archived
• Plan with Claude — generates a plan stored in tasks/<id>.md
• Run with Claude — streams Claude output against the task
• Import from memory — promote a [todo] note to a real task
• Import from GitHub Issues — pull open issues into the board

When to write here

Anything forward-looking. Tasks are about what you'll do next; memory is about what you decided last. The boundary keeps memory free of stale to-dos, and keeps the board free of past decisions that don't need re-doing.

What you can do with it

• Auto-discovered from ~/.claude/projects, attributed by cwd
• Distill — propose memory from a session, approve note by note
• Dedup within a distill run so the same lesson isn't captured twice
• Cost-guarded — a token cap keeps a long transcript honest

Why it exists

A session is where the learning happens and where it's usually lost. Keeping the transcript in the repo — and distilling it on your terms — is how an insight from Tuesday's debugging marathon becomes a durable note the next session reads on open.

What lives here

• Any extension — PDFs, images, CSVs, JSON, source, archives
• Nested folders (plans/, audits/, exports/) or a flat list
• Add via picker, reveal in Finder, delete with confirm
• Filename search today; in-document text search on the roadmap

When to use it

When the artifact matters but isn't a fact to query — the signed contract, the perf-audit PDF, the design export. Keeping it in the repo means it travels with the project and a clone, instead of rotting in a Downloads folder no agent can reach.

How it protects you

• Source of truth is your iCloud Keychain — synced across your Macs by Apple, never leaving your devices
• The note holds only a keychain_ref; reveal / copy in-app, masked by default
• Agents read + write via MCP — each get/set call needs your one-click approval
• Headless/CI sessions can't auto-approve; a verification phrase you set marks the real prompt
• Secret-scan on save blocks known key shapes from ever landing in the note body

When to write here

The moment you (or an agent) create or encounter a credential. Instead of a key pasted into chat history or a .env that drifts, the account is documented where the whole team can find it — and the secret is somewhere safe to fetch from, on your terms, without ever leaving your Apple devices.

How it works

• Folder per template: manifest.md + optional files + README
• Four canonical sections — Prerequisites, Steps, Variables, Verification
• /memophant-template <description> — an agent convention wired through AGENTS.md
• Placeholder-tolerant secret-scan; real credentials still hard-block

When to write here

When you've set the same thing up twice. The third time should be a slash command. Templates can reference vendors, so the agent knows which credentials a setup needs before it starts.