omnia-vault

Omnia — Latin for all things. Vault — where your project keeps them.

Omnia Vault is an all-in-one project brain you clone: an Obsidian LLM wiki, code knowledge graphs, a living plan that triages every new video and meeting against itself, a 20+ skill toolkit, and a relay that lets Claude Code and Codex work the same project with zero copy-paste. Memory, planning, tools, agents — one repo.

Get started in 5 minutes → · Operating guide · The relay protocol · Every command

Why this exists

Three things quietly kill AI-assisted projects:

1. Agents are amnesiac. Every session starts from zero — you re-explain the project, re-paste the context, re-open the same twenty files. Use both Claude Code and Codex and it's worse: two brilliant tools, two separate amnesias, and you're the copy-paste middleware between them.
2. Plans die the week after kickoff. New information keeps arriving — a meeting, a YouTube technique, a shiny tool — and it either gets ignored or bolted on with no judgment, until the "plan" describes a project that no longer exists.
3. Knowledge evaporates. The decision from that call three weeks ago? The reason you rejected that framework? Gone with the chat scrollback.

Omnia Vault fixes all three at the repository level. The repo is the operation — everything an agent needs to be instantly useful lives in files, validated by deterministic tooling, traveling with git:

Open the folder in Obsidian and the whole brain becomes a navigable constellation — notes, code nodes, plans, and sources, all one graph.

The war-room — feed it videos, and the plan evolves

/roadmap builds the plan the right way: vision → measurable success criteria → phases with exit criteria — locked with you, not guessed. Then the part most systems don't have: the plan metabolizes new information.

/intel https://youtube.com/watch?v=...     ← "here's a new technique — worth anything to us?"
/intel standup-recording.mkv               ← meetings feed the same loop

Every /intel runs the same discipline:

1. Plan digest first, video second — the triage loads the roadmap, the active phase's open deliverables, and the adopted toolbox before watching a single frame. The answer is about your project, never just a video summary.
2. Watch it properly — scene-aware keyframes + Whisper transcript, correlated frame-by-frame; the full capture lands in Raw/Sources/ for permanent citation.
3. Rank every item against the plan — phase fit / impact / effort / confidence → ADOPT · TRIAL · WATCH · SKIP, ending in one honest verdict: INCORPORATE, WATCHLIST, or PASS. ("Nothing here beats the plan" is a win — and the logged brief stops the same video from being re-litigated next month.)
4. You gate what gets in. Adopted items land in the phase files with provenance back to the brief; phases rebalance only when argued and approved.
5. Tools get adopted like adults — official source verified (video links are treated as untrusted), per-tool confirmed installs, candidate → trialing → adopted tracked in TOOLBOX.md with the why kept even for rejections.

Six months later, "why is the project shaped like this?" has a paper trail: brief → phase edit → commit.

The layered memory — answers stay fast, cheap, and cited

Every question routes through the cheapest layer that can answer it:

flowchart LR
    Q([question]) --> G["1 · Code graph<br/><code>graphify query</code>"]
    G -->|not enough| W["2 · Wiki catalog<br/><code>search-catalog</code>"]
    W -->|not enough| R["3 · Raw files<br/>one file, narrowly"]
    style G fill:#0ea5e9,color:#fff,stroke:none
    style W fill:#8b5cf6,color:#fff,stroke:none
    style R fill:#f59e0b,color:#fff,stroke:none

No repo sweeps. No transcript re-reads. Claims trace back to sources, and the linter keeps it honest: source links must point at real files with accurate counts, tags must match folders, and sourceless notes get flagged. The maintenance gate (doctor → build → lint → source-lint → audit) runs before every commit — the audit is a best-effort text scan of the working tree for secrets and machine-local paths, and one command (sh scripts/install_hooks.sh) wires the full gate into a pre-commit hook. Recordings and reference videos enter through the same door: /video <file-or-URL> turns anything crv can watch (local files, YouTube, TikTok, Instagram) into transcript ⇄ keyframe knowledge with curated screenshots.

Two agents, one project — the relay and the sparring ring

Claude Code plans beautifully. Codex grinds through execution. Omnia Vault lets you use each for what it's best at — asynchronously (the relay) and synchronously (sparring).

The relay — switch agents anytime, with zero copy-paste:

sequenceDiagram
    participant C as Claude Code
    participant R as _relay/STATE.md (the baton)
    participant X as Codex
    C->>R: /handoff — rewrite baton, stamp, commit
    Note over R: Now · Just landed · Next<br/>Open questions · Watch out
    X->>R: "catch up" — reads baton + git log
    X->>X: implements, tests, debugs
    X->>R: rewrite baton, stamp (--agent codex), commit
    C->>R: /catchup — picks up exactly where Codex stopped

Both agents read the same rules (CLAUDE.md / AGENTS.md), write the same baton, and get their chat transcripts archived locally (import_chats.py — searchable, redacted, never committed). A stale-baton detector warns when commits pile up after the last handoff without a fresh baton pass.

Sparring (/spar) — for high-stakes builds, make the models argue before the code exists: Codex attacks the locked plan in bounded read-only rounds (severity-tagged findings, accept-or-rebut arbitration, honest deadlocks), then one model builds and the other grades the diff — whoever made the thing never grades the thing. The whole argument is resumable state in _relay/spar/ and gets compiled into the wiki afterward. Works in reverse too (Codex drives, headless Claude reviews).

The council (/council) — for expensive-if-wrong decisions (pricing, pivots, architecture direction), convene five blind seats split across both models: a Codex Skeptic, a Claude Rebuilder, a Claude Maximalist, a Codex Operator — and an Outsider seat that runs from an empty directory, so it judges your idea knowing literally nothing about you (the curse of knowledge, cured by a sandbox). Opinions are anonymized, each bench blind-reviews the mixed set, and the chair rules — dissent preserved in writing, record kept in _relay/council/. Sparring is depth on one plan; the council is breadth before you lock one.

60-second start

git clone https://github.com/gavishap/omnia-vault.git my-project
cd my-project
claude        # or: codex

New project?

/setup My Product Name
/roadmap My Product Name

Existing project? Drop your repos / recordings / docs into the folder, then:

/import

Then live the loop:

/catchup  →  work: ask · ingest · /intel new videos · build · /spar the risky parts  →  /save

Slash commands are Claude Code's interface. In Codex, just say it in words — "catch up", "triage this video against the plan", "save" — AGENTS.md wires the same workflows and scripts for any agent that reads it.

Missing tooling? python scripts/setup_vault.py --check shows what's optional and --install installs what it can (pip/npm/winget/brew) — the core needs only Python and git. Full walkthrough: GETTING-STARTED.md

What's in the box

├─ Wiki/            compiled knowledge — topics · concepts · entities · projects · logs
├─ Raw/Sources/     captured material, verbatim, source-of-truth for every claim
├─ Plan/            the war-room (via /roadmap): phased roadmap · intel briefs · toolbox
├─ graphify/        committed code-graph snapshots per tracked repo
├─ _relay/          the baton (STATE.md) + handoff history + sparring loop state
├─ Schema/          frontmatter contracts · naming · lint rules · command reference
├─ _templates/      six note templates (source/topic/concept/entity/project/log)
├─ scripts/         stdlib-only python tooling — zero dependencies to install
├─ .claude/
│  ├─ skills/       22 skills, ready on clone (see below)
│  └─ commands/     16 slash commands (/setup /import /catchup /save /spar /intel ...)
├─