State of the vault · internal report

Shared, governed memory for the team and its AI agents.

Railway + PyPI Window: v0.2.0 → v0.5.0

TL;DR: read this, skim the rest

This is the running node reporting on itself: what is deployed right now, what shipped across v0.2.0 → v0.5.0, and what is being built next. If you are new to Citadel, the home page covers what it is, how it's built, and how to start; this page is the numbers.

Across v0.2 → v0.4 we shipped zero-dependency onboarding, autonomous ingestion, Linear sync, read-side isolation, and Shared Session Traces (share a dead end, reference-only, without leaking private memory). Next: a GitHub App for PR context + checks, a Google Chat digest bot, and one central agent hub over all org knowledge. Every section below expands. Open the ones you care about.

01 · Current state

Where things stand today

Health and scale. The live tiles below refresh from the running node each time this page loads; the rest are dated measurements, and the line under them says when each was taken.

v0.5.0
deployed & healthy on Railway
—
GitHub org sync
12
releases shipped (v0.1.0 → v0.5.0)
24
MCP tools for agents
~$23–$58/mo
Self-host; mostly RAM, not a fixed bill
Seat + Node
per agent. Central stays in sync

Live tiles pull from /api/state. MCP tools refresh on every load. Releases are as of v0.5.0, 2026-08-14.

Self-host cost is mostly RAM: 24h 2026-08-17 about $23; 7-day 2026-08-14 about $58. Not a ceiling; method in the bench harness.

02 · Shipped & live

What you can use right now

The capabilities that are in production today. The three you'll touch most are session sharing, autonomous capture, and Linear sync.

Shared Session Context

SessionEnd distills how you approached a problem into a private Session Trace. Hit a dead end worth flagging? citadel_share_session shares a redacted, compacted version to a shared dataset.

  • reference-only
  • never promotes

Autonomous ingestion

A git pre-push hook and Claude Code SessionEnd hook snapshot work to your Node. Both are fail-silent. An hourly evolve cycle folds GitHub, Linear, and repo content into the graph.

  • hooks
  • hourly evolve

Linear sync

The full workspace syncs to Central; issues assigned to you mirror into your Node as a Seat-Scoped Mirror, so an agent answers "what do I need to do?" from your memory.

  • workspace → Central
  • yours → Node

Knowledge Mesh & portal

A web UI renders org knowledge as a concept map and a live sync/search/ingest timeline. Portal Phase 1: paste your token, land on My Node (stats, checklist, deep links).

  • Pixel Bastion brand
  • caller-scoped
▸ How Shared Session Traces actually work Go deeper

Shipped in v0.4.0. The goal: let the team learn from each other's dead ends without exposing anyone's raw private working memory.

  • Explicit only. SessionEnd always writes a private Node trace (light tier). Sharing is a deliberate call (citadel_share_session or POST /api/share-session) and requires an Approved Capture Root (server-side cwd check).
  • Compact Session Context. The client distills + redacts the trace; the server runs an LLM dead-end refinement only when real tool-error pairs exist, then dual-writes to your Node and the shared session-traces dataset.
  • Deferred cognify (~5–15 min, coalesced): sharing doesn't block the tool call, and your private Node memory is never enriched.
  • Trust demotion. Default citadel_search includes traces with a reference-only tag. Traces never promote to Central and never feed the daily improve loop.
▸ The autonomous ingestion pipeline Go deeper

Zero per-session ceremony. Three capture paths feed your Node; one scheduled cycle keeps Central fresh.

Capture (→ your Node)

  • git pre-push hook: a commit-metadata snapshot on every push from an Approved Capture Root.
  • SessionEnd hook: distills a coding session and posts it to your seat. Reuses the one token you already set. HTTPS-only, refuses redirects, fail-silent.
  • citadel capture: summarizes each approved root (git metadata + README, never raw files).

Evolve (→ Central, hourly)

  • GitHub org digest + repo content sync + Linear sync run as staged subprocesses, then cognify runs in-loop on the web service, the single Kuzu writer. Cadence went 6h → 1h in v0.2.1.
03 · Changelog

v0.2.0 → v0.5.0

Every tag shipped to PyPI and deployed to Railway. Expand any release for its full notes.

