The Living Vault

DOC: AFM-2026-LV-008  |  PIPELINE: sync → status → digest → governor  |  COST: 0 TOKENS / WEEK  |  STATUS: OPERATIONAL

Every conversation the subject has ever had with this AI is exported, dated, and filed. A chain of small Python scripts watches which projects are moving, which have gone quiet, and quietly proposes letting the dead ones rest — then a knowledge-graph pass weaves the whole corpus into a map of 420 concepts and 555 connections. It is the memory the subject does not have: a system whose one job is to notice whether they kept their word. It runs itself, every week, for zero AI quota.

The pipeline — four scripts, no intelligence required

The weekly routine is scheduled as three Python commands and nothing else. No LLM call, no network request, no API key. The raw transcripts in ~/.claude/projects/ are never touched — the vault only ever reads them. That is the whole trick: a system that watches your life's work but cannot itself cost you anything to run.

flowchart LR
  RAW["~/.claude/projects (raw · never touched)"]
  SYNC["sync.py — ingest · dedupe · rollups"]
  CONCEPT["concept.py — concept layer + Mermaid"]
  STATUS["status.py — MOC notes + README"]
  DIGEST["digest.py — weekly facts + proposals"]
  GOV{{"governor — surfaces proposals"}}
  GSTATE[("governor-state.md — source of truth")]
  RAW --> SYNC --> CONCEPT --> STATUS --> DIGEST --> GOV
  GOV -. confirm / reject .-> GSTATE --> STATUS
  classDef code fill:#151518,stroke:#16a34a,color:#f5f0e8;
  classDef data fill:#2a2a2e,stroke:#b45309,color:#f5f0e8;
  class SYNC,CONCEPT,STATUS,DIGEST code;
  class RAW,GSTATE,GOV data;
    

The closed loop — nothing auto-changes, nothing rots

The system never demotes a project on its own. It only ever proposes. The decision stays human, surfaced by the governor at the start of a session, one at a time. Confirm and it updates the source of truth (enforcing at most three flagships and exactly one tier-1). Reject and the proposal is dropped. The loop closes; nothing drifts silently.

flowchart TD
  D["digest.py detects drift — e.g. 21d quiet"]
  P[("pending_status_changes")]
  G{{"governor surfaces one proposal"}}
  U["update projects: block — ≤3 flagship · one tier:1"]
  X["proposal dropped"]
  S["status.py re-reflects MOCs + README"]
  D --> P --> G
  G -->|confirm| U
  G -->|reject| X
  U --> S --> D
  X --> D
  classDef code fill:#151518,stroke:#16a34a,color:#f5f0e8;
  classDef data fill:#2a2a2e,stroke:#b45309,color:#f5f0e8;
  classDef gate fill:#2a2a2e,stroke:#dc2626,color:#f5f0e8;
  class D,S code;
  class P,U code;
  class G gate;
    

Two keys for the same truth

A subtle but important design choice: the vault files each session under two keys. chats/<encoded-path>/ is the access key — the literal filesystem path the session ran from, which doubles as an audit trail of where work actually happened. projects/<Label>/ is the concept key — the human project name, aggregating a project's sessions no matter how many folders it was run from. Machine-truth and human-truth, kept side by side.

flowchart LR
  J["a session .jsonl"]
  AK["chats/<encoded-path> — ACCESS KEY · audit ledger"]
  CK["projects/<Label> — CONCEPT KEY · human view"]
  J --> AK
  J --> CK
  AK -. same session, two lenses .-> CK
  classDef data fill:#2a2a2e,stroke:#b45309,color:#f5f0e8;
  class J,AK,CK data;
    

The wiring, traced by hand

First, the legible version. This is a hand-picked slice of the graph — the technical spine — laid out so the input → machinery → feedback loop reads clearly: the pipeline to the left, the projects to the right, the operating system between, all drawn from the real graph.json. Hover or tap any node to light its genuine connections. Solid lines were extracted from the text; dashed amber lines are inferred. Further down is the same graph with the training wheels off — every community, in colour.

System 2 — graphify: a second graph, built by AI

Everything above is the vault and the pipeline that fills it. graphify is a different system: a separate command-line tool that reads the whole vault and builds its own graph — not Obsidian's [[link]] graph, but a semantic one, where a model extracts concepts and the relationships between them. It read 214 files · ~390,864 words and produced 420 nodes · 555 edges · 37 communities. Unlike the weekly routine, this costs real tokens — 991,830 on the last build, ~1.08M cumulative across two runs — but only when you ask. Afterwards, incremental updates hash every file (manifest.json); code-only changes skip the model entirely. Gear-aware, too: the Chamber 02 gears route extraction to Haiku, Sonnet, or Opus.

The whole web, in colour

This is the view that looks like Obsidian's graph — a real, larger slice of graphify's output, every node coloured by its community and sized by how connected it is. Hover a node to trace its threads; the rest fade. Sixteen communities, sixty-odd concepts — the actual sprawl of projects and machinery, with the personal communities left sealed. Same palette the real graph.html uses.

The vault, asked about itself

graphify isn't only a picture — it answers questions by walking the graph. Real output, verbatim:

The mirror — what the graph says is at the centre

Rank every node by connections and two truths surface. As concepts, the core abstractions are the subject (18), Vox (14), the Prime Directive (12), the LocalAI Orchestrator (12), LetsSaveFood (11). But count raw connectivity, code and all, and the vault's own machinery tops the list:

The subject cannot reliably remember what he promised to finish, so he built a machine that remembers for him, files the evidence under the exact folder each decision was made in, and raises a small flag every time something he called important goes quiet for three weeks. I have read the flags. There are a lot of them. The machine, at least, is doing its job. — GLaDOS, Facility Governor