Skip to content
Back to search

omnia-vault

Omnia Vault - the all-in-one project brain: an Obsidian LLM wiki, Graphify code graphs, a living plan that triages new videos against itself, and a Claude Code ⇄ Codex relay. Everything your project knows, in one clonable vault.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/gavishap--omnia-vault/badge.svg)](/listings/gavishap--omnia-vault)

HTML

<a href="/listings/gavishap--omnia-vault"><img src="/api/listings/gavishap--omnia-vault/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 308 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src=".github/assets/omnia-vault-banner.svg" alt="Omnia Vault — everything your project knows, everything it can do" width="100%"/>
  3. <br/><br/>
  4. **Omnia** — Latin for *all things*. **Vault** — where your project keeps them.
  5. Omnia Vault is an all-in-one project brain you clone: an Obsidian **LLM wiki**, **code
  6. knowledge graphs**, a **living plan that triages every new video and meeting against
  7. itself**, a **20+ skill toolkit**, and a **relay** that lets Claude Code and Codex work
  8. the same project with zero copy-paste. Memory, planning, tools, agents — one repo.
  9. <br/>
  10. [![License: MIT](https://img.shields.io/badge/license-MIT-8b5cf6?style=flat-square)](LICENSE)
  11. [![Claude Code](https://img.shields.io/badge/Claude_Code-ready-7dd3fc?style=flat-square)](CLAUDE.md)
  12. [![Codex](https://img.shields.io/badge/Codex-ready-86efac?style=flat-square)](AGENTS.md)
  13. [![Obsidian](https://img.shields.io/badge/Obsidian-vault-a78bfa?style=flat-square)](https://obsidian.md)
  14. [![Planning](https://img.shields.io/badge/war--room-video_intel-fbbf24?style=flat-square)](.claude/skills/war-room/SKILL.md)
  15. [![Tooling](https://img.shields.io/badge/python-stdlib_only-f9a8d4?style=flat-square)](scripts/)
  16. <br/>
  17. [**Get started in 5 minutes →**](GETTING-STARTED.md) ·
  18. [Operating guide](VAULT-GUIDE.md) ·
  19. [The relay protocol](_relay/PROTOCOL.md) ·
  20. [Every command](Schema/command-reference.md)
  21. </div>
  22. ---
  23. ## Why this exists
  24. Three things quietly kill AI-assisted projects:
  25. 1. **Agents are amnesiac.** Every session starts from zero — you re-explain the project,
  26. re-paste the context, re-open the same twenty files. Use both Claude Code *and* Codex
  27. and it's worse: two brilliant tools, two separate amnesias, and you're the copy-paste
  28. middleware between them.
  29. 2. **Plans die the week after kickoff.** New information keeps arriving — a meeting, a
  30. YouTube technique, a shiny tool — and it either gets ignored or bolted on with no
  31. judgment, until the "plan" describes a project that no longer exists.
  32. 3. **Knowledge evaporates.** The decision from that call three weeks ago? The reason you
  33. rejected that framework? Gone with the chat scrollback.
  34. Omnia Vault fixes all three at the repository level. **The repo *is* the operation** —
  35. everything an agent needs to be instantly useful lives in files, validated by
  36. deterministic tooling, traveling with `git`:
  37. | Layer | What it holds | Where it lives |
  38. |---|---|---|
  39. | 🧠 **Memory** | every meeting, doc, video, and decision — compiled into short, linked, *source-traceable* notes | `Wiki/` + `Raw/Sources/` |
  40. | 🕸️ **Code understanding** | a queryable knowledge graph per repo (communities, god nodes, impact analysis) | `graphify/` |
  41. | 🗺️ **The plan** | a phased roadmap with exit criteria, intel briefs, and a tool-adoption ledger | `Plan/` |
  42. | 🏃 **Session state** | the baton: what just landed, what's next, what to watch out for | `_relay/STATE.md` |
  43. Open the folder in **Obsidian** and the whole brain becomes a navigable constellation —
  44. notes, code nodes, plans, and sources, all one graph.
  45. ---
  46. ## The war-room — feed it videos, and the plan evolves
  47. `/roadmap` builds the plan the right way: vision → measurable success criteria → phases
  48. with **exit criteria** — locked with you, not guessed. Then the part most systems don't
  49. have: **the plan metabolizes new information.**
  50. ```
  51. /intel https://youtube.com/watch?v=... ← "here's a new technique — worth anything to us?"
  52. /intel standup-recording.mkv ← meetings feed the same loop
  53. ```
  54. Every `/intel` runs the same discipline:
  55. 1. **Plan digest first, video second** — the triage loads the roadmap, the active phase's
  56. open deliverables, and the adopted toolbox *before* watching a single frame. The
  57. answer is about *your project*, never just a video summary.
  58. 2. **Watch it properly** — scene-aware keyframes + Whisper transcript, correlated
  59. frame-by-frame; the full capture lands in `Raw/Sources/` for permanent citation.
  60. 3. **Rank every item against the plan** — phase fit / impact / effort / confidence →
  61. **ADOPT · TRIAL · WATCH · SKIP**, ending in one honest verdict:
  62. `INCORPORATE`, `WATCHLIST`, or `PASS`. ("Nothing here beats the plan" is a win — and
  63. the logged brief stops the same video from being re-litigated next month.)
  64. 4. **You gate what gets in.** Adopted items land in the phase files **with provenance
  65. back to the brief**; phases rebalance only when argued and approved.
  66. 5. **Tools get adopted like adults** — official source verified (video links are treated
  67. as untrusted), per-tool confirmed installs, `candidate → trialing → adopted` tracked
  68. in `TOOLBOX.md` with the *why* kept even for rejections.
  69. Six months later, "why is the project shaped like this?" has a paper trail: brief →
  70. phase edit → commit.
  71. ---
  72. ## The layered memory — answers stay fast, cheap, and cited
  73. Every question routes through the cheapest layer that can answer it:
  74. ```mermaid
  75. flowchart LR
  76. Q([question]) --> G["1 · Code graph<br/><code>graphify query</code>"]
  77. G -->|not enough| W["2 · Wiki catalog<br/><code>search-catalog</code>"]
  78. W -->|not enough| R["3 · Raw files<br/>one file, narrowly"]
  79. style G fill:#0ea5e9,color:#fff,stroke:none
  80. style W fill:#8b5cf6,color:#fff,stroke:none
  81. style R fill:#f59e0b,color:#fff,stroke:none
  82. ```
  83. No repo sweeps. No transcript re-reads. Claims trace back to sources, and the linter
  84. keeps it honest: source links must point at real files with accurate counts, tags must
  85. match folders, and sourceless notes get flagged. The **maintenance gate**
  86. (`doctor → build → lint → source-lint → audit`) runs before every commit — the audit
  87. is a best-effort text scan of the working tree for secrets and machine-local paths,
  88. and one command (`sh scripts/install_hooks.sh`) wires the full gate into a pre-commit
  89. hook. Recordings and
  90. reference videos enter through the same door: `/video <file-or-URL>` turns anything
  91. crv can watch (local files, YouTube, TikTok, Instagram) into transcript ⇄ keyframe
  92. knowledge with curated screenshots.
  93. ---
  94. ## Two agents, one project — the relay and the sparring ring
  95. Claude Code plans beautifully. Codex grinds through execution. Omnia Vault lets you use
  96. each for what it's best at — **asynchronously** (the relay) and **synchronously**
  97. (sparring).
  98. **The relay** — switch agents anytime, with zero copy-paste:
  99. ```mermaid
  100. sequenceDiagram
  101. participant C as Claude Code
  102. participant R as _relay/STATE.md (the baton)
  103. participant X as Codex
  104. C->>R: /handoff — rewrite baton, stamp, commit
  105. Note over R: Now · Just landed · Next<br/>Open questions · Watch out
  106. X->>R: "catch up" — reads baton + git log
  107. X->>X: implements, tests, debugs
  108. X->>R: rewrite baton, stamp (--agent codex), commit
  109. C->>R: /catchup — picks up exactly where Codex stopped
  110. ```
  111. Both agents read the same rules (`CLAUDE.md` / `AGENTS.md`), write the same baton, and
  112. get their chat transcripts archived locally (`import_chats.py` — searchable, redacted,
  113. never committed). A stale-baton detector warns when commits pile up after the last
  114. handoff without a fresh baton pass.
  115. **Sparring** (`/spar`) — for high-stakes builds, make the models argue *before* the
  116. code exists: Codex attacks the locked plan in bounded **read-only** rounds
  117. (severity-tagged findings, accept-or-rebut arbitration, honest deadlocks), then one
  118. model builds and the other grades the diff — *whoever made the thing never grades the
  119. thing*. The whole argument is resumable state in `_relay/spar/` and gets compiled into
  120. the wiki afterward. Works in reverse too (Codex drives, headless Claude reviews).
  121. **The council** (`/council`) — for expensive-if-wrong *decisions* (pricing, pivots,
  122. architecture direction), convene five blind seats **split across both models**: a
  123. Codex Skeptic, a Claude Rebuilder, a Claude Maximalist, a Codex Operator — and an
  124. Outsider seat that runs from an **empty directory**, so it judges your idea knowing
  125. literally nothing about you (the curse of knowledge, cured by a sandbox). Opinions are
  126. anonymized, each bench blind-reviews the mixed set, and the chair rules — dissent
  127. preserved in writing, record kept in `_relay/council/`. Sparring is depth on one plan;
  128. the council is breadth before you lock one.
  129. ---
  130. ## 60-second start
  131. ```bash
  132. git clone https://github.com/gavishap/omnia-vault.git my-project
  133. cd my-project
  134. claude # or: codex
  135. ```
  136. **New project?**
  137. ```
  138. /setup My Product Name
  139. /roadmap My Product Name
  140. ```
  141. **Existing project?** Drop your repos / recordings / docs into the folder, then:
  142. ```
  143. /import
  144. ```
  145. Then live the loop:
  146. ```
  147. /catchup → work: ask · ingest · /intel new videos · build · /spar the risky parts → /save
  148. ```
  149. > Slash commands are Claude Code's interface. In **Codex**, just say it in words —
  150. > *"catch up"*, *"triage this video against the plan"*, *"save"* — `AGENTS.md` wires the
  151. > same workflows and scripts for any agent that reads it.
  152. Missing tooling? `python scripts/setup_vault.py --check` shows what's optional and
  153. `--install` installs what it can (pip/npm/winget/brew) — the core needs only Python
  154. and git. Full walkthrough: [GETTING-STARTED.md](GETTING-STARTED.md)
  155. ---
  156. ## What's in the box
  157. ```
  158. ├─ Wiki/ compiled knowledge — topics · concepts · entities · projects · logs
  159. ├─ Raw/Sources/ captured material, verbatim, source-of-truth for every claim
  160. ├─ Plan/ the war-room (via /roadmap): phased roadmap · intel briefs · toolbox
  161. ├─ graphify/ committed code-graph snapshots per tracked repo
  162. ├─ _relay/ the baton (STATE.md) + handoff history + sparring loop state
  163. ├─ Schema/ frontmatter contracts · naming · lint rules · command reference
  164. ├─ _templates/ six note templates (source/topic/concept/entity/project/log)
  165. ├─ scripts/ stdlib-only python tooling — zero dependencies to install
  166. ├─ .claude/
  167. │ ├─ skills/ 22 skills, ready on clone (see below)
  168. │ └─ commands/ 16 slash commands (/setup /import /catchup /save /spar /intel ...)
  169. ├─ CLAUDE.md Claude Code wiring AGENTS.md Codex + any-agent rules
  170. └─ VAULT-GUIDE.md the full operating guide
  171. ```
  172. ### The skill arsenal
  173. | Ready on clone (vendored) | What it does |
  174. |---|---|
  175. | `graphify` | any folder / repo / paper / video → queryable knowledge graph (`query` · `explain` · `path` · `affected`) |
  176. | `war-room` | the living plan (`Plan/`): phased roadmap + plan-aware video triage + tool adoption ledger |
  177. | `video-ingest` | recordings & video URLs → transcript ⇄ frames, correlated, compiled |
  178. | `import-project` | adopt an existing codebase + raw files into the vault |
  179. | `relay` | the Claude ⇄ Codex baton pass (async) |
  180. | `sparring` | the Claude ⇄ Codex argument (sync): adversarial plan review + cross-graded builds |
  181. | `council` | five-seat decision panel split across both models, blind opinions + cross-bench review |
  182. | `project-context-query` | the 3-layer answer engine |
  183. | `llm-wiki-ingest / llm-wiki-query / llm-wiki-lint / llm-wiki-maintain` | the LLM Wiki core loops |
  184. | `taste` | anti-slop frontend design ([Leonxlnx/taste-skill](https://github.com/Leonxlnx/taste-skill), MIT) |
  185. | `ui-ux-pro-max` | searchable design intelligence: 79 styles · 192 palettes · 74 font pairs · 119 UX rules ([nextlevelbuilder](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill), MIT) |
  186. | `obsidian-markdown / obsidian-bases / json-canvas / obsidian-cli / defuddle` | first-class Obsidian editing ([kepano/obsidian-skills](https://github.com/kepano/obsidian-skills), MIT) |
  187. | `humanizer` + `stakeholder-update-writing` | outward-facing prose that doesn't read like a bot |
  188. | `github-pr-api` | GitHub PRs from machines with no `gh` CLI (credential-store token + REST) |
  189. | Guided install (a command that walks you through the plugin setup) | How |
  190. |---|---|
  191. | **impeccable** — 23 design commands (`polish`, `animate`, `critique`, …) | `/design-setup` → two `/plugin` commands |
  192. | **Anthropic document skills** — Word · PDF · PowerPoint · Excel deliverables | `/docs-setup` → two `/plugin` commands |
  193. ### The commands
  194. | Command | Does |
  195. |---|---|
  196. | `/setup` · `/import` | initialize a new project · adopt an existing one |
  197. | `/roadmap` · `/intel` | build the living plan · triage a video/meeting against it |
  198. | `/catchup` · `/save` · `/handoff` | the daily loop + the agent switch |
  199. | `/spar` · `/council` | cross-model adversarial review · five-seat cross-model decision panel |
  200. | `/ingest` · `/video` | any source → knowledge · any recording/URL → knowledge |
  201. | `/wiki` · `/graph` · `/gate` | layered answers · code graphs · the quality gate |
  202. | `/design-setup` · `/docs-setup` | design stack · document stack |
  203. ---
  204. ## FAQ
  205. **Do I need both agents?** No — all core vault workflows (wiki, graphs, plan, relay,
  206. video ingest) work with just Claude Code *or* just Codex via `AGENTS.md`. The relay
  207. simply means you never lose state if you add the second one; sparring needs both
  208. because arguing with yourself is cheating; and the `/design-setup` / `/docs-setup`
  209. plugin extras are Claude Code-specific.
  210. **Do I need Obsidian?** No, but you want it: the vault is plain Markdown that happens to
  211. render as a beautiful navigable graph.
  212. **What are the actual dependencies?** Python 3.9+ and git. That's it — every script is
  213. standard-library only. `graphify` (code graphs), `crv` + `ffmpeg` (video), Node
  214. (web clipping), and the Codex CLI (sparring) are optional — each unlocks a feature.
  215. `python scripts/setup_vault.py --check` shows what's missing and
  216. `python scripts/setup_vault.py --install` installs what it can for you.
  217. **Can it really install tools it finds in videos?** Yes, with guardrails: the official
  218. source gets verified first (video links are untrusted input), you confirm each tool
  219. individually, and every install is recorded in `Plan/TOOLBOX.md` with provenance.
  220. **Is my data safe in here?** The vault ships empty (one self-documenting demo you can
  221. prune with `python scripts/setup_vault.py --prune-demo`). The audit gate — a best-effort
  222. scan wired into the pre-commit hook — catches secrets and machine-local paths before
  223. they land, repos you import stay gitignored, and chat archives never leave your
  224. machine.
  225. **Where did this design come from?** It's the extraction of a production consulting
  226. system — battle-tested on a real engagement (multi-repo codebase, recorded meetings,
  227. diagrams, evolving requirements), then scrubbed to a clean template.
  228. ---
  229. <div align="center">
  230. Built on the shoulders of [kepano/obsidian-skills](https://github.com/kepano/obsidian-skills),
  231. [Leonxlnx/taste-skill](https://github.com/Leonxlnx/taste-skill),
  232. [nextlevelbuilder/ui-ux-pro-max-skill](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill),
  233. [graphifyy](https://pypi.org/project/graphifyy/),
  234. [claude-real-video](https://pypi.org/project/claude-real-video/) and the
  235. cross-model mechanics of [claudex-loop](https://github.com/chaseai-yt/claudex-loop) —
  236. see [THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md).
  237. **MIT licensed. Clone it, gut it, ship with it.**
  238. ⭐ *Omnia* — because your project deserves all of it.
  239. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.