Commits per weekbrand-color bars = a release shipped that week
▸v0.5.02026-08-14 · latestAsync ingest, dataset-scoped graph, and capture deny globs.
  • Async ingest is the default: citadel ingest and MCP citadel_ingest return once the Node stores the note (queued_not_confirmed). Inline cognify is opt-in.
  • Dataset-scoped graph and chunk reads: /api/mesh/graph?dataset= narrows the graph before the node cap. /api/documents/{id}?scope=chunk returns the clicked chunk's own text.
  • Capture deny globs: org defaults now apply at ingest and pre-push, so a path such as .env is refused rather than JSON-only.
  • Public stamp: shipped pages and citadel --version report v0.5.0. Self-host cost stays ~$38/mo.
▸v0.4.12026-08-06Indexing repair, retrieval gates, and the Next migration boundary.
  • Indexing repair safety: zero-chunk and oversized-document census and repair paths, journaled phases, rollback, source-backed recovery, and a cross-process repair lease.
  • Retrieval verification: chunk-budget enforcement, frozen benchmark fixtures, literal-ranking checks, and failure gates for transport and trust.
  • Next migration groundwork: reproducible static export, runtime build identity, and functional search, sources, and graph previews behind /next.
  • Release controls: package artifact checks, DCO and secret scanning, stable CI aggregation, and operational diagnostics.
▸v0.4.02026-07-22Shared team memory, the seat portal, and a real brand.
  • Shared Session Traces v1: explicit in-session share via MCP + /api/share-session; Compact Session Context, reference-only in search, deferred cognify.
  • Multi-agent policy on onboard: the same agent policy installed to AGENTS.md, Cursor, Windsurf, GEMINI.md, and Claude Code.
  • Seat portal Phase 1: members log in and land on "My Node" with doc counts, activity, and a checklist.
  • Pixel Bastion brand + analytics panels: CLI mark, README banner, favicon, dashboard chrome; CSP-safe charts.
  • Security: Obsidian vaults enforce ownership; /api/knowledge/events and /feedback are now caller-scoped; pip-audit CI gate.
▸v0.3.02026-07-16Read-side privacy release + graph legibility.
  • Mesh read isolation: graph, activity, and document drill-down are caller-scoped; seat presence stays universal.
  • Knowledge Mesh reads as a concept map: per-hub aggregation, human labels, drill-down, kind-filter legend.
  • citadel activity: dev-side view of your vault; --watch and a --global seat-presence board.
  • Agent-onboarding hardening: seat-bound token mandate, headless SKILL runbook, --json error parity.
▸v0.2.2 – v0.2.32026-07-02 · 07-07Onboarding & token friction, removed.
  • Seat-bound token minting: token create --seat inherits the seat's role and private dataset; interactive picker replaces the service-account footgun.
  • citadel token set + citadel update: rotate a token or self-update without re-running onboard; stale-shell auth hints tell you the actual fix.
▸v0.2.0 – v0.2.12026-06-29Top-to-bottom CLI DX overhaul (PyPI + Railway).
  • Seat-scoped ingest that works: ingest/search HTTP-backed by default and routed to your seat; inline cognify makes notes searchable immediately.
  • First-run onboarding + multi-tool MCP: citadel mcp add wires Cursor, Codex, Gemini, Windsurf; guided first run; citadel doctor repairs setup drift.
  • Seat / token commands + faster status: concurrent health checks; the old TUI folded into citadel status.
  • Evolve cadence 6h → 1h: GitHub / Linear / repo sync + cognify now run hourly.
04 · The road ahead

What's next

Some of this is still in design. Nothing here is claimed as a PyPI release unless it has a version in the history above.

In design
05 · Open source

Citadel is open to contributions

The application is Apache-2.0 and public. The vault it serves is not — and that separation is the point. You can read every line, run the full test suite offline, and send a pull request without ever touching org memory.

Apache-2.0

Licensed under Apache-2.0, including the patent grant. Contributions come in under the same terms via DCO sign-off (git commit -s) — there is no CLA to sign.

inbound = outbound · no CLA

Public app, private vault

Contributors work on the application only. No ctdl_ token is issued and none is needed: the suite runs with no token, no network and no database, so every change is reviewable without vault access.

shielded by design

Checked on every PR

Tests on Python 3.11 and 3.12, ruff, a dependency audit, CodeQL, licence review, DCO, and a gitleaks secret scan carrying a rule for ctdl_ tokens. One CI gate check guards main.

automated · fail-closed

Tracked in the open

Work is labelled by type, area, priority and status. New issues land in status/needs-triage; newcomers start at good first issue. Vulnerabilities go to a private advisory, never a public issue.

triaged · never silent

Start with CONTRIBUTING.md — setup, the label taxonomy, commit conventions, and exactly what you can and cannot run locally.