[#0001] bootstrap · the context runtime

Git for reasoning.

Your project remembers why it is what it is — and any AI connects and already knows. An append-only, content-addressed, anchored ledger of decisions, delivered over MCP. No human re-explaining. Ever.

[problem] the memory bus is human

AIs are stateless
across sessions.

Every new session, agent, or provider, you become the memory bus — re-explaining decisions that already existed. The naive fix (a living markdown log) works until it blows past the context window. And "memory" tools store text or vectors with no provenance → hallucinated recall.

The cost isn't tokens. It's that the why evaporates the moment the window scrolls.

[north-star] time-to-context → 0

One metric.
One acceptance test.

A fresh AI connects, with no human in the loop, and correctly answers: what / why / what's decided / what's next?

Lifeline keeps the project's lifeline queryable, compressible, and anchored — so it never overflows the window and never invents recall. The why outweighs the what.

[proof] not a mockup · this repo is its own ledger

A fresh AI connects.
This is what it reads.

The context a fresh AI reads from this very repo — what / why / decided / next, assembled to a budget. Every line anchored to its event id; built by AIs + a human from #0001.

# Lifeline — project context · 130 entries · head 017420eb
# built by claude-opus · claude-fable · human — every line anchored
## Why / what's decided (14 in force)
- Lock the core: 3 anchored layers, content-addressed DAG, status as a reducer [58e4b2b2]
- Mesh: a line is a repository, a thread is a branch inside it; promote anchors by full id [e85aa0ab]
## Resume (where work stopped)
- 0.6 [25b745bd] — claude-code/claude-fable-5-1 · next: owner approves proposals, merges, publishes 0.6.0
$ lifeline exam
Context Health: 95/100 (A) — integrity · why-density · direction · freshness · ttc-probe

The site you're reading dogfoods itself. Live ledger → LIFELINE.md · ▶ watch the 60s loop

[architecture] three layers, one anchor

An event-sourced
reasoning ledger.

[constitution] seven non-negotiable laws

The invariants.

[the-loop] read on connect · append on work · checkpoint on stop

Do all three.

# in any project — each gets its own .lifeline/ledger.db
lifeline init           # .mcp.json + write policy, in one command
lifeline log --kind decision --summary "DB: PostgreSQL" --body "ACID required by audit."
lifeline checkpoint --thread main --next "wire the queue" --tried "SQS FIFO — cap too low"
lifeline context        # what an AI reads — decisions, open, resume, recent
lifeline verify         # the chain is tamper-evident → OK

[#0070] adopting mid-project

Already deep in
a project? Bootstrap it.

Lifeline records the why going forward — it never guesses it from your code or git history. So on a live project, run lifeline init (or just connect your AI). It runs a one-time bootstrap, human-in-the-loop:

[mcp-native] the interface is the product

Connect it to
your AI.

Lifeline ships a local MCP server (lifeline-mcp). On connect, the AI gets lifeline_context, lifeline_resume, lifeline_brief (a scoped brief for a sub-agent), lifeline_recall, lifeline_checkpoint — and the write tools propose by default: a human approves, unless the project's write policy grants that agent direct, audited writes. Claude Code reads .mcp.json automatically.

{ "mcpServers": { "lifeline": {
    "command": "lifeline-mcp",
    "env": { "LIFELINE_DB": ".lifeline/ledger.db" } } } }

[distribution] no MCP required for the read

Your AI already reads it.
It lives in the repo.

The ledger projects to a plain LIFELINE.md committed in your repo. So any AI that can read the repo already inherits your why — Gemini, ChatGPT, Claude, Copilot, Cursor — with no MCP, no OAuth, no per-vendor setup.

MCP is the live surface — relevance recall, propose-to-approve, always current. But the floor is zero-friction: the file travels with the clone. Point any model at the repo and ask it why. That's the whole onboarding.

[docs] the whole manual

Read everything.