Markdown is truth.
Postgres is a cache.

Everything is a page: a person, a company, an essay, a saved article, a day. A page carries a body (compiled_truth), frontmatter, a type, a content hash, and a salience score. Deletes are soft — a page sits in a 72-hour recovery window before purge actually removes it.

people/bob-smith, writing/no-way-back, inbox/2026-08-08-a91f2c04. The leading segment is what the schema pack reads to decide a page's type.

Slugs are unique per source, not globally. The same topics/ai can exist in two sources and be two different pages.

Your notes vault is one source. A codebase is another. An essay collection a third. Every page row carries a source_id. A .gbrain-source dotfile in a directory pins every command run there to that source, so you never pass a flag.

Your personal brain is one. A team's published brain that you mount is another. Separate pages tables, separate access control, separate lifecycle.

The rule that separates the two axes: if the data owner changes, it's a brain boundary. If the owner stays the same and only the topic changes, it's a source boundary.

Three fields on the source row: the last git commit imported, when that happened, and which chunker version did it. gbrain sync walks only the diff since last_commit — that's what makes re-syncing a thousand-page vault take seconds instead of minutes.

Bump the chunker version in a release and the mismatch forces a full re-walk automatically. If a sync is interrupted it exits cleanly with last_commit unchanged, so the next run re-walks the same diff and content hashes skip whatever already landed.

A per-source boolean. federated: true and its pages show up in every unqualified query. false and the source is invisible unless you name it — the right setting for draft writing, or anything you don't want bleeding into unrelated answers.

Across brains there is deliberately no federation at all. The agent sees the list of brains and decides when to query each one. Keeping that out of SQL is what keeps access control and debugging sane.

A YAML manifest naming the page types that exist, which folder prefixes map to each, which types get facts mined out of them, which participate in expertise routing, what edge types are legal — and which dream-cycle phases run at all.

Swap the pack and the brain re-interprets itself; swap back and nothing is lost. The pack's name and version are folded into the search cache key, so results from one pack can never leak into another. gbrain schema detect clusters your actual filesystem into proposed types when none of the bundled packs fit.

Written by the auto-linker on every page save — pure pattern matching on [[wikilinks]], zero LLM calls. An edge carries a type (works_at, founded, discusses, derived_from, supersedes) and the surrounding context.

Two grades exist and it matters: a real wikilink, versus a mentions edge inferred from body text. The weak kind is excluded from backlink-count ranking and only counts toward graph traversal, so a name appearing everywhere doesn't inflate its own importance.

Point at a page that doesn't exist yet and a stub is created. That's how the graph grows without anyone curating it.

The simplest primitive: a YAML array, reconciled into a table on import. No hierarchy, no types, no relationships. They filter and they feed the salience score — that's it.

One sharp edge: since v0.41.37 tag reconciliation is add-only. Removing a tag from frontmatter no longer removes it from the database, because enrichment writes tags of its own that a re-index must not wipe.

“I have a call with Arya Thursday.” “I don't drink coffee.” “We decided to cut the second podcast season.” A cheap model pulls these out per turn and files them on the relevant entity page.

Each row carries visibility: world | private. Private text is stripped by the chunker before embedding — it never becomes a vector, never appears in a search result, and never leaves the machine through the MCP surface.

A take is a claim plus an owner. holder=self kind=bet “the AI hardware wave peaks in 2027” at weight 0.7 is a different object from the same sentence held by someone you interviewed. Four kinds: an opinion, a verifiable fact, a dated prediction, an intuition.

Weights use 0.05 increments on purpose. The extraction guidance is explicit that 0.74 is false precision, that amplifying someone else's claim caps out around 0.55, and that self-reported numbers never reach the confidence of verified ones.

Because takes carry a weight and a date, they are the only thing in the system that can later be graded against what actually happened.

A cheap model reads a transcript or article and extracts one to three atoms, each typed from a closed list: insight, anecdote, quote, framework, statistic, story angle, strategy angle, strategy, endorsement, critique, collection. Each becomes its own page under atoms/{date}/.

This is the creator's primitive. Twelve podcast transcripts sitting inert become a few dozen individually addressable, retrievable pieces — the anecdote you half remember telling, findable without re-listening.

Nightly, atoms are grouped by the concept they reference and tiered by how often the theme appears: ten or more is tier one, five is tier two, two is tier three. The top two tiers get a written narrative; the bottom gets a plain stub.

The tier is the finding. A theme reaching tier one means you have circled it ten separate times without noticing — which is a different and more useful signal than any single note.

Two things share the name. gbrain capture writes to inbox/YYYY-MM-DD-<hash> by default, so anything captured without a destination clusters in one predictable place to triage later. And ~/.gbrain/inbox/ is a watched folder — anything dropped in from a Shortcut, AirDrop, or Finder gets ingested.

The hash makes capture idempotent: the same text captured twice is one page, not two.

Added for the Life Chronicle feature. An event under life/events/ is something that happened on a date. A diary entry under life/diary/ is what you thought about it. Neither has facts mined out of it — they're read chronologically, not queried for claims.

These power the chronicle verbs: what happened in a window, what happened on this day in previous years, what has changed since a date.

The trust flag. Every operation runs with remote: true|false, required by the type system. You at your own terminal are local and see everything. Anything reaching the brain through MCP — including an agent on this same machine — is remote, and gets private fact rows and the entire takes fence stripped from its responses.

The install shape. A thin client is a gbrain with no local content at all, pointed at someone else's brain server over HTTP. Same commands, the data lives elsewhere. Local-only operations refuse with a specific hint rather than silently querying an empty database.