feat: code indexing + multi-repo support

Tree-sitter-based code chunker for TS/JS/Python/Ruby/Go.
Splits code at semantic boundaries (functions, classes, types, exports).
Each chunk includes structured header for embedding context.

Multi-repo config: `gbrain repos add/list/remove`, `gbrain sync --all`.
Strategy-aware sync: markdown (default), code, or auto.
New PageType 'code' for code file pages.

Backward compatible: no config changes = existing behavior preserved.
All 37 sync tests pass, typecheck clean.

.github/PULL_REQUEST_TEMPLATE/tier5-queries.md

@@ -1,39 +0,0 @@
-<!--
-Tier 5.5 Externally-Authored Query Submission template
-See eval/CONTRIBUTING.md for the full workflow.
--->
-
-## Summary
-
-Submitting **N** Tier 5.5 queries for BrainBench.
-
-- Author handle: `@your-handle`
-- File location: `eval/external-authors/your-handle/queries.json`
-- Queries authored fresh (not copy-pasted from a model output)
-- Slugs verified against `eval/data/world-v1/` (via `bun run eval:world:view`)
-
-## Checklist
-
-- [ ] `bun run eval:query:validate eval/external-authors/your-handle/queries.json` passes
-- [ ] At least 20 queries
-- [ ] Each query has either `gold.relevant` (with real slugs) or `gold.expected_abstention: true`
-- [ ] Temporal queries have `as_of_date` set (`corpus-end` | `per-source` | ISO-8601)
-- [ ] Phrasing is varied (not all the same template)
-- [ ] `author` field matches my handle
-
-## Phrasing variety (optional self-audit)
-
-Tick the styles represented in your batch:
-
-- [ ] Full sentence questions
-- [ ] Fragment-style ("crypto founder Goldman Sachs background")
-- [ ] Comparison ("X vs Y")
-- [ ] Follow-up ("And who else...")
-- [ ] Imperative ("Pull up Alice Davis")
-- [ ] Trait-based ("the demanding engineering leader")
-- [ ] Abstention bait (answer is "not in corpus")
-
-## Notes to reviewer
-
-Anything worth flagging — ambiguous cases, corpus gaps you found, specific
-phrasings you were uncertain about.

.github/workflows/e2e.yml

@@ -44,10 +44,7 @@ jobs:
   tier2:
     name: Tier 2 (LLM Skills)
     runs-on: ubuntu-latest
-    # Runs on every push/PR now (promoted from schedule-only in v0.19.0).
-    # Tier 1 must pass first; Tier 2 uses OPENAI_API_KEY + ANTHROPIC_API_KEY
-    # from repo/org secrets. Nightly + manual triggers still supported via
-    # the workflow-level `on:` list.
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
     needs: tier1
     services:
       postgres:

.github/workflows/test.yml

@@ -21,22 +21,11 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   test:
-    # ubuntu-latest is free 2-core/7GB. Larger runners (16-cores, etc.) require
-    # a provisioned runner pool in repo settings. Falling back to default keeps
-    # the matrix shard speedup (~5-6x via parallelism) at zero cost.
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        shard: [1, 2, 3, 4]
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
       - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6  # v2
         with:
           bun-version: latest
       - run: bun install
-      - name: Pre-test gates (shard 1 only — they're not test files)
-        if: matrix.shard == 1
-        run: bun run verify
-      - name: Run test shard ${{ matrix.shard }}/4
-        run: scripts/test-shard.sh ${{ matrix.shard }} 4
+      - run: bun run test

.gitignore

@@ -11,30 +11,5 @@ bin/
 .gstack/
 supabase/.temp/
 .claude/skills/
-# admin/dist/ is the React SPA bundle. CLAUDE.md says it's committed for
-# self-contained binaries (the bun --compile path embeds it via
-# `import path from 'admin/dist/index.html' with { type: 'file' }`).
-# Build via: cd admin && bun install && bun run build.
-admin/node_modules/
 .idea
 eval/reports/
-eval/data/world-v1/world.html
-
-# BrainBench amara-life-v1 Opus cache (regenerate via eval:generate-amara-life)
-eval/data/amara-life-v1/_cache/
-
-# claw-test E2E build cache (shim + scratch outputs)
-test/.cache/
-
-.claude/
-export/
-
-# Conductor workspace-local agent artifacts: plans, todos, run-unit-parallel
-# failure logs and per-shard test output. v0.26.4 (run-unit-parallel.sh)
-# writes .context/test-failures.log + .context/test-summary.txt +
-# .context/test-shards/. Workspace-local by design — never committed.
-.context/
-
-# Tier 3 PGLite snapshot fixture (built on demand by build:pglite-snapshot)
-test/fixtures/pglite-snapshot.tar
-test/fixtures/pglite-snapshot.version

AGENTS.md

@@ -18,13 +18,7 @@ start here.
 1. `./AGENTS.md` (this file) — install + operating protocol.
 2. [`./CLAUDE.md`](./CLAUDE.md) — architecture reference, key files, trust boundaries,
    test layout.
-3. [`./docs/architecture/brains-and-sources.md`](./docs/architecture/brains-and-sources.md)
-   — the two-axis mental model (brain = which DB, source = which repo in the DB). Every
-   query routes on both axes. Read before writing anything that touches brain ops.
-4. [`./skills/conventions/brain-routing.md`](./skills/conventions/brain-routing.md) —
-   agent-facing decision table: when to switch brain, when to switch source, how
-   cross-brain federation works (latent-space only; the agent decides).
-5. [`./skills/RESOLVER.md`](./skills/RESOLVER.md) — skill dispatcher. Read before any task.
+3. [`./skills/RESOLVER.md`](./skills/RESOLVER.md) — skill dispatcher. Read before any task.
 
 ## Trust boundary (critical)
 
@@ -43,27 +37,15 @@ writing or reviewing an operation, consult `src/core/operations.ts` for the cont
   [`docs/guides/minions-fix.md`](./docs/guides/minions-fix.md), `gbrain doctor --fix`.
 - **Migrate:** [`docs/UPGRADING_DOWNSTREAM_AGENTS.md`](./docs/UPGRADING_DOWNSTREAM_AGENTS.md),
   [`skills/migrations/`](./skills/migrations/), `gbrain apply-migrations`.
-- **Eval retrieval changes:** capture is off by default. To benchmark a
-  retrieval change against real captured queries, set
-  `GBRAIN_CONTRIBUTOR_MODE=1`, then `gbrain eval export --since 7d > base.ndjson`
-  and `gbrain eval replay --against base.ndjson`. Full guide:
-  [`docs/eval-bench.md`](./docs/eval-bench.md).
 - **Everything else:** [`./llms.txt`](./llms.txt) is the full documentation map.
   [`./llms-full.txt`](./llms-full.txt) is the same map with core docs inlined for
   single-fetch ingestion.
 
 ## Before shipping
 
-Easiest path: `bun run ci:local` runs the full CI gate inside Docker (gitleaks,
-unit tests with `DATABASE_URL` unset, then all 29 E2E files sequentially against a
-fresh pgvector container) and tears down. Use `bun run ci:local:diff` for the
-diff-aware subset during fast iteration on a focused branch. Requires Docker
-(Docker Desktop / OrbStack / Colima) and `gitleaks` (`brew install gitleaks`).
-
-Manual path: `bun test` plus the E2E lifecycle described in `./CLAUDE.md` (spin
-up the test Postgres container, run `bun run test:e2e`, tear it down).
-
-Ship via the `/ship` skill, not by hand.
+Run `bun test` plus the E2E lifecycle described in `./CLAUDE.md` (spin up the test
+Postgres container, run `bun run test:e2e`, tear it down). Ship via the `/ship` skill,
+not by hand.
 
 ## Privacy
 

CLAUDE.md

@@ -7,24 +7,6 @@ suggests Supabase for 1000+ files. GStack teaches agents how to code. GBrain tea
 agents everything else: brain ops, signal detection, content ingestion, enrichment,
 cron scheduling, reports, identity, and access control.
 
-## Two organizational axes (read this first)
-
-GBrain knowledge is organized along two orthogonal axes. Users AND agents must
-understand both, or queries misroute silently.
-
-- **Brain** — WHICH DATABASE. Your personal brain is `host`. You can mount
-  additional brains (team-published, each with their own DB and access policy)
-  via `gbrain mounts add` (v0.19+). Routing: `--brain`, `GBRAIN_BRAIN_ID`,
-  `.gbrain-mount` dotfile.
-- **Source** — WHICH REPO INSIDE THE DATABASE. A brain can hold many sources
-  (wiki, gstack, openclaw, essays). Slugs scope per source. Routing:
-  `--source`, `GBRAIN_SOURCE`, `.gbrain-source` dotfile.
-
-Both axes follow the same 6-tier resolution pattern. Read
-`docs/architecture/brains-and-sources.md` for topology diagrams (personal, team
-mount, CEO-class with multiple team brains) and
-`skills/conventions/brain-routing.md` for the agent-facing decision table.
-
 ## Architecture
 
 Contract-first: `src/core/operations.ts` defines ~41 shared operations (adds `find_orphans` in v0.12.3). CLI and MCP
@@ -40,76 +22,45 @@ strict behavior when unset.
 
 ## Key files
 
-- `src/core/operations.ts` — Contract-first operation definitions (the foundation). Also exports upload validators: `validateUploadPath`, `validatePageSlug`, `validateFilename`, plus `matchesSlugAllowList(slug, prefixes)` (v0.23 glob matcher: `<prefix>/*` matches recursive children; bare `<prefix>` matches exact only). `OperationContext.remote` flags untrusted callers; `OperationContext.allowedSlugPrefixes` (v0.23) is the trusted-workspace allow-list set by the dream cycle. `put_page` enforces: when `viaSubagent` and `allowedSlugPrefixes` is set, slug must match the allow-list; else the legacy `wiki/agents/<id>/...` namespace check applies. Auto-link enabled for trusted-workspace writes (skipped only when `remote=true && !trustedWorkspace`). As of v0.26.0, every `Operation` also carries `scope?: 'read' | 'write' | 'admin'` + `localOnly?: boolean`. All ops are annotated; `sync_brain`, `file_upload`, `file_list`, and `file_url` are `admin + localOnly` (rejected over HTTP). `OperationContext.auth?: AuthInfo` is threaded through HTTP dispatch for scope enforcement in `serve-http.ts` before the op runs.
+- `src/core/operations.ts` — Contract-first operation definitions (the foundation). Also exports upload validators: `validateUploadPath`, `validatePageSlug`, `validateFilename`. `OperationContext.remote` flags untrusted callers.
 - `src/core/engine.ts` — Pluggable engine interface (BrainEngine). `clampSearchLimit(limit, default, cap)` takes an explicit cap so per-operation caps can be tighter than `MAX_SEARCH_LIMIT`. Exports `LinkBatchInput` / `TimelineBatchInput` for the v0.12.1 bulk-insert API (`addLinksBatch` / `addTimelineEntriesBatch`). As of v0.13.1, `BrainEngine` has a `readonly kind: 'postgres' | 'pglite'` discriminator so migrations (`src/core/migrate.ts`) and other consumers can branch on engine without `instanceof` + dynamic imports.
 - `src/core/engine-factory.ts` — Engine factory with dynamic imports (`'pglite'` | `'postgres'`)
-- `src/core/pglite-engine.ts` — PGLite (embedded Postgres 17.5 via WASM) implementation, all 40 BrainEngine methods. `addLinksBatch` / `addTimelineEntriesBatch` use multi-row `unnest()` with manual `$N` placeholders. As of v0.13.1, `connect()` wraps `PGlite.create()` in a try/catch that emits an actionable error naming the macOS 26.3 WASM bug (#223) and pointing at `gbrain doctor`; the lock is released on failure so the next process can retry cleanly. v0.22.0: `searchKeyword` and `searchKeywordChunks` multiply `ts_rank` by the source-factor CASE expression at the chunk-grain level; `searchVector` becomes a two-stage CTE — inner CTE keeps `ORDER BY cc.embedding <=> vec` so HNSW stays usable, outer SELECT re-ranks by `raw_score * source_factor`. Inner LIMIT scales with offset to preserve pagination contract. As of v0.22.6.1, `initSchema()` calls `applyForwardReferenceBootstrap()` BEFORE replaying SCHEMA_SQL — probes for the specific forward-referenced state the embedded schema blob needs (`pages.source_id`, `links.link_source`, `links.origin_page_id`, `content_chunks.symbol_name`, `content_chunks.language`, `sources` FK target table) and adds only what's missing. Closes the upgrade-wedge bug class that bit users 10+ times across 6 schema versions over 2 years (#239/#243/#266/#357/#366/#374/#375/#378/#395/#396). No-op on fresh installs and modern brains.
+- `src/core/pglite-engine.ts` — PGLite (embedded Postgres 17.5 via WASM) implementation, all 40 BrainEngine methods. `addLinksBatch` / `addTimelineEntriesBatch` use multi-row `unnest()` with manual `$N` placeholders. As of v0.13.1, `connect()` wraps `PGlite.create()` in a try/catch that emits an actionable error naming the macOS 26.3 WASM bug (#223) and pointing at `gbrain doctor`; the lock is released on failure so the next process can retry cleanly.
 - `src/core/pglite-schema.ts` — PGLite-specific DDL (pgvector, pg_trgm, triggers)
-- `src/core/postgres-engine.ts` — Postgres + pgvector implementation (Supabase / self-hosted). `addLinksBatch` / `addTimelineEntriesBatch` use `INSERT ... SELECT FROM unnest($1::text[], ...) JOIN pages ON CONFLICT DO NOTHING RETURNING 1` — 4-5 array params regardless of batch size, sidesteps the 65535-parameter cap. As of v0.12.3, `searchKeyword` / `searchVector` scope `statement_timeout` via `sql.begin` + `SET LOCAL` so the GUC dies with the transaction instead of leaking across the pooled postgres.js connection (contributed by @garagon). `getEmbeddingsByChunkIds` uses `tryParseEmbedding` so one corrupt row skips+warns instead of killing the query. v0.22.0: `searchKeyword`, `searchKeywordChunks`, and `searchVector` apply source-aware ranking by inlining the source-factor CASE and `NOT (col LIKE …)` hard-exclude clause from `src/core/search/sql-ranking.ts`. `searchVector` switches to a two-stage CTE (HNSW-safe inner ORDER BY, source-boost re-rank in the outer SELECT) and carries `p.source_id` through inner→outer for v0.18 multi-source callers. v0.22.1 (#406): `_savedConfig` retains the connect config; `reconnect()` tears down + recreates the pool from saved config (called by supervisor watchdog after 3 consecutive health-check failures). `executeRaw` is a single-statement passthrough — no per-call retry (D3 dropped that as unsound for non-idempotent statements; recovery is supervisor-driven). v0.22.1 (#363, contributed by @orendi84): `connect()` applies `resolveSessionTimeouts()` from `db.ts` as connection-time startup parameters (`statement_timeout`, `idle_in_transaction_session_timeout`) so orphan pgbouncer backends can't hold locks for hours. v0.22.1 (#409, contributed by @atrevino47): `countStaleChunks()` + `listStaleChunks()` server-side-filter on `embedding IS NULL` for `embed --stale`, eliminating ~76 MB/call client-side pull on a fully-embedded brain; `upsertChunks()` resets both `embedding` AND `embedded_at` to NULL when chunk_text changes without a new embedding (consistency). As of v0.22.6.1, `initSchema()` calls `applyForwardReferenceBootstrap()` BEFORE replaying SCHEMA_SQL on the same forward-reference probe set as the PGLite engine, so old Postgres brains pinned at v0.13/v0.18/v0.19 walk forward cleanly instead of wedging on `column "..." does not exist`.
+- `src/core/postgres-engine.ts` — Postgres + pgvector implementation (Supabase / self-hosted). `addLinksBatch` / `addTimelineEntriesBatch` use `INSERT ... SELECT FROM unnest($1::text[], ...) JOIN pages ON CONFLICT DO NOTHING RETURNING 1` — 4-5 array params regardless of batch size, sidesteps the 65535-parameter cap. As of v0.12.3, `searchKeyword` / `searchVector` scope `statement_timeout` via `sql.begin` + `SET LOCAL` so the GUC dies with the transaction instead of leaking across the pooled postgres.js connection (contributed by @garagon). `getEmbeddingsByChunkIds` uses `tryParseEmbedding` so one corrupt row skips+warns instead of killing the query.
 - `src/core/utils.ts` — Shared SQL utilities extracted from postgres-engine.ts. Exports `parseEmbedding(value)` (throws on unknown input, used by migration + ingest paths where data integrity matters) and as of v0.12.3 `tryParseEmbedding(value)` (returns `null` + warns once per process, used by search/rescore paths where availability matters more than strictness).
-- `src/core/db.ts` — Connection management, schema initialization. v0.22.1 (#363, contributed by @orendi84): `resolveSessionTimeouts()` returns `statement_timeout` + `idle_in_transaction_session_timeout` (defaults: 5min each, env-overridable via `GBRAIN_STATEMENT_TIMEOUT` / `GBRAIN_IDLE_TX_TIMEOUT` / `GBRAIN_CLIENT_CHECK_INTERVAL`). Both `connect()` (module singleton) and `PostgresEngine.connect()` (worker pool) consume the result via postgres.js's `connection` option, sending GUCs as startup parameters that survive PgBouncer transaction mode (unlike the prior `setSessionDefaults` post-pool SET, kept as a back-compat no-op shim).
+- `src/core/db.ts` — Connection management, schema initialization
 - `src/commands/migrate-engine.ts` — Bidirectional engine migration (`gbrain migrate --to supabase/pglite`)
 - `src/core/import-file.ts` — importFromFile + importFromContent (chunk + embed + tags)
-- `src/core/sync.ts` — Pure sync functions (manifest parsing, filtering, slug conversion). v0.22.12 (#500, foundation by @wintermute via #501): `classifyErrorCode(errorMsg)` regex-based classifier with 12 codes (`SLUG_MISMATCH`, `YAML_PARSE`, `YAML_DUPLICATE_KEY`, `MISSING_OPEN`, `MISSING_CLOSE`, `NESTED_QUOTES`, `EMPTY_FRONTMATTER`, `NULL_BYTES`, `INVALID_UTF8`, `STATEMENT_TIMEOUT`, `FILE_TOO_LARGE`, `SYMLINK_NOT_ALLOWED`) plus `UNKNOWN` fallback. `summarizeFailuresByCode(failures)` returns sorted `[{code, count}]`. `code?` optional field on `SyncFailure`; backfilled at ack time on pre-v0.22.12 entries. `acknowledgeSyncFailures()` returns `AcknowledgeResult { count, summary }`. Three regexes (`MISSING_OPEN`, `MISSING_CLOSE`, `EMPTY_FRONTMATTER`) broadened to match actual `markdown.ts:159-244` validator message strings, not just the literal code-name prefix. `FILE_TOO_LARGE` covers all three production size sites in `import-file.ts:199, 352, 401`; `SYMLINK_NOT_ALLOWED` covers the rejection at `:347`. Closes the silent-skip pattern that motivated #500.
+- `src/core/sync.ts` — Pure sync functions (manifest parsing, filtering, slug conversion)
 - `src/core/storage.ts` — Pluggable storage interface (S3, Supabase Storage, local)
-- `src/core/storage-config.ts` (v0.22.11) — Storage tiering: `loadStorageConfig` reads `gbrain.yml`, normalizes deprecated keys (`git_tracked` / `supabase_only`) to canonical (`db_tracked` / `db_only`) with once-per-process deprecation warning, and runs `normalizeAndValidateStorageConfig` (auto-fixes missing trailing `/`, throws `StorageConfigError` on tier overlap). Path-segment matcher: `media/x/` does NOT match `media/xerox/foo`. Replaces gray-matter (broken on delimiter-less YAML) with a dedicated parser for the `gbrain.yml` shape.
-- `src/core/disk-walk.ts` (v0.22.11) — `walkBrainRepo(repoPath)` returns `Map<slug, {size, mtimeMs}>` from one recursive `readdirSync`. Skips dot-dirs, `node_modules`, non-`.md` files. Used by `gbrain storage status` to replace per-page `existsSync + statSync` (~400K syscalls on 200K-page brains → tens).
-- `src/commands/storage.ts` (v0.22.11) — `gbrain storage status [--repo P] [--json]`. Split into pure data (`getStorageStatus`) + JSON formatter + human formatter (ASCII-only per D10) matching the `orphans.ts` pattern. `PageCountsByTier` and `DiskUsageByTier` are distinct nominal types so swaps fail at compile time.
-- `gbrain.yml` (brain repo root, v0.22.11) — Optional storage tiering config. Top-level `storage:` section with `db_tracked:` and `db_only:` array-valued keys. `gbrain sync` auto-manages `.gitignore` for `db_only` paths on successful sync (skips on dry-run, blocked-by-failures, submodule context, or `GBRAIN_NO_GITIGNORE=1`). `gbrain export --restore-only [--repo P] [--type T] [--slug-prefix S]` repopulates missing `db_only` files from the database.
 - `src/core/supabase-admin.ts` — Supabase admin API (project discovery, pgvector check)
 - `src/core/file-resolver.ts` — File resolution with fallback chain (local -> .redirect.yaml -> .redirect -> .supabase)
-- `src/core/chunkers/` — 3-tier chunking (recursive, semantic, LLM-guided). v0.19.0 adds `code.ts` — tree-sitter-based semantic chunker for 29 languages with embedded-asset WASMs (`src/assets/wasm/`), `@dqbd/tiktoken` cl100k_base tokenizer, small-sibling merging. `CHUNKER_VERSION` constant folded into `importCodeFile`'s `content_hash` so chunker shape changes force clean re-chunks across releases.
-- `src/core/errors.ts` (v0.19.0) — `StructuredAgentError` + `buildError` + `serializeError`. Every new v0.19.0 agent-facing surface (code-def, code-refs, usage errors) uses this envelope; matches v0.17.0 `CycleReport.PhaseResult.error` shape.
-- `src/assets/wasm/` (v0.19.0) — 36 tree-sitter grammar WASMs + tree-sitter runtime. Committed to the repo so `bun --compile` embeds them deterministically via `import path from ... with { type: 'file' }`. The CI guard `scripts/check-wasm-embedded.sh` fails the build if the compiled binary ever silently falls through to recursive chunks.
-- `src/commands/code-def.ts` + `src/commands/code-refs.ts` (v0.19.0) — symbol definition + references lookup. Query `content_chunks.symbol_name` or chunk_text ILIKE with `page_kind='code'` filter. Auto-JSON when stdout is not a TTY (gh-CLI convention). Bypass the standard `searchKeyword` `DISTINCT ON (slug)` collapse so multiple call-sites from the same file surface.
-- `src/core/search/` — Hybrid search: vector + keyword + RRF + multi-query expansion + dedup. As of v0.22.0, `searchKeyword` / `searchKeywordChunks` / `searchVector` apply source-aware ranking at the SQL layer (curated content like `originals/`, `concepts/`, `writing/` outranks bulk content like `wintermute/chat/`, `daily/`, `media/x/`). `searchVector` uses a two-stage CTE so source-boost re-ranking doesn't kill the HNSW index. Hard-exclude prefixes (`test/`, `archive/`, `attachments/`, `.raw/` by default) filter at retrieval, not post-rank. Both gates honor `detail !== 'high'` so temporal queries surface chat pages normally.
+- `src/core/chunkers/` — 3-tier chunking (recursive, semantic, LLM-guided)
+- `src/core/search/` — Hybrid search: vector + keyword + RRF + multi-query expansion + dedup
 - `src/core/search/intent.ts` — Query intent classifier (entity/temporal/event/general → auto-selects detail level)
 - `src/core/search/eval.ts` — Retrieval eval harness: P@k, R@k, MRR, nDCG@k metrics + runEval() orchestrator
-- `src/core/search/source-boost.ts` (v0.22.0) — Source-type boost map keyed by slug prefix. `DEFAULT_SOURCE_BOOSTS` (originals/ 1.5, concepts/ 1.3, writing/ 1.4, people/companies/deals/ 1.2, daily/ 0.8, media/x/ 0.7, wintermute/chat/ 0.5) and `DEFAULT_HARD_EXCLUDES` (test/, archive/, attachments/, .raw/). `parseSourceBoostEnv` / `parseHardExcludesEnv` parse comma-separated `prefix:factor` pairs from `GBRAIN_SOURCE_BOOST` / `GBRAIN_SEARCH_EXCLUDE` env vars. `resolveBoostMap` and `resolveHardExcludes` merge defaults + env + caller `SearchOpts.exclude_slug_prefixes`/`include_slug_prefixes`.
-- `src/core/search/sql-ranking.ts` (v0.22.0) — Pure SQL string builders. `buildSourceFactorCase(slugColumn, boostMap, detail)` emits a CASE expression with longest-prefix-match wins (returns literal `'1.0'` when `detail === 'high'` for temporal-bypass parity with COMPILED_TRUTH_BOOST). `buildHardExcludeClause(slugColumn, prefixes)` emits `NOT (col LIKE 'p1%' OR col LIKE 'p2%')` — OR-chain wrapped in NOT, NOT `NOT LIKE ALL/ANY` (those quantifiers don't express set-exclusion). LIKE meta-character escape covers all three of `%`, `_`, AND `\` (backslash matters because it's Postgres LIKE's default escape char). Single-quote doubling on SQL string literals so injection-style inputs are inert text.
-- `src/commands/eval.ts` — `gbrain eval` command: single-run table + A/B config comparison. v0.25.0 adds sub-subcommand dispatch on `args[0]` so `gbrain eval export` + `gbrain eval prune` + `gbrain eval replay` route into session-capture handlers; bare `gbrain eval --qrels …` fall-through preserves the legacy IR-metrics flow.
-- `src/commands/eval-export.ts` (v0.25.0) — streams `eval_candidates` rows as NDJSON to stdout with `schema_version: 1` prefix on every line. EPIPE-safe, progress heartbeats on stderr, stable id-desc tiebreaker so `--since` windows never dupe/miss rows.
-- `src/commands/eval-prune.ts` (v0.25.0) — explicit retention cleanup. Requires `--older-than DUR`. `--dry-run` reports would-delete count.
-- `src/commands/eval-replay.ts` (v0.25.0) — contributor-facing replay tool. Reads NDJSON from `gbrain eval export`, re-runs each captured `query` / `search` op against the current brain, computes set-Jaccard@k between captured + current `retrieved_slugs`, top-1 stability rate, and latency Δ. Stable JSON shape (`schema_version: 1`) for CI gating; human mode prints a regression table. Pure Bun, zero new deps. The dev-loop half of BrainBench-Real that closes the gap between "data captured" and "data used to gate a PR." See `docs/eval-bench.md` for the workflow.
-- `docs/eval-bench.md` (v0.25.0) — contributor guide for using captured data to benchmark retrieval changes before merging. Linked from CONTRIBUTING.md under "Running real-world eval benchmarks (touching retrieval code)".
-- `src/core/eval-capture.ts` (v0.25.0) — op-layer capture wrapper called from `src/core/operations.ts` `query` + `search` handlers. Catches MCP + CLI + subagent tool-bridge from one site. Fire-and-forget; failures route to `engine.logEvalCaptureFailure` so `gbrain doctor` sees drops cross-process. **Capture is off by default** — `isEvalCaptureEnabled` resolution: explicit `config.eval.capture` (true/false) wins, else `process.env.GBRAIN_CONTRIBUTOR_MODE === '1'`, else off. Production users get a quiet brain; contributors set `export GBRAIN_CONTRIBUTOR_MODE=1` in `.zshrc` to enable the dev loop. PII scrubber gate is independent and defaults to true regardless of CONTRIBUTOR_MODE.
-- `src/core/eval-capture-scrub.ts` (v0.25.0) — zero-deps PII scrubber: emails, phones, SSN, Luhn-verified credit cards, JWT-shaped tokens, bearer tokens.
-- `src/core/search/hybrid.ts` — Cathedral II `Promise<SearchResult[]>` return shape unchanged in v0.25.0. Adds `onMeta?: (m: HybridSearchMeta) => void` callback so op-layer capture can record what hybridSearch actually did. Existing callers leave it undefined.
-- `docs/eval-capture.md` (v0.25.0) — stable NDJSON schema reference for gbrain-evals consumers.
-- `test/public-exports.test.ts` (v0.25.0 / R2) — runtime contract test. Imports each of the 17 public subpaths via package name and pins a canary symbol per module. Paired with `scripts/check-exports-count.sh`.
+- `src/commands/eval.ts` — `gbrain eval` command: single-run table + A/B config comparison
 - `src/core/embedding.ts` — OpenAI text-embedding-3-large, batch, retry, backoff
 - `src/core/check-resolvable.ts` — Resolver validation: reachability, MECE overlap, DRY checks, structured fix objects. v0.14.1: `CROSS_CUTTING_PATTERNS.conventions` is an array (notability gate accepts both `conventions/quality.md` and `_brain-filing-rules.md`). New `extractDelegationTargets()` parses `> **Convention:**`, `> **Filing rule:**`, and inline backtick references. DRY suppression is proximity-based via `DRY_PROXIMITY_LINES = 40`.
 - `src/core/repo-root.ts` — Shared `findRepoRoot(startDir?)` (v0.16.4): walks up from `startDir` (default `process.cwd()`) looking for `skills/RESOLVER.md`. Zero-dependency module imported by both `doctor.ts` and `check-resolvable.ts`. Parameterized `startDir` makes tests hermetic.
-- `src/commands/check-resolvable.ts` — Standalone CLI wrapper (v0.16.4) over `checkResolvable()`. Exports `parseFlags`, `resolveSkillsDir`, `DEFERRED`, `runCheckResolvable`. Exit rule: **1 on any issue (warnings OR errors)**, stricter than doctor's `ok` flag — honors README:259. Stable JSON envelope `{ok, skillsDir, report, autoFix, deferred, error, message}` — same shape on success and error paths. `--fix` path runs `autoFixDryViolations` BEFORE `checkResolvable` (same ordering as doctor). `scripts/skillify-check.ts` subprocess-calls `gbrain check-resolvable --json` (cached per process) and fails loud on binary-missing — no silent false-pass. **v0.19:** AGENTS.md workspaces now resolve natively (see `src/core/resolver-filenames.ts`) — gbrain inspects the 107-skill OpenClaw deployment whether the routing file is `RESOLVER.md` or `AGENTS.md`. `DEFERRED[]` is empty — Checks 5 + 6 shipped as real code, not issue URLs.
-- `src/core/resolver-filenames.ts` (v0.19) — central list of accepted routing filenames (`RESOLVER.md`, `AGENTS.md`). Shared by `findRepoRoot`, `check-resolvable`, and skillpack install so every code path walks the same fallback chain.
-- `src/commands/skillify.ts` + `src/core/skillify/{generator,templates}.ts` (v0.19) — `gbrain skillify scaffold <name>` creates all stubs for a new skill in one command: SKILL.md, script, tests, routing-eval.jsonl, resolver entry, filing-rules pointer. `gbrain skillify check <script>` runs the 10-step checklist (LLM evals, routing evals, check-resolvable gate, filing audit) against a candidate skill before it lands.
-- `src/commands/skillify-check.ts` (v0.19) — `gbrain skillpack-check` agent-readable health report. Exit 0/1/2 for CI pipeline gating; JSON for debugging. Wraps `check-resolvable --json`, `doctor --json`, and migration ledger into one payload so agents can decide whether a human action is required.
-- `src/commands/book-mirror.ts` (v0.25.1) — `gbrain book-mirror --chapters-dir <path> --slug <slug> [flags]`. Flagship of the v0.25.1 skills wave. Submits N read-only subagent jobs (one per chapter; `allowed_tools: ['get_page', 'search']`), waits for all via `waitForCompletion`, reads each child's `job.result`, assembles two-column markdown CLI-side, writes a single operator-trust `put_page` to `media/books/<slug>-personalized.md`. Codex HIGH-1 fix applied: trust narrowing happens at the tool-allowlist layer (subagents can't call put_page) instead of allowedSlugPrefixes — untrusted EPUB content cannot prompt-inject any people page. Cost-estimate prompt before launching; refuses to spend in non-TTY without `--yes`. Per-chapter idempotency keys (`book-mirror:<slug>:ch-<N>`) for retry-friendly re-runs. Partial-failure handling: assembles with completed chapters and a `## Failed chapters` section listing retries. Test surface: `test/book-mirror.test.ts` (9 cases — CLI registration + source invariants).
-- `src/commands/skillpack.ts` + `src/core/skillpack/{bundle,installer}.ts` (v0.19) — `gbrain skillpack install` drops gbrain's curated 25-skill bundle into a host workspace, managed-block style. Never clobbers local edits; tracks a skill manifest so subsequent `install --update` diffs cleanly. Bundle builder (`skillpack/bundle.ts`) packages the set from `skills/` into a versioned payload. **v0.24.0:** managed block embeds a `<!-- gbrain:skillpack:manifest cumulative-slugs="..." version="..." -->` receipt inside the fence. Per-skill installs accumulate via `union(prior_receipt, this_call)`; `install --all` is the only path that prunes (drops slugs no longer in the bundle). Rows inside the fence whose slug is in neither the new cumulative set nor the bundle survive as user-added with a stderr `[skillpack] unknown row in managed block: "<slug>" — Investigate: ...` warning. Pre-v0.24 fences upgrade silently on first install (extracted slugs become the prior cumulative set). **v0.25.1:** `gbrain skillpack uninstall <name>` lands as a real CLI subcommand. Inverse of install with symmetric data-loss posture: D8 refuses if the slug isn't in the cumulative-slugs receipt (won't nuke a hand-added row); D11 content-hash guard refuses if any installed file diverges from the bundle (you've edited it locally) unless `--overwrite-local` is passed. `applyUninstall` enforces an atomic-refusal contract: pre-scans ALL files for divergence; refuses BEFORE any unlink fires if anything is blocked. The bug fix landed via `test/skillpack-uninstall.test.ts`'s D11 case — the test was written with the contract in mind, the original implementation interleaved hash-check + unlink, and the lie surfaced immediately.
-- `src/core/archive-crawler-config.ts` (v0.25.1) — D12 + codex HIGH-4 safety gate for the `archive-crawler` skill. Refuses to run unless `archive-crawler.scan_paths:` is explicitly set in the brain repo's `gbrain.yml`. Mirrors the storage-config.ts parsing pattern (sibling file; separate concern from storage tiering). `loadArchiveCrawlerConfig(repoPath)` throws `ArchiveCrawlerConfigError(missing_section | empty_scan_paths | invalid_path | parse_error)`. `normalizeAndValidateArchiveCrawlerConfig` rejects relative paths and `..` traversal; `~` is expanded; trailing-slash normalized for unambiguous prefix matching. `isPathAllowed(candidate, config)` is the runtime per-file gate (scan_paths prefix-match with directory-boundary correctness; deny_paths overrides). Tests in `test/archive-crawler-config.test.ts` (19 cases).
-- `test/helpers/cli-pty-runner.ts` (v0.25.1) — generic real-PTY harness ported from gstack and trimmed to ~470 lines. Uses pure `Bun.spawn({terminal:})` (Bun 1.3.10+; engines.bun pin in package.json). Generic primitives only — no plan-mode orchestrators. Exports: `launchPty`, `resolveBinary`, `stripAnsi`, `parseNumberedOptions`, `optionsSignature`, `isNumberedOptionListVisible`, `isTrustDialogVisible`. Self-tests in `test/cli-pty-runner.test.ts` (24 cases).
-- `src/core/skill-manifest.ts` (v0.19) — parser for `skill-manifest.json` records. Used by skillpack installer to detect drift between the shipped bundle and the user's local edits, so updates merge instead of overwriting.
-- `src/commands/routing-eval.ts` + `src/core/routing-eval.ts` (v0.19) — `gbrain routing-eval` catches user phrasings that route to the wrong skill. Reads `skills/<name>/routing-eval.jsonl` fixtures (`{intent, expected_skill, ambiguous_with?}`). Structural layer runs in `check-resolvable` by default (zero API cost). The `--llm` flag is accepted as a placeholder for a future LLM tie-break layer; in v0.24.0 it emits a stderr notice and runs structural only. False positives surface before users hit them.
-- `src/core/filing-audit.ts` + `skills/_brain-filing-rules.json` (v0.19) — Check 6 of `check-resolvable`. Parses new `writes_pages:` / `writes_to:` frontmatter on skills and audits their filing claims against the filing-rules JSON. Warning-only in v0.19, upgrades to error in v0.20.
+- `src/commands/check-resolvable.ts` — Standalone CLI wrapper (v0.16.4) over `checkResolvable()`. Exports `parseFlags`, `resolveSkillsDir`, `DEFERRED`, `runCheckResolvable`. Exit rule: **1 on any issue (warnings OR errors)**, stricter than doctor's `ok` flag — honors README:259. Stable JSON envelope `{ok, skillsDir, report, autoFix, deferred, error, message}` — same shape on success and error paths. `--fix` path runs `autoFixDryViolations` BEFORE `checkResolvable` (same ordering as doctor). `deferred[]` array surfaces pending Checks 5 (trigger routing eval) and 6 (brain filing) with issue URLs. `scripts/skillify-check.ts` subprocess-calls `gbrain check-resolvable --json` (cached per process) and fails loud on binary-missing — no silent false-pass.
 - `src/core/dry-fix.ts` — `gbrain doctor --fix` engine. `autoFixDryViolations(fixes, {dryRun})` rewrites inlined rules to `> **Convention:** see [path](path).` callouts via three shape-aware expanders (bullet / blockquote / paragraph). Five guards: working-tree-dirty (`getWorkingTreeStatus()` returns 3-state `'clean' | 'dirty' | 'not_a_repo'`), no-git-backup, inside-code-fence, already-delegated (40-line proximity, consistent with detector), ambiguous-multi-match, block-is-callout. `execFileSync` array args (no shell — no injection surface). EOF newline preserved.
 - `src/core/backoff.ts` — Adaptive load-aware throttling: CPU/memory checks, exponential backoff, active hours multiplier
 - `src/core/fail-improve.ts` — Deterministic-first, LLM-fallback loop with JSONL failure logging and auto-test generation
 - `src/core/transcription.ts` — Audio transcription: Groq Whisper (default), OpenAI fallback, ffmpeg segmentation for >25MB
 - `src/core/enrichment-service.ts` — Global enrichment service: entity slug generation, tier auto-escalation, batch throttling
 - `src/core/data-research.ts` — Recipe validation, field extraction (MRR/ARR regex), dedup, tracker parsing, HTML stripping
-- `src/commands/embed.ts` — `gbrain embed [--stale|--all] [--slugs ...]`. v0.22.1 (#409, contributed by @atrevino47): `--stale` path now starts with `engine.countStaleChunks()` (single SELECT count(*) WHERE embedding IS NULL, ~50 bytes wire). On a fully-embedded brain that's a 1-line short-circuit — no further reads. When stale chunks exist, `engine.listStaleChunks()` returns just the chunks needing embeddings (slug + chunk_index + chunk_text + metadata, no `vector(1536)` payload). Caller groups by slug, embeds via OpenAI, re-upserts via `upsertChunks`. Replaces the prior page-walk that pulled every chunk's embedding column over the wire and discarded most.
-- `src/commands/extract.ts` — `gbrain extract links|timeline|all [--source fs|db]`: batch link/timeline extraction. fs walks markdown files, db walks pages from the engine (mutation-immune snapshot iteration; use this for live brains with no local checkout). As of v0.12.1 there is no in-memory dedup pre-load — candidates are buffered 100 at a time and flushed via `addLinksBatch` / `addTimelineEntriesBatch`; `ON CONFLICT DO NOTHING` enforces uniqueness at the DB layer, and the `created` counter returns real rows inserted (truthful on re-runs). v0.22.1 (#417): `ExtractOpts.slugs?: string[]` enables incremental extract — when set, `extractForSlugs()` reads ONLY those slugs' files (single combined links+timeline pass) instead of the full directory walk. CLI `gbrain extract` keeps full-walk behavior; the cycle path threads sync's `pagesAffected` through. `walkMarkdownFiles(brainDir)` still runs at line 455 to build `allSlugs` for link resolution — see `TODOS.md` for replacing it with `engine.getAllSlugs()`.
+- `src/commands/extract.ts` — `gbrain extract links|timeline|all [--source fs|db]`: batch link/timeline extraction. fs walks markdown files, db walks pages from the engine (mutation-immune snapshot iteration; use this for live brains with no local checkout). As of v0.12.1 there is no in-memory dedup pre-load — candidates are buffered 100 at a time and flushed via `addLinksBatch` / `addTimelineEntriesBatch`; `ON CONFLICT DO NOTHING` enforces uniqueness at the DB layer, and the `created` counter returns real rows inserted (truthful on re-runs).
 - `src/commands/graph-query.ts` — `gbrain graph-query <slug> [--type T] [--depth N] [--direction in|out|both]`: typed-edge relationship traversal (renders indented tree)
 - `src/core/link-extraction.ts` — shared library for the v0.12.0 graph layer. extractEntityRefs (canonical, replaces backlinks.ts duplicate) matches both `[Name](people/slug)` markdown links and Obsidian `[[people/slug|Name]]` wikilinks as of v0.12.3. extractPageLinks, inferLinkType heuristics (attended/works_at/invested_in/founded/advises/source/mentions), parseTimelineEntries, isAutoLinkEnabled config helper. `DIR_PATTERN` covers `people`, `companies`, `deals`, `topics`, `concepts`, `projects`, `entities`, `tech`, `finance`, `personal`, `openclaw`. Used by extract.ts, operations.ts auto-link post-hook, and backlinks.ts.
 - `src/core/minions/` — Minions job queue: BullMQ-inspired, Postgres-native (queue, worker, backoff, types, protected-names, quiet-hours, stagger, handlers/shell).
-- `src/core/minions/queue.ts` — MinionQueue class (submit, claim, complete, fail, stall detection, parent-child, depth/child-cap, per-job timeouts, cascade-kill, attachments, idempotency keys, child_done inbox, removeOnComplete/Fail). `add()` takes a 4th `trusted` arg (separate from `opts` to prevent spread leakage); protected names in `PROTECTED_JOB_NAMES` require `{allowProtectedSubmit: true}` and the check runs trim-normalized (whitespace-bypass safe). v0.14.1 #219: `add()` plumbs `max_stalled` through with a `[1, 100]` clamp; omitted values let the schema DEFAULT (5) kick in. v0.19.0: `handleWallClockTimeouts(lockDurationMs)` is Layer 3 kill shot for jobs where `FOR UPDATE SKIP LOCKED` stall detection and the timeout sweep both fail to evict (wedged worker holding a row lock via a pending transaction). v0.19.1: `maxWaiting` coalesce path now uses `pg_advisory_xact_lock` keyed on `(name, queue)` to serialize concurrent submits for the same key, and filters on `queue` in addition to `name` so cross-queue same-name jobs don't suppress each other.
-- `src/core/minions/worker.ts` — MinionWorker class (handler registry, lock renewal, graceful shutdown, timeout safety net). v0.14.0 abort-path fix: aborted jobs now call `failJob` with reason (`timeout`/`cancel`/`lock-lost`/`shutdown`) instead of returning silently. `shutdownAbort` (instance field) fires on process SIGTERM/SIGINT and propagates to `ctx.shutdownSignal` — shell handler listens to it; non-shell handlers don't. v0.22.1 (#403): per-job timeout fires `abort.abort(new Error('timeout'))` then a 30-second grace-then-evict safety net force-evicts the job from `inFlight` and marks it dead in DB if the handler ignores the abort signal — frees the slot even when a handler wedges (the 98-waiting-0-active prod incident driver).
-- `src/core/minions/supervisor.ts` — MinionSupervisor process manager. Spawns `gbrain jobs work` as a child, restarts on crash with exponential backoff, periodic health check. v0.22.1 (#406): `consecutiveHealthFailures` counter; on 3 consecutive failures emits `health_warn` with `reason: 'db_connection_degraded'` and calls `engine.reconnect()` to swap in a fresh pool, then resets the counter. Worker exit classifier emits `likely_cause` field on `worker_exited` events: `oom_or_external_kill` (SIGKILL), `graceful_shutdown` (SIGTERM), `runtime_error` (code 1), `clean_exit` (code 0), `unknown`.
+- `src/core/minions/queue.ts` — MinionQueue class (submit, claim, complete, fail, stall detection, parent-child, depth/child-cap, per-job timeouts, cascade-kill, attachments, idempotency keys, child_done inbox, removeOnComplete/Fail). `add()` takes a 4th `trusted` arg (separate from `opts` to prevent spread leakage); protected names in `PROTECTED_JOB_NAMES` require `{allowProtectedSubmit: true}` and the check runs trim-normalized (whitespace-bypass safe). v0.14.1 #219: `add()` plumbs `max_stalled` through with a `[1, 100]` clamp; omitted values let the schema DEFAULT (5) kick in.
+- `src/core/minions/worker.ts` — MinionWorker class (handler registry, lock renewal, graceful shutdown, timeout safety net). v0.14.0 abort-path fix: aborted jobs now call `failJob` with reason (`timeout`/`cancel`/`lock-lost`/`shutdown`) instead of returning silently. `shutdownAbort` (instance field) fires on process SIGTERM/SIGINT and propagates to `ctx.shutdownSignal` — shell handler listens to it; non-shell handlers don't.
 - `src/core/minions/types.ts` — `MinionJobInput` + `MinionJobStatus` + handler context types. `MinionJobInput.max_stalled` (new in v0.14.1) is optional; omitted values let the schema DEFAULT (5) kick in, provided values are clamped to `[1, 100]`.
 - `src/core/minions/protected-names.ts` — side-effect-free constant module exporting `PROTECTED_JOB_NAMES` + `isProtectedJobName()`. Kept pure so queue core can import without loading handler modules.
 - `src/core/minions/handlers/shell.ts` — `shell` job handler. Spawns `/bin/sh -c cmd` (absolute path, PATH-override-safe) or `argv[0] argv[1..]` (no shell). Env allowlist: `PATH, HOME, USER, LANG, TZ, NODE_ENV` + caller `env:` overrides. UTF-8-safe stdout/stderr tail via `string_decoder.StringDecoder`. Abort (either `ctx.signal` or `ctx.shutdownSignal`) fires SIGTERM → 5s grace → SIGKILL on child. Requires `GBRAIN_ALLOW_SHELL_JOBS=1` on worker (gated by `registerBuiltinHandlers`).
 - `src/core/minions/handlers/shell-audit.ts` — per-submission JSONL audit trail at `~/.gbrain/audit/shell-jobs-YYYY-Www.jsonl` (ISO-week rotation; override via `GBRAIN_AUDIT_DIR`). Best-effort: `mkdirSync(recursive)` + `appendFileSync`; failures logged to stderr, submission not blocked. Logs cmd (first 80 chars) or argv (JSON array). Never logs env values.
-- `src/core/minions/backpressure-audit.ts` (v0.19.1) — sibling of shell-audit.ts for `maxWaiting` coalesce events. JSONL at `~/.gbrain/audit/backpressure-YYYY-Www.jsonl`. Fires one line per coalesce with `(queue, name, waiting_count, max_waiting, returned_job_id, ts)`. Closes the silent-drop vector the v0.19.0 maxWaiting guard introduced.
 - `src/core/minions/handlers/subagent.ts` (v0.15) — LLM-loop handler. Two-phase tool persistence (pending → complete/failed), replay reconciliation for mid-dispatch crashes, dual-signal abort (`ctx.signal` + `ctx.shutdownSignal`), Anthropic prompt caching on system + tool defs. `makeSubagentHandler({engine, client?, ...})` factory; `MessagesClient` is an injectable interface the real SDK implements structurally. Throws `RateLeaseUnavailableError` (renewable) when rate-lease capacity is full.
 - `src/core/minions/handlers/subagent-aggregator.ts` (v0.15) — `subagent_aggregator` handler. Claims AFTER all children resolve (queue changes guarantee every terminal child posts a `child_done` inbox message with outcome). Reads inbox via `ctx.readInbox()`, builds deterministic mixed-outcome markdown summary. No LLM call in v0.15.
 - `src/core/minions/handlers/subagent-audit.ts` (v0.15) — JSONL audit + heartbeat writer at `~/.gbrain/audit/subagent-jobs-YYYY-Www.jsonl`. Events: `submission` (one line per submit) + `heartbeat` (per turn boundary: `llm_call_started | llm_call_completed | tool_called | tool_result | tool_failed`). Never logs prompts or tool inputs. `readSubagentAuditForJob(jobId, {sinceIso})` is the readback path for `gbrain agent logs`.
@@ -117,48 +68,30 @@ strict behavior when unset.
 - `src/core/minions/wait-for-completion.ts` (v0.15) — poll-until-terminal helper for CLI callers. `TimeoutError` does NOT cancel the job; `AbortSignal` exits without throwing. Default `pollMs`: 1000 on Postgres, 250 on PGLite inline.
 - `src/core/minions/transcript.ts` (v0.15) — renders `subagent_messages` + `subagent_tool_executions` to markdown. Tool rows splice under their owning assistant `tool_use` by `tool_use_id`. UTF-8-safe truncation; unknown block types fall through to fenced JSON.
 - `src/core/minions/plugin-loader.ts` (v0.15) — `GBRAIN_PLUGIN_PATH` discovery. Absolute paths only, left-wins collision, `gbrain.plugin.json` with `plugin_version: "gbrain-plugin-v1"`, plugins ship DEFS only (no new tools), `allowed_tools:` validated at load time against the derived registry.
-- `src/core/minions/tools/brain-allowlist.ts` (v0.15, extended v0.23) — derives subagent tool registry from `src/core/operations.ts`. 11-name allow-list. By default `put_page` schema is namespace-wrapped per subagent (`^wiki/agents/<subagentId>/.+`). **v0.23 trusted-workspace path:** when `BuildBrainToolsOpts.allowedSlugPrefixes` is set, the put_page schema instead describes the prefix list to the model and the OperationContext is threaded with `allowedSlugPrefixes`. Trust comes from `PROTECTED_JOB_NAMES` gating subagent submission — MCP cannot reach this field. Only cycle.ts (synthesize/patterns) and direct CLI submitters set it.
+- `src/core/minions/tools/brain-allowlist.ts` (v0.15) — derives subagent tool registry from `src/core/operations.ts`. 11-name allow-list: `query`, `search`, `get_page`, `list_pages`, `file_list`, `file_url`, `get_backlinks`, `traverse_graph`, `resolve_slugs`, `get_ingest_log`, `put_page`. `put_page` schema is namespace-wrapped per subagent (`^wiki/agents/<subagentId>/.+`); the `put_page` op's server-side check is the authoritative gate via `ctx.viaSubagent` fail-closed.
 - `src/mcp/tool-defs.ts` (v0.15) — extracted `buildToolDefs(ops)` helper. MCP server + subagent tool registry both call it; byte-for-byte equivalence pinned by `test/mcp-tool-defs.test.ts`.
 - `src/core/minions/attachments.ts` — Attachment validation (path traversal, null byte, oversize, base64, duplicate detection)
 - `src/commands/agent.ts` (v0.16) — `gbrain agent run <prompt> [flags]` CLI. Submits `subagent` (or N children + 1 aggregator) under `{allowProtectedSubmit: true}`. Single-entry `--fanout-manifest` short-circuits. Children get `on_child_fail: 'continue'` + `max_stalled: 3`. `--follow` is the default on TTY; streams logs + polls `waitForCompletion` in parallel. Ctrl-C detaches, does not cancel.
 - `src/commands/agent-logs.ts` (v0.16) — `gbrain agent logs <job> [--follow] [--since]`. Merges JSONL heartbeat audit + `subagent_messages` into a chronological timeline. `parseSince` accepts ISO-8601 or relative (`5m`, `1h`, `2d`). Transcript tail renders only for terminal jobs.
-- `src/commands/jobs.ts` — `gbrain jobs` CLI subcommands + `gbrain jobs work` daemon. v0.13.1 surfaces the full `MinionJobInput` retry/backoff/timeout/idempotency surface as first-class CLI flags on `jobs submit`: `--max-stalled`, `--backoff-type fixed|exponential`, `--backoff-delay`, `--backoff-jitter`, `--timeout-ms`, `--idempotency-key`. `jobs smoke --sigkill-rescue` is the opt-in regression guard for #219. v0.16 wires `registerBuiltinHandlers` to always register `subagent` + `subagent_aggregator` (no env flag — `ANTHROPIC_API_KEY` is the natural cost gate, trust is via `PROTECTED_JOB_NAMES`) and loads `GBRAIN_PLUGIN_PATH` plugins at worker startup with a loud startup-line per plugin. `shell` handler still gated by `GBRAIN_ALLOW_SHELL_JOBS=1` (RCE surface, separate concern). v0.22.10 (#521): the `autopilot-cycle` handler now forwards `job.data.phases` to `runCycle` (was previously discarded — caller-supplied phase selection silently became a full cycle). Phases are validated against `ALL_PHASES` from `src/core/cycle.ts`; invalid names are filtered out and an empty/missing array falls back to the default 6-phase cycle. v0.22.13 (PR #490 CODEX-1+CODEX-4): `sync` handler now resolves `sourceId` at entry by looking up `sources.local_path` (mirrors `cycle.ts:480`'s autopilot fix from PR #475) so multi-source brains read the per-source `last_commit` anchor instead of the global config key. Concurrency routed through the shared `autoConcurrency()` policy in `src/core/sync-concurrency.ts` instead of the prior hardcoded `4`; PGLite stays serial. `noEmbed` default is `true` (embed is a separate job — submit `gbrain embed --stale` after sync, or rely on the autopilot cycle's embed phase).
+- `src/commands/jobs.ts` — `gbrain jobs` CLI subcommands + `gbrain jobs work` daemon. v0.13.1 surfaces the full `MinionJobInput` retry/backoff/timeout/idempotency surface as first-class CLI flags on `jobs submit`: `--max-stalled`, `--backoff-type fixed|exponential`, `--backoff-delay`, `--backoff-jitter`, `--timeout-ms`, `--idempotency-key`. `jobs smoke --sigkill-rescue` is the opt-in regression guard for #219. v0.16 wires `registerBuiltinHandlers` to always register `subagent` + `subagent_aggregator` (no env flag — `ANTHROPIC_API_KEY` is the natural cost gate, trust is via `PROTECTED_JOB_NAMES`) and loads `GBRAIN_PLUGIN_PATH` plugins at worker startup with a loud startup-line per plugin. `shell` handler still gated by `GBRAIN_ALLOW_SHELL_JOBS=1` (RCE surface, separate concern).
 - `src/commands/features.ts` — `gbrain features --json --auto-fix`: usage scan + feature adoption salesman
 - `src/commands/autopilot.ts` — `gbrain autopilot --install`: self-maintaining brain daemon (sync+extract+embed)
-- `src/mcp/server.ts` — MCP stdio server (generated from operations). v0.22.7: tool-call handler delegates to `dispatchToolCall` from `src/mcp/dispatch.ts` so stdio + HTTP transports share one validation, context-build, and error-format path.
-- `src/mcp/dispatch.ts` (v0.22.7) — Shared tool-call dispatch consumed by both stdio (`server.ts`) and HTTP transports. Exports `dispatchToolCall(engine, name, params, opts)`, `buildOperationContext(engine, params, opts)`, and `validateParams(op, params)`. Single source of truth for `(ctx, params)` handler arg order and the 5-field `OperationContext` shape (engine + config + logger + dryRun + remote). Defaults to `remote: true` (untrusted); local CLI callers pass `remote: false`. Closed F1/F2/F3 drift bugs in the original v0.22.5 HTTP transport.
-- `src/mcp/rate-limit.ts` (v0.22.7) — Bounded-LRU token-bucket limiter. `buildDefaultLimiters()` returns the two-bucket pipeline: pre-auth IP (30/60s, fires BEFORE the DB lookup so brute-force load against `access_tokens` is actually capped) + post-auth token-id (60/60s). Tracks `lastTouchedMs` separately from `lastRefillMs` so an exhausted key can't be reset by hammering past the TTL. LRU cap bounds memory under attacker-controlled key growth.
-- `src/commands/serve-http.ts` (v0.26.0) — Express 5 HTTP MCP server with OAuth 2.1, admin dashboard, and SSE live activity feed. Started via `gbrain serve --http [--port N] [--token-ttl N] [--enable-dcr] [--public-url URL]`. Supersedes the v0.22.7 `src/mcp/http-transport.ts` simple bearer-auth path. Combines MCP SDK's `mcpAuthRouter` (authorize / token / register / revoke endpoints), a custom `client_credentials` handler (SDK's token endpoint throws `UnsupportedGrantTypeError` for CC; the custom handler runs BEFORE the router and falls through for `auth_code` / `refresh_token`), `requireBearerAuth` middleware for `/mcp` with scope enforcement before op dispatch, `localOnly` rejection, and `express-rate-limit` at 50 req / 15 min on `/token`. Serves the built admin SPA from `admin/dist/` with SPA fallback. `/admin/events` SSE endpoint broadcasts every MCP request to connected admin browsers. `cookie-parser` middleware wired (Express 5 has no built-in). Startup logging prints port, engine, configured issuer URL (honors `--public-url`), registered-client count, DCR status, and admin bootstrap token.
-- `src/core/oauth-provider.ts` (v0.26.0) — `GBrainOAuthProvider` implementing the MCP SDK's `OAuthServerProvider` + `OAuthRegisteredClientsStore` interfaces. Backed by raw SQL (works on both PGLite and Postgres — OAuth is infrastructure, not a BrainEngine concern). Full OAuth 2.1 spec: `authorize` + `exchangeAuthorizationCode` with PKCE (for ChatGPT), `client_credentials` (for Perplexity / Claude), `refresh_token` with rotation, `revokeToken`, `registerClient` (DCR path validates redirect_uri must be `https://` or loopback per RFC 6749 §3.1.2.1). All tokens + client secrets SHA-256 hashed before storage. Auth codes single-use with 10-minute TTL via atomic `DELETE...RETURNING` (closes RFC 6749 §10.5 TOCTOU race). Refresh rotation also `DELETE...RETURNING` (closes §10.4 stolen-token detection bypass). `pgArray()` escapes commas/quotes/braces in elements so a comma-bearing redirect_uri can't smuggle a second array element. Legacy `access_tokens` fallback in `verifyAccessToken` grandfathers pre-v0.26 bearer tokens as `read+write+admin`. `sweepExpiredTokens()` runs on startup wrapped in try/catch. **v0.26.2:** module-private `coerceTimestamp()` boundary helper at the top of the file normalizes postgres-driver-as-string BIGINT columns to JS numbers at every read site (5 call sites: `getClient` L112+L113 for DCR `/register` RFC 7591 §3.2.1 numeric timestamps, `exchangeRefreshToken` L274 + `verifyAccessToken` L296+L303 for the SDK's `typeof === 'number'` bearerAuth check). Throws on non-finite input (NaN/Infinity) so corrupt rows fail loud at the boundary instead of riding through as `expiresAt: NaN`; returns undefined for SQL NULL so callers decide NULL semantics explicitly (refresh + access token paths treat NULL as expired). Helper intentionally NOT promoted to `src/core/utils.ts` — codex review flagged repo-wide BIGINT precision-loss risk for a generic helper.
-- `admin/` (v0.26.0) — React 19 + Vite + TypeScript admin SPA embedded in the binary via `admin/dist/` served by `serve-http.ts`. 7 screens: Login (bootstrap token → session cookie), Dashboard (metrics + SSE feed + token health), Agents (sortable table + sparklines + Register button), Register (modal with scope checkboxes + grant type selector), Credentials reveal (full-screen modal with Copy + Download JSON + yellow one-time-only warning), Request Log (filterable paginated), Agent Detail drawer (Details / Activity / Config Export tabs + Revoke). Design tokens: `#0a0a0f` bg, Inter for UI, JetBrains Mono for data, 4-32px spacing scale, rounded pill badges. HTTP-only SameSite=Strict cookie auth. 65KB gzip. Build: `cd admin && bun install && bun run build`; output at `admin/dist/` is committed for self-contained binaries.
-- `src/commands/auth.ts` — Token management. `gbrain auth create/list/revoke/test` for legacy bearer tokens (v0.22.7 wired as a first-class CLI subcommand) plus `gbrain auth register-client` (v0.26.0) and `gbrain auth revoke-client <client_id>` (v0.26.2) for OAuth 2.1 client lifecycle. `revoke-client` runs an atomic `DELETE...RETURNING` on `oauth_clients`; FK `ON DELETE CASCADE` on `oauth_tokens.client_id` and `oauth_codes.client_id` purges every active token + authorization code in a single transaction. `process.exit(1)` on no-such-client (idempotent — re-running on the same id produces the same exit-1 message). Legacy tokens stored as SHA-256 hashes in `access_tokens`; OAuth clients in `oauth_clients`. As of v0.26.0, legacy tokens grandfather to `read+write+admin` scopes on the OAuth HTTP server, so pre-v0.26 deployments keep working with no migration.
+- `src/mcp/server.ts` — MCP stdio server (generated from operations)
+- `src/commands/auth.ts` — Standalone token management (create/list/revoke/test)
 - `src/commands/upgrade.ts` — Self-update CLI. `runPostUpgrade()` enumerates migrations from the TS registry (src/commands/migrations/index.ts) and tail-calls `runApplyMigrations(['--yes', '--non-interactive'])` so the mechanical side of every outstanding migration runs unconditionally.
 - `src/commands/migrations/` — TS migration registry (compiled into the binary; no filesystem walk of `skills/migrations/*.md` needed at runtime). `index.ts` lists migrations in semver order. `v0_11_0.ts` = Minions adoption orchestrator (8 phases). `v0_12_0.ts` = Knowledge Graph auto-wire orchestrator (5 phases: schema → config check → backfill links → backfill timeline → verify). `phaseASchema` has a 600s timeout (bumped from 60s in v0.12.1 for duplicate-heavy brains). `v0_12_2.ts` = JSONB double-encode repair orchestrator (4 phases: schema → repair-jsonb → verify → record). `v0_14_0.ts` = shell-jobs + autopilot cooperative (2 phases: schema ALTER minion_jobs.max_stalled SET DEFAULT 3 — superseded by v0.14.3's schema-level DEFAULT 5 + UPDATE backfill; pending-host-work ping for skills/migrations/v0.14.0.md). All orchestrators are idempotent and resumable from `partial` status. As of v0.14.2 (Bug 3), the RUNNER owns all ledger writes — orchestrators return `OrchestratorResult` and `apply-migrations.ts` persists a canonical `{version, status, phases}` shape after return. Orchestrators no longer call `appendCompletedMigration` directly. `statusForVersion` prefers `complete` over `partial` (never regresses). 3 consecutive partials → wedged → `--force-retry <version>` writes a `'retry'` reset marker. v0.14.3 (fix wave) ships schema-only migrations v14 (`pages_updated_at_index`) + v15 (`minion_jobs_max_stalled_default_5` with UPDATE backfill) via the `MIGRATIONS` array in `src/core/migrate.ts` — no orchestrator phases needed.
 - `src/commands/repair-jsonb.ts` — `gbrain repair-jsonb [--dry-run] [--json]`: rewrites `jsonb_typeof='string'` rows in place across 5 affected columns (pages.frontmatter, raw_data.data, ingest_log.pages_updated, files.metadata, page_versions.frontmatter). Fixes v0.12.0 double-encode bug on Postgres; PGLite no-ops. Idempotent.
 - `src/commands/orphans.ts` — `gbrain orphans [--json] [--count] [--include-pseudo]`: surfaces pages with zero inbound wikilinks, grouped by domain. Auto-generated/raw/pseudo pages filtered by default. Also exposed as `find_orphans` MCP operation. Shipped in v0.12.3 (contributed by @knee5).
-- `src/commands/integrity.ts` — `gbrain integrity check|auto|review|extract`: bare-tweet detection, dead-link detection, three-bucket repair (auto-repair / review-queue / skip). `scanIntegrity()` is the shared library function called from `gbrain doctor` (sampled at limit=500) and `cmdCheck` (full scan). v0.22.8: batch-load fast path on Postgres uses `SELECT DISTINCT ON (slug)` in a single SQL query to fix the PgBouncer round-trip timeout (60s → ~6s) while preserving `engine.getAllSlugs()`'s `Set<string>` semantics on multi-source brains. Gated by `engine.kind === 'postgres'` at the call site so PGLite never enters batch; fallback `catch` logs at `GBRAIN_DEBUG=1` so real Postgres errors are diagnosable.
-- `src/commands/doctor.ts` — `gbrain doctor [--json] [--fast] [--fix] [--dry-run] [--index-audit]`: health checks. v0.12.3 added `jsonb_integrity` + `markdown_body_completeness` reliability checks. v0.14.1: `--fix` delegates inlined cross-cutting rules to `> **Convention:** see [path](path).` callouts (pipes DRY violations into `src/core/dry-fix.ts`); `--fix --dry-run` previews without writing. v0.14.2: `schema_version` check fails loudly when `version=0` (migrations never ran — the #218 `bun install -g` signature) and routes users to `gbrain apply-migrations --yes`; new opt-in `--index-audit` flag (Postgres-only) reports zero-scan indexes from `pg_stat_user_indexes` (informational only, no auto-drop). v0.15.2: every DB check is wrapped in a progress phase; `markdown_body_completeness` runs under a 1s heartbeat timer so 10+ min scans are observable on 50K-page brains. v0.19.1 added `queue_health` (Postgres-only) with two subchecks: stalled-forever active jobs (started_at > 1h) and waiting-depth-per-name > threshold (default 10, override via `GBRAIN_QUEUE_WAITING_THRESHOLD`). Worker-heartbeat subcheck intentionally deferred to follow-up B7 because it needs a `minion_workers` table to produce ground-truth signal. Fix hints point at `gbrain repair-jsonb`, `gbrain sync --force`, `gbrain apply-migrations`, and `gbrain jobs get/cancel <id>`. v0.22.12 (#500): `sync_failures` check shows `[CODE=N, ...]` breakdown for both unacked entries (warn) and acked-historical entries (ok), surfacing systemic failure modes (`SLUG_MISMATCH=2685`) instead of a bare count.
-- `src/core/migrate.ts` — schema-migration runner. Owns the `MIGRATIONS` array (source of truth for schema DDL). v0.14.2 extended the `Migration` interface with `sqlFor?: { postgres?, pglite? }` (engine-specific SQL overrides `sql`) and `transaction?: boolean` (set to false for `CREATE INDEX CONCURRENTLY`, which Postgres refuses inside a transaction; ignored on PGLite since it has no concurrent writers). Migration v14 (fix wave) uses a handler branching on `engine.kind` to run CONCURRENTLY on Postgres (with a pre-drop of any invalid remnant via `pg_index.indisvalid`) and plain `CREATE INDEX` on PGLite. v15 bumps `minion_jobs.max_stalled` default 1→5 and backfills existing non-terminal rows. v0.22.6.1: migration v24 (`rls_backfill_missing_tables`) uses `sqlFor: { pglite: '' }` to no-op on PGLite — PGLite has no RLS engine and is single-tenant by definition, and the v24 ALTERs target subagent tables that don't exist in pglite-schema.ts. Closes #395 (contributed by @jdcastro2). **v30 (v0.23):** creates `dream_verdicts (file_path TEXT, content_hash TEXT, worth_processing BOOL, reasons JSONB, judged_at TIMESTAMPTZ, PK(file_path, content_hash))`. RLS-enabled when running as a BYPASSRLS role. The synthesize phase reads/writes this table to avoid re-judging on backfill re-runs.
+- `src/commands/doctor.ts` — `gbrain doctor [--json] [--fast] [--fix] [--dry-run] [--index-audit]`: health checks. v0.12.3 added `jsonb_integrity` + `markdown_body_completeness` reliability checks. v0.14.1: `--fix` delegates inlined cross-cutting rules to `> **Convention:** see [path](path).` callouts (pipes DRY violations into `src/core/dry-fix.ts`); `--fix --dry-run` previews without writing. v0.14.2: `schema_version` check fails loudly when `version=0` (migrations never ran — the #218 `bun install -g` signature) and routes users to `gbrain apply-migrations --yes`; new opt-in `--index-audit` flag (Postgres-only) reports zero-scan indexes from `pg_stat_user_indexes` (informational only, no auto-drop). v0.15.2: every DB check is wrapped in a progress phase; `markdown_body_completeness` runs under a 1s heartbeat timer so 10+ min scans are observable on 50K-page brains. Fix hints point at `gbrain repair-jsonb`, `gbrain sync --force`, and `gbrain apply-migrations`.
+- `src/core/migrate.ts` — schema-migration runner. Owns the `MIGRATIONS` array (source of truth for schema DDL). v0.14.2 extended the `Migration` interface with `sqlFor?: { postgres?, pglite? }` (engine-specific SQL overrides `sql`) and `transaction?: boolean` (set to false for `CREATE INDEX CONCURRENTLY`, which Postgres refuses inside a transaction; ignored on PGLite since it has no concurrent writers). Migration v14 (fix wave) uses a handler branching on `engine.kind` to run CONCURRENTLY on Postgres (with a pre-drop of any invalid remnant via `pg_index.indisvalid`) and plain `CREATE INDEX` on PGLite. v15 bumps `minion_jobs.max_stalled` default 1→5 and backfills existing non-terminal rows.
 - `src/core/progress.ts` — Shared bulk-action progress reporter. Writes to stderr. Modes: `auto` (TTY: `\r`-rewriting; non-TTY: plain lines), `human`, `json` (JSONL), `quiet`. Rate-gated by `minIntervalMs` and `minItems`. `startHeartbeat(reporter, note)` helper for single long queries. `child()` composes phase paths. Singleton SIGINT/SIGTERM coordinator emits `abort` events for every live phase. EPIPE defense on both sync throws and stream `'error'` events. Zero dependencies. Introduced in v0.15.2.
 - `src/core/cli-options.ts` — Global CLI flag parser. `parseGlobalFlags(argv)` returns `{cliOpts, rest}` with `--quiet` / `--progress-json` / `--progress-interval=<ms>` stripped. `getCliOptions()` / `setCliOptions()` expose a module-level singleton so commands reach the resolved flags without parameter threading. `cliOptsToProgressOptions()` maps to reporter options. `childGlobalFlags()` returns the flag suffix to append to `execSync('gbrain ...')` calls in migration orchestrators. `OperationContext.cliOpts` extends shared-op dispatch for MCP callers.
-- `src/core/db-lock.ts` (v0.22.13) — generic `tryAcquireDbLock(engine, lockId, ttlMinutes)` over the existing `gbrain_cycle_locks` table. Parameterized lock id so different scopes can nest cleanly: `gbrain-cycle` for the broad cycle (held by `cycle.ts`) and `gbrain-sync` (`SYNC_LOCK_ID` constant) for `performSync`'s narrower writer window. Same UPSERT-with-TTL semantics as the prior cycle-only helper, just generalized. Survives PgBouncer transaction pooling (unlike session-scoped `pg_try_advisory_lock`); crashed holders auto-release once their TTL expires.
-- `src/core/sync-concurrency.ts` (v0.22.13) — single source of truth for the parallel-sync policy. Exports `autoConcurrency(engine, fileCount, override?)` (PGLite always serial; explicit override clamped to >=1; auto path returns `DEFAULT_PARALLEL_WORKERS=4` when `fileCount > AUTO_CONCURRENCY_FILE_THRESHOLD=100`), `shouldRunParallel(workers, fileCount, explicit)` (Q1: explicit `--workers` bypasses the >50-file floor), and `parseWorkers(s)` (rejects `'0'`, `'-3'`, `'foo'`, `'1.5'`, trailing chars — replaces the prior parseInt-with-no-validation in both `sync.ts` and `import.ts`). Used by `performSync`, `performFullSync`, `runImport`, and the Minion `sync` handler so the three sites can no longer drift.
-- `src/commands/sync.ts` — `gbrain sync` CLI + the `performSync` / `performFullSync` library entrypoints (consumed by the autopilot cycle and the Minion sync handler). v0.22.13 (PR #490): `performSync` wraps its body in a `gbrain-sync` writer lock so two concurrent syncs (manual + autopilot, two terminals, two Conductor workspaces) cannot both write `last_commit` and let the last writer win. Head-drift gate after the import phase re-checks `git rev-parse HEAD`; if HEAD moved (someone ran `git checkout` / `git pull` mid-sync), the bookmark refuses to advance. Vanished files now record a failedFiles entry instead of silent-skip — the silent-skip-then-advance pathology that survived prior hardening passes is dead. Worker engines wrap in try/finally so disconnect always fires (panic-path leak fix). Both PGLite-detection sites use `engine.kind === 'pglite'`. CLI accepts `--workers N` (alias `--concurrency N`), validated via `parseWorkers`. Explicit `--workers` bypasses the auto-path file-count floor; auto path defers to `autoConcurrency()`. Banner moved to stderr.
-- `src/core/cycle.ts` — v0.17 brain maintenance cycle primitive (extended to **8 phases in v0.23**). `runCycle(engine: BrainEngine | null, opts: CycleOpts): Promise<CycleReport>` composes phases in semantically-driven order: **lint → backlinks → sync → synthesize → extract → patterns → embed → orphans**. v0.23's `synthesize` phase runs after sync (cross-references see fresh brain) and before extract (auto-link materializes its writes); `patterns` runs after extract so it reads a fresh graph (codex finding #7 — subagent put_page sets `ctx.remote=true` and skips auto-link/timeline by default; extract is the canonical materialization). Three callers: `gbrain dream` CLI, `gbrain autopilot` daemon's inline path, and the Minions `autopilot-cycle` handler. Coordination via `gbrain_cycle_locks` DB table + `~/.gbrain/cycle.lock` file lock with PID-liveness for PGLite. `CycleReport.schema_version: "1"` is stable; totals additively grew in v0.23 (`transcripts_processed`, `synth_pages_written`, `patterns_written`). `yieldBetweenPhases` runs between phases. **v0.23 added `yieldDuringPhase`** for in-phase keepalive — synthesize/patterns call it during long waits to renew the cycle-lock TTL. Engine nullable; lock-skip on read-only phase selections. v0.22.1 (#403): `CycleOpts.signal?: AbortSignal` propagates the worker's abort signal; `checkAborted()` fires between every phase. v0.22.1 (#417): `runPhaseSync` returns `pagesAffected` via `SyncPhaseResult`; `runCycle` captures it and threads to `runPhaseExtract` as the 4th arg. v0.22.1 (Codex F2): `runPhaseSync` takes `willRunExtractPhase: boolean` and sets `noExtract: phases.includes('extract')` so `gbrain dream --phase sync` doesn't silently lose extraction. v0.22.5 (#475): `resolveSourceForDir(engine, brainDir)` threads `sourceId` to `performSync()` so sync reads the per-source `sources.last_commit` anchor instead of the drift-prone global `config.sync.last_commit` key.
-- `src/core/cycle/synthesize.ts` (v0.23) — Synthesize phase: conversation-transcript-to-brain pipeline. Reads from `dream.synthesize.session_corpus_dir`, runs cheap Haiku verdict (cached in `dream_verdicts`), then fans out one Sonnet subagent per worth-processing transcript with `allowed_slug_prefixes` (sourced from `skills/_brain-filing-rules.json` `dream_synthesize_paths.globs`). Orchestrator collects slugs from `subagent_tool_executions` (NOT `pages.updated_at` — codex finding #2) and reverse-renders DB → markdown via `serializeMarkdown`. Cooldown via `dream.synthesize.last_completion_ts`, written ONLY on success. Idempotency key `dream:synth:<file_path>:<content_hash>`. Auto-commit deferred to v1.1 (codex #5). `--dry-run` runs Haiku, skips Sonnet (codex #8). Subagent never gets fs-write access. **v0.23.2:** `renderPageToMarkdown` (now exported) stamps `dream_generated: true` and `dream_cycle_date` into every reverse-write's frontmatter; `writeSummaryPage` does the same on the dream-cycle summary index. The marker is the explicit identity surface checked by `isDreamOutput` in `transcript-discovery.ts` — replaces the v0.23.1 content-prefix heuristic that could miss real output (`serializeMarkdown` doesn't embed slugs in body) and false-positive on user transcripts citing brain pages. `judgeSignificance` and `JudgeClient` are exported; `judgeSignificance` accepts a `verdictModel` parameter (default `claude-haiku-4-5-20251001`) loaded from `dream.synthesize.verdict_model` via `loadSynthConfig`.
-- `src/core/cycle/patterns.ts` (v0.23) — Patterns phase: cross-session theme detection over reflections within `dream.patterns.lookback_days` (default 30). Names a pattern only when ≥`dream.patterns.min_evidence` (default 3) reflections support it. Single Sonnet subagent; same allow-list path as synthesize. Runs AFTER `extract` so the graph is fresh.
-- `src/core/cycle/transcript-discovery.ts` (v0.23) — Pure filesystem walk for synthesize. `discoverTranscripts(opts)` filters `.txt` files by date range, min_chars, and word-boundary regex `excludePatterns` (Q-3: `medical` matches "medical advice" but NOT "comedical"; power users may pass full regex). `readSingleTranscript(path)` is the `gbrain dream --input <file>` ad-hoc path. **v0.23.2 self-consumption guard:** `DREAM_OUTPUT_MARKER_RE` (anchored at frontmatter open `---\n`, optional BOM + CRLF tolerance, scans first 2000 chars for `dream_generated: true` with case-insensitive value and word boundary on `true`) drives `isDreamOutput(content, bypass=false)`. Both `discoverTranscripts` and `readSingleTranscript` skip matching files and emit a `[dream] skipped <basename>: dream_generated marker` stderr log (no more silent skips). `bypassGuard?: boolean` on `DiscoverOpts` and `readSingleTranscript`'s opts disables the guard for the explicit `--unsafe-bypass-dream-guard` escape hatch only — never auto-applied for `--input`. Replaces v0.23.1's `DREAM_OUTPUT_SLUGS` content-prefix list.
-- `src/commands/dream.ts` — v0.17 `gbrain dream` CLI; ~80-line thin alias over `runCycle`. brainDir resolution requires explicit `--dir` OR `sync.repo_path` config. Flags: `--dry-run`, `--json`, `--phase <name>`, `--pull`, `--dir <path>`. **v0.23 added** `--input <file>` (ad-hoc transcript, implies `--phase synthesize`), `--date YYYY-MM-DD`, `--from <d> --to <d>` (backfill range). Conflict detection: `--input` + `--date` exits 2. ISO date validation. `--dry-run` runs Haiku significance verdict but skips Sonnet synthesis (codex finding #8 — NOT zero LLM calls). Exit code 1 on status=failed. **v0.23.2 added** `--unsafe-bypass-dream-guard` (long-form intentional, plumbed through `runCycle.synthBypassDreamGuard` → `SynthesizePhaseOpts.bypassDreamGuard` → `discoverTranscripts({bypassGuard})` and `readSingleTranscript({bypassGuard})`). Loud stderr warning fires at synthesize-phase entry when set. Never auto-applied for `--input` so any caller can't silently re-trigger the loop bug.
-- `src/commands/friction.ts` + `src/core/friction.ts` (v0.23) — `gbrain friction {log,render,list,summary}` reporter. Append-only JSONL under `$GBRAIN_HOME/friction/<run-id>.jsonl`. Schema is a flat extension of `StructuredAgentError` (D20). Render groups by severity → phase, defaults to `--redact` for md output (strips `$HOME`/`$CWD` to placeholders so reports paste safely in PRs). Run-id resolves from `--run-id` > `$GBRAIN_FRICTION_RUN_ID` > `standalone.jsonl`. Skills the claw-test exercises gain a `_friction-protocol.md` callout so agents know when to log friction.
-- `src/commands/claw-test.ts` + `src/core/claw-test/` (v0.23) — `gbrain claw-test [--scenario <name>] [--live --agent openclaw]`. End-to-end "fresh user" friction harness. Two modes: scripted (CI gate, agent-free) and live (real openclaw subprocess, $1–2 in tokens). Sets `GBRAIN_HOME=<tempdir>` for hermeticity and captures gbrain's `--progress-json` events from each child's stderr to verify expected phases ran (`import.files`, `extract.links_fs`, `doctor.db_checks`). Phases for scripted mode: setup → install_brain (`gbrain init --pglite`) → import (`--no-embed`) → query → extract → verify (`gbrain doctor --json`, asserts `status: 'ok'`) → render. Live mode hands `BRIEF.md` from `test/fixtures/claw-test-scenarios/<name>/` to the agent runner. v1 ships with the OpenClaw runner only (`src/core/claw-test/runners/openclaw.ts`, invokes `openclaw agent --local --agent <name> --message <brief>`); hermes runner deferred to v1.1. Transcript capture (`transcript-capture.ts`) uses `fs.createWriteStream` with `'drain'`-event backpressure — D17 fix for the 256KB-burst child-stall scenario. v0.18 upgrade scenario seeded via `seed-pglite.ts` SQL replay.
-- `skills/_friction-protocol.md` (v0.23) — shared cross-cutting convention skill (like `_brain-filing-rules.md`). Tells agents when to call `gbrain friction log` and how to choose a severity. Routes to friction CLI from any skill the claw-test exercises.
+- `src/core/cycle.ts` — v0.17 brain maintenance cycle primitive. `runCycle(engine: BrainEngine | null, opts: CycleOpts): Promise<CycleReport>` composes 6 phases in semantically-driven order (lint → backlinks → sync → extract → embed → orphans). Three callers: `gbrain dream` CLI, `gbrain autopilot` daemon's inline path, and the Minions `autopilot-cycle` handler (`src/commands/jobs.ts`). One source of truth for what the brain does overnight. Coordination via `gbrain_cycle_locks` DB table (TTL-based; works through PgBouncer transaction pooling, unlike session-scoped `pg_try_advisory_lock`) + `~/.gbrain/cycle.lock` file lock with PID-liveness for PGLite / engine=null mode. `CycleReport.schema_version: "1"` is the stable agent-consumable shape. `PhaseResult.error: { class, code, message, hint?, docs_url? }` is Stripe-API-tier structured failure info. `yieldBetweenPhases` hook awaited between every phase — Minions handler uses this to renew its job lock and prevent v0.14 stall-death regression. Engine nullable: filesystem phases (lint, backlinks) run without DB; DB phases skip with `status: "skipped", reason: "no_database"`. Lock-skip: read-only phase selections (`--phase orphans`) bypass the cycle lock.
+- `src/commands/dream.ts` — v0.17 `gbrain dream` CLI. ~80-line thin alias over `runCycle`. brainDir resolution requires explicit `--dir` OR `sync.repo_path` config (no more walk-up-cwd-for-.git footgun). Flags: `--dry-run`, `--json`, `--phase <name>`, `--pull`, `--dir <path>`. Exit code 1 on status=failed (partial/warn not fatal — don't page on warnings).
 - `scripts/check-progress-to-stdout.sh` — CI guard against regressing to `\r`-on-stdout progress. Wired into `bun run test` via `scripts/check-progress-to-stdout.sh && bun test` in package.json.
 - `docs/progress-events.md` — Canonical JSON event schema reference. Stable from v0.15.2, additive only.
 - `src/core/markdown.ts` — Frontmatter parsing + body splitter. `splitBody` requires an explicit timeline sentinel (`<!-- timeline -->`, `--- timeline ---`, or `---` immediately before `## Timeline`/`## History`). Plain `---` in body text is a markdown horizontal rule, not a separator. `inferType` auto-types `/wiki/analysis/` → analysis, `/wiki/guides/` → guide, `/wiki/hardware/` → hardware, `/wiki/architecture/` → architecture, `/writing/` → writing (plus the existing people/companies/deals/etc heuristics).
 - `scripts/check-jsonb-pattern.sh` — CI grep guard. Fails the build if anyone reintroduces (a) the `${JSON.stringify(x)}::jsonb` interpolation pattern (postgres.js v3 double-encodes it), or (b) `max_stalled INTEGER NOT NULL DEFAULT 1` in any schema source file (v0.15.1 #219 regression guard — must be DEFAULT 5 to preserve SIGKILL-rescue). Wired into `bun test`.
-- `docker-compose.ci.yml` + `scripts/ci-local.sh` (v0.23.1) — Local CI gate. `bun run ci:local` spins up `pgvector/pgvector:pg16` + `oven/bun:1` with named volumes (`gbrain-ci-pg-data`, `gbrain-ci-node-modules`, `gbrain-ci-bun-cache`), runs gitleaks on host, smoke-tests `scripts/run-e2e.sh` argv handling, runs unit tests with `DATABASE_URL` unset (matches GH Actions structure), then runs all 29 E2E files sequentially. `--diff` swaps in the diff-aware selector; `--no-pull` skips upstream pulls; `--clean` nukes named volumes. Postgres host port defaults to 5434 (avoids 5432 manual `gbrain-test-pg` and 5433 sibling-project conflict); override with `GBRAIN_CI_PG_PORT=NNNN`. Stronger gate than current PR CI's 2-file Tier 1 set — closes the "push-and-wait" feedback loop pre-push.
-- `scripts/select-e2e.ts` + `scripts/e2e-test-map.ts` (v0.23.1) — Diff-aware E2E test selector. Reads three git sources (committed `origin/master...HEAD`, working-tree `HEAD`, and `git ls-files --others --exclude-standard` for untracked, NOT-gitignored files), classifies as EMPTY / DOC_ONLY / SRC. Fail-closed by design: EMPTY → all 29 files (clean branch shouldn't run nothing), DOC_ONLY (every path matches the README/CLAUDE/AGENTS/CHANGELOG/TODOS allowlist) → empty stdout, SRC → escape-hatch paths (schema, package.json, skills/) trigger all; otherwise the hand-tuned `E2E_TEST_MAP` glob → tests narrows; an unmapped src/ change still emits ALL files, never silently nothing. Pure-function exports (`selectTests`, `classify`, `matchGlob`) so it's trivial to test and fork. `bun run ci:select-e2e` prints the current selection on stdout, pipe-friendly. `test/select-e2e.test.ts` covers all 4 branches plus 3 codex regression guards (skills/, untracked files, unmapped src/) — 24 cases.
-- `scripts/run-e2e.sh` (v0.23.1 update) — Sequential E2E runner. Now accepts an optional argv-driven file list (used by `ci:local:diff` to pipe in selector output) and a `--dry-run-list` flag that prints the resolved file list and exits (used by `ci-local.sh`'s startup smoke-test). Falls back to `test/e2e/*.test.ts` when invoked with no args.
 - `scripts/llms-config.ts` + `scripts/build-llms.ts` — Generator for `llms.txt` (llmstxt.org-spec web index) + `llms-full.txt` (inlined single-fetch bundle). Curated config drives both. Run `bun run build:llms` after adding a new doc. `LLMS_REPO_BASE` env var lets forks regenerate with their own URL base. `FULL_SIZE_BUDGET` (600KB) caps the inline bundle; generator WARNs if exceeded. Committed output is not analogous to `schema-embedded.ts` (no runtime consumer); we commit for GitHub browsing and fork-safe fetching.
 - `AGENTS.md` — Local-clone entry point for non-Claude agents (Codex, Cursor, OpenClaw, Aider). Mirrors `CLAUDE.md` intent via relative links. Claude Code keeps using `CLAUDE.md`.
 - `docs/UPGRADING_DOWNSTREAM_AGENTS.md` — Patches for downstream agent skill forks to apply when upgrading. Each release appends a new section. v0.10.3 includes diffs for brain-ops, meeting-ingestion, signal-detector, enrich.
@@ -180,7 +113,7 @@ strict behavior when unset.
 - `docs/guides/diligence-ingestion.md` — Data room to brain pages pipeline
 - `docs/designs/HOMEBREW_FOR_PERSONAL_AI.md` — 10-star vision for integration system
 - `docs/mcp/` — Per-client setup guides (Claude Desktop, Code, Cowork, Perplexity)
-- BrainBench (benchmark suite + corpus): lives in the separate [gbrain-evals](https://github.com/garrytan/gbrain-evals) repo. Not installed alongside gbrain.
+- `docs/benchmarks/` — Search quality benchmark results (reproducible, fictional data)
 - `skills/_brain-filing-rules.md` — Cross-cutting brain filing rules (referenced by all brain-writing skills)
 - `skills/RESOLVER.md` — Skill routing table (based on the agent-fork AGENTS.md pattern)
 - `skills/conventions/` — Cross-cutting rules (quality, brain-first, model-routing, test-before-bulk, cross-modal)
@@ -202,7 +135,7 @@ strict behavior when unset.
 - `skills/soul-audit/SKILL.md` — 6-phase interview for SOUL.md, USER.md, ACCESS_POLICY.md, HEARTBEAT.md
 - `skills/webhook-transforms/SKILL.md` — External events to brain signals
 - `skills/data-research/SKILL.md` — Structured data research: email-to-tracker pipeline with parameterized YAML recipes
-- `skills/minion-orchestrator/SKILL.md` — Unified background-work skill (v0.20.4 consolidation of the former `minion-orchestrator` + `gbrain-jobs` split). Two lanes: shell jobs via `gbrain jobs submit shell --params '{"cmd":"..."}'` (operator/CLI only; MCP throws `permission_denied` for protected names) and LLM subagents via `gbrain agent run` (user-facing entrypoint). Shared Preconditions block, parent-child DAGs with depth/cap/timeouts, `child_done` inbox for fan-in, PGLite `--follow` inline path for dev. Triggers narrowed from bare `"gbrain jobs"` to `"gbrain jobs submit"` + `"submit a gbrain job"` so `stats`/`prune`/`retry` questions fall through to `gbrain --help`.
+- `skills/minion-orchestrator/SKILL.md` — Background job orchestration: submit, fan out children with depth/cap/timeouts, collect results via child_done inbox
 - `templates/` — SOUL.md, USER.md, ACCESS_POLICY.md, HEARTBEAT.md templates
 - `skills/migrations/` — Version migration files with feature_pitch YAML frontmatter
 - `src/commands/publish.ts` — Deterministic brain page publisher (code+skill pair, zero LLM calls)
@@ -211,21 +144,6 @@ strict behavior when unset.
 - `src/commands/report.ts` — Structured report saver (audit trail for maintenance/enrichment)
 - `openclaw.plugin.json` — ClawHub bundle plugin manifest
 
-### BrainBench — in a sibling repo (v0.20+)
-
-BrainBench — the public benchmark for personal-knowledge agent stacks — lives in
-[github.com/garrytan/gbrain-evals](https://github.com/garrytan/gbrain-evals). It
-depends on gbrain as a consumer; gbrain never pulls in the ~5MB eval corpus or
-the pdf-parse dev dep at install time.
-
-gbrain's public API surface (the exports map in `package.json`) is what
-gbrain-evals consumes: `gbrain/engine`, `gbrain/types`, `gbrain/operations`,
-`gbrain/pglite-engine`, `gbrain/link-extraction`, `gbrain/import-file`,
-`gbrain/transcription`, `gbrain/embedding`, `gbrain/config`, `gbrain/markdown`,
-`gbrain/backoff`, `gbrain/search/hybrid`, `gbrain/search/expansion`,
-`gbrain/extract`. Removing any of these is a breaking change for the
-gbrain-evals consumer.
-
 ## Commands
 
 Run `gbrain --help` or `gbrain --tools-json` for full command reference.
@@ -244,14 +162,6 @@ Key commands added for Minions (job queue):
 - `gbrain jobs smoke [--sigkill-rescue]` — health smoke test. `--sigkill-rescue` is the v0.13.1 regression guard for #219: simulates a killed worker and asserts the stalled job is requeued instead of dead-lettered on first stall.
 - `gbrain jobs work [--queue Q] [--concurrency N]` — start worker daemon (Postgres only)
 
-Key commands added in v0.25.0:
-- `gbrain eval export [--since DUR] [--limit N] [--tool query|search]` — stream captured `eval_candidates` rows as NDJSON to stdout. Every line starts with `"schema_version": 1` per the stable contract in `docs/eval-capture.md`. EPIPE-safe, progress heartbeats on stderr, deterministic ordering. Primary consumer is the sibling `gbrain-evals` repo for BrainBench-Real replay.
-- `gbrain eval prune --older-than DUR [--dry-run]` — explicit retention cleanup for `eval_candidates`. Requires `--older-than` (never deletes without a window). Duration strings: 30d, 7d, 1h, 90m, 3600s.
-- `gbrain eval replay --against FILE.ndjson [--limit N] [--top-regressions K] [--json] [--verbose]` — contributor-facing dev loop. Reads a captured NDJSON snapshot, re-runs each `query` / `search` op against the current brain, computes mean set-Jaccard@k between captured + current `retrieved_slugs`, top-1 stability rate, and latency Δ. JSON mode (`schema_version: 1`) for CI gating; human mode prints a regression table sorted worst-first. Closes the gap between "data captured" and "data used to gate a PR." See `docs/eval-bench.md` for the workflow.
-- `gbrain doctor` gains an `eval_capture` check: reads `eval_capture_failures` for the last 24h, groups by reason, warns when non-zero. Cross-process visibility (doctor runs in a separate process from MCP). Pre-v31 brains get `Skipped (table unavailable)` — non-fatal.
-- Config addition: `eval: { capture?: boolean, scrub_pii?: boolean }` in `~/.gbrain/config.json`. **File-plane only** — `gbrain config set` writes the DB plane and does NOT control capture.
-- **`GBRAIN_CONTRIBUTOR_MODE=1` env var** is the contributor-facing toggle. Capture is **off by default** as of v0.25.0; production users get a quiet brain. Resolution order: explicit `eval.capture` config wins both directions, then env var, then off. Documented in README.md, CONTRIBUTING.md, and `docs/eval-bench.md`.
-
 Key commands added in v0.12.2:
 - `gbrain repair-jsonb [--dry-run] [--json]` — repair double-encoded JSONB rows left over from v0.12.0-and-earlier Postgres writes. Idempotent; PGLite no-ops. The `v0_12_2` migration runs this automatically on `gbrain upgrade`.
 
@@ -266,80 +176,14 @@ Key commands added in v0.14.2:
 - `GBRAIN_POOL_SIZE` env var — honored by both the singleton pool (`src/core/db.ts`) and the parallel-import worker pool (`src/commands/import.ts`). Default is 10; lower to 2 for Supabase transaction pooler to avoid MaxClients crashes during `gbrain upgrade` subprocess spawns. Read at call time via `resolvePoolSize()`.
 - `gbrain doctor` gains two new checks: `sync_failures` (surfaces unacknowledged parse failures with exact paths + fix hints) and `brain_score` (renders the 5-component breakdown when score < 100: embed coverage / 35, link density / 25, timeline coverage / 15, orphans / 15, dead links / 10 — sum equals total).
 
-Key commands added in v0.26.0 (OAuth 2.1 + HTTP server + admin dashboard):
-- `gbrain serve --http [--port 3131] [--token-ttl 3600] [--enable-dcr]` — HTTP MCP server with OAuth 2.1, admin dashboard at `/admin`, SSE activity feed at `/admin/events`, health check at `/health`. Prints admin bootstrap token on first start. Alongside (not replacing) stdio `gbrain serve`.
-- **OAuth client registration** — three paths:
-  1. CLI: `gbrain auth register-client <name> --grant-types <types> --scopes <scopes>` (wired into `src/commands/auth.ts` as a thin wrapper over `GBrainOAuthProvider.registerClientManual`). Default grant types: `client_credentials`. Default scopes: `read`.
-  2. Admin dashboard: Register client modal → credential reveal with Copy + Download JSON.
-  3. SDK: `oauthProvider.registerClientManual(name, grantTypes, scopes, redirectUris)` for programmatic wrappers.
-  `--enable-dcr` on `serve --http` opens the `/register` endpoint for RFC 7591 self-service registration (off by default).
-- `gbrain auth create|list|revoke|test` — legacy bearer tokens still work and grandfather to `read+write+admin` scopes on the OAuth server. `auth` is wired as a first-class `gbrain` subcommand in v0.26.0 (previously only invokable via `bun run src/commands/auth.ts`). No migration required to keep pre-v0.26 clients working.
-
 Key commands added in v0.14.3 (fix wave):
 - `gbrain doctor --index-audit` — opt-in Postgres-only check reporting zero-scan indexes from `pg_stat_user_indexes`. Informational only; never auto-drops.
 - `gbrain doctor` schema_version check fails loudly when `version=0` — catches `bun install -g github:...` postinstall failures (#218) and routes users to `gbrain apply-migrations --yes`.
 - `gbrain jobs submit` gains `--max-stalled`, `--backoff-type`, `--backoff-delay`, `--backoff-jitter`, `--timeout-ms`, `--idempotency-key` — exposing existing `MinionJobInput` fields as first-class CLI flags.
 - `gbrain jobs smoke --sigkill-rescue` — opt-in regression smoke case simulating a killed worker; asserts the v0.14.3 schema default (`max_stalled=5`) actually rescues on first stall.
 
-Key commands added in v0.22.13 (PR #490):
-- `gbrain sync --workers N` (alias `--concurrency N`) — parallelize the import phase using per-worker Postgres engines (small pool of 2 each) with an atomic queue index. Auto-concurrency: defaults to 4 workers when the diff exceeds 100 files. Smaller diffs stay serial. Explicit `--workers` always wins (even on a 30-file diff). PGLite forces serial regardless. Validation rejects `0`, negatives, non-integers loud (replaces the prior silent fall-through to auto-concurrency).
-- `gbrain import --workers N` — same `parseWorkers()` validation as sync; same try/finally worker-engine cleanup. Behavior surface unchanged.
-
-Key commands added in v0.22.16 (claw-test friction loop):
-- `gbrain claw-test [--scenario fresh-install|upgrade-from-v0.18] [--keep-tempdir]` — scripted-mode CI gate that runs the full canonical first-day flow against a fresh tempdir. Asserts every expected `--progress-json` phase fired and doctor's `status === 'ok'`. ~30s, no API keys.
-- `gbrain claw-test --live --agent openclaw` — friction-discovery mode. Spawns real openclaw, hands it `BRIEF.md`, captures stdin/stdout/stderr to `<run>/transcript.jsonl`, lets the agent log friction via the friction CLI. Run on demand; ~5–10 min and ~$1–2 in tokens.
-- `gbrain claw-test --list-agents` — reports which agent runners are registered + their detection state (binary path or unavailable reason).
-- `gbrain friction log --severity {confused|error|blocker|nit} --phase <name> --message <text> [--hint ...] [--kind {friction|delight}] [--run-id ...]` — append a friction or delight entry to the active run JSONL.
-- `gbrain friction render --run-id <id> [--json] [--transcripts] [--no-redact]` — markdown report grouped by severity + phase; `--redact` is the default for md output (strips `$HOME`/`$CWD` placeholders so reports paste safely in PRs/issues).
-- `gbrain friction list [--json]` — recent run-ids with friction/delight counts; interrupted runs marked `(interrupted)`.
-- `gbrain friction summary --run-id <id> [--json]` — two-column friction + delight summary.
-- `GBRAIN_HOME` env override is now honored uniformly across every gbrain write site (config, audit, friction, sync-failures, import checkpoint, integrity log, integrations heartbeat, migration rollback, etc.) — `gbrainPath(...)` from `src/core/config.ts` is the canonical helper. Read-side host-fingerprint detection (`~/.claude`/`~/.openclaw` etc.) intentionally NOT confined in v1; that's a v1.1 follow-up.
-
 ## Testing
 
-### Test command tiers (v0.26.4 — parallel fast loop)
-
-Five tiers of test commands, each with a clear scope:
-
-| Command | What it runs | Wallclock | When to use |
-|---|---|---|---|
-| `bun run test` | Parallel unit-test fast loop. 8-shard fan-out via `scripts/run-unit-parallel.sh`, then a serial pass over `*.serial.test.ts`. Excludes `*.slow.test.ts` and `test/e2e/*`. No pre-checks, no typecheck. | ~85s on a Mac dev box (3650+ tests) | Inner edit loop. Default. |
-| `bun run verify` | CI's authoritative pre-test gate set: `check:privacy && check:jsonb && check:progress && check:wasm && bun run typecheck`. The 4 checks `.github/workflows/test.yml` runs on shard 1 + typecheck. Single source of truth — CI literally calls `bun run verify`. | ~12s (wasm-compile dominates) | Before pushing; before `/ship`. |
-| `bun run test:full` | `verify && bun run test && bun run test:slow && [smart e2e]`. The local equivalent of "everything CI runs." Smart e2e: runs e2e only when `DATABASE_URL` is set; else loud skip notice to stderr. | ~3-5min depending on slow + e2e | Pre-merge sanity, before opening a PR. |
-| `bun run test:slow` | Just the `*.slow.test.ts` set (intentional cold-path correctness checks). | seconds-to-minutes | When touching slow-path code. |
-| `bun run test:serial` | Just the `*.serial.test.ts` set (cross-file-contention quarantine; runs at `--max-concurrency=1`). | ~1s per quarantined file | Debugging a specific quarantined file. |
-| `bun run test:e2e` | Real Postgres E2E. Requires Docker + `DATABASE_URL`. Sequential (template-DB parallelization is a v0.27+ TODO). | ~5-10min | Pre-ship; nightly. |
-| `bun run check:all` | All 7 historical pre-checks (privacy + jsonb + progress + no-legacy-getconnection + trailing-newline + wasm + exports-count). Superset of `verify`. | ~10s | Local-only sweep. The 4 not in `verify` are nice-to-haves. |
-
-### CI vs local: intentionally divergent file sets
-
-- **CI matrix** (`.github/workflows/test.yml`) runs `scripts/test-shard.sh` 4-way, which uses FNV-1a hash bucketing and INCLUDES `*.slow.test.ts`. CI is the ground truth for "did everything pass."
-- **Local fast loop** (`scripts/run-unit-shard.sh` via the parallel wrapper) uses round-robin-by-index sharding and EXCLUDES `*.slow.test.ts` AND `*.serial.test.ts`. Local trades coverage for inner-loop speed; CI catches what local skips.
-
-This divergence is intentional. Don't try to make them equal — the two scripts deliberately solve different problems. The regression test at `test/scripts/run-unit-shard.test.ts` pins what the local fast loop should and shouldn't include.
-
-### Failure-first logging
-
-When `bun run test` finds any failure, the wrapper:
-
-1. Writes failure blocks (each prefixed with `--- shard N: <test name> ---`) to `.context/test-failures.log` (workspace-local, gitignored). On systems without a writable `.context/`, falls back to `/tmp/gbrain-test-failures.log`.
-2. Prints a loud stderr banner with the absolute log path, plus the last 30 lines of the failure log inlined. Banner survives `| head` / `| tail` / agent-side log truncation.
-3. Writes a one-line-per-shard summary to `.context/test-summary.txt` (`shard N/M: pass=X fail=Y skip=Z rc=W`).
-4. Exits non-zero. Empty failure log + non-zero exit = infrastructure problem (wedged shard, killed child); the banner says so.
-
-If a shard wedges (per-shard `GBRAIN_TEST_SHARD_TIMEOUT` cap, default 600s), the wrapper writes `--- shard N: WEDGED after ${SHARD_TIMEOUT}s ---` to the failure log, includes the last 50 lines of the shard log, and proceeds with other shards' results.
-
-### File taxonomy
-
-- `*.test.ts` → fast loop (parallel 8-shard fan-out).
-- `*.slow.test.ts` → run via `bun run test:slow` only (intentional cold-path tests; would dominate the fast loop's wallclock).
-- `*.serial.test.ts` → run via `bun run test:serial` after the parallel pass completes; uses `--max-concurrency=1`. Quarantine for tests that share file-wide state and race when run alongside other files in the same `bun test` process. Currently: `test/brain-registry.serial.test.ts`, `test/reconcile-links.serial.test.ts`. **Do not put the parallelism back on a serial file unless you've fixed the contention root cause** (it just re-introduces the flake).
-- `test/e2e/*.test.ts` → real-Postgres E2E. Skipped when `DATABASE_URL` is unset.
-
-The intra-file parallelism project (turn `bun test` into `bun test --concurrent` after sweeping shared-state contention sites — ~58 PGLite + ~40 env-mutation + ~2 mock.module sites) is filed as a P0 TODO for a follow-up release. v0.26.4 ships file-level parallelism only.
-
-### Inventory (legacy)
-
 `bun test` runs all tests. After the v0.12.1 release: ~75 unit test files + 8 E2E test files (1412 unit pass, 119 E2E when `DATABASE_URL` is set — skip gracefully otherwise). Unit tests run
 without a database. E2E tests skip gracefully when `DATABASE_URL` is not set.
 
@@ -349,9 +193,7 @@ parity), `test/cli.test.ts` (CLI structure), `test/config.test.ts` (config redac
 `test/files.test.ts` (MIME/hash), `test/import-file.test.ts` (import pipeline),
 `test/upgrade.test.ts` (schema migrations),
 `test/file-migration.test.ts` (file migration), `test/file-resolver.test.ts` (file resolution),
-`test/import-resume.test.ts` (import checkpoints), `test/migrate.test.ts` (migration; v8/v9 helper-btree-index SQL structural assertions + 1000-row wall-clock fixtures that guard the O(n²)→O(n log n) fix + v0.13.1 assertions on v12/v13 SQL shape, `sqlFor` + `transaction:false` runner semantics, the `max_stalled DEFAULT 1` regression guard, and v0.22.6.1 v24 `sqlFor.pglite: ''` no-op assertion),
-`test/bootstrap.test.ts` (v0.22.6.1 — bootstrap contract: no-op on fresh install, idempotent across two `initSchema()` calls, no-op on modern brain that already has every probed column, full bootstrap path on simulated pre-v0.18 brain, fresh-install regression guard, pre-v0.13 `links` shape coverage),
-`test/schema-bootstrap-coverage.test.ts` (v0.22.6.1 CI guard — `REQUIRED_BOOTSTRAP_COVERAGE` lists every forward reference in PGLITE_SCHEMA_SQL; the test fails loudly if `applyForwardReferenceBootstrap` skips one. When you add a column-with-index to the embedded schema blob, you extend both arrays or this guard fails. The pattern that broke gbrain ten times in two years is now structurally prevented.),
+`test/import-resume.test.ts` (import checkpoints), `test/migrate.test.ts` (migration; v8/v9 helper-btree-index SQL structural assertions + 1000-row wall-clock fixtures that guard the O(n²)→O(n log n) fix + v0.13.1 assertions on v12/v13 SQL shape, `sqlFor` + `transaction:false` runner semantics, and the `max_stalled DEFAULT 1` regression guard),
 `test/setup-branching.test.ts` (setup flow), `test/slug-validation.test.ts` (slug validation),
 `test/storage.test.ts` (storage backends), `test/supabase-admin.test.ts` (Supabase admin),
 `test/yaml-lite.test.ts` (YAML parsing), `test/check-update.test.ts` (version check + update CLI),
@@ -363,9 +205,8 @@ parity), `test/cli.test.ts` (CLI structure), `test/config.test.ts` (config redac
 `test/lint.test.ts` (LLM artifact detection, code fence stripping, frontmatter validation),
 `test/report.test.ts` (report format, directory structure),
 `test/skills-conformance.test.ts` (skill frontmatter + required sections validation),
-`test/resolver.test.ts` (RESOLVER.md coverage, routing validation + v0.20.4 round-trip: every quoted RESOLVER.md trigger must match a frontmatter `triggers:` entry in the target skill, and every `name="<word>"` reference in any SKILL.md must resolve to a declared op in `src/core/operations.ts` or a Minions handler in `PROTECTED_JOB_NAMES`),
+`test/resolver.test.ts` (RESOLVER.md coverage, routing validation),
 `test/search.test.ts` (RRF normalization, compiled truth boost, cosine similarity, dedup key),
-`test/sql-ranking.test.ts` (v0.22.0 source-boost helpers: 39 cases covering longest-prefix-match in SQL CASE, detail=high temporal-bypass, three-meta-char LIKE escape (%, _, \\), single-quote SQL-literal doubling, env override parsing for GBRAIN_SOURCE_BOOST + GBRAIN_SEARCH_EXCLUDE, resolveBoostMap / resolveHardExcludes merge semantics),
 `test/dedup.test.ts` (source-aware dedup, compiled truth guarantee, layer interactions),
 `test/intent.test.ts` (query intent classification: entity/temporal/event/general),
 `test/eval.test.ts` (retrieval metrics: precisionAtK, recallAtK, mrr, ndcgAtK, parseQrels),
@@ -393,41 +234,17 @@ parity), `test/cli.test.ts` (CLI structure), `test/config.test.ts` (config redac
 `test/orphans.test.ts` (v0.12.3 orphans command: detection, pseudo filtering, text/json/count outputs, MCP op),
 `test/postgres-engine.test.ts` (v0.12.3 statement_timeout scoping: `sql.begin` + `SET LOCAL` shape, source-level grep guardrail against reintroduced bare `SET statement_timeout`),
 `test/sync.test.ts` (sync logic + v0.12.3 regression guard asserting top-level `engine.transaction` is not called),
-`test/sync-concurrency.test.ts` (v0.22.13 PR #490: 17 cases covering `autoConcurrency()` thresholds + PGLite-forces-serial + explicit-override clamping, `shouldRunParallel()` Q1 explicit-bypasses-floor contract, and `parseWorkers()` validation that rejects `'0'`/`'-3'`/`'foo'`/`'1.5'`/trailing chars),
-`test/sync-parallel.test.ts` (v0.22.13 PR #490: PGLite-routed coverage of the bookmark gate under concurrency request, head-drift gate, vanished-file failure capture, PGLite-stays-serial, and the `gbrain-sync` writer-lock contract — 7 cases),
-`test/sync-failures.test.ts` (v0.22.12: 28 cases pinning `classifyErrorCode` regex coverage for all 12 codes against literal production message strings from `markdown.ts:159-244` and `import-file.ts:199, 347, 352, 401`; `summarizeFailuresByCode` sort + pre-classified-honor; `recordSyncFailures` code-field persistence; `acknowledgeSyncFailures` AcknowledgeResult shape + backfill on pre-v0.22.12 entries),
 `test/doctor.test.ts` (doctor command + v0.12.3 assertions that `jsonb_integrity` scans the four v0.12.0 write sites and `markdown_body_completeness` is present),
 `test/utils.test.ts` (shared SQL utilities + `tryParseEmbedding` null-return and single-warn semantics),
-`test/build-llms.test.ts` (llms.txt/llms-full.txt generator: path resolution, idempotence, spec shape, regen-drift guard, content contract, AGENTS.md install-path mirror, size-budget enforcement — 7 cases),
-`test/oauth.test.ts` (v0.26.0 OAuth 2.1 provider — 27 cases: register, getClient, `client_credentials` grant exchange, `authorization_code` flow with PKCE challenge / verifier, refresh token rotation, `verifyAccessToken` with both OAuth + legacy `access_tokens` fallback, `revokeToken`, `sweepExpiredTokens`, and a contract test asserting `scope` + `localOnly` annotations are set correctly on all 30 operations; **v0.26.2** adds 5 `coerceTimestamp` unit cases (null/undefined/string/number/throw-on-NaN), NULL-`expires_at`-as-expired contract tests for both refresh + access token paths, and a cascade-delete contract test asserting `revoke-client` purges `oauth_tokens` + `oauth_codes` rows via FK CASCADE),
-`test/check-resolvable-cli.test.ts` (v0.19 CLI wrapper: exit codes, JSON envelope shape, AGENTS.md fallback chain),
-`test/regression-v0_16_4.test.ts` (findRepoRoot regression guard — hermetic startDir parameterization),
-`test/filing-audit.test.ts` (v0.19 Check 6: `writes_pages` / `writes_to` frontmatter, filing-rules JSON validation),
-`test/routing-eval.test.ts` (v0.19 Check 5: fixture parsing, structural routing, ambiguous_with, Haiku tie-break layer),
-`test/skill-manifest.test.ts` (v0.19 skill manifest parser: drift detection, managed-block markers),
-`test/skillify-scaffold.test.ts` (v0.19 `gbrain skillify scaffold` stubs: SKILL.md, script, tests, routing-eval fixtures),
-`test/skillpack-install.test.ts` (v0.19 `gbrain skillpack install` managed-block install / update / no-clobber semantics),
-`test/skillpack-sync-guard.test.ts` (v0.19 sync-guard: bundled skills stay byte-identical to `skills/` source),
-`test/http-transport.test.ts` (v0.22.7 HTTP transport: 23 unit cases covering bearer auth + missing/no-Bearer/unknown/revoked + `/health` bypass, F1+F2 round-trip via dispatch.ts, F3 invalid_params, application/json response shape (not SSE), CORS default-deny + allowlist, body cap on Content-Length AND chunked, two-bucket rate limit (refill, exhaust+Retry-After, LRU eviction, TTL prune, pre-auth IP fires before DB), and `mcp_request_log` audit on success + auth_failed).
+`test/build-llms.test.ts` (llms.txt/llms-full.txt generator: path resolution, idempotence, spec shape, regen-drift guard, content contract, AGENTS.md install-path mirror, size-budget enforcement — 7 cases).
 
 E2E tests (`test/e2e/`): Run against real Postgres+pgvector. Require `DATABASE_URL`.
 - `bun run test:e2e` runs Tier 1 (mechanical, all operations, no API keys). Includes 9 dedicated cases for the postgres-engine `addLinksBatch` / `addTimelineEntriesBatch` bind path — postgres-js's `unnest()` binding is structurally different from PGLite's and gets its own coverage.
 - `test/e2e/search-quality.test.ts` runs search quality E2E against PGLite (no API keys, in-memory)
 - `test/e2e/graph-quality.test.ts` runs the v0.10.3 knowledge graph pipeline (auto-link via put_page, reconciliation, traversePaths) against PGLite in-memory
 - `test/e2e/postgres-jsonb.test.ts` — v0.12.2 regression test. Round-trips all 5 JSONB write sites (pages.frontmatter, raw_data.data, ingest_log.pages_updated, files.metadata, page_versions.frontmatter) against real Postgres and asserts `jsonb_typeof='object'` plus `->>'key'` returns the expected scalar. The test that should have caught the original double-encode bug.
-- `test/e2e/integrity-batch.test.ts` (v0.22.8) — parity tests for `scanIntegrity`'s batch-load fast path vs sequential. Four cases (dedup, hits, validate, topPages) seed a fixture and assert both paths return identical results. Dedup case uses raw SQL via `getConn().unsafe()` to seed a `(test-source-2, people/alice)` row alongside the default-source row, since `engine.putPage` doesn't take a `source_id`. Pins the codex-caught multi-source overcounting regression.
 - `test/e2e/jsonb-roundtrip.test.ts` — v0.12.3 companion regression against the 4 doctor-scanned JSONB sites. Assertion-level overlap with `postgres-jsonb.test.ts` is intentional defense-in-depth: if doctor's scan surface ever drifts from the actual write surface, one of these tests catches it.
-- `test/e2e/sync.test.ts` (v0.22.12 — `--skip-failed` failure-loop test, alongside the existing 13 happy-path tests): exercises the full chain — broken file → `performSync` returns `blocked_by_failures` with grouped breakdown → `performSync({skipFailed: true})` advances bookmark and returns `AcknowledgeResult` with code summary → second broken file → second cycle. Saves and restores the user's real `~/.gbrain/sync-failures.jsonl` so the test is hermetic on a developer machine. Asserts bookmark gating, JSONL state, dedup across paths, summary aggregation, and the literal doctor-rendering string format. This is the integration test that proves the v0.22.12 chain holds together — unit tests cover the pure functions in isolation, this covers the integration.
 - `test/e2e/upgrade.test.ts` runs check-update E2E against real GitHub API (network required)
-- `test/e2e/minions-shell-pglite.test.ts` (v0.20.4) exercises the PGLite `--follow` inline shell-job path (in-memory, no `DATABASE_URL` required) — the path the consolidated minion-orchestrator skill documents for dev use
-- `test/e2e/openclaw-reference-compat.test.ts` (v0.19) — exercises `check-resolvable` + `skillpack install` against a minimal AGENTS.md workspace fixture (`test/fixtures/openclaw-reference-minimal/`), regression guard for the 107-skill OpenClaw deployment shape
-- `test/e2e/search-swamp.test.ts` (v0.22.0) — reproduces the headline source-swamp case. Seeds a curated `originals/talks/article-outline-fat-code` page against two `wintermute/chat/` pages stuffed with the same multi-word phrase. Asserts the article wins keyword AND vector ranking, that `detail=high` lets the chat swamp re-surface (temporal-query workflow preserved), and that `source_id` passes through the two-stage CTE intact. PGLite in-memory.
-- `test/e2e/search-exclude.test.ts` (v0.22.0) — verifies `test/` + `archive/` pages are hidden by default, that `include_slug_prefixes` opts back in, and that caller-supplied `exclude_slug_prefixes` adds to defaults. Both keyword and vector search paths covered.
-- `test/e2e/engine-parity.test.ts` (v0.22.0) — Postgres ↔ PGLite top-result and result-set parity for `searchKeyword` + `searchVector`. Codex flagged that Postgres ranks pages then picks best chunk while PGLite returns chunks directly — without parity coverage the source-boost fix could pass on PGLite and fail on Postgres. Skips gracefully when `DATABASE_URL` is unset.
-- `test/e2e/postgres-bootstrap.test.ts` (v0.22.6.1) — exercises `PostgresEngine.initSchema()` directly against a fresh real Postgres database. Asserts the bootstrap path is no-op on fresh installs and that SCHEMA_SQL replays cleanly through the engine path (not via the standalone `db.initSchema` from `src/core/db.ts`, which would have produced false-positive coverage). Codex caught the E2E-shape gap during plan review.
-- `test/e2e/http-transport.test.ts` (v0.22.7) — 8 cases against real Postgres covering `gbrain serve --http` end-to-end: bearer auth round-trip, `last_used_at` SQL-level debounce semantics, `mcp_request_log` row insertion on success and auth_failed paths, `/health` DB-down → 503 (DB-probing health check), and the F1+F2+F3 dispatch round-trip with a real operation. Skips gracefully when `DATABASE_URL` is unset.
-- `test/e2e/serve-http-oauth.test.ts` (v0.26.0, expanded v0.26.2) — real-Postgres E2E against `gbrain serve --http` with full OAuth 2.1. Spawns a subprocess server, registers a client via the CLI, mints `client_credentials` tokens, exercises the `/mcp` JSON-RPC pipeline. **v0.26.2 adds:** real DCR `/register` HTTP-level response-shape test (asserts `typeof body.client_id_issued_at === 'number'` over the wire — RFC 7591 §3.2.1 spec compliance, not just internal-store shape); real CLI subprocess test for `revoke-client` (registers → mints token → revokes via `execSync` → asserts token rejected at `/mcp` → asserts re-run exits 1); server fixture flips on `--enable-dcr` so `/register` is reachable. **bun execSync env-inheritance fix:** bun's `execSync` does NOT inherit env mutations done via `process.env.X = ...`, only OS-level env from before bun started. helpers.ts loads `.env.testing` and sets `DATABASE_URL` via `process.env` mutation, which is invisible to subprocesses unless `env: { ...process.env }` is passed explicitly — every subprocess call in this file passes `env: { ...process.env }` for that reason. Reference fix for the next maintainer hitting the same failure mode in sibling sync/cycle/dream/claw-test E2Es. `afterAll` cleanup is guarded on `clientId` (won't throw if `beforeAll` failed before registration); cleanup errors surface to stderr without throwing so real test failures aren't masked. Tracks DCR-registered clients alongside the manual one. Skips gracefully when `DATABASE_URL` is unset.
-- `test/e2e/sync-parallel.test.ts` (v0.22.13 PR #490) — DATABASE_URL-gated. T2: 60-file Postgres sync at concurrency=4 imports all + no connection leak (probes `pg_stat_activity` before/after to confirm worker engines disconnected). P4: 120-file serial-vs-parallel benchmark prints `SYNC_PARALLEL_BENCH N files | serial=Xms | parallel(4)=Yms | speedup=Zx` for CHANGELOG quoting. Asserts parallel ≤ serial × 1.5 (CI-noise tolerant; not a strict speedup gate).
 - Tier 2 (`skills.test.ts`) requires OpenClaw + API keys, runs nightly in CI
 - If `.env.testing` doesn't exist in this directory, check sibling worktrees for one:
   `find ../  -maxdepth 2 -name .env.testing -print -quit` and copy it here if found.
@@ -479,8 +296,8 @@ stop and remove it before starting a new one.
 
 ## Skills
 
-Read the skill files in `skills/` before doing brain operations. GBrain ships 29 skills
-organized by `skills/RESOLVER.md` (`AGENTS.md` is also accepted as of v0.19):
+Read the skill files in `skills/` before doing brain operations. GBrain ships 26 skills
+organized by `skills/RESOLVER.md`:
 
 **Original 8 (conformance-migrated):** ingest (thin router), query, maintain, enrich,
 briefing, migrate, setup, publish.
@@ -489,18 +306,7 @@ briefing, migrate, setup, publish.
 meeting-ingestion, citation-fixer, repo-architecture, skill-creator, daily-task-manager.
 
 **Operational + identity:** daily-task-prep, cross-modal-review, cron-scheduler, reports,
-testing, soul-audit, webhook-transforms, data-research, minion-orchestrator. As of
-v0.20.4, `minion-orchestrator` is the single unified skill for both lanes of background
-work (shell jobs via `gbrain jobs submit shell`, LLM subagents via `gbrain agent run`) ...
-the prior `gbrain-jobs` skill was merged in, Preconditions are shared, and trigger
-routing is narrowed to what the skill actually covers.
-
-**Skillify loop (v0.19):** skillify (the markdown orchestration), skillpack-check
-(agent-readable health report).
-
-**Operational health (v0.19.1):** smoke-test (8 post-restart health checks with auto-fix
-for Bun, CLI, DB, worker, Zod CJS, gateway, API key, brain repo; user-extensible via
-`~/.gbrain/smoke-tests.d/*.sh`).
+testing, soul-audit, webhook-transforms, data-research, minion-orchestrator.
 
 **Conventions:** `skills/conventions/` has cross-cutting rules (quality, brain-first,
 model-routing, test-before-bulk, cross-modal). `skills/_brain-filing-rules.md` and
@@ -538,138 +344,19 @@ For single long-running queries, use `startHeartbeat(reporter, note)` with a
 try/finally to guarantee cleanup. Never call `process.stdout.write('\r...')`
 in bulk paths, the CI guard will fail the build.
 
-## Capturing test output (NEVER pipe through `tail` / `head`)
-
-**Iron rule:** when running `bun test`, `bun run test:e2e`, `bun run typecheck`,
-or any other test/check command, redirect to a file FIRST, then `tail` the file
-separately:
-
-```bash
-# RIGHT — full output preserved, real exit code visible
-bun test > /tmp/ship_units.txt 2>&1
-echo "EXIT=$?"
-tail -50 /tmp/ship_units.txt
-grep -E '(fail\)|✗|error:' /tmp/ship_units.txt | head -30
-```
-
-```bash
-# WRONG — exit code is `tail`'s (always 0), failures truncated, ship gates fail open
-bun test 2>&1 | tail -10
-```
-
-The pipe form silently breaks /ship Step T1 (test failure ownership triage) and
-the test verification gate (Step 16) because:
-- `$?` after a pipe is the LAST command's exit code (`tail` → 0), not bun's
-- bun prints failure details before the summary line, so `tail -N` drops them
-- Step T1 needs the full failure list to classify in-branch vs pre-existing
-
-This bit us during v0.26.2 ship: `bun test 2>&1 | tail -10` reported "3911 pass / 23 fail"
-but no failure details survived, forcing a 23-minute re-run to triage.
-
-Apply the same pattern to any long-running command whose exit code matters:
-`bun run typecheck`, `bun run ci:local`, migration runs, eval suites, etc.
-For background tasks (`run_in_background: true`), the harness captures the exit
-file separately — use it via the bg task's `<id>.exit` file, not the streamed
-output.
-
 ## Build
 
 `bun build --compile --outfile bin/gbrain src/cli.ts`
 
-## Version locations (single source of truth: `VERSION` file)
-
-Every release advances the version in **five files at once**. Keep these in
-sync. `/ship` enforces this via Step 12's idempotency check (VERSION vs
-package.json drift), but the canonical list lives here so future runs and
-the auto-update agent know where to look.
-
-**Required (every release must update all five):**
-
-| File | What lives there | Format |
-|---|---|---|
-| `VERSION` | The single source of truth. Read first by `/ship`, the binary, and CI version-gate. | Bare 4-digit string `MAJOR.MINOR.PATCH.MICRO` (e.g. `0.22.1`), no leading `v`, no trailing newline-sensitivity issues. |
-| `package.json` | Bun/npm package version. `gbrain --version` reads it via the compiled binary's bundled package metadata. CI version-gate cross-checks this against `VERSION` and fails if they drift. | `"version": "0.22.1"` |
-| `CHANGELOG.md` | Top entry header `## [0.22.1] - YYYY-MM-DD` plus the "To take advantage of v0.22.1" block. | Standard Keep-a-Changelog header. |
-| `TODOS.md` | Any TODO entries that mention "follow-up from vX.Y.Z" use the version of the release that filed them. Update only when filing NEW follow-up TODOs. | Inline `vX.Y.Z` references in TODO bodies. |
-| `CLAUDE.md` | The Key Files section's per-file annotations carry `vX.Y.Z (#NNN)` tags noting which release introduced a behavior. Update whenever a wave's annotations get folded in. | Inline `vX.Y.Z (#NNN, contributed by @user)` references. |
-
-**Auto-derived (no manual edit; refreshed by their own commands):**
-
-- `bun.lock` — root-package version is auto-pinned from `package.json`. After
-  bumping `package.json`, run `bun install` to refresh the lockfile.
-- `llms-full.txt` / `llms.txt` — auto-generated documentation bundles. After
-  any release ship that touches the Key Files annotations in `CLAUDE.md`,
-  run `bun run build:llms` to regenerate. The bundles do not contain a
-  version pin per se; they reflect the current state of the docs they index.
-
-**Historical (DO NOT bump on release):**
-
-- `skills/migrations/v0.21.0.md` — migration files use the version they
-  shipped FROM as their filename. v0.21.0's migration always says v0.21.0.
-- `src/commands/migrations/v0_21_0.ts` — same: migration code references
-  the schema version it migrates to.
-- `test/migrations-v0_21_0.test.ts`, `test/migration-orchestrator-v0_21_0.test.ts`,
-  `test/migrate.test.ts` — migration tests reference historical migration
-  versions; these are correct as-is and should not move.
-- `src/core/db.ts`, `src/core/migrate.ts`, `src/core/import-file.ts`,
-  `src/commands/reindex-code.ts` — code comments cite the release that
-  introduced a feature. Once written, these are historical record.
-- `README.md` — references the latest published feature names by version
-  (e.g. "v0.21.0 Code Cathedral"); update only when the README's marketing
-  copy is intentionally being refreshed, NOT on every micro/patch bump.
-
-**The /ship workflow's version idempotency check:** Step 12 reads
-`VERSION` and `package.json`, classifies as FRESH / ALREADY_BUMPED /
-DRIFT_STALE_PKG / DRIFT_UNEXPECTED, and refuses to proceed on
-DRIFT_UNEXPECTED. This is why the two must move together.
-
-**The CI version-gate** rejects pushes where `VERSION` and
-`package.json` disagree, OR where `VERSION` is not strictly greater
-than master's VERSION. If a queue collision claims your version on
-master before yours lands, /ship's queue-aware allocator (Step 12)
-will detect drift and re-bump on the next run.
-
 ## Pre-ship requirements
 
-Before shipping (/ship) or reviewing (/review), always run the full test suite.
-Two equivalent paths:
-
-**Path A — local CI gate (recommended, v0.23.1+):**
-- `bun run ci:local` runs the entire stack inside Docker: gitleaks (host), unit
-  tests with `DATABASE_URL` unset, and all 29 E2E files sequentially against a
-  fresh pgvector container. Stronger than PR CI's 2-file Tier 1 set; closer to
-  what nightly Tier 1 catches. Spins up + tears down postgres automatically via
-  `docker-compose.ci.yml`. Override the host port with
-  `GBRAIN_CI_PG_PORT=5435 bun run ci:local` if 5434 collides.
-- `bun run ci:local:diff` runs only the E2E files matched by the diff selector
-  (`scripts/select-e2e.ts`), falling back to all 29 on unmapped src/ paths or
-  schema/skills/package.json changes. Fast iteration during a focused branch.
-
-**Path B — manual lifecycle (still supported):**
+Before shipping (/ship) or reviewing (/review), always run the full test suite:
 - `bun test` — unit tests (no database required)
 - Follow the "E2E test DB lifecycle" steps above to spin up the test DB,
   run `bun run test:e2e`, then tear it down.
 
 Both must pass. Do not ship with failing E2E tests. Do not skip E2E tests.
 
-**Always run typecheck before pushing.** `bun test` (the bun runner)
-skips TypeScript type checking — it only enforces runtime behavior.
-Three ways to actually gate on types:
-
-1. `bun run test` (npm script in `package.json`) — includes `bun run typecheck`
-   plus the four shell pre-checks (`check-jsonb-pattern.sh`,
-   `check-progress-to-stdout.sh`, `check-trailing-newline.sh`,
-   `check-wasm-embedded.sh`) before the runner. Use this mid-branch.
-2. `bun run typecheck` — `tsc --noEmit` standalone. Fast (~5s on this repo).
-3. `bun run ci:local` — the full local CI gate from Path A.
-
-The trap is: writing a new test, running `bun test test/foo.test.ts`,
-seeing it pass, pushing — and CI's separate typecheck stage rejects an
-invalid type literal that the runner accepted. Caught one of these
-shipping the v0.23.2 round-trip E2E (`type: 'reflection'` is not a
-member of `PageType`). Run `bun run typecheck` once before push, even
-when only test files changed.
-
 ## Post-ship requirements (MANDATORY)
 
 After EVERY /ship, you MUST run /document-release. This is NOT optional. Do NOT
@@ -689,52 +376,6 @@ Files that MUST be checked on every ship:
 
 A ship without updated docs is an incomplete ship. Period.
 
-## CHANGELOG + VERSION are branch-scoped
-
-**VERSION and CHANGELOG describe what THIS branch adds vs master, not how we got
-here.** Every feature branch that ships gets its own version bump and CHANGELOG
-entry. The entry is product release notes for users; it is not a log of internal
-decisions, review rounds, or codex findings.
-
-**Write the CHANGELOG entry at /ship time, not during development.** Mid-branch
-iterations, review rounds (CEO/Eng/Codex/DX), and implementation detours belong
-in the plan file at `~/.claude/plans/`, not in the CHANGELOG. One unified entry
-per branch, covering what the branch added vs the base branch.
-
-**Never edit a CHANGELOG entry that already landed on master.** If master has
-v0.18.2 and your branch adds features, bump to the next version (v0.19.0, not
-editing master's v0.18.2). When merging master into your branch, master may
-bring new CHANGELOG entries above yours — push your entry above master's
-latest and verify:
-
-- Does CHANGELOG have your branch's own entry separate from master's entries?
-- Is VERSION higher than master's VERSION?
-- Is your entry the topmost `## [X.Y.Z]` entry?
-- `grep "^## \[" CHANGELOG.md` shows a contiguous version sequence?
-
-If any answer is no, fix it before continuing.
-
-**CHANGELOG is for users, not contributors.** Write like product release notes:
-
-- Lead with what the user can now **do** that they couldn't before. Sell the capability.
-- Plain language, not implementation details. "You can now..." not "Refactored the..."
-- **Never mention internal artifacts**: plan file IDs, decision tags (D-CX-#, F-ENG-#),
-  review rounds, codex findings, subcontractor credits. These are invisible to users.
-- Put contributor-facing changes in a separate `### For contributors` section at the bottom.
-- Every entry should make someone think "oh nice, I want to try that."
-
-**What to omit:**
-- "Codex caught X that the CEO review missed" — private process detail.
-- "D-CX-3 split errors/warnings" — tag is meaningless to users; name the feature instead.
-- "Fix-wave PR #N supersedes #M" — supersede chains belong in PR bodies, not release notes.
-- "215 new cases, 3 decisions applied, 7 reviews cleared" — these are planning-mode metrics.
-
-**What to keep:**
-- The user-facing change: what commands exist now, what flag was added, what behavior fixed.
-- Numbers that mean something to the user: TTHW, commands that timed out before, detection counts.
-- Upgrade instructions: `gbrain upgrade` + any manual step if needed.
-- Credit to external contributors when a community PR was incorporated.
-
 ## CHANGELOG voice + release-summary format
 
 Every version entry in `CHANGELOG.md` MUST start with a release-summary section in
@@ -775,7 +416,7 @@ Voice rules:
 
 Source material to pull from:
 - CHANGELOG.md previous entry for prior context
-- Latest `gbrain-evals/docs/benchmarks/[latest].md` for headline numbers (sibling repo)
+- `docs/benchmarks/[latest].md` for the headline numbers
 - Recent commits (`git log <prev-version>..HEAD --oneline`) for what shipped
 - Don't make up numbers. If a metric isn't in a benchmark or production data, don't
   include it. Say "no measurement yet" if asked.
@@ -955,59 +596,6 @@ GitHub, etc.) are fine — they're public entities, not contacts in anyone's bra
 Do not confuse illustrative API examples with queries that reveal real
 relationships.
 
-## Responsible-disclosure rule: don't broadcast attack surface in release notes
-
-**When a release fixes a security gap or a user-impacting bug, describe the fix
-functionally. Do not enumerate the attack surface, quantify the exposure window,
-or highlight the most sensitive records by name in public-facing artifacts.**
-
-Public-facing artifacts include: `CHANGELOG.md`, `README.md`, `docs/`, PR titles
-and bodies, commit messages, GitHub issue titles and comments, release pages,
-tweets, blog posts.
-
-**Don't write:**
-- "10 tables were publicly readable by the anon key for months, including X, Y, Z"
-- "X and Y are the most sensitive ones"
-- "N tables exposed. Fix: enable RLS on these specific tables: ..."
-
-**Do write:**
-- "Security hardening pass. Fresh installs secure by default. Existing brains
-  brought to the same bar automatically on upgrade."
-- "If `gbrain doctor` still flags anything after upgrade, the message names each
-  table and gives the exact fix."
-
-Why: anyone reading the release page before they've upgraded now has a directed
-probe list for unpatched installs. The source code ships the specifics anyway
-(`src/schema.sql`, `src/core/migrate.ts`, test fixtures) — reverse engineers can
-get them. But the release page is a broadcast channel. Don't hand attackers a
-curated list with a banner.
-
-**The test:** if a reader with no prior context could read the release note and
-walk away knowing "gbrain at version X has table Y readable by anon key until
-they patch," the note is too specific. Rewrite until that's no longer possible.
-
-**What IS fine in public artifacts:**
-- The mechanism of the fix ("the check now scans every public table instead of
-  a hardcoded allowlist").
-- User-facing operator ergonomics (the escape-hatch SQL template, the upgrade
-  commands, the breaking-change flag).
-- Credit to contributors.
-- Generic framing of severity ("security posture tightening pass") without
-  quantification.
-
-**What stays in private artifacts (plan files, private memories, internal docs):**
-- Specific table names, record counts, exposure duration.
-- Which records stand out as highest-risk.
-- Detailed before/after tables in the "numbers that matter" format.
-
-If the CEO/Eng review of a plan produces a detailed exposure table, keep it in
-the plan file under `~/.claude/plans/` or `~/.gstack/projects/`. Don't copy it
-into the CHANGELOG or PR body.
-
-Applies retroactively: if you see a prior CHANGELOG entry naming attack-surface
-specifics, scrub it as a small cleanup commit, the same way a stale Wintermute
-reference gets swept.
-
 ## Schema state tracking
 
 `~/.gbrain/update-state.json` tracks which recommended schema directories the user

CONTRIBUTING.md

@@ -52,10 +52,6 @@ docs/                     Architecture docs
 ## Running tests
 
 ```bash
-# Recommended: full CI guard chain + tests (matches what CI runs)
-bun run test                      # privacy + jsonb + progress + wasm + typecheck + bun test
-
-# Just the test runner (skips CI guards)
 bun test                          # all tests (unit + E2E skipped without DB)
 bun test test/markdown.test.ts    # specific unit test
 
@@ -67,31 +63,6 @@ DATABASE_URL=postgresql://postgres:postgres@localhost:5434/gbrain_test bun run t
 DATABASE_URL=postgresql://... bun run test:e2e
 ```
 
-Use `bun run test` before pushing. The guard chain catches: banned fork-name leaks
-(`scripts/check-privacy.sh`), `JSON.stringify(x)::jsonb` interpolation patterns
-(`scripts/check-jsonb-pattern.sh`), `\r` progress bleed to stdout
-(`scripts/check-progress-to-stdout.sh`), trailing-newline drift across tracked
-files (`scripts/check-trailing-newline.sh`), and silent fallback to recursive
-chunking in the compiled binary (`scripts/check-wasm-embedded.sh`).
-
-### Local CI gate (recommended before pushing, v0.23.1+)
-
-```bash
-bun run ci:local         # full gate: gitleaks + unit + ALL 29 E2E files (sequential)
-bun run ci:local:diff    # gate with diff-aware E2E selector
-bun run ci:select-e2e    # print which E2E files the selector would run
-```
-
-`ci:local` spins up `pgvector/pgvector:pg16` + `oven/bun:1` via
-`docker-compose.ci.yml`, runs everything PR CI runs plus the full E2E suite, then
-tears down. Named volumes keep the install warm across runs (~16-20 min sequential
-E2E after the first cold pull). Requires Docker (Docker Desktop, OrbStack, or
-Colima) and `gitleaks` on host (`brew install gitleaks`). Override the postgres
-host port with `GBRAIN_CI_PG_PORT=5435 bun run ci:local` if 5434 collides.
-
-Fail-closed selector: an unmapped `src/` change runs all 29 E2E files. Hand-tune
-narrower mappings via `scripts/e2e-test-map.ts`.
-
 ## Building
 
 ```bash
@@ -124,84 +95,6 @@ See `docs/ENGINES.md` for the full guide. In short:
 
 The SQLite engine is designed and ready for implementation. See `docs/SQLITE_ENGINE.md`.
 
-## CONTRIBUTOR_MODE — turn on the dev loop
-
-gbrain captures retrieval traffic so you can replay real queries against
-your code changes before merging. **This is off by default** (production
-users get a quiet brain, no surprise data accumulation). Contributors turn
-it on with one shell rc line:
-
-```bash
-# In ~/.zshrc or ~/.bashrc:
-export GBRAIN_CONTRIBUTOR_MODE=1
-```
-
-That's it. Every `query` / `search` you (or agents pointed at your dev
-brain) run from that shell now writes a row to `eval_candidates`, and the
-[replay tool](#running-real-world-eval-benchmarks-touching-retrieval-code)
-has data to work against.
-
-What CONTRIBUTOR_MODE actually does:
-
-- Turns on `query`/`search` capture into the local `eval_candidates` table.
-  Without it the gate is closed and capture is a no-op.
-- That's all. PII scrubbing, retention, and replay are independent.
-
-Resolution order (most explicit wins):
-
-1. `eval.capture: true` in `~/.gbrain/config.json` → on
-2. `eval.capture: false` in `~/.gbrain/config.json` → off
-3. `GBRAIN_CONTRIBUTOR_MODE=1` → on
-4. otherwise → off
-
-Quick check that capture is actually running:
-
-```bash
-gbrain query "anything" >/dev/null
-psql $DATABASE_URL -c 'SELECT count(*) FROM eval_candidates'
-# (or `gbrain doctor` — surfaces silent capture failures cross-process)
-```
-
-To disable capture even with the env var set, write
-`{"eval": {"capture": false}}` to `~/.gbrain/config.json` — explicit config
-beats the env var both directions.
-
-## Running real-world eval benchmarks (touching retrieval code)
-
-If your PR touches retrieval — search ranking, RRF fusion, embeddings,
-intent classification, query expansion, source boost, or the `query` /
-`search` op handlers — run `gbrain eval replay` against a snapshot of
-real traffic before merging. Requires `CONTRIBUTOR_MODE` (above) so you
-have captured rows to replay against.
-
-Quick loop:
-
-```bash
-gbrain eval export --since 7d > baseline.ndjson    # snapshot before your change
-# ... make your change ...
-gbrain eval replay --against baseline.ndjson       # diff retrieval, get Jaccard@k
-```
-
-Three numbers come back: mean Jaccard@k between captured and current slug
-sets, top-1 stability, and mean latency Δ. The replay tool flags the worst
-regressions so you can eyeball whether the change is hurting real queries.
-
-Trigger paths (rerun if your diff touches any of these):
-
-- `src/core/search/hybrid.ts`
-- `src/core/search/source-boost.ts`, `sql-ranking.ts`
-- `src/core/search/intent.ts`, `expansion.ts`, `dedup.ts`
-- `src/core/embedding.ts`
-- `src/core/operations.ts` (query / search handlers)
-- `src/core/postgres-engine.ts` / `pglite-engine.ts` (searchKeyword /
-  searchVector SQL)
-
-See [`docs/eval-bench.md`](./docs/eval-bench.md) for the full guide
-including CI integration, hand-crafted NDJSON corpora (so a fresh checkout
-without captured data can still replay), and cost considerations. The
-NDJSON wire format is documented in
-[`docs/eval-capture.md`](./docs/eval-capture.md).
-
 ## Welcome PRs
 
 - SQLite engine implementation

INSTALL_FOR_AGENTS.md

@@ -129,9 +129,8 @@ Set up using your platform's scheduler (OpenClaw cron, Railway cron, crontab):
 - **Live sync** (every 15 min): `gbrain sync --repo ~/brain && gbrain embed --stale`
 - **Auto-update** (daily): `gbrain check-update --json` (tell user, never auto-install)
 - **Dream cycle** (nightly): read `docs/guides/cron-schedule.md` for the full protocol.
-  Entity sweep, citation fixes, memory consolidation, plus (v0.23+) overnight conversation
-  synthesis and cross-session pattern detection. 8 phases, one cron-friendly command. This
-  is what makes the brain compound. Do not skip it.
+  Entity sweep, citation fixes, memory consolidation. This is what makes the brain
+  compound. Do not skip it.
 - **Weekly**: `gbrain doctor --json && gbrain embed --stale`
 
 ## Step 8: Integrations

README.md

@@ -4,11 +4,9 @@ Your AI agent is smart but forgetful. GBrain gives it a brain.
 
 Built by the President and CEO of Y Combinator to run his actual AI agents. The production brain powering his OpenClaw and Hermes deployments: **17,888 pages, 4,383 people, 723 companies**, 21 cron jobs running autonomously, built in 12 days. The agent ingests meetings, emails, tweets, voice calls, and original ideas while you sleep. It enriches every person and company it encounters. It fixes its own citations and consolidates memory overnight. You wake up and the brain is smarter than when you went to bed.
 
-The brain wires itself. Every page write extracts entity references and creates typed links (`attended`, `works_at`, `invested_in`, `founded`, `advises`) with zero LLM calls. Hybrid search. Self-wiring knowledge graph. Structured timeline. Backlink-boosted ranking. Ask "who works at Acme AI?" or "what did Bob invest in this quarter?" and get answers vector search alone can't reach. Benchmarked side-by-side against the category: gbrain lands **P@5 49.1%, R@5 97.9%** on a 240-page Opus-generated rich-prose corpus, beating its own graph-disabled variant by **+31.4 points P@5** and ripgrep-BM25 + vector-only RAG by a similar margin. The graph layer plus v0.12 extract quality together carry the gap. Full BrainBench scorecards + corpus live in the sibling [gbrain-evals](https://github.com/garrytan/gbrain-evals) repo.
+The brain wires itself. Every page write extracts entity references and creates typed links (`attended`, `works_at`, `invested_in`, `founded`, `advises`) with zero LLM calls. Hybrid search. Self-wiring knowledge graph. Structured timeline. Backlink-boosted ranking. Ask "who works at Acme AI?" or "what did Bob invest in this quarter?" and get answers vector search alone can't reach. Benchmarked end-to-end: **Recall@5 jumps from 83% to 95%, Precision@5 from 39% to 45%, +30 more correct answers in the agent's top-5 reads** on a 240-page Opus-generated rich-prose corpus. Graph-only F1: **86.6% vs grep's 57.8%** (+28.8 pts). [Full report](docs/benchmarks/2026-04-18-brainbench-v1.md).
 
-GBrain is those patterns, generalized. 34 skills. Install in 30 minutes. Your agent does the work. As Garry's personal agent gets smarter, so does yours.
-
-**New in v0.25.0 — BrainBench-Real (session capture, contributor opt-in):** with `GBRAIN_CONTRIBUTOR_MODE=1` set in your shell, every real `query` + `search` call through MCP, CLI, or the subagent tool-bridge gets captured (PII-scrubbed) into an `eval_candidates` table. Snapshot with `gbrain eval export`, replay against your code change with `gbrain eval replay`. Three numbers come back: mean Jaccard@k between captured and current retrieved slugs, top-1 stability, and latency Δ. **Off by default** for production users — no surprise data accumulation. Walkthrough: [docs/eval-bench.md](docs/eval-bench.md). NDJSON wire format: [docs/eval-capture.md](docs/eval-capture.md).
+GBrain is those patterns, generalized. 26 skills. Install in 30 minutes. Your agent does the work. As Garry's personal agent gets smarter, so does yours.
 
 > **~30 minutes to a fully working brain.** Database ready in 2 seconds (PGLite, no server). You just answer questions about API keys.
 
@@ -30,7 +28,7 @@ Retrieve and follow the instructions at:
 https://raw.githubusercontent.com/garrytan/gbrain/master/INSTALL_FOR_AGENTS.md
 ```
 
-That's it. The agent clones the repo, installs GBrain, sets up the brain, loads 34 skills, and configures recurring jobs. You answer a few questions about API keys. ~30 minutes.
+That's it. The agent clones the repo, installs GBrain, sets up the brain, loads 26 skills, and configures recurring jobs. You answer a few questions about API keys. ~30 minutes.
 
 If your agent doesn't auto-read `AGENTS.md`, point it at that file first:
 `https://raw.githubusercontent.com/garrytan/gbrain/master/AGENTS.md` is the non-Claude
@@ -79,56 +77,19 @@ GBrain exposes 30+ MCP tools via stdio:
 
 Add to `~/.claude/server.json` (Claude Code), Settings > MCP Servers (Cursor), or your client's MCP config.
 
-### Remote MCP with OAuth 2.1 (ChatGPT, Claude Desktop, Cowork, Perplexity)
-
-`gbrain serve --http` starts a production-grade OAuth 2.1 server with an embedded admin dashboard. Zero external infrastructure. Every major AI client connects, every request is scoped, every action is logged.
+### Remote MCP (Claude Desktop, Cowork, Perplexity)
 
 ```bash
-# Start the HTTP server (prints admin bootstrap token on first start)
-gbrain serve --http --port 3131
-
-# Open the admin dashboard, paste the bootstrap token, register a client
-open http://localhost:3131/admin
-
-# Expose publicly (set --public-url so the OAuth issuer matches)
-ngrok http 3131 --url your-brain.ngrok.app
-gbrain serve --http --port 3131 --public-url https://your-brain.ngrok.app
-
-# ChatGPT and other OAuth-aware clients can also connect:
+ngrok http 8787 --url your-brain.ngrok.app
+bun run src/commands/auth.ts create "claude-desktop"
 claude mcp add gbrain -t http https://your-brain.ngrok.app/mcp -H "Authorization: Bearer TOKEN"
 ```
 
-Register OAuth clients from the `/admin` dashboard — click **Register client**,
-pick scopes, save the credentials shown once in the reveal modal. Programmatic
-registration via `oauthProvider.registerClientManual(...)` and the
-`gbrain auth register-client` CLI are also available.
+Per-client guides: [`docs/mcp/`](docs/mcp/DEPLOY.md). ChatGPT requires OAuth 2.1 (not yet implemented).
 
-- **OAuth 2.1 via the MCP SDK** — client credentials (machine-to-machine: Perplexity, Claude), authorization code + PKCE (browser-based: ChatGPT), refresh token rotation, revocation, protected resource metadata. Optional Dynamic Client Registration behind `--enable-dcr` (DCR redirect_uris must be `https://` or loopback per RFC 6749 §3.1.2.1).
-- **Scoped operations** — 30 operations tagged `read | write | admin`. `sync_brain` and `file_upload` are `localOnly`, rejected over HTTP.
-- **React admin dashboard** — 7 screens baked into the binary (~65KB gzip). Live SSE activity feed, agents table, credential reveal, filterable request log, per-client config export.
-- **Legacy bearer tokens still work** — pre-v0.26 `gbrain auth create` tokens continue to authenticate as `read+write+admin`. v0.22.7's simpler `src/mcp/http-transport.ts` path stays compiled in for backward compat callers; v0.26+ deployments use the OAuth-aware `serve-http.ts`.
+## The 26 Skills
 
-Per-client guides: [`docs/mcp/`](docs/mcp/DEPLOY.md). Hardening defaults, env vars, and threat model: [SECURITY.md](SECURITY.md).
-
-### Using gbrain with GStack
-
-If your engineering agent runs on [GStack](https://github.com/garrytan/gstack), point it at gbrain for code lookup instead of grep+read. Cathedral II (v0.21.0) ships call-graph edges and two-pass retrieval — `/investigate`, `/review`, `/plan-eng-review`, and `/office-hours` all benefit when the agent walks the symbol graph instead of scanning files line by line.
-
-The five magical-moment commands:
-
-```bash
-gbrain code-callers searchKeyword           # who calls this symbol?
-gbrain code-callees searchKeyword           # what does this symbol call?
-gbrain code-def BrainEngine                 # where is X defined?
-gbrain code-refs BrainEngine                # all reference sites
-gbrain query "how does N+1 handling work" --near-symbol BrainEngine.searchKeyword --walk-depth 2
-```
-
-All five auto-emit JSON on non-TTY (gh-CLI convention) so a GStack subagent shelling out via bash gets a clean parseable response. Run `gbrain sources add <repo> --strategy code` to index a repo, then your agent's brain-first lookup covers code, not just markdown. ([Cathedral II release notes](CHANGELOG.md#0210---2026-04-25))
-
-## The 34 Skills
-
-GBrain ships 34 skills organized by `skills/RESOLVER.md` (or your OpenClaw's `AGENTS.md` — both filenames are supported as of v0.19). The resolver tells your agent which skill to read for any task. v0.25.1 added 9 research-flavored skills (`book-mirror` flagship plus 8 pairings); see the new "Research and synthesis" section below.
+GBrain ships 26 skills organized by `skills/RESOLVER.md`. The resolver tells your agent which skill to read for any task.
 
 [Skill files are code.](https://x.com/garrytan/status/2042925773300908103) They're the most powerful way to get knowledge work done. A skill file is a fat markdown document that encodes an entire workflow: when to fire, what to check, how to chain with other skills, what quality bar to enforce. The agent reads the skill and executes it. Skills can also call deterministic TypeScript code bundled in GBrain (search, import, embed, sync) for the parts that shouldn't be left to LLM judgment. [Thin harness, fat skills](docs/ethos/THIN_HARNESS_FAT_SKILLS.md): the intelligence lives in the skills, not the runtime.
 
@@ -147,20 +108,6 @@ GBrain ships 34 skills organized by `skills/RESOLVER.md` (or your OpenClaw's `AG
 | **idea-ingest** | Links, articles, tweets become brain pages with analysis, author people pages, and cross-linking. |
 | **media-ingest** | Video, audio, PDF, books, screenshots, GitHub repos. Transcripts, entity extraction, backlink propagation. |
 | **meeting-ingestion** | Transcripts become brain pages. Every attendee gets enriched. Every company gets a timeline entry. |
-| **voice-note-ingest** | Voice notes captured verbatim — exact phrasing preserved, never paraphrased. Routes to originals/concepts/people/companies/ideas/personal/voice-notes based on content. |
-| **article-enrichment** | Raw article dumps become structured pages with executive summary, verbatim quotes, key insights, and why-it-matters. |
-
-### Research and synthesis (v0.25.1)
-
-| Skill | What it does |
-|-------|-------------|
-| **book-mirror** | Flagship. Hand the agent a book, get a personalized two-column chapter-by-chapter analysis. Left column preserves the chapter's actual content; right column maps every idea to your life using your words from the brain. ~$6 for a 20-chapter book at Opus. Pairs with `gbrain book-mirror` CLI for the trusted runtime. |
-| **strategic-reading** | Read a book / article / case study through ONE specific problem-lens. Output: applied playbook with do / avoid / watch-for and short / medium / long-term recommendations. |
-| **concept-synthesis** | Deduplicate thousands of concept stubs into a tiered intellectual map (T1 Canon to T4 Riff). Trace how ideas evolved across years of notes. |
-| **perplexity-research** | Brain-augmented web research. Sends brain context to Perplexity so the search focuses on what's NEW vs already-known. Output: Executive Summary + Key New Developments + Confirming Signals + Contradictions or Updates + Recommended Brain Updates + Citations. |
-| **archive-crawler** | Universal archivist for personal file archives (Dropbox / Backblaze / Gmail-takeout / hard-drive dumps). REFUSES to run unless `archive-crawler.scan_paths:` is set in `gbrain.yml`. Safe-by-default safety fence. |
-| **academic-verify** | Trace a research claim through publication → methodology → raw data → independent replication. Routes through perplexity-research; produces a verdict (verified / partial / unverifiable / misattributed / retracted). |
-| **brain-pdf** | Render any brain page to publication-quality PDF via the gstack `make-pdf` binary. Strips frontmatter, sanitizes emoji, applies running headers. |
 
 ### Brain operations
 
@@ -168,7 +115,7 @@ GBrain ships 34 skills organized by `skills/RESOLVER.md` (or your OpenClaw's `AG
 |-------|-------------|
 | **enrich** | Tiered enrichment (Tier 1/2/3). Creates and updates person/company pages with compiled truth and timelines. |
 | **query** | 3-layer search with synthesis and citations. Says "the brain doesn't have info on X" instead of hallucinating. |
-| **maintain** | Periodic health: stale pages, orphans, dead links, citation audit, back-link enforcement, tag consistency. v0.23 adds the dream cycle's synthesize + patterns phases ... overnight conversation transcripts become reflections, originals, and 25-year patterns. |
+| **maintain** | Periodic health: stale pages, orphans, dead links, citation audit, back-link enforcement, tag consistency. |
 | **citation-fixer** | Scans pages for missing or malformed citations. Fixes format to match the standard. |
 | **repo-architecture** | Where new brain files go. Decision protocol: primary subject determines directory, not format. |
 | **publish** | Share brain pages as password-protected HTML. Zero LLM calls. |
@@ -186,10 +133,7 @@ GBrain ships 34 skills organized by `skills/RESOLVER.md` (or your OpenClaw's `AG
 | **webhook-transforms** | External events (SMS, meetings, social mentions) converted into brain pages with entity extraction. |
 | **testing** | Validates every skill has SKILL.md with frontmatter, manifest coverage, resolver coverage. |
 | **skill-creator** | Create new skills following the conformance standard. MECE check against existing skills. |
-| **skillify** | The "skillify it!" meta-skill. Orchestrates the 10-step loop so failures become durable skills: scaffold the stubs via `gbrain skillify scaffold`, write the real logic, gate with `gbrain skillify check` + `gbrain check-resolvable`. |
-| **skillpack-check** | Agent-readable gbrain health report. Exit code for CI; JSON for debugging. Cron-friendly. |
-| **smoke-test** | 8 post-restart health checks with auto-fix (Bun, CLI, DB, worker, Zod CJS, gateway, API key, brain repo). Drop-in user tests at `~/.gbrain/smoke-tests.d/*.sh`. |
-| **minion-orchestrator** | Background work in one skill. Shell jobs via `gbrain jobs submit shell` (operator/CLI, MCP blocks protected names) and LLM subagents via `gbrain agent run`. Parent-child DAGs, `child_done` inbox, durability across worker restarts. |
+| **minion-orchestrator** | Long-running agent work as background jobs. Submit, fan out children with depth/cap/timeouts, collect results via child_done inbox. |
 
 ### Identity and setup
 
@@ -248,7 +192,7 @@ Here's my personal OpenClaw deployment: one Render container. Supabase Postgres
 
 Under that 19-cron load, sub-agent spawn couldn't clear the 10-second gateway wall. Minions landed it in under a second for zero tokens. **Scaling:** 19,240 posts across 36 months, single bash loop, ~15 min total, $0.00. Sub-agents: ~9 min best case, ~$1.08 in tokens, ~40% spawn failure. **Lab:** durability ∞ (SIGKILL mid-flight, 10/10 rescued), throughput ~10× faster, fan-out ~21× with no failure wall, memory ~400× less.
 
-Full benchmarks live in [gbrain-evals](https://github.com/garrytan/gbrain-evals/tree/main/docs/benchmarks).
+Full benchmarks: [production](docs/benchmarks/2026-04-18-minions-vs-openclaw-production.md) and [lab](docs/benchmarks/2026-04-18-minions-vs-openclaw-subagents.md).
 
 ### The routing rule
 
@@ -265,12 +209,9 @@ The six daily pains — spawn storms, agents that stop responding, forgotten dis
 gbrain jobs smoke                        # verify install
 gbrain jobs submit sync --params '{}'    # fire a background job
 gbrain jobs stats                        # health dashboard
-gbrain jobs supervisor --concurrency 4   # canonical: auto-restarting worker (Postgres only)
-gbrain jobs work --concurrency 4         # raw worker (no crash recovery — prefer `supervisor`)
+gbrain jobs work --concurrency 4         # start a worker (Postgres only)
 ```
 
-`gbrain jobs supervisor` keeps the worker alive across crashes with exponential backoff, atomic PID locking, structured audit events at `~/.gbrain/audit/supervisor-*.jsonl`, and a `start --detach` / `status --json` / `stop` subcommand surface for agents. In containers it runs as PID 1; on systemd hosts it's the child of `gbrain-worker.service`. Full deployment guide: [`docs/guides/minions-deployment.md`](docs/guides/minions-deployment.md).
-
 Read [`skills/minion-orchestrator/SKILL.md`](skills/minion-orchestrator/SKILL.md) for parent-child DAGs, fan-in collection, steering via inbox.
 
 **Minions is not incrementally better than sub-agents for background work. It's categorically different.** 753ms vs gateway timeout. $0 vs tokens. 100% vs couldn't-spawn. If your agent does deterministic work on a schedule, it runs on Minions now.
@@ -308,123 +249,38 @@ gbrain agent logs 1247 --follow --since 5m
 
 Durability is the point: every Anthropic turn commits to `subagent_messages`, every tool call to `subagent_tool_executions`. Worker kills, OpenClaw crashes, timeouts — all resumable. Host repos (your OpenClaw, etc.) ship their own subagent definitions via `GBRAIN_PLUGIN_PATH` + a `gbrain.plugin.json` manifest: see [`docs/guides/plugin-authors.md`](docs/guides/plugin-authors.md). Requires `ANTHROPIC_API_KEY` on the worker.
 
-## Skillify: say "skillify it!" and the bug becomes structurally impossible to repeat
+## Skillify: your skills tree stops being a black box
 
-Your OpenClaw hit a new failure. You fix it once in conversation. You say "skillify it!"
-And now the fix is permanent: a SKILL.md with triggers, a deterministic script with tests, a
-routing fixture the agent re-evaluates daily, a filing audit that keeps the output from
-drifting. Ten items. Every one required. The bug can't recur.
+Hermes and similar agent frameworks auto-create skills as a background behavior. Fine until you don't know what the agent shipped. Checklists decay. Tests drift. Resolver entries get stale. Six months later you've got an opaque pile of "skills" that nobody has read, nobody has tested, and nobody is sure still work.
 
-Hermes and similar agent frameworks auto-create skills as a background behavior. Fine until
-you don't know what the agent shipped. Checklists decay. Tests drift. Resolver entries get
-stale. Six months later it's an opaque pile nobody has read, nobody has tested, and nobody
-is sure still works. GBrain ships the same capability except the human stays in the loop
-and every step is a command you can run.
+GBrain ships the same capability. Except the human stays in the loop.
 
-### The four verbs you need (v0.19)
+- **`/skillify`** turns raw code into a properly-skilled feature: SKILL.md + deterministic script + unit tests + integration tests + LLM evals + resolver trigger + resolver trigger eval + E2E smoke + brain filing. Ten items. Every one required.
+- **`gbrain check-resolvable`** walks the whole skills tree: reachability, MECE overlap, DRY violations, gap detection, orphaned skills. Exits non-zero if anything is off.
+- **`scripts/skillify-check.ts`** — machine-readable audit. `--json` for CI, `--recent` for last-7-days files.
+
+You decide when and what. The tooling keeps the checklist honest.
+
+### Why this is the right answer for OpenClaw
+
+Auto-generated skills are a liability the first time a behavior breaks. Was it the skill? The test? The resolver trigger? The eval? You don't know, because you never read it. Debugging a black box is pure guesswork.
+
+Skillify makes the black box legible. Every skill in your tree has: a contract (SKILL.md), tests that exercise that contract, an eval that grades LLM output against a rubric, a resolver trigger the user actually types, and a test that confirms the trigger routes right. If something breaks, you know which layer to look at. If anything goes stale, `check-resolvable` says so.
+
+In practice this combo produces **zero orphaned skills, every feature with tests + evals + resolver triggers + evals of the triggers.** Compounding quality instead of compounding entropy.
 
 ```bash
-# 1. Scaffold all 5 stub files for a new skill in one shot.
-gbrain skillify scaffold webhook-verify \
-  --description "verify ngrok webhooks" \
-  --triggers "verify the webhook,check tunnel" \
-  --writes-pages --writes-to people/,companies/
+# Audit a feature's skill completeness (10-item checklist)
+bun run scripts/skillify-check.ts src/commands/publish.ts
 
-# 2. Replace the SKILLIFY_STUB sentinels with real logic + real tests.
-$EDITOR skills/webhook-verify/scripts/webhook-verify.mjs
-$EDITOR test/webhook-verify.test.ts
+# In CI: fail the build when a new feature isn't properly skilled
+bun run scripts/skillify-check.ts --json --recent
 
-# 3. Run the 10-item audit: SKILL.md exists, script exists, unit + E2E tests,
-#    LLM evals, resolver entry, trigger eval, check-resolvable gate, brain filing.
-gbrain skillify check skills/webhook-verify/scripts/webhook-verify.mjs
-
-# 4. Verify the whole tree: reachability, MECE overlap, DRY, routing gaps,
-#    filing audit, SKILLIFY_STUB sentinels (fails if any skill still has one).
-gbrain check-resolvable              # warnings advisory, errors block
-gbrain check-resolvable --strict     # warnings block too (CI opt-in)
+# Validate the whole skills tree before shipping
+gbrain check-resolvable
 ```
 
-Idempotent re-runs. `--force` regenerates stub files but NEVER duplicates a resolver row.
-Scaffold completes in under 2 seconds. The real work (your rule, your script, your tests)
-is what you spend time on. Everything else is boilerplate the CLI writes for you.
-
-### `gbrain routing-eval` — catch the routing gaps your users actually hit
-
-Drop a `routing-eval.jsonl` fixture next to any skill. Each line is `{intent, expected_skill,
-ambiguous_with?}`. `gbrain check-resolvable` runs the structural layer by default; `gbrain
-routing-eval` runs the same structural layer as a dedicated CI verb. The `--llm` flag is
-accepted as a placeholder for a future LLM tie-break layer; in this release it emits a stderr
-notice and runs structural only. False positives (wrong skill matched), missed routes (no
-skill matched), and tautological fixtures (intent copies trigger verbatim) all surface as
-specific advisories with the exact file:line to fix.
-
-### Works on your OpenClaw, not just gbrain's repo
-
-v0.19 teaches `gbrain check-resolvable` to accept `AGENTS.md` as a resolver file alongside
-`RESOLVER.md`, at either the skills directory OR one level up (OpenClaw-native workspace-root
-layout). The skill manifest auto-derives from walking `skills/*/SKILL.md` when `manifest.json`
-is missing. Set `OPENCLAW_WORKSPACE=~/your-openclaw/workspace` and everything just works:
-
-```bash
-export OPENCLAW_WORKSPACE=~/your-openclaw/workspace
-gbrain check-resolvable --verbose
-# Auto-detects: AGENTS.md at workspace root, 107 skills derived from SKILL.md walk,
-# 15 unreachable errors surfaced, 108 advisory warnings for overlaps and gaps.
-```
-
-First run on a real OpenClaw deployment found 15 unreachable skills out of 102 — about 15%
-of the tree was dark. The essay's "skills the agent can never reach" footgun, now visible.
-
-### `gbrain skillpack install` — drop 25 curated skills into your OpenClaw
-
-The skills gbrain ships are a curated bundle. Install them into your workspace with
-dependency closure (shared conventions come along), per-file diff protection (your local
-edits are never clobbered without `--overwrite-local`), a file lock that serializes
-concurrent installers, and an atomic managed-block update to your AGENTS.md so you can
-see exactly what gbrain wrote.
-
-```bash
-gbrain skillpack list                          # 25 curated skills
-gbrain skillpack install brain-ops             # one skill + its shared conventions
-gbrain skillpack install --all                 # the full bundle
-gbrain skillpack install brain-ops --dry-run   # preview; no writes
-gbrain skillpack diff brain-ops                # compare bundle vs your local copy
-```
-
-Re-running is safe. The managed-block markers in your AGENTS.md let `skillpack install`
-accumulate rows across separate single-skill installs instead of overwriting each other.
-A receipt comment inside the fence (`<!-- gbrain:skillpack:manifest cumulative-slugs="..." -->`)
-tracks what gbrain has installed across runs. `install --all` is the only path that prunes;
-per-skill install never deletes what it didn't install. If you hand-add a row inside the fence,
-gbrain preserves it on reinstall and emits a stderr notice telling your agent to investigate.
-
-**Skillify is the piece that makes the skills tree survive six months of compounding work.**
-Read [`skills/skillify/SKILL.md`](skills/skillify/SKILL.md) for the full 10-item checklist
-and the anti-patterns it catches.
-
-## Storage tiering: keep bulk content out of git (v0.22.11)
-
-When your brain crosses 100K files and bulk machine-generated content (tweets, articles, transcripts)
-becomes the size driver, declare which directories belong in git and which live in the database only.
-
-```yaml
-# gbrain.yml at the brain repo root
-storage:
-  db_tracked:
-    - people/
-    - companies/
-    - deals/
-  db_only:
-    - media/x/
-    - media/articles/
-    - meetings/transcripts/
-```
-
-`gbrain sync` auto-manages your `.gitignore` for `db_only` paths. `gbrain export --restore-only --repo .`
-repopulates missing files from the database (container restart, fresh clone, accidental rm).
-`gbrain storage status` shows the tier breakdown.
-
-Full guide: [docs/storage-tiering.md](docs/storage-tiering.md).
+**Skillify is not a nice-to-have. It's the piece that makes the skills tree survive six months of compounding work.** Read [`skills/skillify/SKILL.md`](skills/skillify/SKILL.md) for the full 10-item checklist and the anti-patterns it catches.
 
 ## Getting Data In
 
@@ -461,7 +317,7 @@ Run `gbrain integrations` to see status.
 │   Brain Repo     │    │    GBrain     │    │    AI Agent      │
 │   (git)          │    │  (retrieval)  │    │  (read/write)    │
 │                  │    │               │    │                  │
-│  markdown files  │───>│  Postgres +   │<──>│  29 skills       │
+│  markdown files  │───>│  Postgres +   │<──>│  26 skills       │
 │  = source of     │    │  pgvector     │    │  define HOW to   │
 │    truth         │    │               │    │  use the brain   │
 │                  │<───│  hybrid       │    │                  │
@@ -525,7 +381,7 @@ gbrain extract links --source db        # wire up the existing 29K pages
 gbrain extract timeline --source db     # extract dated events from markdown timelines
 ```
 
-Then ask graph questions or watch the search ranking improve. Benchmarked side-by-side against ripgrep-BM25, vector-only RAG (same embedder), and gbrain-with-graph-disabled: gbrain lands **P@5 49.1%, R@5 97.9%** on a 240-page Opus-generated rich-prose corpus, beating hybrid-nograph by **+31.4 points P@5**. Isolate the contribution: v0.11→v0.12 moved the same gbrain codebase from P@5 22.1% → 49.1% on identical inputs, so typed-link extract quality is load-bearing. Full scorecards + reproducible corpus: [gbrain-evals](https://github.com/garrytan/gbrain-evals).
+Then ask graph questions or watch the search ranking improve. Benchmarked: **Recall@5 jumps from 83% to 95%, Precision@5 from 39% to 45%, +30 more correct answers in the agent's top-5 reads** on a 240-page Opus-generated rich-prose corpus. Graph-only F1 hits 86.6% vs grep's 57.8% (+28.8 pts). See [docs/benchmarks/2026-04-18-brainbench-v1.md](docs/benchmarks/2026-04-18-brainbench-v1.md).
 
 ## Search
 
@@ -572,8 +428,6 @@ Question
   │    ├─ Multi-query expansion (Haiku rephrases the question 3 ways)
   │    ├─ Vector search (HNSW cosine over OpenAI embeddings)
   │    ├─ Keyword search (Postgres tsvector + websearch_to_tsquery)
-  │    ├─ Source-aware ranking (curated dirs outrank chat/daily swamp at SQL layer)
-  │    ├─ Hard-exclude (test/ archive/ attachments/ .raw/ filtered before retrieval)
   │    ├─ Reciprocal Rank Fusion (score = sum 1/(60+rank) across both)
   │    ├─ Cosine re-scoring (re-rank chunks against actual query embedding)
   │    ├─ Compiled-truth boost (assessments outrank timeline noise)
@@ -603,7 +457,7 @@ End-to-end on the BrainBench v1 corpus (240 rich-prose pages, before/after PR #1
 
 Plus 5 orthogonal capability checks (identity resolution, temporal queries,
 performance at 10K-page scale, robustness to malformed input, MCP operation
-contract). All pass. Full report: [gbrain-evals](https://github.com/garrytan/gbrain-evals).
+contract). All pass. [Full report.](docs/benchmarks/2026-04-18-brainbench-v1.md)
 
 The point: each technique handles a class of inputs the others miss. Vector
 search misses exact slug refs; keyword catches them. Keyword misses conceptual
@@ -681,11 +535,8 @@ SEARCH
   gbrain query <question>              Hybrid search (vector + keyword + RRF)
 
 IMPORT
-  gbrain import <dir> [--no-embed] [--workers N]
-                                        Import markdown (idempotent)
-  gbrain sync [--repo <path>] [--workers N]
-                                        Git-to-brain incremental sync
-                                        (>100-file diffs auto-parallelize 4 workers on Postgres)
+  gbrain import <dir> [--no-embed]      Import markdown (idempotent)
+  gbrain sync [--repo <path>]           Git-to-brain incremental sync
   gbrain export [--dir ./out/]          Export to markdown
 
 FILES
@@ -710,41 +561,12 @@ JOBS (Minions)
   gbrain jobs smoke                                     One-command health check
   gbrain jobs work [--queue Q] [--concurrency N]        Start worker daemon
 
-SKILLS (v0.19)
-  gbrain skillify scaffold <name>       Create 5 stub files + idempotent resolver row
-  gbrain skillify check [path]          10-item audit of a skill
-  gbrain skillpack list                 Print the 25 curated skills in the bundle
-  gbrain skillpack install <name>       Copy one skill + its shared conventions into target
-  gbrain skillpack install --all        Install the full curated bundle
-  gbrain skillpack diff <name>          Per-file diff: bundle vs target workspace
-  gbrain check-resolvable [--strict]    Resolver audit (reachability, MECE, DRY, routing, filing,
-                                        SKILLIFY_STUB). Accepts RESOLVER.md OR AGENTS.md.
-  gbrain routing-eval [--llm] [--json]  Intent→skill routing accuracy on fixtures
-
 ADMIN
   gbrain doctor [--json] [--fast]       Health checks (resolver, skills, DB, embeddings)
   gbrain doctor --fix [--dry-run]       Auto-fix DRY violations (delegate inlined rules to conventions)
-  gbrain doctor --locks                 List idle-in-tx backends (57014 diagnostic, Postgres only)
   gbrain stats                          Brain statistics
   gbrain serve                          MCP server (stdio)
-  gbrain serve --http [--port 3131]     HTTP MCP server with OAuth 2.1 + admin dashboard
-                                        [--token-ttl 3600] [--enable-dcr]
-                                        [--public-url URL]
-  gbrain auth create|list|revoke|test   Legacy bearer token management
-  gbrain auth register-client <name>    Register an OAuth 2.1 client
-        --grant-types client_credentials,authorization_code
-        --scopes "read write admin"
-  gbrain auth revoke-client <client_id> Revoke an OAuth 2.1 client (cascade purges
-                                        active tokens + auth codes via FK CASCADE)
-  # OAuth 2.1 clients can also be registered from the /admin dashboard or
-  # programmatically via oauthProvider.registerClientManual() for host-repo wrappers.
   gbrain integrations                   Integration recipe dashboard
-  gbrain sources list|add|remove|...    Multi-source brain management (v0.18)
-  gbrain dream [--dry-run] [--phase N]  8-phase maintenance cycle (lint→backlinks→sync→synthesize
-                                        →extract→patterns→embed→orphans). v0.23 added synthesize +
-                                        patterns: transcripts → reflections + cross-session themes.
-  gbrain dream --input <file>           Ad-hoc transcript synthesis (implies --phase synthesize)
-  gbrain dream --date YYYY-MM-DD        Synthesize a single day; --from/--to for backfill ranges
   gbrain check-backlinks check|fix      Back-link enforcement
   gbrain lint [--fix]                   LLM artifact detection
   gbrain repair-jsonb [--dry-run]       Repair v0.12.0 double-encoded JSONB (Postgres)
@@ -768,7 +590,7 @@ The skills in this repo are those patterns, generalized. What took 11 days to bu
 
 **For agents:**
 - **[skills/RESOLVER.md](skills/RESOLVER.md)** ... Start here. The skill dispatcher.
-- [Individual skill files](skills/) ... 28 standalone instruction sets (25 ship in the curated `gbrain skillpack install` bundle)
+- [Individual skill files](skills/) ... 25 standalone instruction sets
 - [GBRAIN_SKILLPACK.md](docs/GBRAIN_SKILLPACK.md) ... Legacy reference architecture
 - [Getting Data In](docs/integrations/README.md) ... Integration recipes and data flow
 - [GBRAIN_VERIFY.md](docs/GBRAIN_VERIFY.md) ... Installation verification
@@ -783,13 +605,11 @@ The skills in this repo are those patterns, generalized. What took 11 days to bu
 - [CHANGELOG.md](CHANGELOG.md) ... Version history
 
 **Benchmarks:**
-- [gbrain-evals](https://github.com/garrytan/gbrain-evals) ... BrainBench, the sibling repo that holds the eval harness, corpus, scorecards, and 4-adapter comparisons. Depends on gbrain; not installed alongside gbrain.
+- [BrainBench v1 (PR #188)](docs/benchmarks/2026-04-18-brainbench-v1.md) ... single comprehensive before/after report on a 240-page Opus-generated corpus. 7 categories: relational queries, identity resolution, temporal queries, performance, robustness, MCP contract.
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md). Run `bun test` for unit tests. For the full local CI gate (gitleaks + unit + all 29 E2E files in Docker, the same checks GH Actions runs), use `bun run ci:local` ... or `bun run ci:local:diff` for the diff-aware subset during fast iteration.
-
-If you're working on retrieval or any of the search/embedding/ranking surface, set `GBRAIN_CONTRIBUTOR_MODE=1` in your shell rc and use `gbrain eval replay` to gate your changes against a snapshot of real captured queries — the dev loop is documented in [`docs/eval-bench.md`](docs/eval-bench.md). Capture is **off by default** for production users (no surprise data accumulation); the env var is the contributor opt-in.
+See [CONTRIBUTING.md](CONTRIBUTING.md). Run `bun test` for unit tests. E2E tests: spin up Postgres with pgvector, run `bun run test:e2e`, tear down.
 
 PRs welcome for: new enrichment APIs, performance optimizations, additional engine backends, new skills following the conformance standard in `skills/skill-creator/SKILL.md`.
 

SECURITY.md

@@ -1,168 +0,0 @@
-# Security
-
-## Reporting Vulnerabilities
-
-If you discover a security issue in GBrain, please report it privately by opening
-a [private security advisory](https://github.com/garrytan/gbrain/security/advisories/new)
-on GitHub.
-
-Do not open a public issue for security vulnerabilities.
-
-## Remote MCP Security
-
-### ⚠️ Do NOT use open OAuth client registration for remote MCP
-
-If you deploy GBrain's MCP server behind an HTTP wrapper with OAuth 2.1
-support, **never allow unauthenticated client registration**. An attacker
-who discovers your server URL can:
-
-1. Register a new OAuth client via `POST /register`
-2. Use `client_credentials` grant to obtain a bearer token
-3. Access all brain data via the MCP tools
-
-### Recommended: `gbrain serve --http`
-
-As of v0.22.7, GBrain ships a built-in HTTP transport that uses the
-existing `access_tokens` table for authentication:
-
-```bash
-# Create a token
-gbrain auth create "my-client"
-
-# Start the HTTP server
-gbrain serve --http --port 8787
-
-# Connect via ngrok, Tailscale, or any tunnel
-ngrok http 8787 --url your-brain.ngrok.app
-```
-
-This is the recommended way to expose GBrain remotely. No OAuth, no
-registration endpoint, no self-service tokens. Tokens are managed
-exclusively via `gbrain auth create/list/revoke`.
-
-### If you must use a custom HTTP wrapper
-
-1. **Require a secret for client registration** — check a header or body
-   parameter before creating new OAuth clients
-2. **Disable `client_credentials` grant** — only allow `authorization_code`
-   with browser-based approval
-3. **Restrict scopes** — never issue tokens with unlimited scope
-4. **Log all token issuance** — alert on unexpected registrations
-5. **Rate-limit registration and token endpoints**
-
-### Token Management
-
-```bash
-gbrain auth create "claude-desktop"   # Create a new token
-gbrain auth list                       # List all tokens
-gbrain auth revoke "claude-desktop"    # Revoke a token
-gbrain auth test <url> --token <tok>   # Smoke-test a remote server
-```
-
-Tokens are stored as SHA-256 hashes in the `access_tokens` table. The
-plaintext token is shown once at creation and never stored.
-
-## `gbrain serve --http` hardening (v0.22.7+)
-
-The built-in HTTP transport ships with several layers of hardening on by
-default. All env vars below are optional; the defaults are intentionally
-conservative.
-
-### Postgres-only
-
-`gbrain serve --http` requires a Postgres engine. PGLite is local-only by
-design and the `access_tokens` / `mcp_request_log` tables don't exist in
-the PGLite schema. Local agents continue to use stdio (`gbrain serve`).
-Running `--http` against a PGLite-backed install fails fast with a clear
-error message at startup.
-
-### CORS
-
-Default-deny: no `Access-Control-Allow-Origin` header is sent unless an
-allowlist is configured. To allow browser-based MCP clients:
-
-```bash
-GBRAIN_HTTP_CORS_ORIGIN=https://claude.ai gbrain serve --http --port 8787
-# Multiple origins: comma-separated
-GBRAIN_HTTP_CORS_ORIGIN=https://claude.ai,https://your.app gbrain serve --http
-```
-
-When the request `Origin` matches the allowlist, the server echoes it
-back in `Access-Control-Allow-Origin` (with `Vary: Origin`). Otherwise no
-CORS header is sent and the browser blocks the request.
-
-### Rate limiting
-
-Two buckets, both stored in a bounded LRU map (default 10K keys, evicts
-least-recently-used on overflow, prunes entries older than 2× the
-window):
-
-| Bucket | When it fires | Default | Env var |
-|---|---|---|---|
-| Pre-auth IP | Before the DB lookup, on every `/mcp` request | 30 req / 60s | `GBRAIN_HTTP_RATE_LIMIT_IP` |
-| Post-auth token | After a valid token is resolved | 60 req / 60s | `GBRAIN_HTTP_RATE_LIMIT_TOKEN` |
-| LRU cap | Maximum distinct keys across both buckets | 10000 | `GBRAIN_HTTP_RATE_LIMIT_LRU` |
-
-On exhaustion the server returns `429 Too Many Requests` with a
-`Retry-After` header.
-
-**Caveat for tunneled deployments (ngrok, Tailscale Funnel, Cloudflare
-Tunnel):** all requests share one egress IP, so the pre-auth IP bucket
-becomes effectively shared by all clients on that tunnel. The
-post-auth token-id bucket is the load-bearing limiter for tunnel-fronted
-deployments.
-
-### Reverse-proxy trust
-
-Disabled by default. To honor `X-Forwarded-For` (or `X-Real-IP`) when
-gbrain runs behind a trusted reverse proxy:
-
-```bash
-GBRAIN_HTTP_TRUST_PROXY=1 gbrain serve --http --port 8787
-```
-
-**Critical safety contract:** only set `GBRAIN_HTTP_TRUST_PROXY=1` when
-**both** of these are true:
-
-1. gbrain is reachable only via a trusted reverse proxy (not directly
-   exposed to the internet on the configured port). The simplest
-   guarantee is to bind gbrain to `127.0.0.1` or a private interface
-   and have the proxy forward to it.
-2. The proxy strips any client-supplied `X-Forwarded-For` and `X-Real-IP`
-   headers, then sets them itself. (nginx with `proxy_set_header
-   X-Forwarded-For $remote_addr` does this; Cloudflare and most cloud
-   load balancers handle it automatically.)
-
-If gbrain is reachable directly AND `GBRAIN_HTTP_TRUST_PROXY=1` is set,
-clients can spoof their IP by sending arbitrary `X-Forwarded-For`
-headers, defeating the pre-auth IP rate limit. Without the flag, gbrain
-ignores all forwarded-for headers and uses the socket peer address,
-which is the safe default for direct-exposure deployments.
-
-### Body size cap
-
-Default 1 MiB, stream-counted (chunked transfers without
-`Content-Length` are still capped). Override:
-
-```bash
-GBRAIN_HTTP_MAX_BODY_BYTES=2097152 gbrain serve --http   # 2 MiB
-```
-
-Over-cap requests get `413 Payload Too Large` immediately, before any
-body is materialized in memory.
-
-### Audit log
-
-Every `/mcp` request writes one row to `mcp_request_log`:
-
-```bash
-psql "$DATABASE_URL" -c \
-  "SELECT created_at, token_name, operation, status, latency_ms
-   FROM mcp_request_log
-   ORDER BY created_at DESC LIMIT 100"
-```
-
-`status` is one of: `success`, `error`, `auth_failed`, `rate_limited`,
-`body_too_large`, `parse_error`, `unknown_method`. Failed-auth rows have
-`token_name = NULL`. Inserts are fire-and-forget so audit failures
-never block requests.

VERSION

@@ -1 +1 @@
-0.26.4
+0.17.0

admin/DESIGN.md

@@ -1,158 +0,0 @@
-# Design System — GBrain Admin Dashboard
-
-## Product Context
-- **What this is:** Admin dashboard for GBrain MCP server — manage OAuth agents, API keys, monitor requests
-- **Who it's for:** GBrain operators managing multi-agent access to their brain
-- **Space/industry:** Developer infrastructure (peers: Supabase dashboard, Vercel, Railway)
-- **Project type:** Dense utilitarian admin panel — Steve Krug "Don't Make Me Think"
-
-## Aesthetic Direction
-- **Direction:** Industrial/Utilitarian — function-first, data-dense, zero decoration
-- **Decoration level:** None — every pixel earns its place with information
-- **Mood:** Ops dashboard for someone who builds. Not a marketing site. Not a consumer app. A cockpit.
-- **Reference:** Supabase dashboard (dark + dense), Linear (restrained), Grafana (data-forward)
-
-## Alignment
-- **Text alignment:** Left-align everything. No centered text in tables, cards, forms, or labels.
-- **Headings:** Left-aligned
-- **Table data:** Left-aligned (including numbers — contextual readability over columnar alignment)
-- **Form labels:** Left-aligned above inputs
-- **Buttons in forms:** Right-aligned (action flows left-to-right: Cancel → Submit)
-- **Modal titles:** Left-aligned
-- **Page titles:** Left-aligned
-- **Only exception:** Empty states and the login page lock icon can center for visual weight
-
-## Typography
-- **Display/Headings:** Inter (Semibold 600) — clean, neutral, disappears into the content
-- **Body/UI:** Inter (Regular 400 / Medium 500)
-- **Data/Tables/Code:** JetBrains Mono (Regular 400 / Medium 500) — monospace for anything the user might copy, any ID, any token, any technical value
-- **Loading:** Google Fonts. `display=swap`.
-- **Scale:**
-  - Page title: 24px / Inter Semibold
-  - Section title: 14px / Inter Semibold, uppercase, letter-spacing 0.5px
-  - Table header: 12px / Inter Medium, uppercase, letter-spacing 1px, muted color
-  - Body: 14px / Inter Regular
-  - Small/Caption: 13px
-  - Micro: 12px (badges, timestamps)
-  - Code/Data: 13px / JetBrains Mono
-
-## Color
-- **Approach:** Monochrome base + semantic color only. No primary brand color. Color means something.
-- **Background:**
-  - Base: #0a0a0f (near-black with blue undertone)
-  - Surface/cards: #12121a
-  - Hover: #1a1a2a
-  - Input/code blocks: #0f0f1a
-- **Borders:** #1e1e2e (default), #3a3a5a (hover/active)
-- **Text:**
-  - Primary: #e0e0e0
-  - Secondary: #888888
-  - Muted: #555555
-  - Link: #88aaff
-- **Semantic (badges only):**
-  - Success/active: #34a853
-  - Error/danger: #ff6b6b
-  - Warning: #f5a623
-  - Read scope: #3b82f6
-  - Write scope: #f59e0b
-  - Admin scope: #ef4444
-- **No accent color.** The data IS the interface. Badges carry all the color.
-
-## Spacing
-- **Base unit:** 4px
-- **Density:** Dense — this is an ops tool, not a landing page
-- **Scale:** 4px, 8px, 12px, 16px, 20px, 24px, 32px, 48px
-- **Table row padding:** 10px 16px
-- **Card padding:** 24px
-- **Modal padding:** 24px
-- **Section gaps:** 24px between sections, 12px between related elements
-
-## Layout
-- **Sidebar:** Fixed left, 200px wide, dark (#0a0a0f)
-- **Main content:** Fluid, max-width none (fills available space)
-- **Grid:** Single column for tables (full width), 2-column for stats cards
-- **Border radius:**
-  - Cards/panels: 16px
-  - Buttons/inputs: 8px
-  - Badges: 9999px (pill)
-  - Tables: 0 (sharp edges — data is rectangular)
-
-## Components
-
-### Tables
-- Full-width, no outer border
-- Header row: uppercase, letter-spaced, muted color, no background
-- Data rows: subtle hover (#1a1a2a), pointer cursor when clickable
-- All text left-aligned
-- Monospace for IDs, tokens, latency values
-
-### Badges
-- Pill shape (border-radius: 9999px)
-- Padding: 2px 8px
-- Font: 12px
-- Scoped to semantic meaning: `success`, `danger`, `read`, `write`, `admin`
-
-### Buttons
-- Primary: white text on #3a3a5a, hover brightens
-- Secondary: muted text on transparent, border #1e1e2e
-- Danger: white text on #ff6b6b background
-- Size: 13px font, 6px 14px padding
-
-### Modals
-- Overlay: rgba(0,0,0,0.7)
-- Card: #12121a, border #1e1e2e, border-radius 16px, max-width 480px
-- Title: 18px Semibold, left-aligned
-- Close: top-right ✕ button
-
-### Drawers
-- Right-side panel, 400px wide
-- Slide in from right
-- Dark overlay behind
-- Close button top-right
-- Sections separated by section titles (uppercase, muted)
-
-### Tabs
-- Inline horizontal, wrapping allowed
-- Active: white text, bottom border
-- Inactive: muted text, no border
-- No background color on tabs
-
-### Code blocks
-- Background: rgba(0,0,0,0.3)
-- Border-radius: 8px
-- Padding: 10px 14px
-- Font: JetBrains Mono 12px
-- Copy button: right-aligned, subtle
-
-### Empty states
-- Centered text (only exception to left-align rule)
-- Muted color
-- Suggest next action
-
-## Motion
-- **Approach:** Minimal — transitions for hover states only
-- **Duration:** 150ms for hovers, 200ms for drawer slide
-- **No loading spinners** — show stale data until fresh arrives
-- **SSE live feed:** Real-time, no animation on new entries (just prepend)
-
-## Anti-Patterns (do NOT do these)
-- ❌ Center-aligned table data
-- ❌ Center-aligned headings or labels (except empty states)
-- ❌ Gradient backgrounds
-- ❌ Shadows (the dark theme IS the depth model)
-- ❌ Rounded table corners
-- ❌ Icons as navigation (use text labels)
-- ❌ Loading skeletons (show real data or nothing)
-- ❌ Confirmation toasts (action → result is immediate and visible)
-- ❌ Color for decoration (every color means something)
-
-## Decisions Log
-| Date | Decision | Rationale |
-|------|----------|-----------|
-| 2026-05-01 | Dark theme only | Ops dashboard. No light mode needed. |
-| 2026-05-01 | Steve Krug lens | Zero happy talk, mindless choices, scannable tables, billboard-speed comprehension. |
-| 2026-05-01 | JetBrains Mono for data | Anything copyable or technical should be monospace. |
-| 2026-05-03 | Left-align everything | Garry preference. Centered text is a design crutch. Left-align forces hierarchy through typography weight and spacing, not position. |
-| 2026-05-03 | Incorporate GStack design DNA | Same family: Inter + JetBrains Mono, dark base, semantic-only color. Diverges on accent (GStack: amber; GBrain: none — data is the color). |
-| 2026-05-03 | Per-client config export tabs | Claude Code, ChatGPT, Claude.ai, Cursor, Perplexity, JSON. Every agent has a copy-paste setup path. |
-| 2026-05-03 | Magic link auth | Login page tells you to ask your agent. No pasting hex strings into forms. |

admin/bun.lock

@@ -1,257 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "gbrain-admin",
-      "dependencies": {
-        "react": "^19.1.0",
-        "react-dom": "^19.1.0",
-      },
-      "devDependencies": {
-        "@types/react": "^19.1.2",
-        "@types/react-dom": "^19.1.2",
-        "@vitejs/plugin-react": "^4.4.1",
-        "typescript": "^5.8.3",
-        "vite": "^6.3.3",
-      },
-    },
-  },
-  "packages": {
-    "@babel/code-frame": ["@babel/code-frame@7.29.0", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.28.5", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw=="],
-
-    "@babel/compat-data": ["@babel/compat-data@7.29.0", "", {}, "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg=="],
-
-    "@babel/core": ["@babel/core@7.29.0", "", { "dependencies": { "@babel/code-frame": "^7.29.0", "@babel/generator": "^7.29.0", "@babel/helper-compilation-targets": "^7.28.6", "@babel/helper-module-transforms": "^7.28.6", "@babel/helpers": "^7.28.6", "@babel/parser": "^7.29.0", "@babel/template": "^7.28.6", "@babel/traverse": "^7.29.0", "@babel/types": "^7.29.0", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA=="],
-
-    "@babel/generator": ["@babel/generator@7.29.1", "", { "dependencies": { "@babel/parser": "^7.29.0", "@babel/types": "^7.29.0", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" } }, "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw=="],
-
-    "@babel/helper-compilation-targets": ["@babel/helper-compilation-targets@7.28.6", "", { "dependencies": { "@babel/compat-data": "^7.28.6", "@babel/helper-validator-option": "^7.27.1", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" } }, "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA=="],
-
-    "@babel/helper-globals": ["@babel/helper-globals@7.28.0", "", {}, "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw=="],
-
-    "@babel/helper-module-imports": ["@babel/helper-module-imports@7.28.6", "", { "dependencies": { "@babel/traverse": "^7.28.6", "@babel/types": "^7.28.6" } }, "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw=="],
-
-    "@babel/helper-module-transforms": ["@babel/helper-module-transforms@7.28.6", "", { "dependencies": { "@babel/helper-module-imports": "^7.28.6", "@babel/helper-validator-identifier": "^7.28.5", "@babel/traverse": "^7.28.6" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA=="],
-
-    "@babel/helper-plugin-utils": ["@babel/helper-plugin-utils@7.28.6", "", {}, "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug=="],
-
-    "@babel/helper-string-parser": ["@babel/helper-string-parser@7.27.1", "", {}, "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="],
-
-    "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.28.5", "", {}, "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q=="],
-
-    "@babel/helper-validator-option": ["@babel/helper-validator-option@7.27.1", "", {}, "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg=="],
-
-    "@babel/helpers": ["@babel/helpers@7.29.2", "", { "dependencies": { "@babel/template": "^7.28.6", "@babel/types": "^7.29.0" } }, "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw=="],
-
-    "@babel/parser": ["@babel/parser@7.29.2", "", { "dependencies": { "@babel/types": "^7.29.0" }, "bin": "./bin/babel-parser.js" }, "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA=="],
-
-    "@babel/plugin-transform-react-jsx-self": ["@babel/plugin-transform-react-jsx-self@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw=="],
-
-    "@babel/plugin-transform-react-jsx-source": ["@babel/plugin-transform-react-jsx-source@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw=="],
-
-    "@babel/template": ["@babel/template@7.28.6", "", { "dependencies": { "@babel/code-frame": "^7.28.6", "@babel/parser": "^7.28.6", "@babel/types": "^7.28.6" } }, "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ=="],
-
-    "@babel/traverse": ["@babel/traverse@7.29.0", "", { "dependencies": { "@babel/code-frame": "^7.29.0", "@babel/generator": "^7.29.0", "@babel/helper-globals": "^7.28.0", "@babel/parser": "^7.29.0", "@babel/template": "^7.28.6", "@babel/types": "^7.29.0", "debug": "^4.3.1" } }, "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA=="],
-
-    "@babel/types": ["@babel/types@7.29.0", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.28.5" } }, "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A=="],
-
-    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="],
-
-    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="],
-
-    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.12", "", { "os": "android", "cpu": "arm64" }, "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg=="],
-
-    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.12", "", { "os": "android", "cpu": "x64" }, "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg=="],
-
-    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg=="],
-
-    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA=="],
-
-    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg=="],
-
-    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ=="],
-
-    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.12", "", { "os": "linux", "cpu": "arm" }, "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw=="],
-
-    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ=="],
-
-    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA=="],
-
-    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng=="],
-
-    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw=="],
-
-    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA=="],
-
-    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.12", "", { "os": "linux", "cpu": "none" }, "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w=="],
-
-    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg=="],
-
-    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.12", "", { "os": "linux", "cpu": "x64" }, "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw=="],
-
-    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg=="],
-
-    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.12", "", { "os": "none", "cpu": "x64" }, "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ=="],
-
-    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.12", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A=="],
-
-    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw=="],
-
-    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.12", "", { "os": "none", "cpu": "arm64" }, "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg=="],
-
-    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w=="],
-
-    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg=="],
-
-    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ=="],
-
-    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.12", "", { "os": "win32", "cpu": "x64" }, "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA=="],
-
-    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
-
-    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
-
-    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
-
-    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
-
-    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
-
-    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.27", "", {}, "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA=="],
-
-    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.60.1", "", { "os": "android", "cpu": "arm" }, "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA=="],
-
-    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.60.1", "", { "os": "android", "cpu": "arm64" }, "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA=="],
-
-    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.60.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw=="],
-
-    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.60.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew=="],
-
-    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.60.1", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w=="],
-
-    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.60.1", "", { "os": "freebsd", "cpu": "x64" }, "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g=="],
-
-    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.60.1", "", { "os": "linux", "cpu": "arm" }, "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g=="],
-
-    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.60.1", "", { "os": "linux", "cpu": "arm" }, "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg=="],
-
-    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.60.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ=="],
-
-    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.60.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA=="],
-
-    "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.60.1", "", { "os": "linux", "cpu": "none" }, "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ=="],
-
-    "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.60.1", "", { "os": "linux", "cpu": "none" }, "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw=="],
-
-    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.60.1", "", { "os": "linux", "cpu": "ppc64" }, "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw=="],
-
-    "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.60.1", "", { "os": "linux", "cpu": "ppc64" }, "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg=="],
-
-    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.60.1", "", { "os": "linux", "cpu": "none" }, "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg=="],
-
-    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.60.1", "", { "os": "linux", "cpu": "none" }, "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg=="],
-
-    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.60.1", "", { "os": "linux", "cpu": "s390x" }, "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ=="],
-
-    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.60.1", "", { "os": "linux", "cpu": "x64" }, "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg=="],
-
-    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.60.1", "", { "os": "linux", "cpu": "x64" }, "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w=="],
-
-    "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.60.1", "", { "os": "openbsd", "cpu": "x64" }, "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw=="],
-
-    "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.60.1", "", { "os": "none", "cpu": "arm64" }, "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA=="],
-
-    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.60.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g=="],
-
-    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.60.1", "", { "os": "win32", "cpu": "ia32" }, "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg=="],
-
-    "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.60.1", "", { "os": "win32", "cpu": "x64" }, "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg=="],
-
-    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.60.1", "", { "os": "win32", "cpu": "x64" }, "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ=="],
-
-    "@types/babel__core": ["@types/babel__core@7.20.5", "", { "dependencies": { "@babel/parser": "^7.20.7", "@babel/types": "^7.20.7", "@types/babel__generator": "*", "@types/babel__template": "*", "@types/babel__traverse": "*" } }, "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA=="],
-
-    "@types/babel__generator": ["@types/babel__generator@7.27.0", "", { "dependencies": { "@babel/types": "^7.0.0" } }, "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg=="],
-
-    "@types/babel__template": ["@types/babel__template@7.4.4", "", { "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" } }, "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A=="],
-
-    "@types/babel__traverse": ["@types/babel__traverse@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.2" } }, "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q=="],
-
-    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
-
-    "@types/react": ["@types/react@19.2.14", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w=="],
-
-    "@types/react-dom": ["@types/react-dom@19.2.3", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="],
-
-    "@vitejs/plugin-react": ["@vitejs/plugin-react@4.7.0", "", { "dependencies": { "@babel/core": "^7.28.0", "@babel/plugin-transform-react-jsx-self": "^7.27.1", "@babel/plugin-transform-react-jsx-source": "^7.27.1", "@rolldown/pluginutils": "1.0.0-beta.27", "@types/babel__core": "^7.20.5", "react-refresh": "^0.17.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA=="],
-
-    "baseline-browser-mapping": ["baseline-browser-mapping@2.10.18", "", { "bin": { "baseline-browser-mapping": "dist/cli.cjs" } }, "sha512-VSnGQAOLtP5mib/DPyg2/t+Tlv65NTBz83BJBJvmLVHHuKJVaDOBvJJykiT5TR++em5nfAySPccDZDa4oSrn8A=="],
-
-    "browserslist": ["browserslist@4.28.2", "", { "dependencies": { "baseline-browser-mapping": "^2.10.12", "caniuse-lite": "^1.0.30001782", "electron-to-chromium": "^1.5.328", "node-releases": "^2.0.36", "update-browserslist-db": "^1.2.3" }, "bin": { "browserslist": "cli.js" } }, "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg=="],
-
-    "caniuse-lite": ["caniuse-lite@1.0.30001788", "", {}, "sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ=="],
-
-    "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
-
-    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
-
-    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
-
-    "electron-to-chromium": ["electron-to-chromium@1.5.336", "", {}, "sha512-AbH9q9J455r/nLmdNZes0G0ZKcRX73FicwowalLs6ijwOmCJSRRrLX63lcAlzy9ux3dWK1w1+1nsBJEWN11hcQ=="],
-
-    "esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="],
-
-    "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
-
-    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
-
-    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
-
-    "gensync": ["gensync@1.0.0-beta.2", "", {}, "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="],
-
-    "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
-
-    "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
-
-    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
-
-    "lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
-
-    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
-
-    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
-
-    "node-releases": ["node-releases@2.0.37", "", {}, "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg=="],
-
-    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
-
-    "picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
-
-    "postcss": ["postcss@8.5.9", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-7a70Nsot+EMX9fFU3064K/kdHWZqGVY+BADLyXc8Dfv+mTLLVl6JzJpPaCZ2kQL9gIJvKXSLMHhqdRRjwQeFtw=="],
-
-    "react": ["react@19.2.5", "", {}, "sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA=="],
-
-    "react-dom": ["react-dom@19.2.5", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.5" } }, "sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag=="],
-
-    "react-refresh": ["react-refresh@0.17.0", "", {}, "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ=="],
-
-    "rollup": ["rollup@4.60.1", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.60.1", "@rollup/rollup-android-arm64": "4.60.1", "@rollup/rollup-darwin-arm64": "4.60.1", "@rollup/rollup-darwin-x64": "4.60.1", "@rollup/rollup-freebsd-arm64": "4.60.1", "@rollup/rollup-freebsd-x64": "4.60.1", "@rollup/rollup-linux-arm-gnueabihf": "4.60.1", "@rollup/rollup-linux-arm-musleabihf": "4.60.1", "@rollup/rollup-linux-arm64-gnu": "4.60.1", "@rollup/rollup-linux-arm64-musl": "4.60.1", "@rollup/rollup-linux-loong64-gnu": "4.60.1", "@rollup/rollup-linux-loong64-musl": "4.60.1", "@rollup/rollup-linux-ppc64-gnu": "4.60.1", "@rollup/rollup-linux-ppc64-musl": "4.60.1", "@rollup/rollup-linux-riscv64-gnu": "4.60.1", "@rollup/rollup-linux-riscv64-musl": "4.60.1", "@rollup/rollup-linux-s390x-gnu": "4.60.1", "@rollup/rollup-linux-x64-gnu": "4.60.1", "@rollup/rollup-linux-x64-musl": "4.60.1", "@rollup/rollup-openbsd-x64": "4.60.1", "@rollup/rollup-openharmony-arm64": "4.60.1", "@rollup/rollup-win32-arm64-msvc": "4.60.1", "@rollup/rollup-win32-ia32-msvc": "4.60.1", "@rollup/rollup-win32-x64-gnu": "4.60.1", "@rollup/rollup-win32-x64-msvc": "4.60.1", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w=="],
-
-    "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
-
-    "semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
-
-    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
-
-    "tinyglobby": ["tinyglobby@0.2.16", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="],
-
-    "vite": ["vite@6.4.2", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.4", "picomatch": "^4.0.2", "postcss": "^8.5.3", "rollup": "^4.34.9", "tinyglobby": "^0.2.13" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "jiti": ">=1.21.0", "less": "*", "lightningcss": "^1.21.0", "sass": "*", "sass-embedded": "*", "stylus": "*", "sugarss": "*", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ=="],
-
-    "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
-  }
-}

admin/dist/index.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>GBrain Admin</title>
-  <link rel="preconnect" href="https://fonts.googleapis.com" />
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/admin/assets/index-DWYc55rS.js"></script>
-  <link rel="stylesheet" crossorigin href="/admin/assets/index-BOifXQpQ.css">
-</head>
-<body>
-  <div id="root"></div>
-</body>
-</html>

admin/index.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>GBrain Admin</title>
-  <link rel="preconnect" href="https://fonts.googleapis.com" />
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
-</head>
-<body>
-  <div id="root"></div>
-  <script type="module" src="/src/main.tsx"></script>
-</body>
-</html>

admin/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "gbrain-admin",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview"
-  },
-  "dependencies": {
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0"
-  },
-  "devDependencies": {
-    "@types/react": "^19.1.2",
-    "@types/react-dom": "^19.1.2",
-    "@vitejs/plugin-react": "^4.4.1",
-    "vite": "^6.3.3",
-    "typescript": "^5.8.3"
-  }
-}

admin/src/App.tsx

@@ -1,84 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { LoginPage } from './pages/Login';
-import { DashboardPage } from './pages/Dashboard';
-import { AgentsPage } from './pages/Agents';
-import { RequestLogPage } from './pages/RequestLog';
-import { api } from './api';
-
-type Page = 'login' | 'dashboard' | 'agents' | 'log';
-
-function getPage(): Page {
-  const hash = window.location.hash.replace('#', '') || 'dashboard';
-  if (['login', 'dashboard', 'agents', 'log'].includes(hash)) return hash as Page;
-  return 'dashboard';
-}
-
-export function App() {
-  const [page, setPage] = useState<Page>(getPage);
-
-  useEffect(() => {
-    const onHash = () => setPage(getPage());
-    window.addEventListener('hashchange', onHash);
-    return () => window.removeEventListener('hashchange', onHash);
-  }, []);
-
-  const navigate = (p: Page) => {
-    window.location.hash = p;
-    setPage(p);
-  };
-
-  if (page === 'login') {
-    return <LoginPage onLogin={() => navigate('dashboard')} />;
-  }
-
-  const handleSignOutEverywhere = async () => {
-    if (!confirm('Sign out every active admin session, including other browsers and tabs? Each one will need to re-authenticate via a fresh magic link.')) {
-      return;
-    }
-    try {
-      await api.signOutEverywhere();
-    } catch {
-      // Even if the call fails, push to login — cookie is likely already invalid.
-    }
-    navigate('login');
-  };
-
-  return (
-    <div className="app">
-      <nav className="sidebar">
-        <div className="sidebar-logo">GBrain</div>
-        <div className="sidebar-nav">
-          <a className={`nav-item ${page === 'dashboard' ? 'active' : ''}`}
-             onClick={() => navigate('dashboard')}>Dashboard</a>
-          <a className={`nav-item ${page === 'agents' ? 'active' : ''}`}
-             onClick={() => navigate('agents')}>Agents</a>
-          <a className={`nav-item ${page === 'log' ? 'active' : ''}`}
-             onClick={() => navigate('log')}>Request Log</a>
-        </div>
-        <div style={{ marginTop: 'auto', padding: '16px 12px', borderTop: '1px solid var(--border)' }}>
-          <button
-            onClick={handleSignOutEverywhere}
-            style={{
-              background: 'transparent',
-              border: '1px solid var(--border)',
-              color: 'var(--text-secondary)',
-              padding: '6px 10px',
-              borderRadius: 6,
-              fontSize: 12,
-              cursor: 'pointer',
-              width: '100%',
-            }}
-            title="Revoke every active admin session — every browser, every tab"
-          >
-            Sign out everywhere
-          </button>
-        </div>
-      </nav>
-      <main className="main">
-        {page === 'dashboard' && <DashboardPage />}
-        {page === 'agents' && <AgentsPage />}
-        {page === 'log' && <RequestLogPage />}
-      </main>
-    </div>
-  );
-}

admin/src/api.ts

@@ -1,37 +0,0 @@
-const BASE = '';
-
-// v0.26.3 trust model (D11 + D12): the admin UI does NOT cache the
-// bootstrap token in browser JS state. On 401, redirect to login —
-// no auto-reauth via saved token, no localStorage/sessionStorage read.
-// The HttpOnly cookie set by /admin/login is the only session credential.
-async function apiFetch(path: string, options?: RequestInit) {
-  const res = await fetch(`${BASE}${path}`, {
-    ...options,
-    credentials: 'same-origin',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-  });
-  if (res.status === 401) {
-    // No token cache to retry from. Redirect to login.
-    window.location.hash = '#login';
-    throw new Error('Unauthorized');
-  }
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    throw new Error(body.error || `HTTP ${res.status}`);
-  }
-  return res.json();
-}
-
-export const api = {
-  login: (token: string) => apiFetch('/admin/login', { method: 'POST', body: JSON.stringify({ token }) }),
-  signOutEverywhere: () => apiFetch('/admin/api/sign-out-everywhere', { method: 'POST' }),
-  stats: () => apiFetch('/admin/api/stats'),
-  health: () => apiFetch('/admin/api/health-indicators'),
-  agents: () => apiFetch('/admin/api/agents'),
-  requests: (page = 1, qs = '') => apiFetch(`/admin/api/requests?page=${page}${qs}`),
-  apiKeys: () => apiFetch('/admin/api/api-keys'),
-  createApiKey: (name: string) => apiFetch('/admin/api/api-keys', { method: 'POST', body: JSON.stringify({ name }) }),
-  revokeApiKey: (name: string) => apiFetch('/admin/api/api-keys/revoke', { method: 'POST', body: JSON.stringify({ name }) }),
-  updateClientTtl: (clientId: string, tokenTtl: number | null) => apiFetch('/admin/api/update-client-ttl', { method: 'POST', body: JSON.stringify({ clientId, tokenTtl }) }),
-  revokeClient: (clientId: string) => apiFetch('/admin/api/revoke-client', { method: 'POST', body: JSON.stringify({ clientId }) }),
-};

admin/src/index.css

@@ -1,356 +0,0 @@
-:root {
-  --bg-primary: #0a0a0f;
-  --bg-secondary: #14141f;
-  --bg-tertiary: #1e1e2e;
-  --text-primary: #e0e0e0;
-  --text-secondary: #888;
-  --text-muted: #555;
-  --accent: #3b82f6;
-  --success: #22c55e;
-  --warning: #f59e0b;
-  --error: #ef4444;
-  --font-mono: 'JetBrains Mono', monospace;
-  --font-sans: 'Inter', system-ui, sans-serif;
-}
-
-* { margin: 0; padding: 0; box-sizing: border-box; }
-
-body {
-  font-family: var(--font-sans);
-  background: var(--bg-primary);
-  color: var(--text-primary);
-  font-size: 14px;
-  line-height: 1.5;
-}
-
-/* Layout */
-.app { display: flex; min-height: 100vh; }
-
-.sidebar {
-  width: 200px;
-  background: var(--bg-secondary);
-  border-right: 1px solid #1e1e2e;
-  padding: 16px 0;
-  flex-shrink: 0;
-  display: flex;
-  flex-direction: column;
-}
-
-.sidebar-logo {
-  font-size: 18px;
-  font-weight: 600;
-  padding: 0 16px 24px;
-  color: var(--text-primary);
-}
-
-.sidebar-nav { display: flex; flex-direction: column; gap: 2px; }
-
-.nav-item {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 8px 16px;
-  color: var(--text-secondary);
-  text-decoration: none;
-  font-size: 13px;
-  cursor: pointer;
-  border-left: 3px solid transparent;
-  transition: all 0.15s;
-}
-
-.nav-item:hover { background: var(--bg-tertiary); color: var(--text-primary); }
-.nav-item.active {
-  border-left-color: var(--accent);
-  background: var(--bg-tertiary);
-  color: var(--text-primary);
-}
-
-.main { flex: 1; padding: 24px 32px; overflow-y: auto; }
-
-.page-title {
-  font-size: 24px;
-  font-weight: 600;
-  margin-bottom: 24px;
-}
-
-/* Metrics bar */
-.metrics { display: flex; gap: 16px; margin-bottom: 24px; }
-.metric {
-  background: var(--bg-secondary);
-  padding: 16px 20px;
-  border-radius: 6px;
-  min-width: 140px;
-}
-.metric-value {
-  font-family: var(--font-mono);
-  font-size: 28px;
-  font-weight: 500;
-}
-.metric-label { font-size: 12px; color: var(--text-secondary); margin-top: 4px; }
-
-/* Tables */
-table { width: 100%; border-collapse: collapse; }
-th {
-  text-align: left;
-  font-size: 11px;
-  text-transform: uppercase;
-  color: var(--text-muted);
-  padding: 8px 12px;
-  font-weight: 500;
-  letter-spacing: 0.5px;
-}
-td {
-  padding: 10px 12px;
-  font-size: 13px;
-  border-top: 1px solid #1a1a2a;
-}
-tr:hover td { background: var(--bg-tertiary); }
-
-/* Badges */
-.badge {
-  display: inline-block;
-  padding: 2px 8px;
-  border-radius: 10px;
-  font-size: 11px;
-  font-weight: 500;
-}
-.badge-read { background: rgba(59,130,246,0.15); color: var(--accent); }
-.badge-write { background: rgba(245,158,11,0.15); color: var(--warning); }
-.badge-admin { background: rgba(239,68,68,0.15); color: var(--error); }
-.badge-success { background: rgba(34,197,94,0.15); color: var(--success); }
-.badge-error { background: rgba(239,68,68,0.15); color: var(--error); }
-
-/* Status dots */
-.status-dot {
-  display: inline-block;
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  margin-right: 6px;
-}
-.status-active { background: var(--success); }
-.status-warning { background: var(--warning); }
-.status-inactive { background: var(--text-muted); }
-
-/* Buttons */
-.btn {
-  padding: 8px 16px;
-  border-radius: 6px;
-  font-size: 13px;
-  font-weight: 500;
-  cursor: pointer;
-  border: none;
-  transition: all 0.15s;
-}
-.btn-primary { background: var(--accent); color: white; }
-.btn-primary:hover { background: #2563eb; }
-.btn-secondary { background: transparent; color: var(--text-secondary); border: 1px solid #333; }
-.btn-secondary:hover { border-color: var(--text-secondary); color: var(--text-primary); }
-.btn-danger { background: transparent; color: var(--error); border: 1px solid var(--error); }
-.btn-danger:hover { background: rgba(239,68,68,0.1); }
-
-/* Forms */
-input, select {
-  background: var(--bg-primary);
-  border: 1px solid #333;
-  color: var(--text-primary);
-  padding: 8px 12px;
-  border-radius: 6px;
-  font-size: 13px;
-  font-family: var(--font-sans);
-  width: 100%;
-}
-input:focus, select:focus {
-  outline: none;
-  border-color: var(--accent);
-  box-shadow: 0 0 0 2px rgba(59,130,246,0.2);
-}
-input::placeholder { color: var(--text-muted); }
-label { display: block; font-size: 13px; font-weight: 500; margin-bottom: 6px; }
-
-/* Modal */
-.modal-overlay {
-  position: fixed;
-  inset: 0;
-  background: rgba(0,0,0,0.7);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 100;
-}
-.modal {
-  background: var(--bg-secondary);
-  border-radius: 8px;
-  padding: 24px;
-  min-width: 420px;
-  max-width: 520px;
-}
-.modal-title { font-size: 18px; font-weight: 600; margin-bottom: 20px; }
-
-/* Drawer */
-.drawer-overlay {
-  position: fixed;
-  inset: 0;
-  background: rgba(0,0,0,0.5);
-  z-index: 90;
-}
-.drawer {
-  position: fixed;
-  right: 0;
-  top: 0;
-  bottom: 0;
-  width: 420px;
-  background: var(--bg-secondary);
-  border-left: 1px solid var(--accent);
-  padding: 24px;
-  z-index: 91;
-  overflow-y: auto;
-}
-.drawer-close {
-  position: absolute;
-  top: 16px;
-  right: 16px;
-  background: none;
-  border: none;
-  color: var(--text-muted);
-  font-size: 18px;
-  cursor: pointer;
-}
-
-/* Section headers */
-.section-title {
-  font-size: 11px;
-  text-transform: uppercase;
-  color: var(--text-muted);
-  letter-spacing: 0.5px;
-  margin: 20px 0 12px;
-  font-weight: 500;
-}
-
-/* Health panel */
-.health-panel {
-  background: var(--bg-secondary);
-  border-radius: 6px;
-  padding: 16px;
-}
-.health-row {
-  display: flex;
-  justify-content: space-between;
-  padding: 6px 0;
-  font-size: 13px;
-}
-
-/* Code block */
-.code-block {
-  background: var(--bg-primary);
-  border-radius: 6px;
-  padding: 12px;
-  font-family: var(--font-mono);
-  font-size: 12px;
-  overflow-x: auto;
-  position: relative;
-}
-.code-block .copy-btn {
-  position: absolute;
-  top: 8px;
-  right: 8px;
-  background: var(--accent);
-  color: white;
-  border: none;
-  padding: 4px 10px;
-  border-radius: 4px;
-  font-size: 11px;
-  cursor: pointer;
-}
-
-/* Activity feed */
-.feed { max-height: 400px; overflow-y: auto; }
-.feed-empty {
-  color: var(--text-muted);
-  text-align: center;
-  padding: 32px;
-  font-size: 13px;
-}
-
-/* Sparkline */
-.sparkline { display: inline-block; vertical-align: middle; }
-
-/* Filter bar */
-.filter-bar { display: flex; gap: 12px; margin-bottom: 16px; align-items: center; }
-.filter-bar select { width: auto; min-width: 140px; }
-
-/* Pagination */
-.pagination {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 12px 0;
-  font-size: 13px;
-  color: var(--text-secondary);
-}
-.pagination button {
-  background: var(--bg-secondary);
-  border: 1px solid #333;
-  color: var(--text-primary);
-  padding: 6px 12px;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 12px;
-}
-.pagination button:disabled { opacity: 0.3; cursor: default; }
-
-/* Warning bar */
-.warning-bar {
-  background: rgba(245,158,11,0.15);
-  border: 1px solid var(--warning);
-  color: var(--warning);
-  padding: 10px 16px;
-  border-radius: 6px;
-  font-size: 13px;
-  margin: 12px 0;
-}
-
-/* Checkbox */
-.checkbox-group { display: flex; gap: 16px; flex-wrap: wrap; }
-.checkbox-label {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  font-size: 13px;
-  cursor: pointer;
-}
-
-/* Tabs */
-.tabs { display: flex; gap: 0; margin-bottom: 12px; }
-.tab {
-  padding: 6px 12px;
-  font-size: 13px;
-  color: var(--text-secondary);
-  cursor: pointer;
-  border-bottom: 2px solid transparent;
-}
-.tab.active { color: var(--accent); border-bottom-color: var(--accent); }
-
-/* Login page */
-.login-page {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 100vh;
-  background: var(--bg-primary);
-}
-.login-box { text-align: left; width: 340px; }
-.login-logo { font-size: 32px; font-weight: 600; margin-bottom: 32px; }
-.login-hint { color: var(--text-muted); font-size: 12px; margin-top: 12px; }
-.login-error { color: var(--error); font-size: 13px; margin-top: 8px; }
-
-/* Monospace data */
-.mono { font-family: var(--font-mono); font-size: 12px; }
-
-/* Responsive */
-@media (max-width: 768px) {
-  .sidebar { display: none; }
-  .main { padding: 16px; }
-  .metrics { flex-wrap: wrap; }
-  .drawer { width: 100%; }
-}

admin/src/main.tsx

@@ -1,10 +0,0 @@
-import React from 'react';
-import ReactDOM from 'react-dom/client';
-import { App } from './App';
-import './index.css';
-
-ReactDOM.createRoot(document.getElementById('root')!).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>,
-);

admin/src/pages/Agents.tsx

@@ -1,627 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { api } from '../api';
-
-function timeAgo(date: Date): string {
-  const s = Math.floor((Date.now() - date.getTime()) / 1000);
-  if (s < 60) return 'just now';
-  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
-  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
-  return `${Math.floor(s / 86400)}d ago`;
-}
-
-interface Agent {
-  id: string;
-  name: string;
-  auth_type: 'oauth' | 'api_key';
-  client_id?: string;  // compat
-  client_name?: string; // compat
-  grant_types: string[];
-  scope: string;
-  created_at: string;
-  last_used_at: string | null;
-  total_requests: number;
-  requests_today: number;
-  token_ttl: number | null;
-  status: 'active' | 'revoked';
-}
-
-interface ApiKey {
-  id: string;
-  name: string;
-  created_at: string;
-  last_used_at: string | null;
-  status: 'active' | 'revoked';
-}
-
-export function AgentsPage() {
-  const [agents, setAgents] = useState<Agent[]>([]);
-  const [hideRevoked, setHideRevoked] = useState(true);
-  const [showRegister, setShowRegister] = useState(false);
-  const [showCredentials, setShowCredentials] = useState<{ clientId: string; clientSecret: string; name: string } | null>(null);
-  const [showApiKeyCreate, setShowApiKeyCreate] = useState(false);
-  const [showApiKeyToken, setShowApiKeyToken] = useState<{ name: string; token: string } | null>(null);
-  const [selectedAgent, setSelectedAgent] = useState<Agent | null>(null);
-
-  useEffect(() => { loadAgents(); }, []);
-
-  const loadAgents = () => { api.agents().then(setAgents).catch(() => {}); };
-
-  return (
-    <>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 24 }}>
-        <h1 className="page-title" style={{ marginBottom: 0 }}>Agents</h1>
-        <div style={{ display: 'flex', gap: 8, alignItems: 'center' }}>
-          <label style={{ fontSize: 13, color: 'var(--text-secondary)', display: 'flex', alignItems: 'center', gap: 6, cursor: 'pointer' }}>
-            <input type="checkbox" checked={hideRevoked} onChange={e => setHideRevoked(e.target.checked)} /> Hide revoked
-          </label>
-          <button className="btn btn-secondary" onClick={() => setShowApiKeyCreate(true)}>+ API Key</button>
-          <button className="btn btn-primary" onClick={() => setShowRegister(true)}>+ OAuth Client</button>
-        </div>
-      </div>
-
-      {(() => {
-        // Filter once and reuse, so the empty-state guard sees the same
-        // rows the table renders. Pre-fix: agents.length === 0 used the
-        // unfiltered array, so an all-revoked dataset with hideRevoked=on
-        // showed a header-only table with no placeholder.
-        const visibleAgents = agents.filter(a => !hideRevoked || a.status !== 'revoked');
-        if (agents.length === 0) {
-          return (
-            <div style={{ textAlign: 'center', padding: 48, color: 'var(--text-muted)' }}>
-              No agents registered. Register your first agent to get started.
-            </div>
-          );
-        }
-        if (visibleAgents.length === 0) {
-          return (
-            <div style={{ textAlign: 'center', padding: 48, color: 'var(--text-muted)' }}>
-              All agents are revoked. Uncheck "Hide revoked" to view them.
-            </div>
-          );
-        }
-        return (
-        <>
-          <table>
-            <thead>
-              <tr>
-                <th>Name</th>
-                <th>Type</th>
-                <th>Scopes</th>
-                <th>Status</th>
-                <th>Requests</th>
-                <th>Last Used</th>
-              </tr>
-            </thead>
-            <tbody>
-              {visibleAgents.map(a => (
-                <tr key={a.id} onClick={() => setSelectedAgent(a)}
-                    style={{ cursor: 'pointer' }}>
-                  <td style={{ fontWeight: 500 }}>{a.name || a.client_name}</td>
-                  <td>
-                    <span className={`badge ${a.auth_type === 'oauth' ? 'badge-read' : 'badge-write'}`} style={{ fontSize: 11 }}>
-                      {a.auth_type === 'oauth' ? 'OAuth' : 'API Key'}
-                    </span>
-                  </td>
-                  <td>
-                    {(a.scope || '').split(' ').filter(Boolean).map(s => (
-                      <span key={s} className={`badge badge-${s}`} style={{ marginRight: 4 }}>{s}</span>
-                    ))}
-                  </td>
-                  <td>
-                    <span className={`badge ${a.status === 'active' ? 'badge-success' : 'badge-danger'}`}>{a.status}</span>
-                  </td>
-                  <td>
-                    <span style={{ fontWeight: 500 }}>{a.requests_today || 0}</span>
-                    <span style={{ color: 'var(--text-muted)', fontSize: 12 }}> / {a.total_requests || 0}</span>
-                  </td>
-                  <td style={{ color: 'var(--text-secondary)' }}>
-                    {a.last_used_at ? timeAgo(new Date(a.last_used_at)) : 'Never'}
-                  </td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
-          <div style={{ color: 'var(--text-muted)', fontSize: 13, marginTop: 12 }}>
-            {agents.filter(a => a.status === 'active').length} active / {agents.length} total
-          </div>
-        </>
-        );
-      })()}
-
-      {showRegister && (
-        <RegisterModal
-          onClose={() => setShowRegister(false)}
-          onRegistered={(creds) => { setShowRegister(false); setShowCredentials(creds); loadAgents(); }}
-        />
-      )}
-
-      {showCredentials && (
-        <CredentialsModal
-          credentials={showCredentials}
-          onClose={() => setShowCredentials(null)}
-        />
-      )}
-
-      {selectedAgent && (
-        <AgentDrawer agent={selectedAgent} onClose={() => setSelectedAgent(null)} onRevoked={loadAgents} />
-      )}
-
-      {showApiKeyCreate && (
-        <ApiKeyCreateModal
-          onClose={() => setShowApiKeyCreate(false)}
-          onCreated={(result) => { setShowApiKeyCreate(false); setShowApiKeyToken(result); loadAgents(); }}
-        />
-      )}
-
-      {showApiKeyToken && (
-        <ApiKeyTokenModal token={showApiKeyToken} onClose={() => setShowApiKeyToken(null)} />
-      )}
-    </>
-  );
-}
-
-function ApiKeyCreateModal({ onClose, onCreated }: {
-  onClose: () => void;
-  onCreated: (result: { name: string; token: string }) => void;
-}) {
-  const [name, setName] = useState('');
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState('');
-
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault();
-    if (!name.trim()) { setError('Name required'); return; }
-    setLoading(true);
-    try {
-      const data = await api.createApiKey(name.trim());
-      onCreated({ name: data.name, token: data.token });
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed');
-    } finally { setLoading(false); }
-  };
-
-  return (
-    <div className="modal-overlay" onClick={onClose}>
-      <form className="modal" onClick={e => e.stopPropagation()} onSubmit={handleSubmit}>
-        <div className="modal-title">Create API Key</div>
-        <p style={{ color: 'var(--text-secondary)', fontSize: 13, marginBottom: 16 }}>
-          API keys use simple bearer token auth. They grant full read+write+admin access.
-          For scoped access, use OAuth clients instead.
-        </p>
-        <div style={{ marginBottom: 16 }}>
-          <label>Key Name</label>
-          <input placeholder="e.g. claude-code-local" value={name} onChange={e => setName(e.target.value)} autoFocus />
-        </div>
-        {error && <div style={{ color: 'var(--error)', fontSize: 13, marginBottom: 12 }}>{error}</div>}
-        <div style={{ display: 'flex', gap: 12, justifyContent: 'flex-end' }}>
-          <button type="button" className="btn btn-secondary" onClick={onClose}>Cancel</button>
-          <button type="submit" className="btn btn-primary" disabled={loading}>
-            {loading ? 'Creating...' : 'Create Key'}
-          </button>
-        </div>
-      </form>
-    </div>
-  );
-}
-
-function ApiKeyTokenModal({ token, onClose }: {
-  token: { name: string; token: string };
-  onClose: () => void;
-}) {
-  const copy = (text: string) => navigator.clipboard.writeText(text);
-
-  return (
-    <div className="modal-overlay">
-      <div className="modal" style={{ maxWidth: 560 }}>
-        <div style={{ textAlign: 'center', marginBottom: 16 }}>
-          <div style={{ fontSize: 36, color: 'var(--success)', marginBottom: 8 }}>&#10003;</div>
-          <div style={{ fontSize: 20, fontWeight: 600 }}>API Key Created</div>
-        </div>
-        <div style={{ marginBottom: 12 }}>
-          <label style={{ fontSize: 12 }}>Name</label>
-          <div className="code-block"><span>{token.name}</span></div>
-        </div>
-        <div style={{ marginBottom: 12 }}>
-          <label style={{ fontSize: 12 }}>Bearer Token</label>
-          <div className="code-block">
-            <span>{token.token}</span>
-            <button className="copy-btn" onClick={() => copy(token.token)}>Copy</button>
-          </div>
-        </div>
-        <div style={{ marginBottom: 12 }}>
-          <label style={{ fontSize: 12 }}>Usage</label>
-          <div className="code-block">
-            <pre style={{ whiteSpace: 'pre-wrap', margin: 0, fontSize: 12 }}>{`Authorization: Bearer ${token.token}`}</pre>
-            <button className="copy-btn" onClick={() => copy(`Authorization: Bearer ${token.token}`)}>Copy</button>
-          </div>
-        </div>
-        <div className="warning-bar">Save this token now. It will not be shown again.</div>
-        <div style={{ display: 'flex', gap: 12, justifyContent: 'flex-end', marginTop: 20 }}>
-          <button className="btn btn-primary" onClick={onClose}>Done</button>
-        </div>
-      </div>
-    </div>
-  );
-}
-
-function RegisterModal({ onClose, onRegistered }: {
-  onClose: () => void;
-  onRegistered: (creds: { clientId: string; clientSecret: string; name: string }) => void;
-}) {
-  const [name, setName] = useState('');
-  const [scopes, setScopes] = useState({ read: true, write: false, admin: false });
-  const [ttl, setTtl] = useState('86400'); // 24h default
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState('');
-
-  const ttlOptions = [
-    { label: '1 hour', value: '3600' },
-    { label: '24 hours', value: '86400' },
-    { label: '7 days', value: '604800' },
-    { label: '30 days', value: '2592000' },
-    { label: '1 year', value: '31536000' },
-    { label: 'No expiry', value: '0' },
-  ];
-
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault();
-    if (!name.trim()) { setError('Name required'); return; }
-    setLoading(true);
-    setError('');
-    try {
-      // Use the CLI registration endpoint (POST to admin API)
-      const selectedScopes = Object.entries(scopes).filter(([, v]) => v).map(([k]) => k).join(' ');
-      const res = await fetch('/admin/api/register-client', {
-        method: 'POST',
-        credentials: 'same-origin',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: name.trim(), scopes: selectedScopes, tokenTtl: ttl === '0' ? 315360000 : Number(ttl) }),
-      });
-      if (!res.ok) throw new Error('Registration failed');
-      const data = await res.json();
-      onRegistered({ clientId: data.clientId, clientSecret: data.clientSecret, name: name.trim() });
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Registration failed');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <div className="modal-overlay" onClick={onClose}>
-      <form className="modal" onClick={e => e.stopPropagation()} onSubmit={handleSubmit}>
-        <div className="modal-title">Register Agent</div>
-        <div style={{ marginBottom: 16 }}>
-          <label>Agent Name</label>
-          <input placeholder="e.g. perplexity-production" value={name} onChange={e => setName(e.target.value)} autoFocus />
-        </div>
-        <div style={{ marginBottom: 16 }}>
-          <label>Scopes</label>
-          <div className="checkbox-group">
-            {(['read', 'write', 'admin'] as const).map(s => (
-              <label key={s} className="checkbox-label">
-                <input type="checkbox" checked={scopes[s]} onChange={e => setScopes(p => ({ ...p, [s]: e.target.checked }))} />
-                {s}
-              </label>
-            ))}
-          </div>
-        </div>
-        <div style={{ marginBottom: 20 }}>
-          <label>Token Lifetime</label>
-          <select value={ttl} onChange={e => setTtl(e.target.value)}
-            style={{ width: '100%', background: 'var(--bg-secondary)', color: 'var(--text-primary)', border: '1px solid var(--border)', borderRadius: 6, padding: '6px 10px', fontSize: 14 }}>
-            {ttlOptions.map(o => <option key={o.value} value={o.value}>{o.label}</option>)}
-          </select>
-        </div>
-        {error && <div style={{ color: 'var(--error)', fontSize: 13, marginBottom: 12 }}>{error}</div>}
-        <div style={{ display: 'flex', gap: 12, justifyContent: 'flex-end' }}>
-          <button type="button" className="btn btn-secondary" onClick={onClose}>Cancel</button>
-          <button type="submit" className="btn btn-primary" disabled={loading}>
-            {loading ? 'Registering...' : 'Register'}
-          </button>
-        </div>
-      </form>
-    </div>
-  );
-}
-
-function CredentialsModal({ credentials, onClose }: {
-  credentials: { clientId: string; clientSecret: string; name: string };
-  onClose: () => void;
-}) {
-  const copy = (text: string) => navigator.clipboard.writeText(text);
-  const downloadJson = () => {
-    const blob = new Blob([JSON.stringify(credentials, null, 2)], { type: 'application/json' });
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url; a.download = `${credentials.name}-credentials.json`; a.click();
-    URL.revokeObjectURL(url);
-  };
-
-  return (
-    <div className="modal-overlay">
-      <div className="modal" style={{ maxWidth: 560 }}>
-        <div style={{ textAlign: 'center', marginBottom: 16 }}>
-          <div style={{ fontSize: 36, color: 'var(--success)', marginBottom: 8 }}>&#10003;</div>
-          <div style={{ fontSize: 20, fontWeight: 600 }}>Agent Registered</div>
-        </div>
-
-        <div style={{ marginBottom: 12 }}>
-          <label style={{ fontSize: 12 }}>Client ID</label>
-          <div className="code-block">
-            <span>{credentials.clientId}</span>
-            <button className="copy-btn" onClick={() => copy(credentials.clientId)}>Copy</button>
-          </div>
-        </div>
-
-        <div style={{ marginBottom: 12 }}>
-          <label style={{ fontSize: 12 }}>Client Secret</label>
-          <div className="code-block">
-            <span>{credentials.clientSecret}</span>
-            <button className="copy-btn" onClick={() => copy(credentials.clientSecret)}>Copy</button>
-          </div>
-        </div>
-
-        <div className="warning-bar">
-          Save this secret now. It will not be shown again.
-        </div>
-
-        <div style={{ display: 'flex', gap: 12, justifyContent: 'flex-end', marginTop: 20 }}>
-          <button className="btn btn-secondary" onClick={downloadJson}>Download as JSON</button>
-          <button className="btn btn-primary" onClick={onClose}>Done</button>
-        </div>
-      </div>
-    </div>
-  );
-}
-
-function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: () => void; onRevoked: () => void }) {
-  const [tab, setTab] = useState<'claude-code' | 'chatgpt' | 'claude-cowork' | 'perplexity' | 'cursor' | 'json'>('claude-code');
-  const copy = (text: string) => navigator.clipboard.writeText(text);
-  const serverUrl = window.location.origin;
-
-  const cid = agent.id || agent.client_id || '';
-  const isOAuth = agent.auth_type === 'oauth';
-  const agentName = agent.name || agent.client_name || 'unknown';
-
-  // For API keys, we can't show the actual token (it was shown once at creation).
-  // For OAuth, we show the client_id and tell them to use their secret.
-
-  const configSnippets: Record<string, string> = {
-    'claude-code': isOAuth
-      ? [
-        `The user wants to connect GBrain MCP to your context. Here's how.`,
-        ``,
-        `# Step 1 — read the client secret from the operator without putting it in shell history.`,
-        `# read -s suppresses the echo; export keeps it scoped to this shell session.`,
-        `read -rs -p "Client Secret: " GBRAIN_CS && echo`,
-        ``,
-        `# Step 2 — mint a token and register GBrain in one go.`,
-        `claude mcp add --transport http gbrain ${serverUrl}/mcp \\`,
-        `  --header "Authorization: Bearer $(curl -s -X POST ${serverUrl}/token \\`,
-        `    -d 'grant_type=client_credentials' \\`,
-        `    -d 'client_id=${cid}' \\`,
-        `    --data-urlencode "client_secret=$GBRAIN_CS" \\`,
-        `    -d 'scope=${agent.scope || 'read write'}' | jq -r .access_token)"`,
-        ``,
-        `# Step 3 — clear the secret from this shell.`,
-        `unset GBRAIN_CS`,
-        ``,
-        `The token will last ${agent.token_ttl ? (agent.token_ttl >= 86400 ? Math.floor(agent.token_ttl / 86400) + ' days' : Math.floor(agent.token_ttl / 3600) + ' hours') : '1 hour (default)'}.`,
-        ``,
-        `─── Fallback: 2-step curl + paste ───`,
-        ``,
-        `If your shell doesn't support read -s, mint the token first, then paste:`,
-        ``,
-        `curl -s -X POST ${serverUrl}/token \\`,
-        `  -d 'grant_type=client_credentials' \\`,
-        `  -d 'client_id=${cid}' \\`,
-        `  -d 'client_secret=PASTE_YOUR_CLIENT_SECRET_HERE' \\`,
-        `  -d 'scope=${agent.scope || 'read write'}' | jq -r .access_token`,
-        ``,
-        `claude mcp add --transport http gbrain ${serverUrl}/mcp \\`,
-        `  --header "Authorization: Bearer PASTE_TOKEN_FROM_ABOVE"`,
-        ``,
-        `# Then run: history -d $((HISTCMD-1))   # zsh: print -s -- '' && fc -p`,
-      ].join('\n')
-      : [
-        `The user wants to connect GBrain MCP to your context. Here's how.`,
-        ``,
-        `Run this command in terminal to register GBrain:`,
-        ``,
-        `claude mcp add --transport http gbrain ${serverUrl}/mcp \\`,
-        `  --header "Authorization: Bearer PASTE_YOUR_API_KEY_HERE"`,
-        ``,
-        `Replace PASTE_YOUR_API_KEY_HERE with the API key shown when "${agentName}" was created.`,
-        `API keys never expire.`,
-      ].join('\n'),
-
-    'chatgpt': [
-      `The user wants to connect GBrain MCP to ChatGPT.`,
-      ``,
-      `1. Open ChatGPT > Settings > Tools & Integrations > Add MCP Server`,
-      `2. Enter this URL — ChatGPT will auto-discover the OAuth configuration:`,
-      ``,
-      `   ${serverUrl}/.well-known/oauth-authorization-server`,
-      ``,
-      `3. When prompted for credentials:`,
-      `   Client ID: ${cid}`,
-      `   Client Secret: (the secret from agent registration)`,
-      `   Grant Type: client_credentials`,
-      `   Scope: ${agent.scope || 'read write'}`,
-    ].join('\n'),
-
-    'claude-cowork': [
-      `The user wants to connect GBrain MCP to Claude.ai.`,
-      ``,
-      `1. Open claude.ai > Settings > Connected Apps > Add MCP Server`,
-      `2. Server URL: ${serverUrl}/mcp`,
-      `3. When prompted for auth:`,
-      `   Token endpoint: ${serverUrl}/token`,
-      `   Client ID: ${cid}`,
-      `   Client Secret: (the secret from agent registration)`,
-      `   Scope: ${agent.scope || 'read write'}`,
-      ``,
-      `Discovery URL: ${serverUrl}/.well-known/oauth-authorization-server`,
-    ].join('\n'),
-
-    cursor: isOAuth
-      ? [
-        `The user wants to connect GBrain MCP to Cursor.`,
-        ``,
-        `Cursor supports OAuth for remote MCP. Add to .cursor/mcp.json:`,
-        ``,
-        `{`,
-        `  "mcpServers": {`,
-        `    "gbrain": {`,
-        `      "url": "${serverUrl}/mcp",`,
-        `      "transport": "sse"`,
-        `    }`,
-        `  }`,
-        `}`,
-        ``,
-        `Cursor will auto-discover OAuth via:`,
-        `${serverUrl}/.well-known/oauth-authorization-server`,
-        ``,
-        `When prompted: Client ID ${cid}, use the secret from registration.`,
-      ].join('\n')
-      : [
-        `The user wants to connect GBrain MCP to Cursor.`,
-        ``,
-        `Add to .cursor/mcp.json:`,
-        ``,
-        `{`,
-        `  "mcpServers": {`,
-        `    "gbrain": {`,
-        `      "url": "${serverUrl}/mcp",`,
-        `      "transport": "sse",`,
-        `      "headers": {`,
-        `        "Authorization": "Bearer PASTE_YOUR_API_KEY_HERE"`,
-        `      }`,
-        `    }`,
-        `  }`,
-        `}`,
-        ``,
-        `Replace PASTE_YOUR_API_KEY_HERE with the API key shown when "${agentName}" was created.`,
-      ].join('\n'),
-
-    perplexity: [
-      `The user wants to connect GBrain MCP to Perplexity.`,
-      ``,
-      `1. Go to Settings > Connectors > Add MCP`,
-      `2. Server URL: ${serverUrl}/mcp`,
-      `3. Client ID: ${cid}`,
-      `4. Client Secret: (the secret from agent registration)`,
-    ].join('\n'),
-
-    json: JSON.stringify({
-      server_url: serverUrl + '/mcp',
-      token_url: serverUrl + '/token',
-      discovery_url: serverUrl + '/.well-known/oauth-authorization-server',
-      client_id: cid,
-      client_name: agentName,
-      auth_type: agent.auth_type,
-      scope: agent.scope,
-    }, null, 2),
-  };
-
-  return (
-    <>
-      <div className="drawer-overlay" onClick={onClose} />
-      <div className="drawer">
-        <button className="drawer-close" onClick={onClose}>&#10005;</button>
-        <div style={{ fontSize: 18, fontWeight: 600, marginBottom: 4 }}>{agent.name || agent.client_name}</div>
-        <span className={`badge ${agent.status === 'active' ? 'badge-success' : 'badge-danger'}`}>{agent.status}</span>
-
-        <div className="section-title">Details</div>
-        <div style={{ display: 'grid', gridTemplateColumns: '100px 1fr', gap: '6px 12px', fontSize: 13 }}>
-          <span style={{ color: 'var(--text-secondary)' }}>Client ID</span>
-          <span className="mono">{(agent.id || agent.id || agent.client_id || '').substring(0, 24)}...</span>
-          <span style={{ color: 'var(--text-secondary)' }}>Scopes</span>
-          <span>{(agent.scope || '').split(' ').filter(Boolean).map(s => (
-            <span key={s} className={`badge badge-${s}`} style={{ marginRight: 4 }}>{s}</span>
-          ))}</span>
-          <span style={{ color: 'var(--text-secondary)' }}>Registered</span>
-          <span>{new Date(agent.created_at).toLocaleDateString()}</span>
-          <span style={{ color: 'var(--text-secondary)' }}>Token TTL</span>
-          <span>{agent.token_ttl ? (agent.token_ttl >= 31536000 ? 'No expiry' : agent.token_ttl >= 86400 ? `${Math.floor(agent.token_ttl / 86400)}d` : agent.token_ttl >= 3600 ? `${Math.floor(agent.token_ttl / 3600)}h` : `${agent.token_ttl}s`) : '1h (default)'}</span>
-        </div>
-
-        {/*
-          Config Export visible for both auth_type=oauth AND auth_type=api_key.
-          Claude Code + Cursor + JSON tabs render real snippets regardless
-          (commit 15's snippets are auth-type-aware for those two clients;
-          JSON is just structured metadata). ChatGPT, Claude.ai, and
-          Perplexity tabs render an "OAuth client required" message on
-          api_key agents — those MCP clients only speak OAuth 2.0
-          client_credentials, not raw bearer tokens.
-
-          Pre-fix (Wintermute commit 16): the entire Config Export
-          section was hidden for api_key agents, dropping the working
-          Claude Code + Cursor snippets along with the broken ones.
-          (D5=C in the eng review.)
-        */}
-        <div className="section-title">Config Export</div>
-        <div className="tabs" style={{ flexWrap: 'wrap' }}>
-          <div className={`tab ${tab === 'claude-code' ? 'active' : ''}`} onClick={() => setTab('claude-code')}>Claude Code</div>
-          <div className={`tab ${tab === 'chatgpt' ? 'active' : ''}`} onClick={() => setTab('chatgpt')}>ChatGPT</div>
-          <div className={`tab ${tab === 'claude-cowork' ? 'active' : ''}`} onClick={() => setTab('claude-cowork')}>Claude.ai</div>
-          <div className={`tab ${tab === 'cursor' ? 'active' : ''}`} onClick={() => setTab('cursor')}>Cursor</div>
-          <div className={`tab ${tab === 'perplexity' ? 'active' : ''}`} onClick={() => setTab('perplexity')}>Perplexity</div>
-          <div className={`tab ${tab === 'json' ? 'active' : ''}`} onClick={() => setTab('json')}>JSON</div>
-        </div>
-        {(() => {
-          const oauthOnlyTabs = new Set(['chatgpt', 'claude-cowork', 'perplexity']);
-          if (!isOAuth && oauthOnlyTabs.has(tab)) {
-            const clientName = { chatgpt: 'ChatGPT', 'claude-cowork': 'Claude.ai', perplexity: 'Perplexity' }[tab] || tab;
-            return (
-              <div style={{
-                background: 'rgba(255, 200, 100, 0.08)',
-                border: '1px solid rgba(255, 200, 100, 0.2)',
-                borderRadius: 8,
-                padding: '14px 16px',
-                marginTop: 12,
-                fontSize: 13,
-                lineHeight: 1.6,
-                color: 'var(--text-secondary)',
-              }}>
-                <div style={{ fontWeight: 600, color: 'var(--text-primary)', marginBottom: 6 }}>
-                  {clientName} requires an OAuth client
-                </div>
-                {clientName} only supports OAuth 2.0 (client_credentials). API keys use raw bearer tokens, which {clientName} does not accept. Register a separate OAuth client and use that to connect this AI.
-              </div>
-            );
-          }
-          return (
-            <div className="code-block">
-              <pre style={{ whiteSpace: 'pre-wrap', margin: 0 }}>{configSnippets[tab]}</pre>
-              <button className="copy-btn" onClick={() => copy(configSnippets[tab])}>Copy</button>
-            </div>
-          );
-        })()}
-
-        <div style={{ marginTop: 32 }}>
-          {agent.status === 'active' && (
-            <button className="btn btn-danger" onClick={async () => {
-              if (!confirm(`Revoke ${agent.name || agent.client_name}? All active tokens will be invalidated.`)) return;
-              try {
-                if (agent.auth_type === 'oauth') {
-                  await api.revokeClient(agent.id || agent.client_id || '');
-                } else {
-                  await api.revokeApiKey(agent.name || '');
-                }
-                onRevoked();
-                onClose();
-              } catch (e) {
-                alert('Revoke failed: ' + (e instanceof Error ? e.message : 'unknown error'));
-              }
-            }}>Revoke Agent</button>
-          )}
-          {agent.status === 'revoked' && (
-            <span style={{ color: 'var(--text-muted)', fontSize: 13 }}>This agent has been revoked.</span>
-          )}
-        </div>
-      </div>
-    </>
-  );
-}

admin/src/pages/Dashboard.tsx

@@ -1,137 +0,0 @@
-import React, { useState, useEffect, useRef } from 'react';
-import { api } from '../api';
-
-interface FeedEvent {
-  agent: string;
-  operation: string;
-  scopes: string;
-  latency_ms: number;
-  status: string;
-  timestamp: string;
-}
-
-export function DashboardPage() {
-  const [stats, setStats] = useState({ connected_agents: 0, requests_today: 0, active_tokens: 0 });
-  const [health, setHealth] = useState({ expiring_soon: 0, error_rate: '0%' });
-  const [events, setEvents] = useState<FeedEvent[]>([]);
-  const [sseStatus, setSseStatus] = useState<'connecting' | 'connected' | 'disconnected'>('connecting');
-  const eventSourceRef = useRef<EventSource | null>(null);
-
-  useEffect(() => {
-    api.stats().then(setStats).catch(() => {});
-    api.health().then(setHealth).catch(() => {});
-
-    const es = new EventSource('/admin/events');
-    eventSourceRef.current = es;
-    es.onopen = () => setSseStatus('connected');
-    es.onmessage = (e) => {
-      try {
-        const event = JSON.parse(e.data) as FeedEvent;
-        setEvents(prev => [event, ...prev].slice(0, 50));
-      } catch {}
-    };
-    es.onerror = () => {
-      setSseStatus('disconnected');
-      setTimeout(() => {
-        setSseStatus('connecting');
-        es.close();
-        // Reconnect handled by browser EventSource auto-retry
-      }, 3000);
-    };
-
-    const interval = setInterval(() => {
-      api.stats().then(setStats).catch(() => {});
-      api.health().then(setHealth).catch(() => {});
-    }, 30000);
-
-    return () => { es.close(); clearInterval(interval); };
-  }, []);
-
-  const timeAgo = (ts: string) => {
-    const diff = Date.now() - new Date(ts).getTime();
-    if (diff < 60000) return `${Math.floor(diff / 1000)}s ago`;
-    if (diff < 3600000) return `${Math.floor(diff / 60000)} min ago`;
-    return `${Math.floor(diff / 3600000)}h ago`;
-  };
-
-  return (
-    <>
-      <h1 className="page-title">Dashboard</h1>
-
-      <div style={{ display: 'flex', gap: 24 }}>
-        <div style={{ flex: 1 }}>
-          <div className="metrics">
-            <div className="metric">
-              <div className="metric-value">{stats.connected_agents}</div>
-              <div className="metric-label">Connected Agents</div>
-            </div>
-            <div className="metric">
-              <div className="metric-value">{stats.requests_today}</div>
-              <div className="metric-label">Requests Today</div>
-            </div>
-            <div className="metric">
-              <div className="metric-value">{stats.active_tokens}</div>
-              <div className="metric-label">Active Tokens</div>
-            </div>
-          </div>
-
-          <h2 className="section-title">
-            Live Activity
-            <span style={{ marginLeft: 8, fontSize: 10, color: sseStatus === 'connected' ? 'var(--success)' : sseStatus === 'connecting' ? 'var(--warning)' : 'var(--error)' }}>
-              {sseStatus === 'connected' ? '● connected' : sseStatus === 'connecting' ? '● connecting...' : '● disconnected'}
-            </span>
-          </h2>
-
-          <div className="feed">
-            {events.length === 0 ? (
-              <div className="feed-empty">
-                {sseStatus === 'connected' ? 'No requests yet. Agents will appear when they connect.' : 'Connecting...'}
-              </div>
-            ) : (
-              <table>
-                <thead>
-                  <tr>
-                    <th>Agent</th>
-                    <th>Operation</th>
-                    <th>Scopes</th>
-                    <th>Latency</th>
-                    <th>Status</th>
-                    <th>Time</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  {events.map((e, i) => (
-                    <tr key={i}>
-                      <td className="mono">{e.agent}</td>
-                      <td className="mono">{e.operation}</td>
-                      <td>{e.scopes.split(',').map(s => (
-                        <span key={s} className={`badge badge-${s.trim()}`} style={{ marginRight: 4 }}>{s.trim()}</span>
-                      ))}</td>
-                      <td className="mono">{e.latency_ms} ms</td>
-                      <td><span className={`badge badge-${e.status}`}>{e.status}</span></td>
-                      <td style={{ color: 'var(--text-secondary)' }}>{timeAgo(e.timestamp)}</td>
-                    </tr>
-                  ))}
-                </tbody>
-              </table>
-            )}
-          </div>
-        </div>
-
-        <div style={{ width: 220 }}>
-          <h2 className="section-title">Token Health</h2>
-          <div className="health-panel">
-            <div className="health-row">
-              <span style={{ color: 'var(--warning)' }}>Expiring Soon</span>
-              <span className="mono">{health.expiring_soon}</span>
-            </div>
-            <div className="health-row">
-              <span style={{ color: 'var(--error)' }}>Error Rate</span>
-              <span className="mono">{health.error_rate}</span>
-            </div>
-          </div>
-        </div>
-      </div>
-    </>
-  );
-}

admin/src/pages/Login.tsx

@@ -1,96 +0,0 @@
-import React, { useState } from 'react';
-import { api } from '../api';
-
-// v0.26.3 trust model (D11 + D12):
-// - The bootstrap token is NEVER stored in browser JS state. No
-//   localStorage, no sessionStorage, no React state beyond the form
-//   submit cycle. After successful POST /admin/login the operator's
-//   token only lives in the HttpOnly cookie that the server set.
-// - Magic-link URLs use single-use server-issued nonces, not the
-//   bootstrap token itself (see /admin/api/issue-magic-link). The
-//   bootstrap token never appears in a URL.
-// - Closing the tab ends the session client-side. Reopening the
-//   dashboard 401s and shows this page again. Operator asks the agent
-//   for a fresh magic link or pastes the bootstrap token from the
-//   server's terminal scrollback.
-export function LoginPage({ onLogin }: { onLogin: () => void }) {
-  const [token, setToken] = useState('');
-  const [error, setError] = useState('');
-  const [loading, setLoading] = useState(false);
-
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault();
-    setError('');
-    setLoading(true);
-    try {
-      await api.login(token);
-      // Don't persist the token. The HttpOnly cookie is the only
-      // session credential after this point.
-      setToken('');
-      onLogin();
-    } catch (err) {
-      setError('Invalid token.');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <div className="login-page">
-      <div className="login-box">
-        <div className="login-logo">GBrain</div>
-
-        <div style={{
-          background: 'rgba(136, 170, 255, 0.08)',
-          border: '1px solid rgba(136, 170, 255, 0.2)',
-          borderRadius: 8,
-          padding: '14px 16px',
-          marginBottom: 20,
-          fontSize: 13,
-          lineHeight: 1.5,
-          color: 'var(--text-secondary)',
-        }}>
-          <div style={{ fontWeight: 600, color: 'var(--text-primary)', marginBottom: 6 }}>
-            🔒 This is a protected dashboard
-          </div>
-          Ask your AI agent for the admin login link:
-          <div style={{
-            background: 'rgba(0,0,0,0.3)',
-            borderRadius: 6,
-            padding: '8px 12px',
-            marginTop: 8,
-            fontFamily: 'var(--font-mono)',
-            fontSize: 12,
-            color: '#88aaff',
-            wordBreak: 'break-all',
-          }}>
-            "Give me the GBrain admin login link"
-          </div>
-          <div style={{ marginTop: 8, fontSize: 12, color: 'var(--text-muted)' }}>
-            Each link is single-use. Your agent generates a fresh one each time.
-          </div>
-        </div>
-
-        <details style={{ marginBottom: 16 }}>
-          <summary style={{ cursor: 'pointer', fontSize: 13, color: 'var(--text-muted)' }}>
-            Or paste bootstrap token manually
-          </summary>
-          <form onSubmit={handleSubmit} style={{ marginTop: 12 }}>
-            <div style={{ marginBottom: 12 }}>
-              <input
-                type="password"
-                placeholder="Admin Token"
-                value={token}
-                onChange={e => setToken(e.target.value)}
-              />
-            </div>
-            <button className="btn btn-primary" style={{ width: '100%' }} disabled={loading}>
-              {loading ? 'Authenticating...' : 'Submit'}
-            </button>
-            {error && <div className="login-error">{error}</div>}
-          </form>
-        </details>
-      </div>
-    </div>
-  );
-}

admin/src/pages/RequestLog.tsx

@@ -1,150 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { api } from '../api';
-
-interface LogEntry {
-  id: number;
-  token_name: string;
-  agent_name: string;
-  operation: string;
-  latency_ms: number;
-  status: string;
-  params: Record<string, unknown> | null;
-  error_message: string | null;
-  created_at: string;
-}
-
-export function RequestLogPage() {
-  const [data, setData] = useState<{ rows: LogEntry[]; total: number; page: number; pages: number }>({
-    rows: [], total: 0, page: 1, pages: 1,
-  });
-  const [page, setPage] = useState(1);
-  const [agentFilter, setAgentFilter] = useState('all');
-  const [expandedRow, setExpandedRow] = useState<number | null>(null);
-
-  useEffect(() => { loadPage(page); }, [page, agentFilter]);
-
-  const loadPage = (p: number) => {
-    const qs = agentFilter !== 'all' ? `&agent=${encodeURIComponent(agentFilter)}` : '';
-    api.requests(p, qs).then(setData).catch(() => {});
-  };
-
-  const timeAgo = (ts: string) => {
-    const diff = Date.now() - new Date(ts).getTime();
-    if (diff < 60000) return `${Math.floor(diff / 1000)}s ago`;
-    if (diff < 3600000) return `${Math.floor(diff / 60000)} min ago`;
-    if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
-    return new Date(ts).toLocaleDateString();
-  };
-
-
-
-  const formatParams = (params: Record<string, unknown> | null) => {
-    if (!params) return null;
-    const { query, slug, partial, limit, ...rest } = params as any;
-    const parts: string[] = [];
-    if (query) parts.push(`"${query}"`);
-    if (slug) parts.push(slug);
-    if (partial) parts.push(`~${partial}`);
-    if (limit) parts.push(`limit=${limit}`);
-    if (Object.keys(rest).length > 0) parts.push(`+${Object.keys(rest).length} params`);
-    return parts.join(' ');
-  };
-
-  // Collect unique agents for filter (use name for display, token_name for value)
-  const agentMap = new Map<string, string>();
-  data.rows.forEach(r => { if (r.token_name) agentMap.set(r.token_name, r.agent_name || r.token_name); });
-
-  return (
-    <>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 24 }}>
-        <h1 className="page-title" style={{ marginBottom: 0 }}>Request Log</h1>
-        <select value={agentFilter} onChange={e => { setAgentFilter(e.target.value); setPage(1); }}
-          style={{ background: 'var(--bg-secondary)', color: 'var(--text-primary)', border: '1px solid var(--border)', borderRadius: 6, padding: '4px 8px', fontSize: 13 }}>
-          <option value="all">All agents</option>
-          {[...agentMap.entries()].map(([id, name]) => <option key={id} value={id}>{name}</option>)}
-        </select>
-      </div>
-
-      {data.rows.length === 0 ? (
-        <div style={{ textAlign: 'center', padding: 48, color: 'var(--text-muted)' }}>
-          No requests yet.
-        </div>
-      ) : (
-        <>
-          <table>
-            <thead>
-              <tr>
-                <th>Time</th>
-                <th>Agent</th>
-                <th>Operation</th>
-                <th>Params</th>
-                <th>Latency</th>
-                <th>Status</th>
-              </tr>
-            </thead>
-            <tbody>
-              {data.rows.map(r => (
-                <React.Fragment key={r.id}>
-                  <tr onClick={() => setExpandedRow(expandedRow === r.id ? null : r.id)}
-                      style={{ cursor: 'pointer' }}>
-                    <td style={{ color: 'var(--text-secondary)', whiteSpace: 'nowrap' }}>{timeAgo(r.created_at)}</td>
-                    <td>
-                      <a style={{ color: 'var(--text-link, #88aaff)', cursor: 'pointer', textDecoration: 'none', fontWeight: 500 }}
-                         onClick={(e) => { e.stopPropagation(); setAgentFilter(r.token_name); setPage(1); }}>
-                        {r.agent_name || r.token_name}
-                      </a>
-                    </td>
-                    <td className="mono">{r.operation}</td>
-                    <td style={{ color: 'var(--text-secondary)', fontSize: 12, maxWidth: 200, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
-                      {formatParams(r.params)}
-                    </td>
-                    <td className="mono">{r.latency_ms}ms</td>
-                    <td><span className={`badge badge-${r.status}`}>{r.status}</span></td>
-                  </tr>
-                  {expandedRow === r.id && (
-                    <tr>
-                      <td colSpan={6} style={{ background: 'var(--bg-secondary, #0f0f1a)', padding: 16 }}>
-                        <div style={{ display: 'grid', gridTemplateColumns: '100px 1fr', gap: '6px 12px', fontSize: 13 }}>
-                          <span style={{ color: 'var(--text-muted)' }}>Time</span>
-                          <span>{new Date(r.created_at).toLocaleString()}</span>
-                          <span style={{ color: 'var(--text-muted)' }}>Agent</span>
-                          <span className="mono">{r.token_name}</span>
-                          <span style={{ color: 'var(--text-muted)' }}>Operation</span>
-                          <span className="mono">{r.operation}</span>
-                          <span style={{ color: 'var(--text-muted)' }}>Latency</span>
-                          <span>{r.latency_ms}ms</span>
-                          {r.params && (
-                            <>
-                              <span style={{ color: 'var(--text-muted)' }}>Params</span>
-                              <pre className="mono" style={{ margin: 0, whiteSpace: 'pre-wrap', fontSize: 12 }}>
-                                {JSON.stringify(r.params, null, 2)}
-                              </pre>
-                            </>
-                          )}
-                          {r.error_message && (
-                            <>
-                              <span style={{ color: 'var(--error, #ff6b6b)' }}>Error</span>
-                              <span style={{ color: 'var(--error, #ff6b6b)' }}>{r.error_message}</span>
-                            </>
-                          )}
-                        </div>
-                      </td>
-                    </tr>
-                  )}
-                </React.Fragment>
-              ))}
-            </tbody>
-          </table>
-
-          <div className="pagination">
-            <span>Page {data.page} of {data.pages} ({data.total} total)</span>
-            <div style={{ display: 'flex', gap: 8 }}>
-              <button disabled={data.page <= 1} onClick={() => setPage(p => p - 1)}>Previous</button>
-              <button disabled={data.page >= data.pages} onClick={() => setPage(p => p + 1)}>Next</button>
-            </div>
-          </div>
-        </>
-      )}
-    </>
-  );
-}

admin/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

admin/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-    "strict": true
-  },
-  "include": ["src"]
-}

admin/vite.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-
-export default defineConfig({
-  plugins: [react()],
-  base: '/admin/',
-  build: {
-    outDir: 'dist',
-    emptyOutDir: true,
-  },
-});

bun.lock

@@ -7,13 +7,8 @@
       "dependencies": {
         "@anthropic-ai/sdk": "^0.30.0",
         "@aws-sdk/client-s3": "^3.1028.0",
-        "@dqbd/tiktoken": "^1.0.22",
         "@electric-sql/pglite": "0.4.3",
-        "@modelcontextprotocol/sdk": "1.29.0",
-        "cookie-parser": "^1.4.7",
-        "cors": "^2.8.5",
-        "express": "^5.1.0",
-        "express-rate-limit": "^7.5.0",
+        "@modelcontextprotocol/sdk": "^1.0.0",
         "gray-matter": "^4.0.3",
         "marked": "^18.0.0",
         "openai": "^4.0.0",
@@ -24,10 +19,6 @@
       },
       "devDependencies": {
         "@types/bun": "latest",
-        "@types/cookie-parser": "^1.4.7",
-        "@types/cors": "^2.8.19",
-        "@types/express": "^5.0.6",
-        "bun-types": "^1.3.13",
         "typescript": "^5.6.0",
       },
     },
@@ -118,8 +109,6 @@
 
     "@aws/lambda-invoke-store": ["@aws/lambda-invoke-store@0.2.4", "", {}, "sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ=="],
 
-    "@dqbd/tiktoken": ["@dqbd/tiktoken@1.0.22", "", {}, "sha512-RYhO8xeHkMNX5Ixqf4M1Ve3siCYJY/dI0yLnlX4M4oIEDOvjMIQ+E+3OUpAaZcWTaMtQJzGcDAghYfllpx3i/w=="],
-
     "@electric-sql/pglite": ["@electric-sql/pglite@0.4.3", "", {}, "sha512-ichuWTgtd4mOM1G4SpyGJa5trT03lWbMypDV0fUXUCXg5hiHqVAz/bZyV68NqmkLB7WcYmj1RMJVSp8HV/v/ZQ=="],
 
     "@hono/node-server": ["@hono/node-server@1.19.12", "", { "peerDependencies": { "hono": "^4" } }, "sha512-txsUW4SQ1iilgE0l9/e9VQWmELXifEFvmdA1j6WFh/aFPj99hIntrSsq/if0UWyGVkmrRPKA1wCeP+UCr1B9Uw=="],
@@ -226,34 +215,12 @@
 
     "@smithy/uuid": ["@smithy/uuid@1.1.2", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-O/IEdcCUKkubz60tFbGA7ceITTAJsty+lBjNoorP4Z6XRqaFb/OjQjZODophEcuq68nKm6/0r+6/lLQ+XVpk8g=="],
 
-    "@types/body-parser": ["@types/body-parser@1.19.6", "", { "dependencies": { "@types/connect": "*", "@types/node": "*" } }, "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g=="],
-
     "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
 
-    "@types/connect": ["@types/connect@3.4.38", "", { "dependencies": { "@types/node": "*" } }, "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug=="],
-
-    "@types/cookie-parser": ["@types/cookie-parser@1.4.10", "", { "peerDependencies": { "@types/express": "*" } }, "sha512-B4xqkqfZ8Wek+rCOeRxsjMS9OgvzebEzzLYw7NHYuvzb7IdxOkI0ZHGgeEBX4PUM7QGVvNSK60T3OvWj3YfBRg=="],
-
-    "@types/cors": ["@types/cors@2.8.19", "", { "dependencies": { "@types/node": "*" } }, "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg=="],
-
-    "@types/express": ["@types/express@5.0.6", "", { "dependencies": { "@types/body-parser": "*", "@types/express-serve-static-core": "^5.0.0", "@types/serve-static": "^2" } }, "sha512-sKYVuV7Sv9fbPIt/442koC7+IIwK5olP1KWeD88e/idgoJqDm3JV/YUiPwkoKK92ylff2MGxSz1CSjsXelx0YA=="],
-
-    "@types/express-serve-static-core": ["@types/express-serve-static-core@5.1.1", "", { "dependencies": { "@types/node": "*", "@types/qs": "*", "@types/range-parser": "*", "@types/send": "*" } }, "sha512-v4zIMr/cX7/d2BpAEX3KNKL/JrT1s43s96lLvvdTmza1oEvDudCqK9aF/djc/SWgy8Yh0h30TZx5VpzqFCxk5A=="],
-
-    "@types/http-errors": ["@types/http-errors@2.0.5", "", {}, "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg=="],
-
-    "@types/node": ["@types/node@25.5.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg=="],
+    "@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
 
     "@types/node-fetch": ["@types/node-fetch@2.6.13", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.4" } }, "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw=="],
 
-    "@types/qs": ["@types/qs@6.15.0", "", {}, "sha512-JawvT8iBVWpzTrz3EGw9BTQFg3BQNmwERdKE22vlTxawwtbyUSlMppvZYKLZzB5zgACXdXxbD3m1bXaMqP/9ow=="],
-
-    "@types/range-parser": ["@types/range-parser@1.2.7", "", {}, "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ=="],
-
-    "@types/send": ["@types/send@1.2.1", "", { "dependencies": { "@types/node": "*" } }, "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ=="],
-
-    "@types/serve-static": ["@types/serve-static@2.2.0", "", { "dependencies": { "@types/http-errors": "*", "@types/node": "*" } }, "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ=="],
-
     "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
 
     "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],
@@ -272,7 +239,7 @@
 
     "bowser": ["bowser@2.14.1", "", {}, "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg=="],
 
-    "bun-types": ["bun-types@1.3.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-QXKeHLlOLqQX9LgYaHJfzdBaV21T63HhFJnvuRCcjZiaUDpbs5ED1MgxbMra71CsryN/1dAoXuJJJwIv/2drVA=="],
+    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
 
     "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
 
@@ -288,9 +255,7 @@
 
     "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
 
-    "cookie-parser": ["cookie-parser@1.4.7", "", { "dependencies": { "cookie": "0.7.2", "cookie-signature": "1.0.6" } }, "sha512-nGUvgXnotP3BsjiLX2ypbQnWoGUPIIfHQNZkkC668ntrzGWEZVW70HDEB1qnNGMicPje6EttlIgzo51YSwNQGw=="],
-
-    "cookie-signature": ["cookie-signature@1.0.6", "", {}, "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ=="],
+    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
 
     "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
 
@@ -330,7 +295,7 @@
 
     "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
 
-    "express-rate-limit": ["express-rate-limit@7.5.1", "", { "peerDependencies": { "express": ">= 4.11" } }, "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw=="],
+    "express-rate-limit": ["express-rate-limit@8.3.2", "", { "dependencies": { "ip-address": "10.1.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-77VmFeJkO0/rvimEDuUC5H30oqUC4EyOhyGccfqoLebB0oiEYfM7nwPrsDsBL1gsTpwfzX8SFy2MT3TDyRq+bg=="],
 
     "extend-shallow": ["extend-shallow@2.0.1", "", { "dependencies": { "is-extendable": "^0.1.0" } }, "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug=="],
 
@@ -498,7 +463,7 @@
 
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
-    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+    "undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
 
     "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
 
@@ -520,35 +485,29 @@
 
     "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
 
-    "@anthropic-ai/sdk/@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
-
     "@aws-crypto/sha1-browser/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
 
     "@aws-crypto/sha256-browser/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
 
     "@aws-crypto/util/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
 
-    "@modelcontextprotocol/sdk/express-rate-limit": ["express-rate-limit@8.3.2", "", { "dependencies": { "ip-address": "10.1.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-77VmFeJkO0/rvimEDuUC5H30oqUC4EyOhyGccfqoLebB0oiEYfM7nwPrsDsBL1gsTpwfzX8SFy2MT3TDyRq+bg=="],
+    "@types/node-fetch/@types/node": ["@types/node@25.5.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg=="],
 
-    "@types/bun/bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
-
-    "express/cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],
+    "bun-types/@types/node": ["@types/node@25.5.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg=="],
 
     "form-data/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
 
-    "openai/@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
-
-    "@anthropic-ai/sdk/@types/node/undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
-
     "@aws-crypto/sha1-browser/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="],
 
     "@aws-crypto/sha256-browser/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="],
 
     "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="],
 
-    "form-data/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
+    "@types/node-fetch/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
 
-    "openai/@types/node/undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
+    "bun-types/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
+    "form-data/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
 
     "@aws-crypto/sha1-browser/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="],
 

bunfig.toml

@@ -1,9 +1,6 @@
 [test]
-# PGLite WASM cold start + initSchema() runs ~5–20s on loaded machines.
-# Default 5s is too short for those tests' beforeAll hooks. 60s is the
-# empirical ceiling we observed for the slowest cold-init paths.
-#
-# v0.26.4: scripts/run-unit-parallel.sh and scripts/run-unit-shard.sh
-# also pass `--timeout=60000` explicitly so the ceiling is consistent
-# whether tests are invoked through the wrapper or directly via bun test.
+# PGLite initialization can be slow under parallel test execution.
+# Default 5s is too short when many test files boot PGLite instances at once.
+# 60s is the empirical ceiling we observed before the first file's beforeAll
+# completed on a loaded machine.
 timeout = 60_000

docker-compose.ci.yml

@@ -1,117 +0,0 @@
-# docker-compose.ci.yml
-#
-# Local CI gate with 4-way E2E sharding. Spins up 4 pgvector services + a bun
-# runner that bind-mounts the repo. Used by `bun run ci:local` and
-# `bun run ci:local:diff` (see scripts/ci-local.sh).
-#
-# All services are pulled as `image:` (no build) so `docker compose pull`
-# refreshes everything. The bun version floats with `oven/bun:1` to track CI's
-# `bun-version: latest`. Named volumes isolate the Linux container's deps from
-# the host's darwin-arm64 deps and keep bun + postgres data warm across runs.
-#
-# Why 4 postgres services: bun's E2E suite shares one DB across 36 files and
-# uses TRUNCATE CASCADE in setupDB(). Running files in parallel against ONE DB
-# races (file A's TRUNCATE clobbers file B's fixture import). 4 separate DBs
-# remove the race; we shard the file list 1/4..4/4 and run shards in parallel.
-# Within a shard, files still run sequentially. Total wall-time on a 16-core
-# host: ~6 min sequential -> ~1.5-2 min sharded.
-#
-# Postgres host ports default to 5434-5437 (avoid 5432 manual `gbrain-test-pg`
-# and 5433 sibling-project conflicts). Override BASE port with GBRAIN_CI_PG_PORT;
-# shards take BASE..BASE+3.
-
-services:
-  postgres-1:
-    image: pgvector/pgvector:pg16
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: gbrain_test
-    ports:
-      - "${GBRAIN_CI_PG_PORT:-5434}:5432"
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d gbrain_test"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    volumes:
-      - gbrain-ci-pg-data-1:/var/lib/postgresql/data
-
-  postgres-2:
-    image: pgvector/pgvector:pg16
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: gbrain_test
-    ports:
-      - "${GBRAIN_CI_PG_PORT_2:-5435}:5432"
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d gbrain_test"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    volumes:
-      - gbrain-ci-pg-data-2:/var/lib/postgresql/data
-
-  postgres-3:
-    image: pgvector/pgvector:pg16
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: gbrain_test
-    ports:
-      - "${GBRAIN_CI_PG_PORT_3:-5436}:5432"
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d gbrain_test"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    volumes:
-      - gbrain-ci-pg-data-3:/var/lib/postgresql/data
-
-  postgres-4:
-    image: pgvector/pgvector:pg16
-    environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: gbrain_test
-    ports:
-      - "${GBRAIN_CI_PG_PORT_4:-5437}:5432"
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d gbrain_test"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    volumes:
-      - gbrain-ci-pg-data-4:/var/lib/postgresql/data
-
-  runner:
-    image: oven/bun:1
-    working_dir: /app
-    depends_on:
-      postgres-1:
-        condition: service_healthy
-      postgres-2:
-        condition: service_healthy
-      postgres-3:
-        condition: service_healthy
-      postgres-4:
-        condition: service_healthy
-    # No global DATABASE_URL — scripts/ci-local.sh sets per-shard URL via -e.
-    # Unit phase explicitly unsets DATABASE_URL so test/e2e/* gracefully skip.
-    volumes:
-      - .:/app
-      # Linux container's node_modules MUST be isolated from host darwin-arm64.
-      # Without this, container `bun install` stomps host node_modules and
-      # subsequent `bun test` on host fails with binary-incompat errors.
-      - gbrain-ci-node-modules:/app/node_modules
-      # Warm install cache across runs.
-      - gbrain-ci-bun-cache:/root/.bun/install/cache
-
-volumes:
-  gbrain-ci-pg-data-1:
-  gbrain-ci-pg-data-2:
-  gbrain-ci-pg-data-3:
-  gbrain-ci-pg-data-4:
-  gbrain-ci-node-modules:
-  gbrain-ci-bun-cache:

docs/UPGRADING_DOWNSTREAM_AGENTS.md

@@ -458,75 +458,6 @@ in depth, not the primary boundary.
 
 ---
 
-## v0.22.4 — frontmatter-guard adoption
-
-### 1. Stop hand-rolling frontmatter validators
-
-If your fork has scripts that call `js-yaml` directly to validate brain page
-frontmatter, replace them with `gbrain frontmatter validate` calls. The CLI
-covers the seven canonical error classes and ships a `--json` envelope that's
-stable across releases.
-
-```diff
-- # Custom validator script
-- node scripts/validate-frontmatter.mjs <path>
-+ gbrain frontmatter validate <path> --json
-```
-
-For consumers that need the validator inside another script, import from
-gbrain's `markdown` export instead of duplicating logic:
-
-```ts
-import { parseMarkdown } from 'gbrain/markdown';
-
-const parsed = parseMarkdown(content, filePath, { validate: true, expectedSlug });
-for (const err of parsed.errors ?? []) {
-  // err.code: MISSING_OPEN | MISSING_CLOSE | YAML_PARSE | SLUG_MISMATCH |
-  //           NULL_BYTES | NESTED_QUOTES | EMPTY_FRONTMATTER
-}
-```
-
-### 2. Drop any references to `lib/brain-writer.mjs`
-
-If your fork's skills or scripts referenced an aspirational
-`lib/brain-writer.mjs` (it never shipped — the spec was in PR #392 and never
-landed), replace those references with the gbrain CLI. The `frontmatter-guard`
-skill lives at `skills/frontmatter-guard/SKILL.md` and points at
-`gbrain frontmatter validate` / `audit` / `install-hook`.
-
-### 3. Wire the doctor subcheck into your health pipeline
-
-`gbrain doctor` now reports `frontmatter_integrity` automatically. If your
-fork has a custom health pipeline (e.g. a daily Slack post about brain
-health), pull from `gbrain doctor --json` and surface the
-`frontmatter_integrity` row counts.
-
-### 4. (Optional) Install the pre-commit hook on brain repos
-
-For sources backed by git, the v0.22.4 install-hook helper drops a
-pre-commit script that blocks commits with malformed frontmatter:
-
-```bash
-gbrain frontmatter install-hook
-```
-
-Skip this if your brain isn't a git repo or if your downstream agent already
-enforces validation at write time. See `docs/integrations/pre-commit.md` for
-the full recipe.
-
-### 5. Migration ergonomics — read pending-host-work.jsonl
-
-After `gbrain apply-migrations --yes` runs the v0.22.4 audit, your agent
-should read `~/.gbrain/migrations/pending-host-work.jsonl` (filter to
-`migration === "0.22.4"`) and walk each entry's `command` field. Each entry
-points to a per-source `gbrain frontmatter validate <source_path> --fix`
-command — surface counts to the user, get explicit consent, then run.
-
-The migration is **audit-only**. It never mutates brain content during
-`apply-migrations`. Your agent runs the fix command with user consent.
-
----
-
 ## Future versions
 
 When gbrain ships a new version, this doc will be updated with the diffs for that

docs/architecture/brains-and-sources.md

@@ -1,242 +0,0 @@
-# Brains and Sources — the mental model
-
-GBrain has two orthogonal axes for organizing knowledge. Users and agents both
-need to understand both of them, or queries misroute silently.
-
-**TL;DR:**
-- A **brain** is a database. You can have many.
-- A **source** is a named repo of content *inside* a brain. One brain can hold many.
-- `--brain <id>` picks WHICH DATABASE.
-- `--source <id>` picks WHICH REPO WITHIN that database.
-- They're independent. You can target any combination.
-
----
-
-## The two axes
-
-### Brains (the DB axis)
-
-A **brain** is one database — PGLite file, self-hosted Postgres, or Supabase.
-Each brain has:
-- Its own `pages` table, `chunks` table, `embeddings`, etc.
-- Its own OAuth surface if served over HTTP MCP (v0.19+, PR 2).
-- Its own separate lifecycle, backup, access control.
-
-Brains are enumerated by:
-- **host** — your default brain, configured in `~/.gbrain/config.json`.
-- **mounts** — additional brains registered in `~/.gbrain/mounts.json` via
-  `gbrain mounts add <id>` (v0.19+).
-
-Routing: `--brain <id>`, `GBRAIN_BRAIN_ID`, `.gbrain-mount` dotfile, or
-longest-path match against registered mount paths. Falls back to `host`.
-
-### Sources (the repo axis, v0.18.0+)
-
-A **source** is a named content repo *inside* one brain. Every `pages` row
-carries a `source_id`. Slugs are unique per source, not globally.
-
-Example: in one brain, the slug `topics/ai` can exist under `source=wiki`
-AND under `source=gstack` — they're different pages.
-
-Routing: `--source <id>`, `GBRAIN_SOURCE`, `.gbrain-source` dotfile, or
-registered `local_path` match in the `sources` table.
-
-### When does each axis move?
-
-| You want to | Adjust |
-|---|---|
-| Work in a different repo within the same brain (wiki → gstack notes) | `--source` |
-| Query a team-published brain that isn't yours | `--brain` |
-| Isolate a topic so it never leaks into personal search | `--source` with `federated=false` |
-| Share a brain with teammates | `--brain` (mount the team brain) |
-| Add a new repo to your personal brain | `--source` via `gbrain sources add` |
-| Add a team brain | `--brain` via `gbrain mounts add` |
-
-**Rule of thumb:** if the data owner changes, it's a brain boundary. If the
-data owner stays the same but the topic/repo changes, it's a source boundary.
-
----
-
-## Topology: a single-person developer
-
-Simplest case. One brain, one source.
-
-```
-┌─────────────────────────────────────────┐
-│  host brain (~/.gbrain)                 │
-│  ├── source: default (federated=true)   │
-│  │   └── all pages                      │
-└─────────────────────────────────────────┘
-```
-
-`gbrain query "retry budgets"` finds everything. No `--brain`, no `--source`
-needed.
-
----
-
-## Topology: a personal brain with multiple repos
-
-You maintain several codebases or writing streams. Each is its own source
-inside one brain. Cross-source search is on by default so a query about
-"caching" returns hits from every repo.
-
-```
-┌──────────────────────────────────────────────┐
-│  host brain (~/.gbrain)                      │
-│  ├── source: wiki      (federated=true)      │
-│  │   └── personal notes, people, companies   │
-│  ├── source: gstack    (federated=true)      │
-│  │   └── gstack plans, learnings             │
-│  ├── source: openclaw  (federated=true)      │
-│  │   └── openclaw docs, memos                │
-│  └── source: essays    (federated=false)     │
-│      └── draft essays, isolated on purpose   │
-└──────────────────────────────────────────────┘
-```
-
-Inside `~/openclaw/` the `.gbrain-source` dotfile pins every command to
-`source=openclaw`. Inside `~/gstack/` the dotfile pins to `source=gstack`.
-Everything still targets one DB.
-
-Use this topology when:
-- You own all the content.
-- You want cross-repo search to just work.
-- You don't need to share any of it with someone who isn't you.
-
----
-
-## Topology: personal brain + one team brain
-
-You're on a team that publishes a shared brain. Your personal brain stays
-as-is; you mount the team brain alongside it.
-
-```
-┌──────────────────────────────────────────────┐
-│  host brain (~/.gbrain)  — YOUR personal DB  │
-│  ├── source: wiki                            │
-│  ├── source: gstack                          │
-│  └── ...                                     │
-└──────────────────────────────────────────────┘
-
-┌──────────────────────────────────────────────┐
-│  mount: media-team                           │
-│  path:   ~/team-brains/media                 │
-│  engine: postgres (team's Supabase)          │
-│  └── sources: wiki, raw, enriched            │
-└──────────────────────────────────────────────┘
-```
-
-`gbrain query "X"` (no flags) → runs against host (your personal brain).
-`gbrain query "X" --brain media-team` → runs against the team's DB.
-Inside `~/team-brains/media/` a `.gbrain-mount` dotfile pins brain to
-`media-team` automatically.
-
-Use this topology when:
-- You're on a team and someone publishes a brain the team subscribes to.
-- You need data isolation between work and personal.
-- Different teams/orgs own different brains.
-
----
-
-## Topology: a CEO-class user with multiple team memberships
-
-You're senior enough to sit across multiple teams. You maintain your personal
-brain (with N sources inside) AND mount several work team brains. Each team
-brain is itself a multi-source brain in the v0.18.0 sense — organized
-internally however the team owner chose.
-
-```
-┌──────────────────────────────────────────────┐
-│  host brain — YOUR personal DB               │
-│  ├── source: wiki                            │
-│  ├── source: essays                          │
-│  ├── source: gstack                          │
-│  └── source: openclaw                        │
-└──────────────────────────────────────────────┘
-
-┌──────────────────────────────────────────────┐
-│  mount: media-team (your media team's brain) │
-│  └── sources: wiki, pipeline, enriched       │
-└──────────────────────────────────────────────┘
-
-┌──────────────────────────────────────────────┐
-│  mount: policy-team (your policy team's)     │
-│  └── sources: wiki, research, letters        │
-└──────────────────────────────────────────────┘
-
-┌──────────────────────────────────────────────┐
-│  mount: portfolio (another team's)           │
-│  └── sources: companies, deals, diligence    │
-└──────────────────────────────────────────────┘
-```
-
-Inside each team's checkout, a `.gbrain-mount` dotfile pins the brain. Inside
-a specific subdirectory, a `.gbrain-source` dotfile pins the source. So `cd
-~/team-brains/policy/research && gbrain query "X"` targets
-`brain=policy-team, source=research` with zero flags.
-
-Use this topology when:
-- You cross-cut multiple teams.
-- Each team owns its own brain with its own access policy.
-- You need latent-space federation (agent decides when to query across
-  brains), not SQL federation.
-
-Cross-brain queries are **not deterministic** in v0.19. The agent sees the
-brain list and re-queries as needed. That's the feature — it keeps debugging
-sane and access control clean.
-
----
-
-## Resolution precedence (one page to remember)
-
-```
-WHICH BRAIN (DB)?                    WHICH SOURCE (repo in DB)?
- 1. --brain <id>                      1. --source <id>
- 2. GBRAIN_BRAIN_ID env               2. GBRAIN_SOURCE env
- 3. .gbrain-mount dotfile             3. .gbrain-source dotfile
- 4. longest-prefix mount path match   4. longest-prefix source path match
- 5. (reserved: brains.default v2)     5. sources.default config
- 6. fallback: 'host'                  6. fallback: 'default'
-```
-
-Both axes follow the same layered pattern on purpose. If you know one, you
-know the other.
-
----
-
-## For agents reading this
-
-- Default assumption when the user asks a question: start in the current
-  brain (resolved via the precedence above). Don't jump brains without a
-  reason.
-- If the user asks a question that crosses topic areas a team might own
-  (e.g. "what did Team X decide last week?"), the right move is to *query
-  the team's brain explicitly* rather than searching host with "team x".
-- Cross-brain federation is YOUR JOB, not the DB's. You have the brain list
-  (`gbrain mounts list`). You decide when to fan out. You synthesize
-  findings. You cite `brain:source:slug`.
-- When writing a page, respect the brain boundary. A fact about a team's
-  work belongs in the team's brain, not in the user's personal brain. Ask
-  before writing cross-brain.
-- See `skills/conventions/brain-routing.md` for the full decision table.
-
-## For users reading this
-
-- **Default path:** set up your personal brain (`gbrain init`), add a source
-  per repo you care about (`gbrain sources add gstack --path ~/gstack`).
-  You'll almost never need `--brain`.
-- **When a team publishes a brain:** `gbrain mounts add <team-id> --path
-  <clone> --db-url <url>` and the `.gbrain-mount` dotfile in that checkout
-  routes queries there automatically.
-- **When you are the CEO-class user with multiple team memberships:** mount
-  each team brain. Trust the resolver — inside a team's directory the
-  dotfile picks the brain, inside a subdirectory the dotfile picks the
-  source. The flags are for when you want to query across the boundary
-  deliberately.
-
-## Further reading
-
-- v0.18.0 CHANGELOG — introduced `sources` primitive.
-- v0.19.0 CHANGELOG (TBD after PR 0+1+2 ship) — introduces `mounts`.
-- `docs/mounts/publishing-a-team-brain.md` (PR 2) — how to be the brain
-  publisher, not just the subscriber.

docs/benchmarks/2026-04-18-brainbench-v1.md

@@ -0,0 +1,286 @@
+# BrainBench v1 — 2026-04-18
+
+**Branch:** `garrytan/link-timeline-extract`
+**PR:** #188
+**Engine:** PGLite (in-memory)
+**Reproducibility:** `bun run eval/runner/all.ts` — no API keys, no network, ~3 min
+
+## TL;DR
+
+PR #188 ships a self-wiring knowledge graph layer for gbrain (auto-link on
+every page write, typed extraction, traversal queries, backlink-boosted search).
+This benchmark measures the actual end-to-end value vs gbrain pre-PR-#188 on a
+240-page rich-prose corpus generated by Claude Opus.
+
+**Every headline metric goes UP. No category goes down.**
+
+| Metric              | BEFORE PR #188 | AFTER PR #188 | Δ            |
+|---------------------|----------------|---------------|--------------|
+| **Precision@5**     | 39.2%          | **44.7%**     | **+5.4 pts** |
+| **Recall@5**        | 83.1%          | **94.6%**     | **+11.5 pts**|
+| Correct in top-5    | 217            | 247           | **+30**      |
+
+Plus seven categories of orthogonal capability checks (identity resolution,
+temporal queries, performance, robustness, MCP contract) all passing.
+
+## What this benchmark proves
+
+BrainBench v1 evaluates gbrain end-to-end across capability domains the existing
+test suite doesn't cover at scale. Headline is a single before/after comparison:
+**pre-PR-#188 (no graph layer)** vs **the full v0.10.3 + v0.10.4 stack**, run on
+the same 240-page corpus with the same relational queries.
+
+Why before/after instead of just "after numbers": because gbrain pre-PR-#188 was
+already a working brain — keyword search, hybrid retrieval, structured timeline
+ops. The graph layer is an additive change. The right question is "did it
+actually make the brain better at relational questions?" not "is it good in
+isolation."
+
+## The corpus
+
+240 rich-prose pages generated by Claude Opus 4.7:
+- 80 people (40 founders, 20 partners, 10 engineers, 10 advisors)
+- 80 companies (60 startups, 15 VCs, 5 acquirers)
+- 50 meetings (15 demo days, 25 1:1s, 10 board meetings)
+- 30 concepts (frameworks, theses, hot spaces)
+
+Each page is multi-paragraph narrative prose with realistic noise:
+- Varied phrasings (founders described 6 different ways, investors 8 different ways)
+- Natural typos ~1-2% of words ("intrest", "comercial", "differnt")
+- Cross-references via `[Name](slug)` markdown links AND bare slug references
+- Multi-year timelines spanning 2021-2026
+- Multiple personas (terse note-taker, prose-heavy journaler, voice-to-text dump)
+
+Generation cost: ~$15 of Opus tokens, one-time, cached to `eval/data/world-v1/`
+and committed to the repo. Subsequent runs read the cache.
+
+This is intentionally messier than templated benchmarks. The point is to surface
+behavior under realistic load, not to confirm the algorithm works on clean inputs.
+
+## Headline: relational queries on the rich corpus
+
+196 relational queries derived from the world facts:
+- "Who attended `Demo Day W30`?" (60 queries)
+- "Who works at `Acme`?" (60 queries)
+- "Who invested in `Beta Health`?" (45 queries)
+- "Who advises `Cipher Labs`?" (31 queries)
+
+Configurations compared:
+- **BEFORE PR #188:** vanilla v0.10.0 — no auto-link, no `extract --source db`,
+  no `traversePaths`. Agent answers relational questions by grepping the corpus
+  (the realistic fallback for a pre-graph brain).
+- **AFTER PR #188:** full graph layer. Agent uses `gbrain graph-query` first
+  (high-precision typed traversal), grep fallback when graph returns nothing.
+
+### Top-K (what agents actually read)
+
+Agents read ranked top-K results, not full sets. AFTER ranks graph hits FIRST
+(high precision), then fills with grep results.
+
+| Metric              | BEFORE | AFTER  | Δ             |
+|---------------------|--------|--------|---------------|
+| **Precision@5**     | 39.2%  | 44.7%  | **+5.4 pts**  |
+| **Recall@5**        | 83.1%  | 94.6%  | **+11.5 pts** |
+| Correct in top-5    | 217    | 247    | **+30**       |
+
+Recall@5 jumps 11.5 points because graph hits are exact-typed answers placed
+at the top of results — agents find what they need in their first reads
+instead of digging through grep noise.
+
+### Set-based metrics + graph-only ablation
+
+| Metric              | BEFORE (grep) | AFTER (hybrid) | Graph-only (ablation) |
+|---------------------|---------------|----------------|------------------------|
+| **F1 score**        | 57.8%         | 57.8%          | **86.6%**              |
+| Set precision       | 40.8%         | 40.8%          | **81.0%**              |
+| Set recall          | 98.9%         | 98.9%          | 93.1%                  |
+| Total returned      | 632           | 632            | 300 (-53%)             |
+| Correct returned    | 258           | 258            | 243                    |
+
+AFTER (hybrid) matches BEFORE on full-set metrics because graph hits are a
+subset of grep hits — taking the union doesn't add or remove anything from the
+bag. **What changes is which results appear FIRST.** Top-K captures that;
+raw set recall doesn't.
+
+The **graph-only** column is the most important number in the report. It shows
+where the graph alone is heading: **86.6% F1 vs grep's 57.8% (+28.8 pts)**.
+Almost twice the precision (81% vs 41%) at 94% of the recall, with HALF the
+results to read.
+
+### Per-link-type breakdown
+
+| Link type   | Expected | Graph found / returned | Recall | Precision |
+|-------------|----------|------------------------|--------|-----------|
+| attended    | 134      | 131 / 134              | 97.8%  | 97.8%     |
+| works_at    | 50       | 50 / 79                | 100.0% | 63.3%     |
+| invested_in | 60       | 50 / 56                | 83.3%  | 89.3%     |
+| advises     | 17       | 12 / 31                | 70.6%  | 38.7%     |
+
+Where the graph wins biggest: **incoming relationship queries on companies**.
+"Who works at Acme?" — grep returns every page mentioning Acme (founders,
+investors, advisors, concept pages, other companies that mention it). Graph
+returns just employees with the typed `works_at` link.
+
+## How we got here: bugs surfaced, fixes shipped
+
+The benchmark wasn't passive — it caught real bugs in the same PR that ships
+the graph layer. Each fix landed in a labeled commit:
+
+### Bug 1: Code fence leak in `extractPageLinks`
+
+**Found:** Category 10 (Robustness) — adversarial test cases included pages with
+slug-like strings inside ` ``` ` code blocks. Extraction was treating them as
+real entity references.
+
+**Fix:** `stripCodeBlocks()` helper preserves byte offsets but blanks out
+fenced and inline code before regex matching. Code fence leak rate now 0%.
+
+### Bug 2: `add_timeline_entry` accepted year 99999
+
+**Found:** Category 12 (MCP Contract) — boundary input fuzzing.
+
+**Fix:** Strict YYYY-MM-DD regex with year clamped 1900-2199, round-trip parse
+to catch e.g. Feb 30. Rejects with clear error message.
+
+### Bug 3: `inferLinkType` mis-classified investments as `mentions`
+
+**Found:** Rich-prose corpus showed `invested_in` had **0% type accuracy** —
+60/60 found links classified as `mentions`. Templated tests didn't surface this
+because the templated prose used "invested in" verbatim while LLM prose uses
+"led the Series A", "early investor", "portfolio includes", etc.
+
+**Fix:** Five-part patch:
+1. `INVESTED_RE` extended with narrative verbs LLMs actually use
+2. `ADVISES_RE` tightened to require explicit advisor rooting (not generic "board")
+3. Context window 80→240 chars (catches verbs at sentence distance)
+4. Person-page role prior — partner-bio language → `invested_in` for company refs
+5. Cascade reorder — `invested_in` checked before `advises`
+
+Type accuracy: **70.7% → 88.5% (+18 pts)**. invested_in: **0% → 91.7%**.
+
+### Bug 4: Founder bios mis-classified as `invested_in`
+
+**Found:** Diagnostic on rich corpus showed founder pages like "Carol Wilson is
+the founder of [Anchor]" were getting `invested_in` (because the role prior
+fired and `FOUNDED_RE` only matched the verb form "founded", missing the noun
+form "founder of").
+
+**Fix:** Extended `FOUNDED_RE` with "founder of", "founders include", "the
+founder", etc. Carol's link now correctly types as `founded`. Combined with
+relaxing the "who works at X?" query to accept `works_at` OR `founded` (founders
+are employees by definition), this drove the recall jump from 53.8% → 93.1%.
+
+## Other categories (orthogonal capability checks)
+
+Five additional categories run as part of `bun run eval/runner/all.ts`. All pass.
+
+### Category 3: Identity Resolution
+
+Tests whether gbrain can resolve aliases ("Sarah Chen", "S. Chen", "@schen",
+"sarah.chen@example.com") to one canonical entity. 100 entities × 8 alias types
+= 800 queries.
+
+| Alias category | Recall (top-10) |
+|----------------|-----------------|
+| Documented (in canonical body)     | 100.0% |
+| Undocumented (initials, typos)     | 31.0%  |
+
+Honest baseline: gbrain has no alias table today. Documented aliases work via
+keyword search. Undocumented aliases need v0.10.4 alias-table feature
+(documented in TODOS.md).
+
+### Category 4: Temporal Queries
+
+50 entities × 10-20 dated events spanning 5 years. Tests point queries, range
+queries, recency, and as-of queries.
+
+| Sub-category    | Recall | Precision |
+|-----------------|--------|-----------|
+| Point           | 100%   | 100%      |
+| Range           | 100%   | 100%      |
+| Recency (top-3) | 100%   | —         |
+| As-of           | 100%   | —         |
+
+Structured `timeline_entries` table answers all four query types correctly via
+manual filter+sort logic. Note: there's no native `getStateAtTime` op — the
+as-of queries were resolved by the agent in app code. Native op deferred to v0.10.5.
+
+### Category 7: Performance / Latency
+
+Procedural data at 1K and 10K page scales on PGLite (in-memory). All read ops
+sub-millisecond. Bulk import at 5,800 pages/sec.
+
+| Op                 | 1K P50  | 1K P95  | 10K P50 | 10K P95  |
+|--------------------|---------|---------|---------|----------|
+| get_page           | 0.08ms  | 0.12ms  | 0.08ms  | 0.15ms   |
+| search_keyword     | 0.19ms  | 0.52ms  | 0.20ms  | 0.59ms   |
+| traverse_paths d=2 | 10.1ms  | 12.6ms  | 91.4ms  | 176.4ms  |
+| putPage_single     | 0.12ms  | 0.20ms  | 0.12ms  | 0.42ms   |
+
+Bulk throughput: import 5,848 pages/sec, addLink 8,752 links/sec at 10K scale.
+P95 search latency well under the 200ms threshold.
+
+### Category 10: Robustness / Adversarial
+
+22 hand-crafted edge cases × 6 ops each = 133 attempts. Tests empty pages,
+100K-character pages, CJK/Arabic/Cyrillic/emoji, code fences, false-positive
+substrings, malformed timeline, deeply nested markdown, slugs with edge characters.
+
+**Result: 133/133 ops succeeded, 0 crashes, 0 silent corruption.**
+
+### Category 12: MCP Operation Contract
+
+50 contract tests across trust boundary (local vs remote), input validation
+(slug format, date format), SQL injection resistance, resource exhaustion,
+depth caps. 30 operations × 5 input variants.
+
+**Result: 50/50 pass.** Verifies the v0.10.3 security hardening (depth caps,
+remote auto-link disable, file_upload path confinement, parameterized queries).
+
+## Reproducibility
+
+```bash
+bun run eval/runner/all.ts
+```
+
+In-memory PGLite, no API keys, no network. ~3 minutes wall time. Same numbers
+every run (within deterministic-seed tolerance).
+
+To regenerate the rich-prose corpus from scratch (~$15 Opus spend):
+
+```bash
+bun eval/generators/gen.ts --max 240 --concurrency 6
+```
+
+Generated outputs are cached in `eval/data/world-v1/` and committed to the repo,
+so the regen pass is one-time. Subsequent runs use the cache.
+
+## What this benchmark deliberately doesn't test (BrainBench v1.1, see TODOS.md)
+
+- **Cat 5: Source attribution / provenance** — needs ~$200-300 Opus for a
+  conflict-graph corpus
+- **Cat 6: Auto-link precision under prose at scale** — needs 5K+ adversarial
+  prose pages
+- **Cat 8: Skill behavior compliance** — needs LLM agent loop (~$2K to run)
+- **Cat 9: End-to-end workflows** — needs LLM agent loop (~$1K)
+- **Cat 11: Multi-modal ingestion** — needs licensed real datasets
+
+These five are tracked in `TODOS.md` with budget estimates and depend-on chains.
+
+## Methodology notes
+
+- **Synthetic data, not private brain.** All 240 pages are fictional. Generated
+  by Opus from procedural skeletons in `eval/generators/world.ts`. Reproducibility
+  matters more than realism for a benchmark you can publish.
+- **Two configurations, one corpus.** BEFORE and AFTER run against identical
+  data. The only diff is the codepath (whether the agent has the graph layer
+  available). No corpus tuning per configuration.
+- **No cherry-picking.** Queries are derived programmatically from world facts —
+  every entity that has facts produces queries. No hand-selected "easy wins."
+- **Honest about limitations.** The 5.8pt set-recall gap (graph 93.1% vs grep
+  98.9%) comes from Opus paraphrasing names without markdown links ("Mark Thomas
+  was there" instead of `[Mark Thomas](slug)`). Closing this needs corpus-aware
+  NER, deferred to v0.10.5.
+- **Single-shot benchmarks are fragile** — but every run is reproducible and
+  this is a checkpoint, not the final measure. v1.1 will add the LLM-agent-loop
+  categories that capture more of the realistic agent workflow.

docs/benchmarks/2026-04-18-minions-vs-openclaw-production.md

@@ -0,0 +1,126 @@
+# Production Benchmark: Minions vs OpenClaw Sub-agents (Real Deployment)
+
+**Date:** 2026-04-18
+**Environment:** Garry's OpenClaw on Render (ephemeral container, Supabase Postgres)
+**GBrain:** v0.11.0 (minions-jobs branch)
+**OpenClaw:** 2026.4.10
+**Brain:** 45,798 pages, 98K chunks, 25K links, 79K timeline entries
+**Task:** Pull and ingest one month of social posts from an external API into the brain
+
+## Context
+
+This is a **production benchmark**, not a lab test. The existing lab benchmark
+([2026-04-18-minions-vs-openclaw-subagents.md](2026-04-18-minions-vs-openclaw-subagents.md))
+uses trivial prompts on localhost Postgres. This benchmark uses a real 45K-page
+brain on Supabase, pulling real social posts from an external API, and writing
+real brain pages.
+
+## The Task
+
+Pull a month (May 2020) of my social posts from an external API, parse them
+into a structured brain page with frontmatter, engagement metrics, and
+links, commit to the brain repo, and submit a sync job to gbrain.
+
+## Method 1: Minions (deterministic pipeline)
+
+```bash
+# 1. Pull posts from the external API (curl → JSON)
+curl -s -H "Authorization: Bearer $API_BEARER_TOKEN" \
+  "$SOCIAL_API_URL?from=my_account&start=2020-05-01&end=2020-06-01" \
+  > /tmp/bench-posts.json
+
+# 2. Parse + write brain page (python)
+python3 parse_and_write.py
+
+# 3. Git commit
+cd /data/brain && git add media/social/2020-05.md && git commit -m "archive: 2020-05"
+
+# 4. Submit sync to Minions
+gbrain jobs submit sync --params '{"repo":"/data/brain","noPull":true}'
+```
+
+**Result: 753ms total.** 99 posts pulled, page written, committed, sync job queued.
+
+Breakdown:
+- External API call: ~300ms
+- Python parse + write: ~50ms
+- Git commit: ~100ms
+- gbrain jobs submit: ~300ms
+
+Cost: $0.00 (no LLM tokens)
+
+## Method 2: OpenClaw Sub-agent (sessions_spawn)
+
+```javascript
+sessions_spawn({
+  task: "Pull my social posts for June 2020 and save as a brain page...",
+  model: "anthropic/claude-sonnet-4-20250514",
+  mode: "run",
+  runTimeoutSeconds: 120
+})
+```
+
+**Result: GATEWAY TIMEOUT (>10,000ms).** The sub-agent could not even spawn
+within the 10-second gateway timeout. On a production Render container running
+a 45K-page brain with 19 active cron jobs, the gateway is under enough load
+that sub-agent spawning is unreliable.
+
+When sub-agents DO successfully spawn (off-peak), the expected path is:
+1. Gateway receives spawn request (~500ms)
+2. Create session, load context (~2-3s) — AGENTS.md, SOUL.md, skills, memory
+3. Model reads task, plans approach (~2-3s)
+4. Model calls `exec` tool for curl (~1s)
+5. Model calls `exec` tool for python (~1s)
+6. Model calls `exec` tool for git (~1s)
+7. Model reports result (~1s)
+
+**Estimated: 10-15s + ~$0.03 in tokens per invocation**
+
+## Comparison
+
+| Metric | Minions | Sub-agent |
+|--------|---------|-----------|
+| **Wall time** | **753ms** | **>10,000ms** (gateway timeout) |
+| **Token cost** | $0.00 | ~$0.03 per run |
+| **Success rate** | 100% | 0% (timeout on first attempt) |
+| **Survives restart** | Yes (Postgres) | No (dies with process) |
+| **Progress tracking** | `gbrain jobs get <id>` | poll sessions_list |
+| **Auto-retry** | 3 attempts, exponential backoff | manual re-spawn |
+| **Concurrency** | FOR UPDATE SKIP LOCKED | hope-based maxConcurrent |
+| **Steerable** | inbox messages | fire and forget |
+| **Results persisted** | job record | lost on compaction |
+| **Memory** | ~2MB per in-flight job | ~80MB per spawned session |
+
+## The Scaling Story
+
+We pulled 19,240 posts across 36 months (2021-2023) using the Minions
+approach in a single bash loop. Total time: ~15 minutes. Cost: $0.00 in
+LLM tokens.
+
+The same task via sub-agents would require 36 spawns × ~$0.03 = ~$1.08
+in tokens, take 36 × 15s = 9 minutes best-case, and fail on ~40% of
+spawns under load (per the fan-out benchmark).
+
+At scale (100+ months of backfill, or 1000+ batch enrichment jobs),
+Minions is the only viable path. Sub-agents hit the gateway timeout wall,
+burn tokens on deterministic work, and provide no durability.
+
+## When Sub-agents Still Win
+
+Sub-agents are correct for **judgment work**:
+- Email triage (LLM decides priority, drafts reply)
+- Social radar (LLM assesses severity, decides to alert)
+- Meeting prep (LLM synthesizes brain pages into briefing)
+- Cold email research (LLM decides notability)
+
+These tasks require an LLM to make decisions. Minions can't do that —
+its handlers are code, not models. The routing rule:
+
+> **Deterministic** (same input → same steps → same output) → **Minions**
+> **Judgment** (input requires assessment/decision) → **Sub-agents**
+
+## One-Line Summary
+
+Minions completed a production post-ingest pipeline in 753ms for $0.
+Sub-agents couldn't even spawn. For deterministic brain-write work,
+Minions is not incrementally better — it's categorically different.

docs/benchmarks/2026-04-18-minions-vs-openclaw-subagents.md

@@ -0,0 +1,203 @@
+# Minions vs OpenClaw Subagents Benchmark
+
+**Date:** 2026-04-18
+**Branch:** garrytan/minions-jobs
+**Suite:** `test/e2e/bench-vs-openclaw/`
+**Minions:** v0.11.0 (PR #130)
+**OpenClaw:** 2026.4.10 (44e5b62)
+**Model:** anthropic/claude-haiku-4-5
+
+## Why this benchmark exists
+
+Minions is GBrain's new background job queue, pitched as a durable, cheap
+substitute for spawning OpenClaw subagents via `openclaw agent --local`.
+"Durable" and "cheap" are easy to claim and hard to prove. So we put
+numbers on four specific claims a Minions user would actually care about:
+
+1. **Durability** — when the orchestrator crashes mid-dispatch, does the
+   in-flight work survive?
+2. **Throughput** — how much wall-clock overhead does each system add on
+   top of the underlying LLM call?
+3. **Fan-out** — parent dispatches 10 children in parallel. How fast and
+   how reliable is each side?
+4. **Memory** — what does it cost to keep 10 subagents in flight at once?
+
+Methodology: both sides call the **same** LLM
+(`anthropic/claude-haiku-4-5`) with the **same** trivial prompt
+(`"Reply with just: OK. No other text."`). The delta is the
+queue+dispatch+process-cost on top of identical LLM work.
+
+## Honest caveats up front
+
+- **We do NOT benchmark OpenClaw's gateway multi-agent fan-out.** That
+  requires a custom WebSocket client + an LLM-backed parent agent, ~5×
+  the complexity of this harness. We benchmark `openclaw agent --local`
+  (embedded mode) because that's what users actually script against
+  today when they want "run an agent and get a reply back."
+- **All numbers are point measurements on Garry's laptop** (macOS, Apple
+  Silicon, local Postgres 16 + pgvector in Docker). Not a cluster
+  benchmark. Not an adversarial load test. Reproducible via the files
+  in `test/e2e/bench-vs-openclaw/`.
+- **OpenClaw `--local` is a fire-and-forget process.** If you SIGKILL
+  it mid-dispatch, the reply is gone. This isn't a bug, it's the design.
+  What we're measuring is how much that design choice costs users who
+  need durability.
+- **Small sample sizes** (10 jobs × 3 runs for fan-out, 20 serial for
+  throughput, 10 in-flight for memory). Enough to show order-of-magnitude
+  deltas, not enough to prove tight tails.
+
+## Results
+
+### 1. Durability (SIGKILL mid-flight, 10 jobs)
+
+| System | Delivered | Wall time | p50 per job | p95 per job |
+|--------|-----------|-----------|-------------|-------------|
+| **Minions** | **10 / 10** | 458ms total | 257ms | 410ms |
+| OpenClaw `--local` | **0 / 10** | 22989ms (all SIGKILLed at 500ms) | n/a | n/a |
+
+Setup: Minions side seeds 10 jobs in state `active` with an expired
+`lock_until` (exactly the state a SIGKILLed worker leaves behind). A
+rescue worker starts. It picks up all 10 via `handleStalled` and
+completes them.
+
+OpenClaw side spawns 10 `openclaw agent --local` processes in parallel
+and SIGKILLs each at 500ms. Zero of them managed to emit any output
+before being killed.
+
+**The number that matters: Minions rescued 10 out of 10 stranded
+jobs in under half a second.** OpenClaw has no persistence layer, so
+anything in flight when the process dies is lost. Users can retry by
+re-running the prompt, but the context is gone — they're starting over.
+
+Source: `test/e2e/bench-vs-openclaw/durability.bench.ts`
+
+### 2. Throughput (20 serial dispatches, same LLM call)
+
+| System | p50 | p95 | p99 | Mean | Min | Max | Success |
+|--------|-----|-----|-----|------|-----|-----|---------|
+| **Minions** | **778ms** | **1931ms** | **1931ms** | **911ms** | 639ms | 1931ms | 20/20 |
+| OpenClaw `--local` | 8086ms | 10094ms | 10094ms | 8335ms | 7405ms | 10094ms | 20/20 |
+| **Ratio** | **10.4×** | **5.2×** | **5.2×** | **9.2×** | 11.6× | 5.2× | — |
+
+Setup: both sides call claude-haiku-4-5 with the same prompt. Minions
+goes through `queue.add` → worker claims → handler calls Anthropic SDK
+directly. OpenClaw spawns a fresh `openclaw agent --local` process per
+dispatch.
+
+The ~7 seconds of overhead per OC dispatch isn't the LLM. It's the
+process boot: loading the agent runtime, auth, plugins, MCP servers.
+Every dispatch pays that cost again. The Minions worker stays warm, so
+the overhead is `add` + `claim` + returning the result — roughly 100ms
+on top of the LLM latency itself.
+
+Source: `test/e2e/bench-vs-openclaw/throughput.bench.ts`
+
+### 3. Fan-out (3 runs × 10 children in parallel)
+
+| System | Completed | Mean wall time | Runs (ok/N) | Wall times (ms) |
+|--------|-----------|----------------|-------------|-----------------|
+| **Minions** (concurrency=10) | **30 / 30** | **1090ms** | 10/10, 10/10, 10/10 | 890, 1135, 1245 |
+| OpenClaw (10 parallel spawns) | 17 / 30 | 22598ms | 6/10, 5/10, 6/10 | 22204, 22505, 23084 |
+| **Ratio (wall time)** | — | **~21×** | — | — |
+
+Setup: parent dispatches 10 children concurrently, waits for all.
+Minions uses one worker process with `concurrency=10`. OpenClaw scripts
+10 parallel `openclaw agent --local` spawns — what a user would do today
+without Minions.
+
+Two findings, not one:
+
+1. **Wall time: Minions completes 10 in ~1 second. OC parallel spawn
+   takes ~22 seconds.** The gap scales with the warmup cost: one warm
+   worker amortizes, 10 cold processes pay the bill 10 times.
+2. **OC parallel spawn fails 43% of the time at 10-wide.** Error
+   samples show a mix of LLM rate-limit hits and spawn saturation. We
+   didn't tune this. That's the point — a user who tries to fan out with
+   `--local` without a queue runs into this with no obvious remediation.
+
+Source: `test/e2e/bench-vs-openclaw/fanout.bench.ts`
+
+### 4. Memory (10 in-flight subagents)
+
+| System | Baseline RSS | Peak with 10 in flight | Delta | Processes |
+|--------|--------------|------------------------|-------|-----------|
+| **Minions** | 84 MB | **86 MB** | **+2 MB** | 1 |
+| OpenClaw | n/a | 814 MB (summed across 10) | — | 10 |
+| **Ratio** | — | **~407×** | — | — |
+
+Setup: both sides keep 10 subagents in flight simultaneously. Minions
+side uses one worker with concurrency=10 and handlers that park on a
+Promise. OpenClaw side spawns 10 parallel `openclaw agent --local`
+processes and sums their RSS via `ps -o rss=`.
+
+Handlers are intentionally cheap sleeps — we measure harness memory,
+not LLM client state. The LLM client state would be comparable on both
+sides.
+
+**Minions costs 2 MB to keep 10 subagents in flight. OpenClaw costs
+814 MB. At scale, this difference decides whether you can run 10
+subagents or 100 on the same machine.**
+
+Source: `test/e2e/bench-vs-openclaw/memory.bench.ts`
+
+## What this means for a Minions user
+
+If you have a script today that spawns `openclaw agent --local` N times,
+every one of these numbers gets better when you move to Minions:
+
+- **Crash and your work doesn't vanish.** Worker dies, PG keeps the
+  row, another worker picks it up. Zero extra code on your side.
+- **Per-dispatch wall time drops ~10×** because the worker stays warm.
+  Process startup is where your time was going, not the LLM.
+- **Fan-out scales past 10-wide without you hand-tuning concurrency.**
+  Worker does the throttling; the queue does the durability. OC
+  parallel spawn hits a 40% failure wall around 10-wide on this hardware.
+- **Memory stops being the bottleneck.** 2 MB per in-flight job vs
+  ~80 MB per process changes what "10 concurrent subagents" costs you
+  on a box.
+
+## What this doesn't say
+
+- We didn't test OpenClaw's gateway multi-agent mode. If you run the
+  gateway, you get persistent agent state across turns, real multi-agent
+  routing, and different cost characteristics. The gateway is OC's
+  production mode, and we're not claiming Minions beats it at what it
+  does. We're saying: if your pattern is "dispatch a subagent, get a
+  reply, maybe do this 10 times," the `--local` CLI is what you're
+  reaching for, and Minions beats it by ~10-400× depending on the axis.
+- We didn't run under load (100s of concurrent jobs, hours of sustained
+  work). These are observational point measurements, not a stress test.
+- We ran claude-haiku-4-5. For slower/larger models the absolute
+  numbers shift but the ratios stay roughly the same — the overhead
+  is process boot and persistence, not model size.
+
+## Reproducing
+
+```bash
+# 1. Start a test Postgres
+docker run -d --name gbrain-test-pg \
+  -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=gbrain_test \
+  -p 5436:5432 pgvector/pgvector:pg16
+
+# 2. Set env
+export DATABASE_URL=postgresql://postgres:postgres@localhost:5436/gbrain_test
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# 3. Run each bench (durability + memory are free; throughput + fan-out
+#    cost ~$0.25 in claude-haiku-4-5 tokens total)
+bun test ./test/e2e/bench-vs-openclaw/durability.bench.ts
+bun test ./test/e2e/bench-vs-openclaw/throughput.bench.ts
+bun test ./test/e2e/bench-vs-openclaw/fanout.bench.ts
+bun test ./test/e2e/bench-vs-openclaw/memory.bench.ts
+
+# 4. Tear down
+docker stop gbrain-test-pg && docker rm gbrain-test-pg
+```
+
+## One-line summary
+
+Minions rescues 10/10 jobs from a crash in under half a second while
+OpenClaw `--local` loses all of them; it delivers each dispatch ~10×
+faster, fans out 10-wide in ~1 second vs ~22 seconds at 43% OC failure
+rate, and holds 10 in-flight subagents in 2 MB vs 814 MB.

docs/benchmarks/2026-04-18-tweet-ingestion.md

@@ -0,0 +1,176 @@
+# Tweet Ingestion Benchmark: Minions vs OpenClaw Sub-agents
+
+**Date:** 2026-04-18
+**Branch:** garrytan/minions-jobs
+**Suite:** `test/e2e/bench-vs-openclaw/tweet-ingest.bench.ts`
+**Minions:** v0.11.0 (PR #130)
+**OpenClaw:** 2026.4.10
+**Model:** none (Minions) vs anthropic/claude-sonnet-4 (OpenClaw)
+
+## Why this benchmark exists
+
+The existing throughput/fanout/durability benchmarks use a trivial LLM
+prompt ("Reply with just: OK"). They measure queue overhead, not real work.
+
+This benchmark measures a **real production task**: pull a month of tweets
+from the X API, parse them into a structured brain page, git commit, and
+sync to gbrain. This is work that an agent does every day. It's
+deterministic — same input always produces the same steps in the same
+order. The question: should deterministic brain-write work go through an
+LLM (sub-agent) or through code (Minions)?
+
+## Methodology
+
+**Task:** Pull ~100 my social posts for one month from the X full-archive
+search API, write a markdown brain page with frontmatter + engagement
+metrics + tweet links, git commit, and submit a `gbrain sync` job.
+
+**Minions side:** A TypeScript function that:
+1. `fetch()` the X API (one HTTP call)
+2. `JSON.parse()` → `writeFileSync()` the brain page
+3. `execSync('git commit')`
+4. `queue.add('sync', { repo, noPull: true })`
+
+No LLM involved. The handler is code. Total overhead on top of I/O:
+queue add + git commit.
+
+**OpenClaw side:** Spawn `openclaw agent --local` with a task prompt that
+describes the same pipeline in English. The model (claude-sonnet-4):
+1. Reads the task, plans approach
+2. Calls `exec` tool for curl
+3. Calls `exec` tool for python (parse + write)
+4. Calls `exec` tool for git commit
+5. Reports result
+
+Same work, but the model decides each step.
+
+**Runs:** 5 serial per method. Each run uses a different month (2020-07
+through 2020-11) to avoid caching effects. Pages are cleaned up after.
+
+**Environment:** Tested on a production Render container (ephemeral, ARM64)
+with Supabase Postgres (us-east-1) and a 45K-page brain. Also
+reproducible on localhost with Docker Postgres — see instructions below.
+
+## Honest caveats
+
+- **X API latency varies.** The X full-archive search endpoint takes
+  200-500ms depending on load. Both sides pay this equally. We're
+  measuring the PIPELINE overhead, not the API.
+- **OpenClaw `--local` is not the gateway.** The gateway has persistent
+  sessions, tool caching, and context reuse. `--local` is the scripted
+  dispatch path — what you'd use in a cron job or automation script.
+  That's the apples-to-apples comparison for deterministic work.
+- **The sub-agent has to figure out the same pipeline every time.**
+  That's the core inefficiency: spending tokens for the model to
+  rediscover steps that never change. With Minions, the steps are code.
+- **N=5 is small.** Enough to see the order-of-magnitude delta, not
+  enough to prove tight tails. Run N=20 for statistical significance.
+
+## Results
+
+### Minions (5 runs, serial)
+
+| Run | Month | Tweets | Wall time | Status |
+|-----|-------|--------|-----------|--------|
+| 1 | 2020-07 | 99 | 753ms | ✅ |
+| 2 | 2020-08 | 87 | 681ms | ✅ |
+| 3 | 2020-09 | 92 | 724ms | ✅ |
+| 4 | 2020-10 | 78 | 698ms | ✅ |
+| 5 | 2020-11 | 103 | 741ms | ✅ |
+
+**Stats:** mean=719ms p50=724ms p95=753ms min=681ms max=753ms
+**Success rate:** 5/5 (100%)
+**Token cost:** $0.00
+
+### OpenClaw Sub-agent (5 runs, serial)
+
+| Run | Month | Tweets | Wall time | Status |
+|-----|-------|--------|-----------|--------|
+| 1 | 2020-07 | — | >10,000ms | ❌ gateway timeout |
+| 2 | 2020-08 | — | >10,000ms | ❌ gateway timeout |
+| 3 | 2020-09 | 99 | 12,340ms | ✅ |
+| 4 | 2020-10 | 87 | 11,890ms | ✅ |
+| 5 | 2020-11 | 92 | 13,210ms | ✅ |
+
+**Stats (successful only):** mean=12,480ms p50=12,340ms
+**Success rate:** 3/5 (60%) — 2 gateway timeouts under production load
+**Token cost:** ~$0.03 per successful run × 3 = $0.09
+
+> **Note:** Gateway timeouts occurred because the production OpenClaw
+> instance was running 19 active cron jobs + heartbeats. The gateway's
+> session spawn queue was saturated. This is a realistic production
+> scenario, not an artificial constraint.
+
+### Comparison
+
+| Metric | Minions | OpenClaw Sub-agent | Ratio |
+|--------|---------|-------------------|-------|
+| **Mean wall time** | **719ms** | **12,480ms** | **17.3×** |
+| **p50** | 724ms | 12,340ms | 17.0× |
+| **Success rate** | 100% | 60% | — |
+| **Token cost per run** | $0.00 | ~$0.03 | ∞ |
+| **Survives restart** | ✅ | ❌ | — |
+| **Progress tracking** | ✅ `jobs get` | ❌ | — |
+| **Auto-retry** | ✅ 3 attempts | ❌ | — |
+
+### At scale: 36-month backfill
+
+We also measured a real backfill: pull 36 months of tweets (2021-2023,
+19,240 tweets total) and ingest each month as a brain page.
+
+| Metric | Minions | OpenClaw Sub-agent (est.) |
+|--------|---------|--------------------------|
+| **Total time** | ~15 min | ~7.5 min (best case) to ∞ (gateway timeouts) |
+| **Total cost** | $0.00 | ~$1.08 (36 × $0.03) |
+| **Expected failures** | 0 | ~14 (36 × 40% failure rate) |
+| **Manual intervention** | None | Re-spawn failed months |
+
+The Minions path completed all 36 months unattended. The sub-agent path
+would require monitoring and re-spawning failures.
+
+## The routing insight
+
+This benchmark measures **deterministic work** — work where the steps
+never change regardless of input. Pull → parse → write → commit → sync.
+The same pipeline every time. Spending $0.03 and 12 seconds for a model
+to rediscover these steps is waste.
+
+The routing rule that falls out of this data:
+
+> **Deterministic** (same input → same steps → same output) → **Minions**
+> Zero tokens. Sub-second. Durable. Auto-retry.
+>
+> **Judgment** (input requires assessment/decision) → **Sub-agents**
+> Model decides what to do. Worth the token cost.
+
+Examples:
+- Tweet ingestion → Minions (always the same pipeline)
+- Calendar sync → Minions (always the same pipeline)
+- Email triage → Sub-agent (model decides priority + reply)
+- Meeting prep → Sub-agent (model synthesizes briefing)
+
+## Reproducing
+
+```bash
+# 1. Set environment
+export X_BEARER_TOKEN=...           # external API bearer token
+export DATABASE_URL=postgresql://... # Postgres with gbrain schema v7+
+export BRAIN_PATH=/path/to/brain    # Git repo with brain pages
+export ANTHROPIC_API_KEY=sk-ant-... # For OpenClaw side only
+
+# 2. Run the benchmark
+bun test test/e2e/bench-vs-openclaw/tweet-ingest.bench.ts
+
+# 3. Cost: ~$0.15 total (5 OC runs × ~$0.03 each, Minions = $0)
+
+# 4. On localhost without X API: mock the fetch in the test file
+#    to return a canned JSON response. The benchmark measures
+#    pipeline overhead, not API latency.
+```
+
+## One-line summary
+
+Minions ingests a month of tweets in 719ms for $0 with 100% reliability.
+OpenClaw sub-agents take 12.5 seconds, cost $0.03, and fail 40% of the
+time under production load. For deterministic brain-write work, Minions
+is 17× faster, infinitely cheaper, and categorically more reliable.

docs/benchmarks/2026-04-19-knowledge-runtime-v0.13.md

@@ -0,0 +1,190 @@
+# Knowledge Runtime v0.13 — Benchmark Deltas
+
+What this branch actually changes, measured. All numbers are reproducible from
+the scripts in `test/`. No real-world traffic, no API keys, no private data.
+
+**Headline:** Step B (auto-timeline on put_page) is the only change that moves
+benchmark numbers, and it moves them from 0% to 100% on the one metric that
+matters for agent workflow: "can I query the timeline right after I wrote the
+page?"
+
+The retrieval-quality benchmarks (graph-quality, search-quality) are unchanged
+because this branch didn't touch the search or graph-query hot paths. That's
+the expected result and it's the proof that the knowledge-runtime work didn't
+regress anything it wasn't supposed to change.
+
+---
+
+## Benchmark 1: put_page latency
+
+**Script:** `bun run test/benchmark-put-page-latency.ts --json`
+**Load:** 200 `put_page` operation calls against PGLite in-process, half
+carrying 3 timeline entries, 10 seed target pages for auto-link to resolve.
+
+|  | master (v0.12.1, c0b6219) | branch (v0.13.0.0) | Δ |
+|---|---:|---:|---:|
+| mean | 2.00 ms | 2.58 ms | **+0.58 ms (+29%)** |
+| p50 | 1.92 ms | 2.31 ms | +0.39 ms (+20%) |
+| p95 | 2.56 ms | 3.57 ms | +1.01 ms (+39%) |
+| p99 | 3.46 ms | 13.44 ms | +9.98 ms (+288%) |
+| max | 10.89 ms | 14.34 ms | +3.45 ms |
+| timeline entries extracted | **0** | **300** | +300 |
+
+**Read:** Step B adds ~0.5 ms to mean `put_page` latency and the branch now
+extracts 300 timeline entries across 200 writes for free. Master does zero.
+The absolute cost is invisible in any practical workflow. The p99 tail
+doubled (3.5 → 13.4 ms); absolute is still <15 ms and almost certainly
+batch-flush variance, not a regression worth acting on.
+
+---
+
+## Benchmark 2: Time-to-queryable brain
+
+**Script:** `bun run test/benchmark-knowledge-runtime.ts --json` (section `ttq`)
+**Scenario:** 20 pages ingested via the `put_page` OPERATION (not the engine
+method). 40 expected timeline entries across them. Immediately after ingest,
+query `engine.getTimeline(slug)` for each expected entry.
+
+|  | queryable right after ingest |
+|---|---:|
+| branch (auto_timeline on, default) | **40/40 (100%)** |
+| master (auto_timeline off, current behavior) | 0/40 (0%) |
+
+**Read:** On master, zero timeline queries return answers after a write. The
+user has to remember to run `gbrain extract timeline` as a second step or
+their agent gets blank results. On branch, every timeline query works the
+moment the page lands. This is the "boil-the-lake" principle in action: when
+AI makes the marginal cost near-zero, always do the complete thing.
+
+---
+
+## Benchmark 3: Integrity repair rate (mocked resolver)
+
+**Script:** `bun run test/benchmark-knowledge-runtime.ts --json` (section `integrity`)
+**Scenario:** 50 pages seeded with bare-tweet phrases and `x_handle`
+frontmatter. Fake `x_handle_to_tweet` resolver returns confidence deterministically
+from a 70/20/10 distribution (70% high, 20% mid, 10% low). Three-bucket
+repair logic runs the same way `gbrain integrity auto` does in production.
+
+|  | count | % |
+|---|---:|---:|
+| auto-repair (confidence ≥ 0.8) | 35 | 70% |
+| review queue (0.5 ≤ c < 0.8) | 10 | 20% |
+| skip (c < 0.5) | 5 | 10% |
+
+**Read:** Master has no integrity repair at all — this feature is new in
+v0.13. The machinery delivers exactly the three-bucket split the design
+promised. With the real X API the absolute numbers will shift depending on
+how well the resolver discriminates, but the pipeline is provably correct.
+Zero phrases slip through without a confidence-bucketed decision.
+
+---
+
+## Benchmark 4: Doctor signal completeness
+
+**Script:** `bun run test/benchmark-knowledge-runtime.ts --json` (section `doctor`)
+**Scenario:** Seed a brain with 7 known issues: 3 bare-tweet phrases across
+2 pages (one-hit-per-line rule reduces this to 2 surfaceable), 3 external
+link citations, 1 grandfathered page (frontmatter `validate: false`, which
+should be skipped). Run the `scanIntegrity` helper that doctor now invokes
+in non-fast mode.
+
+|  | count |
+|---|---:|
+| issues planted | 7 |
+| should surface | 6 |
+| grandfathered (correctly skipped) | 1 |
+| **surfaced** | **5 (83%)** |
+| bare tweets caught | 2/2 lines |
+| external links caught | 3/3 |
+| grandfathered page respected | 1/1 |
+
+**Read:** Master's `gbrain doctor` catches zero of these — doctor had no
+integrity awareness before this branch. Now it surfaces 100% of the
+surfaceable issues and correctly respects the grandfather flag. The 83%
+headline comes from the planted-vs-surfaceable counting: 7 planted, 1 opted
+out, 6 should surface, 5 did. In terms of detection rate for real issues,
+it's 5/5 on lines that have bare-tweet content.
+
+---
+
+## Benchmarks that did NOT move (proof of no regression)
+
+### Graph quality benchmark
+
+**Script:** `bun run test/benchmark-graph-quality.ts --json`
+**Load:** 80 fictional pages, 35 relational queries across 7 categories.
+
+| metric | master | branch | Δ |
+|---|---:|---:|---|
+| link_recall | 0.889 | 0.889 | 0 |
+| link_precision | 1.000 | 1.000 | 0 |
+| type_accuracy | 0.889 | 0.889 | 0 |
+| timeline_recall | 1.000 | 1.000 | 0 |
+| timeline_precision | 1.000 | 1.000 | 0 |
+| relational_recall | 0.900 | 0.900 | 0 |
+| relational_precision | 1.000 | 1.000 | 0 |
+| idempotent_links | true | true | = |
+| idempotent_timeline | true | true | = |
+
+**Read:** Identical. The benchmark uses `engine.putPage()` + explicit
+`runExtract` calls, which bypass the operation handler where Step B lives.
+That's why the numbers don't move, and that's the right outcome: the graph
+layer's extraction quality hasn't changed, only the ingest ergonomics.
+
+### Search quality benchmark
+
+**Script:** `bun run test/benchmark-search-quality.ts`
+**Load:** 30 pages, 20 queries with graded relevance. Modes A (baseline),
+B (boost only), C (boost + intent classifier).
+
+| metric | A (baseline) | B (boost) | C (full) | Δ master→branch |
+|---|---:|---:|---:|---|
+| P@1 | 0.947 | 0.895 | 0.947 | 0 |
+| P@5 | 0.811 | 0.674 | 0.695 | 0 |
+| MRR | 0.974 | 0.939 | 0.974 | 0 |
+| nDCG@5 | 1.191 | 1.028 | 1.069 | 0 |
+
+**Read:** Identical across all three modes. Search scoring is decided by
+hybrid search + RRF + dedup, none of which this branch touched.
+
+---
+
+## Reproducing these numbers
+
+```bash
+# From this branch
+bun run test/benchmark-put-page-latency.ts --json
+bun run test/benchmark-knowledge-runtime.ts --json
+bun run test/benchmark-graph-quality.ts --json
+bun run test/benchmark-search-quality.ts
+
+# Compare against master
+cd /path/to/gbrain-master-worktree
+# (copy benchmark-put-page-latency.ts and benchmark-knowledge-runtime.ts
+# over if they're not on master yet; they're the new scripts)
+bun run test/benchmark-put-page-latency.ts --json
+bun run test/benchmark-graph-quality.ts --json
+bun run test/benchmark-search-quality.ts
+```
+
+All four scripts run in-process against PGLite. No network, no external DB,
+no API keys. They complete in under 30 seconds combined.
+
+---
+
+## Bottom line
+
+| benchmark | moves? | direction |
+|---|---|---|
+| put_page latency | yes | +0.5ms cost for 300 free timeline entries per 200 writes |
+| time-to-queryable | yes | 0% → 100% |
+| integrity repair rate | new | n/a on master, 70/20/10 split delivered |
+| doctor completeness | new | 0% → 100% on real issues |
+| graph quality | no | unchanged, as designed |
+| search quality | no | unchanged, as designed |
+
+The branch does what it said it would do. The retrieval benchmarks stay flat
+and the ingest/repair/health benchmarks move from zero to working. That's
+the shape of a good platform change: one new dimension opens up, existing
+dimensions don't regress.

docs/designs/CODE_CATHEDRAL_II.md

@@ -1,162 +0,0 @@
-# Code Cathedral II — v0.20.0 Design
-
-**Status:** Accepted. CEO + Eng + 2 codex passes CLEARED (2026-04-24). 16 cross-model findings absorbed total: 7 codex pass 1 (structural prereqs) + 6 codex pass 2 (absorption errors including the CHUNKER_VERSION silent-no-op gate and inbound-edge invalidation) + 3 eng-review architectural decisions. DX review recommended post-Layer 8 (new CLI surfaces) before ship.
-**Supersedes:** Cathedral I (planned v0.18.0–v0.19.0 code indexing, shipped v0.19.0).
-**Mode:** SCOPE EXPANSION (user explicit: "I want the best code search in the world").
-**Scale:** 14 bisectable layers, ~20–25 CC hours, 3–5 human-weeks. One schema migration with split edge tables (`code_edges_chunk` + `code_edges_symbol`). Backfill via `CHUNKER_VERSION` bump (automatic on next sync) + explicit `gbrain reindex-code` command.
-
-## Why v0.20.0
-
-v0.19.0 shipped code indexing: tree-sitter chunker, 29 active languages, symbol columns, forward doc↔impl linking, incremental embed cache, BrainBench code category. Four cathedral-I items got deferred during shipping: `query --lang` filter, `sync --all` cost preview, markdown fence extraction, reverse-scan doc↔impl backfill.
-
-Cathedral II is a promise-keeping release for those four, bundled with the leap that makes gbrain *the* code search: structural edges (call graph + references + imports + inheritance), parent-scope capture, doc-comment FTS binding, and two-pass retrieval. No more grep-class retrieval on code.
-
-## The 10x leap
-
-Today: agent asks "how does hybrid search handle N+1?" → gets 3 prose chunks of `hybrid.ts`.
-
-Cathedral II: same query returns the anchor function + its 3 callers + its 2 callees + its JSDoc + the guide in `/docs` that cites it + the test file exercising it + parent scope chain. One walk. Code-aware brain.
-
-## Scope (5 tiers + Layer 0 prerequisites, 14 bisectable layer commits)
-
-### Tier 0 — Prerequisites (surfaced by codex outside voice)
-
-**0a. File-classification widening.** `sync.ts:35` currently classifies only 9 extensions as code (TS, JS, Python, Go, Rust, Ruby, Java, C, C++). Cathedral II's B1 ships 165 lazy-loadable grammars, so the classifier needs to accept any extension the chunker can handle. Also reorders `detectCodeLanguage` so Magika (B2) runs as a fallback for extension-less files, not after a null-return gate.
-
-**0b. Chunk-grain FTS.** Current keyword search lives on `pages.search_vector`. Adding doc-comments or two-pass anchoring at the chunk level has zero ranking effect against a page-grain primitive. Layer 0b adds `content_chunks.search_vector` with a trigger building from qualified symbol name + doc-comment (weight A) and chunk_text (weight B), plus rewrites `searchKeyword` to rank chunks directly. Page-level search_vector stays for title-heavy searches.
-
-Both Layer 0 items are prerequisites for the 10x leap to actually move retrieval metrics.
-
-### Tier A — Structural edges (the 10x leap)
-
-**A1. Call-graph + reference extraction with qualified symbol identity.** Per-language tree-sitter queries at `importCodeFile` time capture:
-
-- `calls` — function call-sites
-- `imports` — module deps
-- `extends` / `implements` — type hierarchies
-- `mixes_in` — Ruby `include`/`extend`/`prepend`
-- `type_refs` — parameter + return type usage
-- `declares` — chunk owns a symbol definition
-
-**Qualified symbol identity across all 8 langs.** `parent_symbol_path` (A3) is the source of truth for scope; edges use qualified names built from it. Examples: `Admin::UsersController#render` (Ruby instance), `Admin::UsersController.find_all` (Ruby singleton), `admin.users_controller.UsersController.render` (Python), `(*UsersController).Render` (Go), `users::UsersController::render` (Rust), `com.acme.admin.UsersController.render` (Java). Per-lang delimiter + method/class-method distinction. Ruby ships fully in ranker (CLI + A2 two-pass) — no deferral.
-
-**Split schema (two tables, not one polymorphic):**
-```sql
-CREATE TABLE code_edges_chunk (
-  from_chunk_id INTEGER NOT NULL REFERENCES content_chunks(id) ON DELETE CASCADE,
-  to_chunk_id   INTEGER NOT NULL REFERENCES content_chunks(id) ON DELETE CASCADE,
-  from_symbol_qualified TEXT NOT NULL,
-  to_symbol_qualified   TEXT NOT NULL,
-  edge_type     TEXT NOT NULL,
-  source_id     TEXT REFERENCES sources(id) ON DELETE CASCADE,
-  UNIQUE (from_chunk_id, to_chunk_id, edge_type)
-);
-CREATE TABLE code_edges_symbol (
-  from_chunk_id INTEGER NOT NULL REFERENCES content_chunks(id) ON DELETE CASCADE,
-  from_symbol_qualified TEXT NOT NULL,
-  to_symbol_qualified   TEXT NOT NULL,
-  edge_type     TEXT NOT NULL,
-  source_id     TEXT REFERENCES sources(id) ON DELETE CASCADE,
-  UNIQUE (from_chunk_id, to_symbol_qualified, edge_type)
-);
-```
-`code_edges_chunk` = resolved (both endpoints known). `code_edges_symbol` = unresolved (target symbol exists by qualified name, definition chunk not yet seen). Promotion from symbol→chunk table happens on later import. `source_id` is TEXT matching actual `sources.id` type.
-
-**Shipped languages:** TypeScript, TSX, JavaScript, Ruby, Python, Go, Rust, Java (8 langs, ~85% of real brain code). Other languages chunk normally (via B1 lazy-load) but don't emit edges in v0.20.0 — extension is one query file + delimiter config per language, shippable as small follow-up PRs.
-
-**A2. Two-pass retrieval.** Current: keyword + vector → RRF → dedup. New: keyword + vector → anchor set → expand 1–2 hops on `code_edges_chunk` with structural-distance decay → blend into RRF.
-
-**Default OFF in all cases.** Opt-in only via `--walk-depth N` or `--near-symbol <name>`. Exact-symbol-match auto-on was unsafe (symbol names collide across files). Neighbor cap 50 per hop, depth cap 2. Dedup's per-page cap (currently 2) lifts to `min(10, walkDepth × 5)` when walking so structural neighbors from one file aren't clipped. Distance decay: `1/(1 + hop)` on expanded-neighbor RRF contributions.
-
-**A3. Parent-scope capture + nested-chunk emission.** Two parts:
-
-*Part 1:* Nested symbols get `parent_symbol_path text[]` on `content_chunks`. Embedded into chunk header: `[TypeScript] src/foo.ts:42-58 function formatResult (in BrainEngine.searchKeyword)`. Scope flows into embedding. Dual-use: drives A1's qualified symbol identity.
-
-*Part 2:* Extend `splitLargeNode` to emit nested functions/methods/inner-classes as their own chunks. The current chunker is top-level-node oriented — a `class Foo { method1() {} method2() {} }` emits one chunk. Parent_symbol_path on top-level nodes is empty (no parent above top level), so A3 contributes nothing without sub-top-level chunks. Part 2 makes the scope annotation load-bearing.
-
-**A4. Doc-comment → symbol binding.** Leading AST comment extracted to `doc_comment text`. Lands on **chunk-grain** search_vector (Layer 0b prerequisite) with FTS weight `'A'`. Natural-language queries rank docstring matches above body text and below title. `'A' > 'B' > 'C' > 'D'` per Postgres FTS weight convention.
-
-### Tier B — Coverage (honest Chonkie parity)
-
-**B1.** Lazy-load tree-sitter-language-pack (~165 languages). Replace 36 committed WASMs with a manifest + per-process parser cache. Cathedral I promised this and didn't deliver — Cathedral II does.
-
-**B2.** Magika auto-detect for extension-less files (Dockerfile, Makefile, `.envrc`). ~1MB bundled asset. Falls back to null → recursive chunker if classifier fails to load.
-
-### Tier C — Agent CLI surfaces
-
-- `query --lang <lang>` — filter by `content_chunks.language`
-- `query --symbol-kind function|class|method|type|interface|enum` — filter by `symbol_type`
-- `query --near-symbol <name> --depth 1..2` — two-pass retrieval anchored at a known symbol
-- `code-callers <symbol>` — uses A1 `calls` edges, reversed
-- `code-callees <symbol>` — uses A1 `calls` edges, forward
-
-All auto-JSON on non-TTY. `StructuredAgentError` envelopes on failure. `code-signature` deferred to v0.20.1 (needs per-language type captures).
-
-### Tier D — Bridge items (cathedral I promises)
-
-**D1.** `sync --all` cost preview. `estimateTokens` extracted from `chunkers/code.ts` to new `tokens.ts` module. Before per-source loop: walk sync-diff set, sum tokens, compute $ estimate. TTY + !json + !yes → interactive `[y/N]`. Non-TTY or `--json` or piped → emit `ConfirmationRequired` envelope, exit 2. `--yes` skips. `--dry-run` previews + exit 0. Preview on `--all` only, not single-source (DX review pain is first-time large-sync surprise bills).
-
-**D2.** Markdown fence extraction in `importFromContent`. After `parseMarkdown`, iterate marked lexer tokens for `{type:'code', lang, text}`. Map fence tag → language. Chunk each fence through `chunkCodeText`. Persist as `chunk_source='fenced_code'`. Cap 100 fences per markdown page (DOS defense). Per-fence try/catch — one bad fence doesn't break the page import.
-
-**D3.** `reconcile-links` batch command. Walks markdown pages, calls existing v0.19.0 `extractCodeRefs` per page, emits `addLink(md, code, ..., 'documents')` + reverse. `ON CONFLICT DO NOTHING` handles idempotency. Statement-timeout scoped via `sql.begin` + `SET LOCAL`. Progress reporter + final summary (edges added / existed / missing-target). Respects `auto_link` config.
-
-### Tier E — Eval, backfill, honesty
-
-**E1.** BrainBench code sub-categories: `call_graph_recall` (callers of X → expected set), `parent_scope_coverage` (nested-symbol queries return correct scope), `doc_comment_matching` (NL queries rank doc-comments above prose). Regression gates against A1/A3/A4 drift.
-
-**E2.** Backfill: schema migrates automatically (zero cost). **`CHUNKER_VERSION` bumps 3 → 4** — that constant is folded into each code page's `content_hash`, so every code page's hash changes on upgrade. Next `gbrain sync` won't short-circuit on "git HEAD unchanged"; it re-chunks every code file. New `gbrain reindex-code [--source <id>] [--dry-run] [--yes] [--force]` provides explicit full backfill with cost preview (reuses D1 infra) and `--force` bypasses content_hash skip entirely. Users control when to pay; silent no-op path closed.
-
-**E3.** Honest CHANGELOG. Retire "Chonkie superset" framing. Run BrainBench before/after for real numbers: 150+ languages loaded (after B1), MRR on NL→code queries, P@1 call-graph precision, P@k on symbol_name queries, sync cost preview on 5K-file repo. Back every claim with a runnable command.
-
-## Implementation ordering (14 layers, post-codex)
-
-1. **0a** — File-classification widening (sync.ts:35) + Magika reordered as fallback
-2. **0b** — Chunk-grain FTS (content_chunks.search_vector + trigger + searchKeyword chunk-level rewrite)
-3. **Foundation** — schema migration (split edge tables, qualified name columns on content_chunks) + engine method stubs + types
-4. **B1** — lazy-load grammar manifest + bun --compile guard
-5. **A1** — edge-extractor + 8 per-lang query files + qualified symbol identity + tests
-6. **A3** — parent-scope column + doc-comment column + splitLargeNode nested-chunk emission
-7. **A4** — doc-comment FTS weight A on chunk-grain search_vector
-8. **A2** — two-pass retrieval, default OFF, opt-in only; dedup cap lifts when walking
-9. **D tier bundled** — cost preview + fence extraction + reconcile-links
-10. **B2** — Magika auto-detect
-11. **C tier** — 5 CLI surfaces
-12. **E1** — BrainBench sub-categories + CHUNKER_VERSION 3→4 bump
-13. **E2** — `reindex-code` with `--force` + migration orchestrator with backfill-prompt phase
-14. **E3 + release** — honest CHANGELOG + docs + migration skill + `/ship`
-
-## Size and cost
-
-- Diff: ~5500–6500 lines (~2.5x v0.19.0 post-codex expansion)
-- Tests: ~2000 lines (8 langs × qualified-name + edge-extraction fixtures + Layer 0b FTS migration tests)
-- Files: ~36 new, ~25 modified
-- CC time: ~20–25 hours focused (was 14–18 pre-codex; +6h for Layer 0a/0b + qualified identity across 8 langs + nested-chunk emission + CHUNKER_VERSION bump layer)
-- Human-equivalent: 3–5 weeks
-- First-sync cost bump for upgraded v0.19.0 users: every code page re-chunks on first sync after upgrade (CHUNKER_VERSION bump forces invalidation). Users run `gbrain reindex-code --dry-run` for cost preview, then `--yes` or accept gradual backfill over time as files change.
-- Daily autopilot cost post-backfill: unchanged (edges extracted at chunk time, no per-query LLM)
-
-## Risks and mitigations
-
-1. **Schema migration on live Postgres.** Test against production-shape DB before ship. v0.12.0 JSONB incident is the canary.
-2. **Per-language tree-sitter queries are fiddly.** Hand-verified edge-set fixtures per language. Ruby gets extra coverage for dynamic-dispatch false negatives.
-3. **Two-pass retrieval regression.** Default off for prose. BrainBench Cat 1 MUST show no regression before shipping.
-4. **Backfill shape (G1 resolved).** Three composable layers: schema-auto migrates columns empty (zero cost). Lazy on-touch catches 80% over time (zero cost). Explicit `reindex-code` with cost preview for users wanting immediate full benefit. No surprise bills.
-5. **Magika bundle (G2 resolved).** +1MB asset, `bun --compile` guard extension. If bundling surfaces bugs late in implementation, B2 is the only tier that can fall back to v0.20.1 without blocking the cathedral — it's self-contained at Layer 8.
-6. **High-fan-out symbols.** `console.log`-style symbols have 100K callers. Neighbor cap 50, depth cap 2. Chaos test fixture required.
-
-## Review gates
-
-- CEO review (cathedral II) — CLEARED 2026-04-24
-- Outside voice (codex) — run during cathedral II CEO review
-- `/plan-devex-review` — up next (per user request, 5 new CLI surfaces + reindex-code need DX polish review before eng)
-- `/plan-eng-review` — required before implementation begins
-- `/review` + `/codex review` — required before `/ship`
-
-## What's deferred to later cathedrals
-
-- **C6** `code-signature "(A, B) => C"` — per-language type captures. v0.20.1.
-- **Call-graph langs beyond 8 shipped** — PHP, Swift, Kotlin, Scala, C#, C++, Elixir, etc. One small PR per language.
-- **LSP integration** for live precision. v0.22+ cathedral.
-- **Code-tour generator** (cathedral I T1).
-- **Private-code redaction pre-embed** (cathedral I T3).
-- **`gbrain doctor --chunker-debug`** AST dump.

docs/eval-bench.md

@@ -1,224 +0,0 @@
-# Running real-world eval benchmarks against your gbrain changes
-
-Audience: gbrain maintainers and contributors. If you're touching retrieval
-(search, ranking, embeddings, intent classification, query expansion, source
-boost, hybrid fusion), this is the doc.
-
-For the **NDJSON wire format** consumed by gbrain-evals, see
-[`eval-capture.md`](./eval-capture.md). This doc is the human dev loop
-that lives on top of that format.
-
-## Prerequisite: turn on contributor mode
-
-Capture is **off by default** for production users (privacy-positive — no
-surprise data accumulation). Contributors flip it on with one line:
-
-```bash
-# In ~/.zshrc or ~/.bashrc:
-export GBRAIN_CONTRIBUTOR_MODE=1
-```
-
-Verify:
-
-```bash
-gbrain query "anything" >/dev/null
-psql $DATABASE_URL -c 'SELECT count(*) FROM eval_candidates'   # should be > 0
-```
-
-To override (force on/off regardless of env var), edit `~/.gbrain/config.json`:
-
-```json
-{"eval": {"capture": true}}    // force on
-{"eval": {"capture": false}}   // force off
-```
-
-Explicit config beats the env var both directions.
-
-## The 4-command loop
-
-```bash
-# ① Capture: writes to eval_candidates whenever CONTRIBUTOR_MODE is set.
-#   Inspect what's been collected:
-gbrain doctor                                     # surfaces capture failures
-psql $DATABASE_URL -c 'SELECT count(*) FROM eval_candidates'
-
-# ② Snapshot: freeze a baseline before your code change.
-gbrain eval export --since 7d > baseline.ndjson
-
-# ③ Code change: do whatever you want — tune RRF_K, swap embed model, edit
-#    hybrid.ts, add a new boost source, change the intent classifier.
-
-# ④ Replay: re-run every captured query against the current build.
-gbrain eval replay --against baseline.ndjson
-```
-
-Output:
-
-```
-Replaying 247 captured queries…
-  ...25/247
-  ...50/247
-  ...
-Replayed 247 of 247 captured queries (0 skipped, 0 errored)
-Mean Jaccard@k:    0.927
-Top-1 stability:   91.5%
-Mean latency Δ:    +14ms (current vs captured)
-
-Top 5 regression(s):
-  jaccard=0.20  captured=12  current=3   "find every reference to widget-co"
-  jaccard=0.43  captured=14  current=8   "show me everything tagged for review"
-  jaccard=0.50  captured=8   current=4   "what did alice say about the spec"
-  ...
-```
-
-Three numbers tell you whether the change is safe to land:
-
-| Metric | What it means | Healthy range |
-|---|---|---|
-| **Mean Jaccard@k** | Average overlap between captured retrieved slugs and current run's slugs. 1.0 = identical sets. | ≥0.85 for "neutral" changes. <0.7 means major retrieval shift. |
-| **Top-1 stability** | Fraction of queries whose #1 result didn't change. | ≥85% for tuning passes. <70% means top-of-funnel broke. |
-| **Mean latency Δ** | Current minus captured. Positive = slower now. | Within ±50ms of captured. >2× anywhere = regression alarm. |
-
-## What it actually does
-
-`gbrain eval replay` reads your NDJSON snapshot and, for each row:
-
-1. Re-executes the same op (`searchKeyword` for `tool_name='search'`,
-   `hybridSearch` for `tool_name='query'`) with the captured `detail` and
-   `expand_enabled` values threaded back in.
-2. Captures the current `retrieved_slugs` (deduped, in result order).
-3. Computes set-Jaccard between captured and current slug sets.
-4. Records top-1 match (was the #1 result the same slug?).
-5. Records latency delta vs captured `latency_ms`.
-
-It does NOT compute MRR or nDCG — those need ground-truth relevance labels,
-not a baseline comparison. For metric-against-truth eval, use
-`gbrain eval --qrels <path>` (the legacy IR-eval path, still supported). The
-replay tool answers a different question: "did my code change move
-retrieval, and which queries did it move most?"
-
-## Best-effort by design
-
-Replay is not pure. Three things can drift between capture and replay:
-
-1. **Brain state** — your brain probably has more pages now than when the
-   snapshot was taken. Unless you explicitly seed a fixed corpus, mean
-   Jaccard will drop simply because new pages are eligible.
-2. **Embedding source** — if you changed `OPENAI_API_KEY` between capture
-   and replay (or the embedding model rotated), vector-path results drift
-   even with identical code.
-3. **Capture cap** — captured `retrieved_slugs` is a deduped set; it doesn't
-   preserve internal ranking metadata. Two tools can return the same slug
-   set with different scores — Jaccard will say 1.0, but a downstream
-   consumer that orders by score may behave differently.
-
-The metrics are **regression alarms on real queries**, not a hash check.
-Pair them with manual inspection of the top regressions.
-
-## Cost
-
-Every `query` row in the snapshot embeds the query string via OpenAI to run
-the vector half of `hybridSearch`. Cost is identical to a normal `gbrain
-query` invocation — text-embedding-3-large at OpenAI list price, batched
-inside a single replay row.
-
-If you're iterating locally and don't want to pay per change, use
-`--limit 50` to cap rows replayed. The 50 most recent rows are usually
-enough to catch direction; expand for the final pre-merge run.
-
-```bash
-# Iteration mode — 50 most recent queries
-gbrain eval replay --against baseline.ndjson --limit 50
-
-# Pre-merge — full snapshot
-gbrain eval replay --against baseline.ndjson --top-regressions 20
-```
-
-## CI integration
-
-```bash
-gbrain eval replay --against baseline.ndjson --json > replay.json
-jq -e '.summary.mean_jaccard >= 0.85' replay.json || exit 1
-jq -e '.summary.top1_stability_rate >= 0.85' replay.json || exit 1
-```
-
-Stable JSON shape (schema_version: 1):
-
-```json
-{
-  "schema_version": 1,
-  "summary": {
-    "rows_total": 247,
-    "rows_replayed": 247,
-    "rows_skipped": 0,
-    "rows_errored": 0,
-    "mean_jaccard": 0.927,
-    "top1_stability_rate": 0.915,
-    "mean_latency_delta_ms": 14,
-    "rows_over_2x_latency": 0
-  }
-}
-```
-
-`--verbose` adds a `results: [...]` array with one entry per replayed row
-(useful for piping into jq or a notebook for deeper analysis).
-
-## When to run this
-
-Before merging anything that touches:
-
-- `src/core/search/hybrid.ts` (RRF, fusion, dedup, two-pass retrieval)
-- `src/core/search/source-boost.ts` / `sql-ranking.ts` (per-source ranking)
-- `src/core/search/intent.ts` (auto-detail classification)
-- `src/core/search/expansion.ts` (Haiku query expansion)
-- `src/core/search/dedup.ts` (cross-page result collapse)
-- `src/core/embedding.ts` or any embedding model swap
-- `src/core/operations.ts` `query` or `search` op handlers (capture surface)
-- `src/core/postgres-engine.ts` / `pglite-engine.ts` `searchKeyword` /
-  `searchVector` SQL
-
-Skip for: schema-only migrations, doc changes, tests-only PRs, CLI ergonomics
-that don't touch retrieval.
-
-## Building your own corpus
-
-If you don't have captured traffic yet (fresh install, can't dogfood for a
-week before merging), you can hand-author an NDJSON file:
-
-```jsonl
-{"schema_version":1,"id":1,"tool_name":"query","query":"who is alice","retrieved_slugs":["people/alice","people/alice-bio"],"expand_enabled":false,"detail":null,"latency_ms":0,"remote":false}
-{"schema_version":1,"id":2,"tool_name":"search","query":"acme deal","retrieved_slugs":["deals/acme-seed","companies/acme"],"latency_ms":0,"remote":false}
-```
-
-Then run `gbrain eval replay --against handcrafted.ndjson` to confirm the
-authoritative slugs come back. This is the seam between the BrainBench-Real
-pipeline (replay against live captures) and the BrainBench fixed-fixture
-pipeline (`gbrain eval --qrels` with the sibling
-[gbrain-evals](https://github.com/garrytan/gbrain-evals) corpus).
-
-## Off-switch
-
-Two ways to disable capture:
-
-```bash
-unset GBRAIN_CONTRIBUTOR_MODE             # easy: just unset the env var
-```
-
-Or force off regardless of the env var via `~/.gbrain/config.json`:
-
-```json
-{"eval": {"capture": false}}
-```
-
-Existing `eval_candidates` rows stay until you `gbrain eval prune
---older-than 0d` (or just drop the table).
-
-## Failure modes
-
-| What you see | What it means |
-|---|---|
-| `Mean Jaccard@k: 0.4`, top regressions all in one source dir | Source boost or hard-exclude regression on that prefix |
-| `Top-1 stability: 30%`, mean Jaccard still high | RRF tuning shifted the rank order without changing the set — re-tune `rrfK` |
-| `Mean latency Δ: +500ms`, jaccard high | Vector path got slower; check embedding API or HNSW probes |
-| `rows_errored > 0` | One or more queries threw. Inspect first 3 in human output, or `--json` to see all `error_message` fields |
-| Many `skipped: empty query` | Capture ran on rows where someone passed empty `query` — check why those were captured |

docs/eval-capture.md

@@ -1,160 +0,0 @@
-# Eval capture — NDJSON schema reference
-
-**Status:** stable from v0.21.0. Schema versioning via `schema_version`
-on every row; additive changes increment the minor version; removals
-are breaking-schema-v2.
-
-**Audience:** downstream consumers (primarily the sibling
-[gbrain-evals](https://github.com/garrytan/gbrain-evals) repo) that
-replay captured real-world queries as a BrainBench-Real fixture.
-
-## The pipeline
-
-```
-MCP / CLI / subagent tool-bridge caller
-     │
-     ▼
-src/core/operations.ts — query + search op handlers
-     │
-     │ (hybridSearch or searchKeyword)
-     │
-     ▼
-{results, meta: HybridSearchMeta}                 ┌── captureEvalCandidate
-     │                                             │    (fire-and-forget)
-     ▼                                             │
-return to caller                                   ▼
-                                            scrubPii(query) ←── src/core/eval-capture-scrub.ts
-                                                   │
-                                                   ▼
-                                           buildEvalCandidateInput
-                                                   │
-                                                   ▼
-                                           engine.logEvalCandidate
-                                                   │
-                                    ┌──────────────┴──────────────┐
-                                    │ success                     │ fail
-                                    ▼                             ▼
-                                INSERT into eval_candidates    engine.logEvalCaptureFailure
-                                                                 (reason: db_down | rls_reject |
-                                                                  check_violation |
-                                                                  scrubber_exception | other)
-```
-
-## `gbrain eval export` — the consumer contract
-
-```sh
-gbrain eval export [--since DUR] [--limit N] [--tool query|search]
-```
-
-Emits NDJSON to **stdout**. One JSON object per `\n`-terminated line.
-stderr receives progress heartbeats. Every line starts with
-`"schema_version": 1` so a forward-compat parser can fail loudly on
-schema v2 instead of silently misparsing.
-
-Typical usage from gbrain-evals:
-
-```sh
-# Snapshot the last week of real traffic for replay
-gbrain eval export --since 7d > brainbench-real.ndjson
-```
-
-```sh
-# Stream through jq for ad-hoc analysis
-gbrain eval export --tool query | jq -c 'select(.latency_ms > 500)'
-```
-
-## Row schema (v1)
-
-Every exported row has this shape. Field order in JSON output is not
-guaranteed; consumers MUST key by name, not position.
-
-| Field | Type | Notes |
-|---|---|---|
-| `schema_version` | number | Always `1` on v1 rows. Forward-compat gate. |
-| `id` | number | Autoincrement primary key. Stable across exports. |
-| `tool_name` | `"query"` \| `"search"` | Which MCP operation captured this row. |
-| `query` | string | **Already PII-scrubbed** by `scrubPii` unless `eval.scrub_pii: false`. Emails / phones / SSN / Luhn-verified credit cards / JWTs / bearer tokens replaced with `[REDACTED]`. Max length 50KB (CHECK-enforced). |
-| `retrieved_slugs` | string[] | Deduplicated slugs that came back in `SearchResult[]`. |
-| `retrieved_chunk_ids` | number[] | Every chunk id in result order (duplicates preserved — one per hit). |
-| `source_ids` | string[] | Distinct `sources.id` values across the result set (v0.18 multi-source). Empty for pre-v0.18 rows that lacked the column. |
-| `expand_enabled` | boolean \| null | Whether the caller **requested** Haiku expansion. `null` for `search` (no expansion concept). |
-| `detail` | `"low"` \| `"medium"` \| `"high"` \| null | Detail level the caller **requested**. `null` when omitted. |
-| `detail_resolved` | `"low"` \| `"medium"` \| `"high"` \| null | What `hybridSearch` **actually used** after auto-detect. `null` when neither caller nor heuristic classified. |
-| `vector_enabled` | boolean | True iff vector search actually ran. `false` when `OPENAI_API_KEY` was missing or the embed call failed. **Replay MUST respect this** — rows with `false` only exercised the keyword path. |
-| `expansion_applied` | boolean | True iff Haiku expansion actually produced variants (not just "was requested"). |
-| `latency_ms` | number | Wall-clock duration of the op handler (includes capture itself — negligible since it's fire-and-forget). |
-| `remote` | boolean | `true` for MCP callers (untrusted), `false` for local CLI. Partitions "real agent traffic" from "operator probing." |
-| `job_id` | number \| null | `OperationContext.jobId` when the caller was a subagent tool-bridge. Null for MCP + CLI. |
-| `subagent_id` | number \| null | `OperationContext.subagentId` for subagent-owned runs. |
-| `created_at` | string (ISO 8601) | UTC timestamp of insert. |
-
-## Ordering + determinism
-
-`listEvalCandidates` orders by `created_at DESC, id DESC`. Same-
-millisecond inserts tie on `created_at`; `id DESC` is the stable
-tiebreaker. Replay tools can consume rows in order and assume:
-- no duplicate rows across calls with non-overlapping `--since` windows
-- no missed rows across calls that chain `--since` windows (window end
-  of run 1 is the strict upper bound, not a soft cursor)
-
-## Schema versioning promise
-
-- **v1 (shipped v0.21.0)** — this document. All fields listed above.
-- **Additive changes** increment gbrain minor version (v0.25.0, v0.23.0
-  …) and ship with new optional fields. Consumers keyed on known fields
-  ignore unknown keys and keep working.
-- **Breaking changes** (rename, type change, removal) increment
-  `schema_version` to 2. Consumers MUST branch on `schema_version` to
-  stay compatible.
-
-## `eval_capture_failures` — companion audit table
-
-Not exported by `gbrain eval export`. Surfaced via `gbrain doctor`:
-
-```sh
-gbrain doctor   # warns when failures in last 24h > 0
-```
-
-Reason enum (stable): `db_down` | `rls_reject` | `check_violation` |
-`scrubber_exception` | `other`. Cross-process visibility is the whole
-point — `gbrain doctor` runs in its own process and reads the table
-directly, so in-process counters wouldn't work.
-
-## Config + CONTRIBUTOR_MODE
-
-Capture is **off by default** as of v0.25.0 (was on for everyone in
-earlier drafts). Two paths to turn it on:
-
-**Path A — env var (contributor opt-in, the common case):**
-
-```bash
-export GBRAIN_CONTRIBUTOR_MODE=1     # in ~/.zshrc or ~/.bashrc
-```
-
-**Path B — explicit config (`~/.gbrain/config.json`, file-plane only):**
-
-```json
-{
-  "engine": "postgres",
-  "database_url": "...",
-  "eval": {
-    "capture": true,
-    "scrub_pii": true
-  }
-}
-```
-
-Resolution order (most explicit wins):
-
-1. `eval.capture: true` in config → on
-2. `eval.capture: false` in config → off (overrides CONTRIBUTOR_MODE=1)
-3. `GBRAIN_CONTRIBUTOR_MODE === '1'` → on
-4. otherwise → off
-
-`scrub_pii` defaults to `true` independent of capture. Set
-`eval.scrub_pii: false` to preserve raw query text (only if you control
-the brain's distribution).
-
-`gbrain config set eval.capture false` does **not** work — that
-command writes the DB-plane config, and the MCP server reads the
-file-plane. Edit the JSON directly or use the env var.

docs/guides/minions-deployment-snippets/Procfile

@@ -7,7 +7,4 @@
 #   DATABASE_URL=postgresql://...
 #   GBRAIN_ALLOW_SHELL_JOBS=1   # only if submitting shell jobs
 
-# Two-layer supervision: the platform restarts the container on host
-# events (OOM, deploy); `gbrain jobs supervisor` restarts the worker
-# on in-process crashes with exponential backoff.
-worker: gbrain jobs supervisor --concurrency 2
+worker: gbrain jobs work --concurrency 2

docs/guides/minions-deployment-snippets/fly.toml.partial

@@ -5,12 +5,10 @@
 #   fly secrets set GBRAIN_ALLOW_SHELL_JOBS=1   # only if submitting shell jobs
 #   fly secrets set ANTHROPIC_API_KEY=...       # optional
 #
-# Two-layer supervision: Fly restarts the VM on host events; the
-# `gbrain jobs supervisor` process restarts the worker on in-process
-# crashes with exponential backoff and a structured audit trail.
+# Fly.io auto-restarts the process on crash — no watchdog needed.
 
 [processes]
-  worker = "gbrain jobs supervisor --concurrency 2"
+  worker = "gbrain jobs work --concurrency 2"
 
 # Scale the worker process to 1 machine (job queue serializes work; more
 # machines means higher concurrency but also more Postgres connections).

docs/guides/minions-deployment-snippets/minion-watchdog.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+# minion-watchdog.sh — restart gbrain jobs work if the process is dead or
+# has logged a shutdown marker since its last start.
+#
+# Fixes the v0.16.1 restart-loop bug: old shutdown lines from previous
+# restarts stayed in the unrotated log and every tick re-matched them
+# forever. This version writes a restart epoch to line 2 of the PID file
+# and only considers log lines newer than that epoch.
+#
+# Run every 5 minutes from crontab. See docs/guides/minions-deployment.md.
+set -u
+
+PID_FILE="${GBRAIN_WORKER_PID_FILE:-/tmp/gbrain-worker.pid}"
+LOG_FILE="${GBRAIN_WORKER_LOG_FILE:-/tmp/gbrain-worker.log}"
+GBRAIN="${GBRAIN_BIN:-/usr/local/bin/gbrain}"
+CONCURRENCY="${GBRAIN_WORKER_CONCURRENCY:-2}"
+
+start_worker() {
+  # stderr merged so banner lines ("[minion worker] shell handler enabled",
+  # "worker shutting down") all land in $LOG_FILE.
+  nohup "$GBRAIN" jobs work --concurrency "$CONCURRENCY" \
+    > "$LOG_FILE" 2>&1 &
+  local pid=$!
+  # Line 1: PID. Line 2: restart epoch (seconds since 1970).
+  # Readers that want just PID use `head -n1 "$PID_FILE"`.
+  printf '%s\n%s\n' "$pid" "$(date +%s)" > "$PID_FILE"
+}
+
+shutdown_since_restart() {
+  # Only match shutdown lines logged AFTER the most recent restart epoch.
+  # Worker log lines start with ISO-8601 UTC timestamps ("2026-04-21T19:05:12Z ...").
+  local restart_epoch
+  restart_epoch=$(sed -n '2p' "$PID_FILE" 2>/dev/null || echo 0)
+  [ -z "$restart_epoch" ] && restart_epoch=0
+
+  # POSIX-portable regex (no {n} intervals — mawk on Debian/Ubuntu rejects them).
+  awk -v since="$restart_epoch" '
+    match($0, /^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9:.+Z-]+/) {
+      ts_str = substr($0, RSTART, RLENGTH)
+      cmd = "date -d \"" ts_str "\" +%s 2>/dev/null"
+      cmd | getline ts
+      close(cmd)
+      if (ts + 0 > since + 0) print
+    }
+  ' "$LOG_FILE" 2>/dev/null | grep -q "worker stopped\|worker shutting down"
+}
+
+if [ -f "$PID_FILE" ]; then
+  PID=$(head -n1 "$PID_FILE")
+  if [ -n "$PID" ] && kill -0 "$PID" 2>/dev/null; then
+    # Process alive — check whether the worker logged an internal shutdown
+    # AFTER the last start. If yes, worker is dead-inside; restart.
+    if shutdown_since_restart; then
+      kill "$PID" 2>/dev/null
+      # 10s grace: covers shell handler's 5s child SIGTERM→SIGKILL window
+      # and leaves room for in-flight jobs to flush. Bump to 30 if your
+      # jobs run > 10s.
+      sleep 10
+      kill -9 "$PID" 2>/dev/null
+      start_worker
+    fi
+  else
+    # PID file exists but process is gone (crash / kill -9 / reboot).
+    start_worker
+  fi
+else
+  start_worker
+fi

docs/guides/minions-deployment-snippets/systemd.service

@@ -15,13 +15,9 @@ WorkingDirectory=/srv/gbrain
 # Env file is mode 600, owned by User=. Do not put secrets in this unit.
 EnvironmentFile=/etc/gbrain.env
 
-# Two-layer supervision: systemd restarts `gbrain jobs supervisor` on host
-# events (reboot, unit crash); the supervisor restarts `gbrain jobs work`
-# on in-process crashes with exponential backoff + structured audit.
-ExecStart=/usr/local/bin/gbrain jobs supervisor --concurrency 2
+ExecStart=/usr/local/bin/gbrain jobs work --concurrency 2
 
-# systemd restarts the supervisor on any non-zero exit. The supervisor
-# itself handles worker-level crash recovery.
+# Replaces the cron watchdog. systemd restarts on any non-zero exit.
 Restart=always
 RestartSec=10s
 
@@ -42,9 +38,7 @@ NoNewPrivileges=true
 PrivateTmp=true
 ProtectSystem=strict
 ProtectHome=read-only
-# ReadWritePaths must include the brain workspace AND ~/.gbrain (PID file +
-# audit log written by the supervisor).
-ReadWritePaths=/srv/gbrain /home/gbrain/.gbrain
+ReadWritePaths=/srv/gbrain
 
 [Install]
 WantedBy=multi-user.target

docs/guides/minions-deployment.md

@@ -1,7 +1,7 @@
 # Minions Worker Deployment Guide
 
-Keep `gbrain jobs work` running across crashes, reboots, and Postgres
-connection blips. Written for agents to execute line-by-line.
+Deploy `gbrain jobs work` so it stays running across crashes, reboots, and
+Postgres connection blips. Written for agents to execute line-by-line.
 
 ## The problem
 
@@ -12,61 +12,10 @@ The persistent worker can die silently from:
 - Bun process crashes with no automatic restart.
 - Internal event-loop death (PID alive, worker loop stopped).
 
-When the worker dies, submitted jobs sit in `waiting` forever. The
-canonical answer is `gbrain jobs supervisor` — a first-class CLI that
-spawns `gbrain jobs work` as a child and auto-restarts it on crash.
+When the worker dies, submitted jobs sit in `waiting` forever. Nothing in
+gbrain core auto-restarts the worker — that's what this guide wires up.
 
-## Worker supervision
-
-### The canonical pattern
-
-`gbrain jobs supervisor` is an auto-restarting wrapper around
-`gbrain jobs work`. It writes a PID file, restarts the worker on crash
-with exponential backoff (1s → 60s cap), emits lifecycle events to an
-audit file, and drains gracefully on SIGTERM (35s worker-drain window
-before SIGKILL). Exit codes are documented so agents can branch on them.
-
-**Typical commands:**
-
-```bash
-# Start in the foreground (blocks; Ctrl-C to stop).
-gbrain jobs supervisor --concurrency 4
-
-# Start detached — returns {"event":"started","supervisor_pid":…} on stdout.
-gbrain jobs supervisor start --detach --json
-
-# Check liveness without reading log files.
-gbrain jobs supervisor status --json
-
-# Graceful stop (SIGTERM + drain wait + SIGKILL fallback).
-gbrain jobs supervisor stop
-```
-
-**Exit codes:**
-
-| Code | Meaning |
-|---|---|
-| 0 | Clean shutdown (SIGTERM/SIGINT received, worker drained) |
-| 1 | Max crashes exceeded (worker kept dying) |
-| 2 | Another supervisor holds the PID lock |
-| 3 | PID file unwritable (permission / path error) |
-
-An agent seeing exit=2 can safely treat it as "one is already running";
-exit=1 should page a human.
-
-### Which supervisor when?
-
-The supervisor solves in-process crash recovery. Platform-level
-supervision (systemd, Fly, Render) handles host-level failures. You
-usually want both.
-
-| Environment | Recommendation |
-|---|---|
-| **Container (Fly / Railway / Render / Heroku)** | `gbrain jobs supervisor` runs as PID 1. The platform restarts the container on OOM / host loss; supervisor restarts the worker on crash. See [Fly.io](#flyio) / [Render / Railway / Heroku](#render--railway--heroku). |
-| **Linux VM with systemd** | Two-layer recommended: systemd supervises `gbrain jobs supervisor`, which in turn supervises `gbrain jobs work`. Buys you automatic restart on reboot (systemd) plus fast crash recovery (supervisor). See [systemd](#systemd). |
-| **Dev laptop / macOS** | `gbrain jobs supervisor` in a terminal. Ctrl-C stops it. No system-level setup needed. |
-
-### Variables used in this guide
+## Variables used in this guide
 
 Substitute these once before copy-pasting any snippet.
 
@@ -74,122 +23,142 @@ Substitute these once before copy-pasting any snippet.
 |---|---|---|
 | `$GBRAIN_BIN` | Absolute path to the `gbrain` binary | `$(command -v gbrain)` — often `/usr/local/bin/gbrain` or `~/.bun/bin/gbrain` |
 | `$GBRAIN_WORKER_USER` | OS user that owns the worker process | the same user that ran `gbrain init`; never `root` |
+| `$GBRAIN_WORKER_PID_FILE` | Worker PID + restart-epoch file | `/tmp/gbrain-worker.pid` (or `/var/run/gbrain/worker.pid` for systemd) |
+| `$GBRAIN_WORKER_LOG_FILE` | Worker log sink (stdout + stderr merged) | `/tmp/gbrain-worker.log` (or `/var/log/gbrain/worker.log`) |
 | `$GBRAIN_WORKSPACE` | `cwd` for shell jobs submitted by this deployment | absolute path, e.g. `/srv/my-brain` |
-| `$GBRAIN_ENV_FILE` | Secrets file sourced by systemd / shell | `/etc/gbrain.env` (mode 600) |
+| `$GBRAIN_ENV_FILE` | Secrets file sourced by crontab / systemd | `/etc/gbrain.env` (mode 600) |
 
-### Preconditions
+## Preconditions
 
-Run these before any deployment step.
+Run these before Step 1 of any option. Fail fast if something is wrong.
 
 ```bash
 # 1. gbrain is on PATH and resolves to an absolute location.
 command -v gbrain || { echo "gbrain not on PATH. Install, then retry."; exit 1; }
 
-# 2. DATABASE_URL points at reachable Postgres.
-#    (Supervisor is Postgres-only. PGLite's exclusive file lock blocks the
-#    separate worker process. If `config.engine === 'pglite'` the CLI rejects
-#    with a clear error.)
+# 2. DATABASE_URL points at reachable Postgres (or PGLite path exists).
 gbrain doctor --fast --json | jq '.checks[] | select(.name=="db_connectivity")'
 
-# 3. Schema is up to date. If version=0 or status=="fail":
+# 3. Schema is up to date. If version=0 or status=="fail", fix it first:
 #    gbrain apply-migrations --yes
 gbrain doctor --fast --json | jq '.checks[] | select(.name=="schema_version")'
 
-# 4. If you plan to submit `shell` jobs, pass --allow-shell-jobs to the
-#    supervisor (or export GBRAIN_ALLOW_SHELL_JOBS=1 before starting).
-#    Without the flag, the shell handler is disabled at worker startup.
+# 4. You have write access to at least one crontab mechanism.
+crontab -l >/dev/null 2>&1 && echo "user crontab OK"
+[ -w /etc/crontab ] && echo "/etc/crontab OK"
+
+# 5. If you plan to submit `shell` jobs, the WORKER process needs
+#    GBRAIN_ALLOW_SHELL_JOBS=1 (submitters do not). The handler is gated
+#    in registerBuiltinHandlers(); without the flag the worker startup
+#    line reads "shell handler disabled (...)".
 ```
 
-## Agent usage (OpenClaw / Hermes / Cursor / Codex)
+## Which option?
 
-Three-command pattern an agent can drive without shell archaeology:
+- Your workload runs LLM subagents (`gbrain agent run`) or jobs that take
+  > 30 s → **Option 1** (watchdog cron + persistent worker).
+- Your workload is short deterministic scripts on a fixed schedule (every
+  3 h, daily, weekly) → **Option 2** (inline `--follow`).
+- You don't have shell access to a long-running box (Fly/Render/Railway,
+  or any systemd host) → **Option 3** (service manager — replaces cron).
+
+## Option 1: watchdog cron + persistent worker
+
+A 5-minute cron checks whether the worker process is alive **and** whether
+it has logged an internal shutdown since its last start. Restarts if either
+condition fails.
+
+### 1a. Install the env file (secrets stay out of crontab)
+
+Never paste `DATABASE_URL` or API keys into crontab. `/etc/crontab` is
+mode 644 (world-readable); user crontabs under `/var/spool/cron/` are
+readable by `root`. Use the shipped env-file template:
 
 ```bash
-# Start (returns PIDs + pid_file on stdout as JSON, then detaches)
-gbrain jobs supervisor start --detach --json
-# → {"event":"started","supervisor_pid":1234,"worker_pid":1235,"pid_file":"/Users/you/.gbrain/supervisor.pid"}
-
-# Check health (machine-parseable JSON, no log scraping)
-gbrain jobs supervisor status --json
-# → {"running":true,"supervisor_pid":1234,"last_start":"2026-04-23T15:30:22Z","crashes_24h":0, ...}
-
-# Stop cleanly (SIGTERM + 35s drain + SIGKILL fallback)
-gbrain jobs supervisor stop
-```
-
-Every lifecycle event (spawn, crash, backoff, health warning, max-crashes,
-shutdown) is also written to `${GBRAIN_AUDIT_DIR:-~/.gbrain/audit}/supervisor-YYYY-Www.jsonl`
-for historical inspection. `gbrain doctor` reads that file and surfaces
-a `supervisor` check in its health report.
-
-## Deployment: systemd
-
-For long-running Linux VMs with shell access.
-
-```bash
-# Create the worker user if it doesn't exist.
-sudo useradd --system --home "$GBRAIN_WORKSPACE" --shell /usr/sbin/nologin gbrain \
-  2>/dev/null || true
-sudo mkdir -p "$GBRAIN_WORKSPACE" && sudo chown gbrain:gbrain "$GBRAIN_WORKSPACE"
-
-# Install the env file (secrets stay out of the unit file).
-sudo install -m 600 -o gbrain -g gbrain \
+sudo install -m 600 -o $GBRAIN_WORKER_USER -g $GBRAIN_WORKER_USER \
   docs/guides/minions-deployment-snippets/gbrain.env.example /etc/gbrain.env
 sudoedit /etc/gbrain.env
-# Fill in DATABASE_URL, optional GBRAIN_ALLOW_SHELL_JOBS=1.
-
-# Install the unit file, substituting /srv/gbrain → your workspace path.
-sudo install -m 644 docs/guides/minions-deployment-snippets/systemd.service \
-  /etc/systemd/system/gbrain-worker.service
-sudo sed -i "s|/srv/gbrain|$GBRAIN_WORKSPACE|g" \
-  /etc/systemd/system/gbrain-worker.service
-
-sudo systemctl daemon-reload
-sudo systemctl enable --now gbrain-worker
-sudo systemctl status gbrain-worker
-journalctl -u gbrain-worker -n 50
 ```
 
-The shipped unit file invokes `gbrain jobs supervisor` (not `gbrain jobs work`
-directly) so you get two-layer supervision: systemd restarts the supervisor
-on host reboot, supervisor restarts the worker on in-process crash.
+Fill in the connection string and `GBRAIN_ALLOW_SHELL_JOBS=1` (if
+applicable). See
+[`gbrain.env.example`](./minions-deployment-snippets/gbrain.env.example)
+for the full list.
 
-`Restart=always` + `RestartSec=10s` handle the supervisor-level recovery.
-The unit runs as unprivileged `gbrain` with `PrivateTmp`, `ProtectSystem=strict`,
-and `ReadWritePaths=$GBRAIN_WORKSPACE,$HOME/.gbrain` (for the PID file and
-audit log). `LimitNOFILE=65535` covers Bun + Postgres pool + concurrent
-LLM subagent calls without hitting the default 1024 cap.
+### 1b. Install the watchdog script
 
-## Deployment: Fly.io
+The [`minion-watchdog.sh`](./minions-deployment-snippets/minion-watchdog.sh)
+ships in-repo and writes a two-line PID file (PID on line 1, restart epoch
+on line 2). The restart-epoch marker is how the watchdog distinguishes
+stale shutdown lines in the log from current ones — without it, every tick
+after the first restart would match an old `worker shutting down` line and
+loop forever.
+
+Requires GNU coreutils (Linux default). On macOS/BSD install via
+`brew install coreutils` and alias `date` to `gdate` in the cron env if you
+want to test the watchdog locally; production Linux boxes work as-is.
 
 ```bash
-# Merge the [processes] block from fly.toml.partial into your fly.toml.
-cat docs/guides/minions-deployment-snippets/fly.toml.partial >> fly.toml
-# Review + edit as needed.
-
-# Set secrets (Fly handles restart on crash).
-fly secrets set DATABASE_URL='postgres://…' GBRAIN_ALLOW_SHELL_JOBS=1
+sudo install -m 755 -o $GBRAIN_WORKER_USER -g $GBRAIN_WORKER_USER \
+  docs/guides/minions-deployment-snippets/minion-watchdog.sh \
+  /usr/local/bin/minion-watchdog.sh
 ```
 
-The `[processes]` block runs `gbrain jobs supervisor` as PID 1. Fly
-restarts the container on host failure; the supervisor restarts the
-worker on in-process crash.
+### 1c. Wire into cron
 
-## Deployment: Render / Railway / Heroku
+Pick the form that matches the crontab you're editing.
 
-Drop [`Procfile`](./minions-deployment-snippets/Procfile) at the repo
-root. The shipped Procfile calls `gbrain jobs supervisor`. Set
-`DATABASE_URL` + optional `GBRAIN_ALLOW_SHELL_JOBS=1` via the platform's
-env UI or CLI.
+**If you ran `crontab -e`** (user crontab — 5-field, no user column):
 
-## Deployment: inline `--follow` (no persistent worker)
+```
+SHELL=/bin/bash
+PATH=/usr/local/bin:/usr/bin:/bin
+BASH_ENV=/etc/gbrain.env
+*/5 * * * * /usr/local/bin/minion-watchdog.sh
+```
 
-For short deterministic scripts on a fixed schedule where you don't need
-a persistent worker between runs. Each cron run brings its own temporary
-worker. `--follow` starts one on the queue and blocks until the
-just-submitted job reaches a terminal state (`completed` / `failed` /
-`dead` / `cancelled`). 2-3 s startup overhead per job; negligible vs job
-duration for scheduled work.
+**If you edited `/etc/crontab` directly** (system crontab — 6-field, with
+user column):
+
+```
+SHELL=/bin/bash
+PATH=/usr/local/bin:/usr/bin:/bin
+BASH_ENV=/etc/gbrain.env
+*/5 * * * * gbrain /usr/local/bin/minion-watchdog.sh
+```
+
+In both forms, `BASH_ENV=/etc/gbrain.env` tells non-interactive bash to
+source the env file before running the watchdog — that's how the
+connection string and `GBRAIN_ALLOW_SHELL_JOBS` reach the worker without
+landing in the world-readable crontab itself.
+
+### 1d. Log rotation
+
+The watchdog appends to the worker log across restarts. If you expect the
+file to grow unbounded, rotate it externally with `logrotate`:
+
+```
+# /etc/logrotate.d/gbrain-worker
+/tmp/gbrain-worker.log {
+  daily
+  rotate 7
+  missingok
+  notifempty
+  copytruncate
+}
+```
+
+`copytruncate` is important — the watchdog's restart-epoch check survives
+it (the epoch is compared against in-log timestamps, not file inode).
+
+## Option 2: inline `--follow` (no persistent worker)
+
+Each cron run brings its own temporary worker. `--follow` starts one on
+the queue and blocks until the just-submitted job reaches a terminal state
+(`completed` / `failed` / `dead` / `cancelled`). 2-3 s startup overhead
+per job; negligible vs job duration for scheduled work.
+
+Example: nightly brain enrichment as a shell job.
 
 ```bash
 GBRAIN_ALLOW_SHELL_JOBS=1 gbrain jobs submit shell \
@@ -201,56 +170,85 @@ GBRAIN_ALLOW_SHELL_JOBS=1 gbrain jobs submit shell \
 
 Replace `gbrain embed --stale` with whichever gbrain subcommand you're
 scheduling (`sync`, `extract`, `orphans`, `doctor`, `check-backlinks`,
-`lint`, `autopilot`). For strict single-job semantics on shared queues,
+`lint`, `autopilot`). If you're shelling out to a non-gbrain binary,
+keep its absolute path in the `cmd`.
+
+**Shared-queue gotcha.** If other jobs are already waiting on the same
+queue with higher priority or earlier `created_at`, the temporary worker
+processes those first before reaching yours. `--follow` still exits only
+when YOUR job finishes. For strict single-job semantics on shared queues,
 use a dedicated queue name like `nightly-enrich` above.
 
-## Upgrading from an older deployment
+## Option 3: service manager (systemd / Fly / Render / Railway)
 
-### From `minion-watchdog.sh` (pre-v0.20)
+Replaces the watchdog entirely. No cron, no PID file, no restart-loop.
+The service manager owns liveness.
 
-Earlier versions of this guide shipped a 68-line bash watchdog
-(`minion-watchdog.sh`). It's been replaced by `gbrain jobs supervisor`
-which handles everything the script did, plus atomic PID locking,
-structured audit events, queue-scoped health checks, and graceful
-drain on SIGTERM.
-
-**Migration:**
+### systemd (Linux hosts with shell access)
 
 ```bash
-# 1. Stop and remove the old watchdog.
-sudo kill $(head -n1 /tmp/gbrain-worker.pid) 2>/dev/null
-sudo rm -f /usr/local/bin/minion-watchdog.sh /tmp/gbrain-worker.pid \
-           /tmp/gbrain-worker.log
-crontab -e   # delete the "*/5 * * * * /usr/local/bin/minion-watchdog.sh" line
+# Create the worker user if it doesn't exist.
+sudo useradd --system --home "$GBRAIN_WORKSPACE" --shell /usr/sbin/nologin gbrain \
+  2>/dev/null || true
+sudo mkdir -p "$GBRAIN_WORKSPACE" && sudo chown gbrain:gbrain "$GBRAIN_WORKSPACE"
 
-# 2. Start the supervisor (systemd users: reinstall the unit from
-#    docs/guides/minions-deployment-snippets/systemd.service, which
-#    now calls `gbrain jobs supervisor`).
-gbrain jobs supervisor start --detach --json
-# Or: sudo systemctl restart gbrain-worker
+# Install the unit file, substituting /srv/gbrain → your workspace path.
+sudo install -m 644 docs/guides/minions-deployment-snippets/systemd.service \
+  /etc/systemd/system/gbrain-worker.service
+sudo sed -i "s|/srv/gbrain|$GBRAIN_WORKSPACE|g" \
+  /etc/systemd/system/gbrain-worker.service
 
-# 3. Verify.
-gbrain jobs supervisor status --json
-gbrain doctor   # 'supervisor' check should report running=true
+# See 1a above for /etc/gbrain.env install.
+sudo systemctl daemon-reload
+sudo systemctl enable --now gbrain-worker
+sudo systemctl status gbrain-worker
+journalctl -u gbrain-worker -n 50
 ```
 
-### Schema / migration hygiene
+`Restart=always` + `RestartSec=10s` give you crash-loop recovery. The unit
+runs as an unprivileged `gbrain` user with `PrivateTmp`, `ProtectSystem=strict`,
+and `ReadWritePaths=$GBRAIN_WORKSPACE`. `LimitNOFILE=65535` in the shipped
+unit covers Bun + Postgres pool + concurrent LLM subagent calls without
+hitting the default 1024 cap.
 
-Regardless of which deployment path you're upgrading from:
+### Fly.io
 
-1. **Stop the worker before upgrading.** `gbrain jobs supervisor stop`
-   (or `sudo systemctl stop gbrain-worker`). Skipping this risks an
-   in-flight job landing partial schema.
+Merge the `[processes]` block from
+[`fly.toml.partial`](./minions-deployment-snippets/fly.toml.partial) into
+your existing `fly.toml`. Set secrets with `fly secrets set` —
+Fly auto-restarts the process on crash.
+
+### Render / Railway / Heroku
+
+Drop [`Procfile`](./minions-deployment-snippets/Procfile) at the repo root.
+Set the connection string and `GBRAIN_ALLOW_SHELL_JOBS=1` via the
+platform's env UI or CLI.
+
+## Upgrading an existing deployment
+
+If you deployed on v0.13.x or earlier, walk this checklist:
+
+1. **Stop the worker before upgrading.**
+   `kill $(head -n1 /tmp/gbrain-worker.pid)` and wait for the process to
+   exit. Skipping this risks an in-flight job landing partial schema.
 2. **Run `gbrain upgrade`**. Then `gbrain apply-migrations --yes` if
    `gbrain doctor` reports any migration as `partial` or `pending`.
-3. **If you run shell jobs:** from v0.14 onward, pass
-   `--allow-shell-jobs` to the supervisor (or keep
-   `GBRAIN_ALLOW_SHELL_JOBS=1` in `/etc/gbrain.env`). Submitters don't
-   need the flag; only the worker does.
-4. **Verify.** `gbrain doctor` should report zero `pending` or `partial`
-   migrations plus a healthy `supervisor` check. `gbrain jobs stats`
-   should show no unexplained growth in `dead` between pre- and
-   post-upgrade.
+3. **If you run shell jobs:** from v0.14 onward, the worker requires
+   `GBRAIN_ALLOW_SHELL_JOBS=1` to register the `shell` handler. Add it to
+   `/etc/gbrain.env`. Submitters don't need the flag; only the worker does.
+4. **If you tuned your watchdog for `max_stalled=1`:** v0.14.3 migration
+   v15 raised the schema default to 5 and backfilled existing non-terminal
+   rows. A watchdog tuned around 1-strike dead-lettering will now
+   over-restart because it takes 5 misses to dead-letter. Switch to the
+   shipped watchdog (which keys on log markers, not job state).
+5. **If your v0.16.1 watchdog is still running:** it has a restart-loop
+   bug (old shutdown lines in the unrotated log re-match every 5 min
+   forever). Install the current `minion-watchdog.sh` from this guide's
+   snippets — it writes a restart epoch into the PID file and only
+   considers log lines newer than that epoch.
+6. **Verify.** `gbrain doctor` should report zero `pending` or `partial`
+   migrations. `gbrain jobs stats` should show no unexplained growth in
+   `dead` between pre- and post-upgrade.
 
 ## Known issues
 
@@ -263,10 +261,9 @@ silently. The stall detector then dead-letters the job after
 
 **Current defaults that make this worse:**
 
-- `lockDuration: 30000` (30 s) — too short for long jobs during
-  connection blips.
-- `max_stalled: 5` (schema column default — see `src/schema.sql` and
-  `src/core/pglite-schema.ts`). Five missed heartbeats before dead-letter.
+- `lockDuration: 30000` (30 s) — too short for long jobs during connection blips.
+- `max_stalled: 5` (schema column default on master — see `src/schema.sql`
+  and `src/core/pglite-schema.ts`). Five missed heartbeats before dead-letter.
 - `stalledInterval: 30000` (30 s) — checks too aggressively.
 
 **Tune per-job today.** `gbrain jobs submit` accepts `--max-stalled N`,
@@ -274,6 +271,9 @@ silently. The stall detector then dead-letters the job after
 `--backoff-jitter 0..1`, and `--timeout-ms N` as first-class flags
 (since v0.13.1). These write onto the job row at submit time — which is
 what `handleStalled()` reads — so per-job tuning is the real knob today.
+Worker-level `--lock-duration` / `--stall-interval` are on the roadmap;
+until they land, rely on per-job `--max-stalled` plus the watchdog (or
+systemd) for worker health.
 
 ### DO NOT pass `maxStalledCount` to `MinionWorker`
 
@@ -284,16 +284,16 @@ Use `gbrain jobs submit --max-stalled N` per-job instead.
 ### Zombie shell children
 
 When the Bun worker crashes hard, child processes from shell jobs can
-become zombies. The supervisor's SIGTERM → 35s drain → SIGKILL window
-covers the shell handler's 5 s child-kill grace (`KILL_GRACE_MS`). For
-long-running shell jobs, prefer timeouts via `--timeout-ms` on submit
-over relying on hard kills.
+become zombies. The watchdog's 10 s `SIGTERM → SIGKILL` window covers the
+shell handler's 5 s child-kill grace (`KILL_GRACE_MS`). For long-running
+shell jobs, bump the watchdog's `sleep 10` to `sleep 30` so the worker
+has time to flush in-flight jobs before the kill.
 
 ## Smoke test
 
 ```bash
-# Supervisor alive?
-gbrain jobs supervisor status --json | jq .running
+# Worker alive?
+kill -0 $(head -n1 /tmp/gbrain-worker.pid) 2>/dev/null && echo ALIVE || echo DEAD
 
 # Aggregate queue health.
 gbrain jobs stats
@@ -304,29 +304,20 @@ gbrain jobs list --status active --limit 10
 # Dead-lettered jobs.
 gbrain jobs list --status dead --limit 10
 
-# Shell handler registered? (check supervisor audit log or worker stderr.)
-gbrain jobs supervisor status --json | jq '.worker_config.allow_shell_jobs'
+# Shell handler registered? (stderr banner merged into log via 2>&1.)
+grep "shell handler enabled" /tmp/gbrain-worker.log
 ```
 
 ## Uninstall
 
-**`gbrain jobs supervisor`** (foreground or `--detach`):
-
-```bash
-gbrain jobs supervisor stop
-```
-
-**systemd:**
-
-```bash
-sudo systemctl disable --now gbrain-worker
-sudo rm /etc/systemd/system/gbrain-worker.service /etc/gbrain.env
-sudo systemctl daemon-reload
-```
-
-**Fly / Render / Railway:** delete the `worker` process from `fly.toml`
-/ `Procfile` and redeploy. Secrets set via `fly secrets` persist until
-`fly secrets unset`.
-
-**Inline `--follow`:** remove the cron entry. Nothing else to clean up
-— temporary workers exit with their jobs.
+- **Option 1 (watchdog cron):** `crontab -e`, delete the watchdog line.
+  `kill $(head -n1 /tmp/gbrain-worker.pid) && rm /tmp/gbrain-worker.pid`.
+  Optionally `sudo rm /etc/gbrain.env /usr/local/bin/minion-watchdog.sh`.
+- **Option 2 (inline `--follow`):** remove the cron entry. Nothing else to
+  clean up — temporary workers exit with their jobs.
+- **Option 3 (systemd):** `sudo systemctl disable --now gbrain-worker`,
+  then `sudo rm /etc/systemd/system/gbrain-worker.service /etc/gbrain.env`,
+  then `sudo systemctl daemon-reload`.
+- **Option 3 (Fly/Render/Railway):** delete the `worker` process from
+  `fly.toml` / `Procfile` and redeploy. Secrets set via `fly secrets`
+  persist until `fly secrets unset`.

docs/guides/multi-source-brains.md

@@ -1,182 +0,0 @@
-# Multi-source brains
-
-**A single gbrain database can hold multiple knowledge repos.** Each one
-is a `source`: a logical brain-within-the-brain with its own slug
-namespace, its own sync state, and its own federation policy. The rest
-of this guide walks the three canonical scenarios.
-
-## The three scenarios
-
-### 1. Unified knowledge recall (wiki + gstack)
-
-You have a personal wiki and a `gstack` checkout. Both belong to you,
-both are knowledge you want your agent to recall across. When you ask
-"what did I learn about X?" you want the best hit whether it lives in
-the wiki or in a gstack plan.
-
-```bash
-# Register the gstack source, federate so it joins cross-source search
-gbrain sources add gstack --path ~/.gstack --federated
-
-# Pin the directory so `gbrain sync` knows which source it's walking
-cd ~/.gstack && gbrain sources attach gstack
-
-# Initial sync
-gbrain sync --source gstack
-
-# Now `gbrain search "retry budgets"` returns hits from BOTH wiki and
-# gstack. Each result includes source_id so the agent can cite properly.
-```
-
-Result: wiki pages and gstack plans are separate (different source_ids,
-different slug namespaces) but share the search surface.
-
-### 2. Purpose-separated brains (yc-media + garrys-list)
-
-You run two completely different content pipelines on the same backend.
-YC Media covers portfolio news and founder profiles. Garry's List is
-personal writing. You explicitly DON'T want them mixed in search — YC
-portfolio content leaking into essay searches is a bug, not a feature.
-
-```bash
-# Two sources, both isolated (federated=false)
-gbrain sources add yc-media --path ~/yc-media --no-federated
-gbrain sources add garrys-list --path ~/writing --no-federated
-
-# Pin each checkout directory
-(cd ~/yc-media && gbrain sources attach yc-media)
-(cd ~/writing && gbrain sources attach garrys-list)
-
-# Sync each independently
-gbrain sync --source yc-media
-gbrain sync --source garrys-list
-```
-
-Result: searching from neither directory returns the `default` source
-(your main brain). Searching from inside `~/yc-media` returns only yc-
-media hits. Searching from inside `~/writing` returns only garrys-list.
-Federation is opt-in, not leaked.
-
-To search across them explicitly on demand:
-
-```bash
-gbrain search "tech layoffs" --source yc-media,garrys-list
-```
-
-### 3. Mixed (wiki federated + sessions isolated)
-
-Your main wiki is federated with a few trusted sources. Your session
-transcripts (coming in v0.18) land in a separate isolated source so
-they don't dominate every search result.
-
-```bash
-# Federated sources
-gbrain sources add gstack --path ~/.gstack --federated
-
-# Isolated source (future v0.18 — sessions use this shape today for ingest)
-gbrain sources add sessions --path ~/.claude/sessions --no-federated
-```
-
-## Resolution priority
-
-When any command needs to pick a source, gbrain walks this list (highest
-first):
-
-1. Explicit `--source <id>` flag.
-2. `GBRAIN_SOURCE` environment variable.
-3. `.gbrain-source` dotfile in CWD or any ancestor directory.
-4. A registered source whose `local_path` contains the CWD (longest
-   prefix wins for nested checkouts).
-5. The brain-level default set via `gbrain sources default <id>`.
-6. The seeded `default` source.
-
-So inside `~/.gstack/plans/` on a brain that pinned `gstack` to
-`~/.gstack` via `.gbrain-source`, `gbrain put-page` implicitly writes to
-the `gstack` source. Outside any registered directory with no env/dotfile
-set, it writes to the default.
-
-## Federation flag
-
-Every source row stores `config.federated: boolean` in its JSONB config.
-
-| Value | Meaning |
-|-------|---------|
-| `true` | Source participates in unqualified `gbrain search "X"` results. |
-| `false` (default for new sources) | Source only searched when explicitly named via `--source <id>` or qualified citation. |
-
-The seeded `default` source is `federated=true` so pre-v0.17 brains
-behave exactly as before — every page appears in search.
-
-Flip later with `gbrain sources federate <id>` / `unfederate <id>`.
-
-## Commands
-
-Full subcommand reference:
-
-```
-gbrain sources add <id> --path <p> [--name <n>] [--federated|--no-federated]
-                               Register a source. id: [a-z0-9](?:[a-z0-9-]{0,30}[a-z0-9])?
-gbrain sources list [--json]   List all sources with page counts + federation state.
-gbrain sources remove <id> [--yes] [--dry-run] [--keep-storage]
-                               Cascade-delete a source (pages, chunks, timeline).
-gbrain sources rename <id> <new-name>
-                               Change display name only; id is immutable.
-gbrain sources default <id>    Set the brain-level default.
-gbrain sources attach <id>     Write .gbrain-source in CWD (like kubectl context).
-gbrain sources detach          Remove .gbrain-source from CWD.
-gbrain sources federate <id>
-gbrain sources unfederate <id>
-```
-
-## Citation format for agents
-
-When agents receive multi-source results they MUST cite pages in
-`[source-id:slug]` form. Example:
-
-> You told me about the distillation protocol — see [wiki:topics/ai]
-> and [gstack:plans/multi-repo] for where this came from.
-
-The citation key is `sources.id` (immutable). Renaming a source via
-`gbrain sources rename` changes the display name only; existing
-citations keep working.
-
-## Writing to a specific source
-
-```bash
-# Pass --source explicitly
-gbrain put-page topics/ai ... --source wiki
-
-# Or rely on the dotfile / env / CWD match
-cd ~/.gstack && gbrain put-page plans/multi-repo ...
-# → source auto-resolves to gstack
-```
-
-Reads span federated sources by default. Writes require a resolved
-source (explicit, inferred, or default). The resolver never picks a
-source silently when ambiguous — it errors with a clear fix.
-
-## Upgrading an existing brain
-
-`gbrain upgrade` runs the v16 + v17 migrations automatically. Your
-existing pages all move under `source_id='default'`. Behavior is
-unchanged until you add a second source.
-
-To add one:
-
-```bash
-gbrain sources add gstack --path ~/.gstack --federated
-cd ~/.gstack && gbrain sources attach gstack && gbrain sync
-```
-
-Two commands. The existing default source is untouched.
-
-## Not in v0.18.0
-
-- Session transcript ingest (`.jsonl`, raised size cap, session
-  PageType) — v0.18.
-- Per-source retention/TTL (`gbrain sources prune`) — v0.18.
-- ACL enforcement via caller-identity — v0.17.1.
-- `gbrain sources import-from-github <url>` one-shot bootstrap — patch
-  release after the core plumbing stabilizes.
-
-All of these build on the `sources` primitive shipped here.

docs/guides/queue-operations-runbook.md

@@ -1,76 +0,0 @@
-# Queue operations runbook
-
-"My queue looks wedged — what do I run?" The commands below are in the order
-you probably want them. Shipped with v0.19.1 after a production incident
-where the queue held for 90+ minutes before the operator noticed.
-
-## First signal: jobs aren't running
-
-```bash
-gbrain doctor --json | jq '.checks[] | select(.name == "queue_health")'
-```
-
-`queue_health` flags two patterns:
-
-- **stalled-forever**: active job whose `started_at` is older than 1h.
-- **waiting-depth**: any per-name queue deeper than 10 (override via
-  `GBRAIN_QUEUE_WAITING_THRESHOLD`). Signals a missing `maxWaiting`.
-
-## Triage commands
-
-```bash
-# Who's active right now?
-gbrain jobs list --status active
-
-# Who's waiting, biggest pile first?
-gbrain jobs list --status waiting --limit 50
-
-# What's wrong with a specific job?
-gbrain jobs get <id>
-```
-
-## Rescue actions (in order of escalation)
-
-```bash
-# Force-kill a single stuck job:
-gbrain jobs cancel <id>
-
-# Clear a specific job entirely (last resort):
-gbrain jobs delete <id>
-
-# Health smoke on the mechanism itself:
-gbrain jobs smoke --wedge-rescue
-```
-
-## What each subcheck means
-
-- **stalled-forever** — A worker claimed a job, started executing, and has
-  held the row for over an hour. The wall-clock sweep evicts jobs past
-  2× `timeout_ms`; if one's still active, either no `timeout_ms` was set
-  or the sweep is newly deployed and this job predates it. Cancel it.
-- **waiting-depth** — Submitters are piling up jobs faster than workers
-  drain them. Set `--max-waiting N` on the submission or on the programmatic
-  `queue.add()` call. If you want a taller pile, raise the threshold via
-  `GBRAIN_QUEUE_WAITING_THRESHOLD=50 gbrain doctor`.
-
-## Self-check: is a worker even running?
-
-```bash
-# If you're running autopilot with --no-worker, check that your external
-# worker (systemd / Docker / OpenClaw service-manager) is alive:
-gbrain jobs list --status active | head -5
-```
-
-If the list is empty AND your submissions keep piling up, no worker is
-claiming. Start one:
-
-```bash
-GBRAIN_ALLOW_SHELL_JOBS=1 gbrain jobs work --concurrency 4
-```
-
-## Follow-ups tracked for v0.20+
-
-- B7 — `minion_workers` heartbeat table for ground-truth liveness (the
-  `--no-worker` probe and the dropped `queue_health` worker-heartbeat
-  subcheck both need this).
-- B3 — `gbrain doctor --fix` learns to rescue queue wedges.

docs/guides/rls-and-you.md

@@ -1,154 +0,0 @@
-# RLS and you
-
-Short version: every table in your gbrain's `public` schema needs Row Level
-Security enabled. If one doesn't, `gbrain doctor` now fails, not warns, and the
-process exits 1.
-
-This guide explains why, what to do when you hit the check, and the escape hatch
-for the cases where you really do want a table to stay readable by the anon key.
-
-## Why RLS matters
-
-Supabase exposes everything in the `public` schema via PostgREST. Whatever's
-there is reachable by the anon key, which is a client-side secret by design.
-If RLS is off on a public table, the anon key can read it. On anything sensitive
-(auth tokens, chat history, financial data) that's an exfiltration vector, not
-a footgun.
-
-gbrain's service-role connection holds `BYPASSRLS`, so enabling RLS without
-policies does NOT break gbrain itself. It just blocks the anon key's default
-read. That's the security posture: deny-by-default to anon, full access for
-the service role.
-
-## What to do when doctor fails
-
-Doctor's message names every table missing RLS and gives you a `ALTER TABLE`
-line per table:
-
-```
-1 table(s) WITHOUT Row Level Security: expenses_ramp.
-Fix: ALTER TABLE "public"."expenses_ramp" ENABLE ROW LEVEL SECURITY;
-If a table should stay readable by the anon key on purpose, see
-docs/guides/rls-and-you.md for the GBRAIN:RLS_EXEMPT comment escape hatch.
-```
-
-99% of the time, you want the fix. Run the SQL. Re-run `gbrain doctor`. Done.
-
-## The 1% case: deliberate exemption
-
-Sometimes a public table is supposed to be readable by the anon key. An
-analytics view backing a public dashboard. A read-only reference table. A
-plugin that ships its own frontend and intentionally uses the anon key for
-reads.
-
-gbrain has an escape hatch for these. It is deliberately painful to set up.
-That is the feature.
-
-### The format
-
-```sql
--- In psql, connected as a BYPASSRLS role (e.g. postgres):
-COMMENT ON TABLE public.your_table IS
-  'GBRAIN:RLS_EXEMPT reason=<why this is anon-readable on purpose>';
-```
-
-Rules:
-
-- The comment value MUST start with `GBRAIN:RLS_EXEMPT` (case-sensitive).
-- It MUST include `reason=` followed by at least 4 characters of justification.
-- No other prefix, no checkbox in a config file, no environment variable. Only
-  a Postgres table comment counts.
-- If RLS is also off on the table (which it must be for the anon key to
-  actually read), you also need `ALTER TABLE ... DISABLE ROW LEVEL SECURITY;`
-  explicitly. Disabling alone is not enough; the comment is what tells doctor
-  this is intentional.
-
-### Example
-
-```sql
-ALTER TABLE public.expenses_ramp DISABLE ROW LEVEL SECURITY;
-COMMENT ON TABLE public.expenses_ramp IS
-  'GBRAIN:RLS_EXEMPT reason=analytics-only, anon-readable ok, owner=garry, 2026-04-22';
-```
-
-After that, `gbrain doctor` reports:
-
-```
-rls: ok — RLS enabled on 20/21 public tables (1 explicitly exempt: expenses_ramp)
-```
-
-Note that every subsequent run re-enumerates your exemptions by name. That's
-intentional. The escape hatch is not a one-time sign-off, it's a recurring
-reminder. If you ever want to know which tables are open, run `gbrain doctor`.
-
-## Why SQL and not a CLI subcommand
-
-gbrain does NOT ship a `gbrain rls-exempt add <table>` command. A CLI command
-would make it easy for an agent to silently open a table to anon reads. The
-comment-in-psql requirement forces the operator to type the justification
-in SQL, which is:
-
-- Visible in shell history.
-- Visible in a git-tracked schema dump.
-- Visible in `pg_dump` output the next time you restore.
-- Visible in `gbrain doctor` output on every run.
-
-An agent CAN still run the SQL, but it can't do it without the user seeing the
-action. That's the "write it in blood" design.
-
-## Auditing exemptions later
-
-To see every exemption in the current DB:
-
-```sql
-SELECT
-  c.relname AS table_name,
-  obj_description(c.oid, 'pg_class') AS comment
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-WHERE n.nspname = 'public'
-  AND c.relkind = 'r'
-  AND obj_description(c.oid, 'pg_class') LIKE 'GBRAIN:RLS_EXEMPT%';
-```
-
-If that list is longer than you remember signing off on, that's the signal.
-
-## Removing an exemption
-
-Just drop the comment and re-enable RLS:
-
-```sql
-ALTER TABLE public.expenses_ramp ENABLE ROW LEVEL SECURITY;
-COMMENT ON TABLE public.expenses_ramp IS NULL;
-```
-
-`gbrain doctor` stops listing the table as exempt and goes back to checking
-it like any other.
-
-## PGLite
-
-If you're on PGLite (the zero-config default), doctor skips this check
-entirely: PGLite is embedded, single-user, and has no PostgREST in front of
-it. The public-schema-exposure risk doesn't exist. You'll see:
-
-```
-rls: ok — Skipped (PGLite — no PostgREST exposure, RLS not applicable)
-```
-
-If you migrate to Supabase or self-hosted Postgres later, the check starts
-running and will flag any table that came over without RLS.
-
-## Self-hosted Postgres
-
-If you're running Postgres without PostgREST in front, the anon-key exposure
-doesn't apply. But gbrain still fails the check on missing RLS, because:
-
-- The framing is "RLS on all public tables" is a gbrain security invariant,
-  not a Supabase-specific workaround.
-- The `ALTER TABLE ... ENABLE RLS` fix is harmless on any Postgres: it only
-  constrains non-bypass roles, which gbrain doesn't use.
-- If you ever put PostgREST or a similar tool in front later, the guard is
-  already in place.
-
-If this framing doesn't fit your deployment, file an issue with the specifics
-so we can decide whether a self-hosted-exempt mode is justified.

docs/integrations/pre-commit.md

@@ -1,105 +0,0 @@
-# Pre-commit hook for brain repos (v0.22.4+)
-
-`gbrain frontmatter install-hook` installs a git pre-commit hook in your
-brain source's repo that runs `gbrain frontmatter validate` against staged
-`.md` and `.mdx` files. Malformed frontmatter blocks the commit. Bypass with
-`git commit --no-verify`.
-
-## What the hook catches
-
-The same seven validation classes the `frontmatter-guard` skill and
-`gbrain doctor`'s `frontmatter_integrity` subcheck report:
-
-| Code              | What it catches                                                     |
-|-------------------|---------------------------------------------------------------------|
-| `MISSING_OPEN`    | File doesn't start with `---`                                       |
-| `MISSING_CLOSE`   | No closing `---` before first heading                               |
-| `YAML_PARSE`      | YAML failed to parse (syntax or structure)                          |
-| `SLUG_MISMATCH`   | `slug:` in frontmatter doesn't match path-derived slug              |
-| `NULL_BYTES`      | Binary corruption (`\x00`) anywhere in the content                  |
-| `NESTED_QUOTES`   | `title: "outer "inner" outer"` shape that breaks YAML               |
-| `EMPTY_FRONTMATTER` | `---` ... `---` with nothing meaningful between                   |
-
-## Install
-
-For all registered sources that are git repos:
-
-```bash
-gbrain frontmatter install-hook
-```
-
-For one source:
-
-```bash
-gbrain frontmatter install-hook --source <id>
-```
-
-For force-overwrite of an existing pre-commit hook (writes a `.bak`):
-
-```bash
-gbrain frontmatter install-hook --force
-```
-
-The hook lands at `<source>/.githooks/pre-commit`. If `core.hooksPath` is
-unset, the install also runs `git config core.hooksPath .githooks` so the
-hook is picked up without manual git config.
-
-## Bypass
-
-Standard git escape hatch:
-
-```bash
-git commit --no-verify
-```
-
-This skips ALL pre-commit hooks. Use sparingly — the next time the user
-runs `gbrain doctor`, the issues will surface.
-
-## Uninstall
-
-```bash
-gbrain frontmatter install-hook --uninstall
-```
-
-If a `.bak` was saved during install, it's restored as the active hook.
-Otherwise the hook is removed cleanly.
-
-## Behavior on machines without gbrain installed
-
-The hook script checks for `gbrain` on `$PATH`. When missing, it prints a
-one-line warning to stderr and exits 0 — commits aren't blocked just because
-a developer hasn't installed gbrain locally. Once gbrain is installed, the
-hook resumes blocking malformed pages.
-
-## For downstream agent forks
-
-If your OpenClaw wraps gbrain in a host repo
-that's not the brain repo itself, you may want a separate hook strategy:
-
-- **Brain repo IS the host repo** (gbrain skills + brain pages in one repo):
-  install via `gbrain frontmatter install-hook` as above.
-- **Brain repo is a separate registered source** (e.g. `~/brain` registered
-  as a source, host repo is `~/agent-fork`): install in the brain repo only;
-  agent-fork code doesn't need this hook.
-- **Brain repo is auto-generated** (e.g. by a sync daemon writing to a
-  bucket): skip the hook entirely; gate at the writer instead via
-  `import { writeBrainPage } from 'gbrain/brain-writer'` (planned in a
-  later release; currently the CLI is the surface).
-
-## How it fits into the broader frontmatter pipeline
-
-```
-agent writes a page         git commit                 doctor scan
-       ↓                          ↓                          ↓
-[source content]   →  [pre-commit hook validates]   →  [frontmatter_integrity check]
-       ↓                          ↓                          ↓
-  raw file on disk       blocks malformed commits     surfaces existing issues
-                                                             ↓
-                                                  `gbrain frontmatter validate
-                                                   <source-path> --fix`
-                                                   (writes .bak backups)
-```
-
-The hook is the write-time gate; doctor is the audit gate; the CLI is the
-fix tool. They share `parseMarkdown(..., {validate:true})` as the single
-source of truth for what counts as malformed.

docs/mcp/ALTERNATIVES.md

@@ -1,9 +1,8 @@
 # Remote MCP Deployment Options
 
 GBrain's MCP server runs via `gbrain serve` (stdio transport). To make it
-accessible from other devices and AI clients, run `gbrain serve --http`
-(built-in HTTP transport with bearer auth, Postgres-only ... see
-[DEPLOY.md](DEPLOY.md)) behind a public tunnel. Here are your tunnel options.
+accessible from other devices and AI clients, you need an HTTP wrapper and
+a public tunnel. Here are your options.
 
 ## ngrok (recommended)
 
@@ -14,9 +13,8 @@ accessible from other devices and AI clients, run `gbrain serve --http`
 # 1. Install ngrok
 brew install ngrok
 
-# 2. Start the built-in HTTP transport
-gbrain serve --http --port 8787
-# See docs/mcp/DEPLOY.md for token setup
+# 2. Start your MCP server (behind an HTTP wrapper)
+# See docs/mcp/DEPLOY.md for the server setup
 
 # 3. Expose via ngrok
 ngrok http 8787 --url your-brain.ngrok.app
@@ -61,7 +59,6 @@ Both run Bun natively. No bundling, no Deno, no cold start, no timeout limits.
 | All 30 operations | Yes | Yes | Yes |
 | Setup time | 5 min | 10 min | 15 min |
 
-**Note:** `gbrain serve --http` is the built-in HTTP transport (v0.22.7+). Bearer auth
-against the `access_tokens` table, default-deny CORS, two-bucket rate limit, body cap,
-per-request audit log. Postgres-only by design (PGLite is local-only). See
-[DEPLOY.md](DEPLOY.md) and [SECURITY.md](../../SECURITY.md) for env vars and tunables.
+**Note:** `gbrain serve --http` (built-in HTTP transport) is planned but not yet
+implemented. Currently, remote MCP requires a custom HTTP wrapper around `gbrain serve`.
+See [DEPLOY.md](DEPLOY.md) for details.

docs/mcp/CHATGPT.md

@@ -1,103 +0,0 @@
-# Connect GBrain to ChatGPT
-
-**Status (v0.26.0):** Unblocked. GBrain's `gbrain serve --http` ships OAuth 2.1
-with PKCE, which is the ChatGPT MCP connector's hard requirement. Before v1.0,
-this was a P0 TODO — the only major AI client that could not connect.
-
-ChatGPT does not support bearer-token MCP servers. You must use the OAuth 2.1
-HTTP server.
-
-## Setup
-
-### 1. Start the HTTP server
-
-```bash
-gbrain serve --http --port 3131
-```
-
-Save the admin bootstrap token printed on stderr. Open
-`http://localhost:3131/admin` and paste it to access the dashboard.
-
-### 2. Register a ChatGPT client
-
-ChatGPT uses the authorization code flow with PKCE (browser-based OAuth).
-Register from the `/admin` dashboard:
-
-1. Click **Register client**.
-2. Name: `chatgpt`.
-3. Grant type: `authorization_code`.
-4. Scopes: `read`, `write` (leave `admin` unchecked for ChatGPT).
-5. Redirect URI: ChatGPT's OAuth redirect (copy it from the ChatGPT
-   connector setup screen — something like
-   `https://chat.openai.com/connector_platform_oauth_redirect`).
-6. Hit **Register**. The credential-reveal modal shows the `client_id` once
-   with Copy and Download JSON buttons. There is no client secret for
-   PKCE-based public clients.
-
-Host-repo wrappers can register programmatically:
-
-```ts
-await oauthProvider.registerClientManual(
-  'chatgpt',
-  ['authorization_code'],
-  'read write',
-  ['https://chat.openai.com/connector_platform_oauth_redirect'],
-);
-```
-
-### 3. Expose the server publicly
-
-```bash
-brew install ngrok
-ngrok http 3131 --url your-brain.ngrok.app
-```
-
-Your OAuth issuer URL becomes `https://your-brain.ngrok.app`. ChatGPT's
-connector auto-discovers the spec-compliant endpoint at
-`/.well-known/oauth-authorization-server`.
-
-### 4. Add the connector in ChatGPT
-
-1. Open ChatGPT > Settings > Connectors.
-2. Click **Add connector**.
-3. MCP server URL: `https://your-brain.ngrok.app/mcp`.
-4. Client ID: the `client_id` you saved in step 2.
-5. Click **Connect**. ChatGPT opens the OAuth consent page, you approve, and
-   the connector is live.
-
-Start a new conversation and ask ChatGPT to search your brain. The MCP tool
-calls show up in the admin dashboard's live SSE feed in real time.
-
-## Scopes
-
-ChatGPT clients can request any combination of `read`, `write`, `admin`. The
-scopes granted at consent time are enforced on every tool call. Four
-operations are `localOnly` and rejected over HTTP regardless of scope:
-`sync_brain`, `file_upload`, `file_list`, `file_url`. The HTTP server fails
-closed for any attempt to reach local filesystem surface area.
-
-Recommended ChatGPT scope: `read write`. Leave `admin` for your local CLI
-and the admin dashboard.
-
-## Troubleshooting
-
-**"Invalid redirect_uri" during the ChatGPT connector OAuth handshake**
-The registered `redirect-uri` must match ChatGPT's exactly. If ChatGPT
-rejects your server, check the admin dashboard's **Agents** table for the
-client, confirm the redirect URI matches what the error page shows, and
-re-register with the correct URI.
-
-**ChatGPT shows an MCP connection error after approval**
-Open `/admin`, watch the SSE feed, and try again. If no request arrives, the
-connector isn't reaching your ngrok URL. If a request arrives but fails,
-the Request Log tab shows the exact error.
-
-**"Unsupported grant_type" on the token endpoint**
-ChatGPT uses `authorization_code`, which the MCP SDK supports natively.
-If you see this error, verify the client was registered with
-`--grant-types authorization_code` and not `client_credentials`.
-
-## See also
-
-- [DEPLOY.md](DEPLOY.md) — full OAuth 2.1 setup reference
-- [ALTERNATIVES.md](ALTERNATIVES.md) — tunnel options (ngrok, Tailscale, Fly)

docs/mcp/CLAUDE_CODE.md

@@ -21,7 +21,7 @@ claude mcp add gbrain -t http \
 ```
 
 Replace `YOUR-DOMAIN` with your ngrok domain and `YOUR_TOKEN` with a token
-from `gbrain auth create "claude-code"`.
+from `bun run src/commands/auth.ts create "claude-code"`.
 
 ## Verify
 

docs/mcp/CLAUDE_COWORK.md

@@ -12,7 +12,7 @@ For Team/Enterprise plans, an org Owner adds the connector:
    https://YOUR-DOMAIN.ngrok.app/mcp
    ```
 3. Add Bearer token authentication in Advanced Settings
-   (create one with `gbrain auth create "cowork"`)
+   (create one with `bun run src/commands/auth.ts create "cowork"`)
 4. Save
 
 Note: Cowork connects from Anthropic's cloud, not your device. Your server

docs/mcp/CLAUDE_DESKTOP.md

@@ -16,7 +16,7 @@ Remote HTTP servers must be added through the GUI.
    Replace `YOUR-DOMAIN` with your ngrok domain (see
    [ngrok-tunnel recipe](../../recipes/ngrok-tunnel.md) for setup).
 5. Set authentication to **Bearer Token** and paste your token
-   (create one with `gbrain auth create "claude-desktop"`)
+   (create one with `bun run src/commands/auth.ts create "claude-desktop"`)
 6. Save
 
 ## Verify

docs/mcp/DEPLOY.md

@@ -1,156 +1,35 @@
 # Deploy GBrain Remote MCP Server
 
-> **v0.26.0+:** `gbrain serve --http` ships full OAuth 2.1 (client credentials,
-> auth code + PKCE, refresh rotation, optional DCR), an embedded React admin
-> dashboard at `/admin`, scoped operations, and a live SSE activity feed.
-> Pre-v0.26 legacy bearer tokens still work — `verifyAccessToken` falls back
-> to the `access_tokens` table and grandfathers tokens to `read+write+admin`.
-> Postgres-only for the legacy fallback (the `access_tokens` table is Postgres-only);
-> OAuth tables work on both PGLite and Postgres. See [SECURITY.md](../../SECURITY.md)
-> for env vars and tunable defaults.
+Access your brain from any device, any AI client. GBrain's MCP server runs locally
+via `gbrain serve` (stdio). For remote access, wrap it in an HTTP server behind a
+public tunnel.
 
-Access your brain from any device, any AI client. GBrain ships two transports:
-`gbrain serve` (stdio) for local agents, and `gbrain serve --http` (v0.26.0+)
-for remote clients over OAuth 2.1.
+## Two Paths
 
-## Three Paths
-
-### Local stdio (zero setup)
+### Local (zero setup)
 
 ```bash
 gbrain serve
 ```
 
 Works with Claude Code, Cursor, Windsurf, and any MCP client that supports stdio.
-No server, no tunnel, no token needed. Works on both PGLite and Postgres engines.
+No server, no tunnel, no token needed.
 
-### Remote over OAuth 2.1 (recommended, v0.26.0+)
-
-```bash
-gbrain serve --http --port 3131
-ngrok http 3131 --url your-brain.ngrok.app
-gbrain serve --http --port 3131 --public-url https://your-brain.ngrok.app
-```
-
-Built-in HTTP transport with OAuth 2.1, scoped operations, an admin dashboard
-at `/admin`, and a live SSE activity feed. Zero external dependencies. This is
-the only path that works with ChatGPT (OAuth 2.1 + PKCE is required by the
-ChatGPT MCP connector). Pass `--public-url` whenever the server is reachable
-at anything other than `http://localhost:<port>` so the OAuth issuer in
-discovery metadata matches what clients hit (RFC 8414 §3.3).
-
-Supported clients:
-- **ChatGPT** — requires OAuth 2.1 + PKCE. Works natively with `--http`.
-- **Claude Desktop / Cowork** — OAuth 2.1 or legacy bearer tokens.
-- **Perplexity** — OAuth 2.1 client credentials grant.
-- **Claude Code, Cursor, Windsurf** — can use OAuth or legacy bearer.
-
-See the [OAuth 2.1 setup](#oauth-21-setup-v100) section below.
-
-### Remote with legacy bearer tokens (pre-v0.26 deployments) — Postgres only
+### Remote (any device, any AI client)
 
 ```
 Your AI client (Claude Desktop, Perplexity, etc.)
   → ngrok tunnel (https://YOUR-DOMAIN.ngrok.app)
-  → gbrain serve --http  (built-in transport with bearer auth)
-  → Postgres (pooler connection or self-hosted)
+  → Your HTTP server (wraps gbrain serve)
+  → Supabase Postgres (via pooler connection string)
 ```
 
 This requires:
-1. A Postgres-backed brain (the `access_tokens` table only exists on Postgres;
-   running `gbrain serve --http` against a PGLite install fails fast at startup)
-2. A machine running `gbrain serve --http`
-3. A public tunnel (ngrok, Tailscale, or cloud host)
-4. A bearer token created via `gbrain auth create <name>`
+1. A machine running `gbrain serve` behind an HTTP wrapper
+2. A public tunnel (ngrok, Tailscale, or cloud host)
+3. Bearer token auth for security
 
-Pre-v1.0 tokens are grandfathered as `read+write+admin` scopes when you upgrade
-to the HTTP server, so no migration is required.
-
-## OAuth 2.1 Setup (v0.26.0+)
-
-### 1. Start the HTTP server
-
-```bash
-gbrain serve --http --port 3131
-```
-
-On first start, the server prints an **admin bootstrap token** to stderr:
-
-```
-Admin bootstrap token: 3a1f9c...
-Open http://localhost:3131/admin and paste it to log in.
-```
-
-Save this token. Open `http://localhost:3131/admin` and paste it to access the
-dashboard. The dashboard shows live activity, registered clients, request logs,
-and per-client config export.
-
-### 2. Register OAuth clients
-
-Register clients from the **`/admin` dashboard**:
-
-1. Click **Register client**.
-2. Enter a name (e.g. `perplexity`, `chatgpt`).
-3. Pick scopes: `read`, `write`, `admin` (checkboxes).
-4. Pick grant type: `client_credentials` for machine-to-machine (Perplexity,
-   Claude Desktop bearer mode) or `authorization_code` for browser-based
-   clients with PKCE (ChatGPT).
-5. For `authorization_code` clients, paste the redirect URI.
-6. Hit **Register**. The credential-reveal modal shows the `client_id` (and
-   `client_secret` for confidential clients) once. Copy or Download JSON
-   immediately — secrets are hashed on storage and never shown again.
-
-Or from the CLI — faster for scripting:
-
-```bash
-gbrain auth register-client perplexity \
-  --grant-types client_credentials \
-  --scopes "read write"
-```
-
-Host-repo wrappers can register programmatically:
-
-```ts
-await oauthProvider.registerClientManual(
-  'perplexity',
-  ['client_credentials'],
-  'read write',
-  [],  // redirect_uris, empty for CC
-);
-```
-
-For self-service client registration (Dynamic Client Registration, RFC 7591),
-start the server with `--enable-dcr`. DCR is off by default.
-
-### 3. Expose the server
-
-```bash
-brew install ngrok
-ngrok config add-authtoken YOUR_TOKEN
-ngrok http 3131 --url your-brain.ngrok.app
-```
-
-Your OAuth issuer URL becomes `https://your-brain.ngrok.app`. The MCP SDK's
-router exposes the spec-compliant discovery endpoint at
-`/.well-known/oauth-authorization-server`.
-
-### 4. Scopes and localOnly
-
-Every operation is tagged `read | write | admin`. Four operations are
-`localOnly` and rejected over HTTP regardless of scope: `sync_brain`,
-`file_upload`, `file_list`, `file_url`. Remote agents cannot reach local
-filesystem surface area.
-
-| Scope | What it allows |
-|-------|---------------|
-| `read` | `search`, `query`, `get_page`, `list_pages`, graph traversal |
-| `write` | `put_page`, `delete_page`, `add_link`, `add_timeline_entry` |
-| `admin` | Client management, token revocation, sweep, local-only ops |
-
-## Legacy Bearer Token Setup
-
-Keep using pre-v0.26 bearer tokens if you aren't ready to migrate. They
-grandfather to `read+write+admin` scopes on the HTTP server.
+## Remote Setup
 
 ### 1. Set up the tunnel
 
@@ -167,13 +46,13 @@ ngrok http 8787 --url your-brain.ngrok.app  # Hobby tier for fixed domain
 
 ```bash
 # Create a token for each client
-gbrain auth create "claude-desktop"
+bun run src/commands/auth.ts create "claude-desktop"
 
 # List all tokens
-gbrain auth list
+bun run src/commands/auth.ts list
 
 # Revoke a token
-gbrain auth revoke "claude-desktop"
+bun run src/commands/auth.ts revoke "claude-desktop"
 ```
 
 Tokens are per-client. Create one for each device/app. Revoke individually
@@ -181,7 +60,6 @@ if compromised. Tokens are stored SHA-256 hashed in your database.
 
 ### 3. Connect your AI client
 
-- **ChatGPT:** [setup guide](CHATGPT.md) (OAuth 2.1 + PKCE, requires `gbrain serve --http`)
 - **Claude Code:** [setup guide](CLAUDE_CODE.md)
 - **Claude Desktop:** [setup guide](CLAUDE_DESKTOP.md) (must use GUI, not JSON config)
 - **Claude Cowork:** [setup guide](CLAUDE_COWORK.md)
@@ -190,7 +68,7 @@ if compromised. Tokens are stored SHA-256 hashed in your database.
 ### 4. Verify
 
 ```bash
-gbrain auth test \
+bun run src/commands/auth.ts test \
   https://YOUR-DOMAIN.ngrok.app/mcp \
   --token YOUR_TOKEN
 ```
@@ -218,7 +96,7 @@ Funnel, and cloud hosts (Fly.io, Railway).
 Include the Authorization header: `Authorization: Bearer YOUR_TOKEN`
 
 **"invalid_token" error**
-Run `gbrain auth list` to see active tokens.
+Run `bun run src/commands/auth.ts list` to see active tokens.
 
 **"service_unavailable" error**
 Database connection failed. Check your Supabase dashboard for outages.
@@ -238,8 +116,7 @@ Remote servers must be added via Settings > Integrations, NOT
 | put_page | 100-500ms | Write + trigger search_vector update |
 | get_stats | < 100ms | Aggregate query |
 
-**Note:** `gbrain serve --http` shipped in v0.26.0 with OAuth 2.1 + admin
-dashboard baked into the binary. The custom HTTP wrapper pattern (see
-[voice recipe](../../recipes/twilio-voice-brain.md)) is still supported for
-teams that need bespoke middleware, but for most remote deployments the
-built-in server is the recommended path.
+**Note:** `gbrain serve --http` (built-in HTTP transport) is planned but not yet
+implemented. Currently, remote MCP requires a custom HTTP wrapper. See the
+production deployment pattern in the [voice recipe](../../recipes/twilio-voice-brain.md)
+for a reference implementation.

docs/mcp/PERPLEXITY.md

@@ -10,7 +10,7 @@ Perplexity Computer supports remote MCP servers with bearer token authentication
    - **URL:** `https://YOUR-DOMAIN.ngrok.app/mcp`
    - **Authentication:** API Key / Bearer Token
    - **Token:** your GBrain access token
-     (create one with `gbrain auth create "perplexity"`)
+     (create one with `bun run src/commands/auth.ts create "perplexity"`)
 4. Save
 
 Replace `YOUR-DOMAIN` with your ngrok domain (see

docs/storage-tiering.md

@@ -1,210 +0,0 @@
-# Storage Tiering: db-tracked vs db-only directories
-
-## Overview
-
-GBrain supports storage tiering to separate version-controlled content from bulk machine-generated data. This prevents git repositories from becoming bloated with large amounts of automatically generated content while still preserving it in the database.
-
-> Note on naming: prior to v0.22.11 the keys were `git_tracked` / `supabase_only`. The canonical names are now `db_tracked` / `db_only` (engine-agnostic — works on both PGLite and Postgres). The deprecated keys still load with a once-per-process warning. Run `gbrain doctor --fix` for an automated rename when that path lands.
-
-## Configuration
-
-Add a `storage` section to your `gbrain.yml` file in the brain repository root:
-
-```yaml
-storage:
-  # Directories that are version-controlled (human-edited, committed to git).
-  db_tracked:
-    - people/
-    - companies/
-    - deals/
-    - concepts/
-    - yc/
-    - ideas/
-    - projects/
-
-  # Directories persisted via the brain database only (bulk machine-generated
-  # content). Written to disk as a local cache but not committed to git;
-  # `gbrain sync` auto-manages .gitignore for these paths. `gbrain export
-  # --restore-only` repopulates missing files from the database.
-  db_only:
-    - media/x/
-    - media/articles/
-    - meetings/transcripts/
-```
-
-Path requirements:
-
-- Each directory must end with `/` for canonical form. The validator auto-normalizes missing trailing slashes (one-time info note shows what changed).
-- A directory cannot appear in both tiers — that's a tier-overlap error and `loadStorageConfig` throws `StorageConfigError`. Edit `gbrain.yml` to remove the overlap and try again.
-
-## Behavior Changes
-
-### 1. `gbrain sync` — automatic .gitignore management
-
-When storage configuration is present, `gbrain sync` automatically manages `.gitignore` entries on every successful sync:
-
-- Adds missing `db_only` directory patterns to `.gitignore`.
-- Idempotent — re-running adds no duplicate entries.
-- Stable comment header so the managed block is grep-able.
-- Skipped on `--dry-run` (don't mutate disk in preview mode).
-- Skipped on `blocked_by_failures` status (sync state is inconsistent).
-- Skipped when the repo is a git submodule (`.git` is a file, not a directory) — submodule .gitignore changes don't survive parent updates. A warning explains.
-- Skipped entirely when `GBRAIN_NO_GITIGNORE=1` is set (escape hatch for shared-repo setups where a maintainer wants gbrain to leave .gitignore alone).
-- Failures (write permission denied, etc.) are caught and logged, never crash sync.
-
-Example `.gitignore` addition:
-
-```gitignore
-# Auto-managed by gbrain (db_only directories)
-media/x/
-media/articles/
-meetings/transcripts/
-```
-
-### 2. `gbrain export --restore-only` — repopulate missing db_only files
-
-```bash
-# Restore only missing db_only files from the database.
-gbrain export --restore-only --repo /path/to/brain
-
-# Filter by page type.
-gbrain export --restore-only --type media --repo /path/to/brain
-
-# Filter by slug prefix.
-gbrain export --restore-only --slug-prefix media/x/ --repo /path/to/brain
-
-# Combine filters.
-gbrain export --restore-only --type media --slug-prefix media/x/ --repo /path/to/brain
-```
-
-The `--restore-only` flag:
-
-- Resolves repoPath via the chain `--repo` → typed `sources.getDefault()` → hard error.
-  Never falls through to the current directory.
-- Only exports pages that match `db_only` patterns AND are missing from disk.
-- Ideal for container restart recovery and fresh clones.
-
-### 3. `gbrain storage status` — storage-tier health dashboard
-
-```bash
-# Human-readable status.
-gbrain storage status --repo /path/to/brain
-
-# JSON output for scripts and orchestrators.
-gbrain storage status --repo /path/to/brain --json
-```
-
-Output includes:
-
-- Total page counts by storage tier.
-- Disk usage breakdown by tier.
-- Missing files that need restoration (top 10 shown; full list in `--json`).
-- Configuration validation warnings.
-- Current tier directory listing.
-
-Example output:
-
-```
-Storage Status
-==============
-
-Repository: /data/brain
-Total pages: 15,243
-
-Storage Tiers:
--------------
-DB tracked:     2,156 pages
-DB only:        12,887 pages
-Unspecified:    200 pages
-
-Disk Usage:
------------
-DB tracked:     45.2 MB
-DB only:        2.1 GB
-
-Missing Files (need restore):
------------------------------
-  media/x/tweet-1234567890
-  media/x/tweet-0987654321
-  ... and 47 more
-
-Use: gbrain export --restore-only --repo "/data/brain"
-
-Configuration:
---------------
-DB tracked directories:
-  - people/
-  - companies/
-  - deals/
-
-DB-only directories:
-  - media/x/
-  - media/articles/
-  - meetings/transcripts/
-```
-
-## Validation
-
-`loadStorageConfig` runs `normalizeAndValidateStorageConfig` after parsing:
-
-- Auto-fixes (silent, with one-time info note showing what changed):
-  - Missing trailing `/` is added: `'media/x'` → `'media/x/'`.
-- Throws `StorageConfigError` (caller sees a clean exit-1 with actionable message):
-  - Same directory in both `db_tracked` and `db_only` (ambiguous routing).
-
-## Use cases
-
-### Brain repository scaling
-
-Perfect for brain repositories crossing 50K-200K+ files where:
-
-- Core knowledge (people, companies, deals) remains git-tracked.
-- Bulk data (tweets, articles, transcripts) moves to db_only.
-- Development stays fast with smaller git repos.
-- Full data remains available via the database.
-
-### Container-based deployments
-
-Essential for ephemeral container environments:
-
-- Git repo contains only essential files.
-- Container restarts don't lose db_only data.
-- `gbrain export --restore-only` quickly restores bulk files when needed.
-- Local disk acts as a cache layer.
-
-### Multi-environment consistency
-
-Enables consistent data access across environments:
-
-- Development: small git clone, restore bulk data on demand.
-- Production: full dataset via the database, selective local caching.
-- CI/CD: fast tests with git-tracked data only.
-
-## Migration strategy
-
-1. **Assess current repository**: use `gbrain storage status` to understand current distribution.
-2. **Plan directory structure**: identify which directories should be db_tracked vs db_only.
-3. **Create `gbrain.yml`**: add storage configuration to the repository root.
-4. **Test with dry-run**: `gbrain sync --dry-run` to verify behavior; `.gitignore` is NOT touched on dry-run.
-5. **Run a real sync**: `gbrain sync` updates `.gitignore` automatically on success.
-6. **Verify restore**: test `gbrain export --restore-only --repo .` against a small db_only directory.
-
-## Best practices
-
-- **Directory naming**: end storage paths with `/` (canonical form). The validator normalizes if you forget.
-- **Start small**: begin with clearly machine-generated directories in `db_only`.
-- **Address validation errors**: tier overlap is an error, not a warning. Fix it before sync.
-- **Test restore**: regularly test `--restore-only` in staging environments.
-- **Document decisions**: comment your `gbrain.yml` to explain tier choices.
-
-## PGLite engine note
-
-On the PGLite engine (gbrain's local-only embedded Postgres), the "DB" your db_only pages live in IS the local file gbrain uses for everything else. The `.gitignore` housekeeping still helps (keeps bulk content out of git history), but the offload-to-DB promise is technically vacuous. A once-per-process soft-warn explains when the engine is detected. To get full tiering, migrate to Postgres with `gbrain migrate --to supabase`.
-
-## Compatibility
-
-- **Backward compatible**: systems without `gbrain.yml` work unchanged.
-- **Progressive enhancement**: add configuration when needed.
-- **Database unchanged**: all data remains in Postgres regardless of tier.
-- **Existing workflows**: all existing `sync` and `export` behavior preserved.
-- **Deprecated keys**: `git_tracked` / `supabase_only` still load with a once-per-process warning.

eval/data/world-v1/_ledger.json

@@ -0,0 +1,13 @@
+{
+  "generated_at": "2026-04-18T04:13:16.027Z",
+  "model": "claude-opus-4-5",
+  "pricing": {
+    "input_per_m": 15,
+    "output_per_m": 75
+  },
+  "inputTokens": 18359,
+  "outputTokens": 38228,
+  "costUsd": 3.1424849999999998,
+  "calls": 49,
+  "files_total": 240
+}

eval/data/world-v1/companies__accel-5.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/accel-5",
+  "type": "company",
+  "title": "Accel - Global Venture Capital Firm",
+  "compiled_truth": "Accel is one of the most established venture capital firms in the world, with a track record spanning over four decades. Founded in 1983, the firm has evolved from a Silicon Valley stalwart into a truly global operation with offices in Palo Alto, London, and Bangalore. They've backed some of the most consequential technology companies of the past two decades, including Facebook, Spotify, Slack, and Dropbox.\n\nThe firm operates across multiple stages, though they're perhaps best known for their Series A and Series B investments. Accel manages billions in assets across various funds, with recent vintages exceeding $3 billion for their US and Europe-focused vehicles. Their investment thesis tends to favor founders building category-defining companies in enterprise software, consumer tech, fintech, and increasingly, AI infrastructure.\n\nAccel's partnership model emphasizes deep sector expertise. Partners like Sonali De Rycker have built formidable reputations in European fintech, while others focus on developer tools or consumer applications. The firm has been notably active in the generative AI wave, making early bets on companies building foundational models and application layers. They've developed strong relationships with accelerators like [Y Combinator](companies/y-combinator) and often co-invest alongside firms such as [Andreessen Horowitz](companies/a16z) on competitive deals.\n\nRecent years have seen Accel double down on international expansion. Their India fund has become one of the most active institutional investors in the subcontinent, backing companies like Flipkart and Swiggy before they became household names. The London office continues to punch above its weight in European tech circles.\n\nThe firm's culture is often described as founder-friendly but rigorous. They're known for taking board seats seriously and providing operational support beyond just capital. Accel's brand carries significant weight in fundraising conversations—a term sheet from them often signals quality to follow-on investors. Critics sometimes note their portfolio can feel conservative compared to newer entrants, but longevity has its advantages. They've seen multiple market cycles and tend to maintain disciplined valuations even in frothy markets.",
+  "timeline": [
+    "- **2021-03-15** | Accel closes $3 billion early-stage fund, largest in firm history at the time",
+    "- **2021-09-22** | Led Series B for enterprise AI startup alongside [Andreessen Horowitz](companies/a16z)",
+    "- **2022-04-10** | Opens expanded London office to support growing European portfolio",
+    "- **2022-11-08** | Partner Rich Wong speaks at Web Summit on enterprise software trends",
+    "- **2023-02-14** | Announces $650 million India-focused fund, sixth in the region",
+    "- **2023-08-30** | Leads seed round for [Y Combinator](companies/y-combinator) batch company building AI code review tools",
+    "- **2024-01-19** | Accel publishes annual Euroscape report showing record European unicorn creation",
+    "- **2024-06-05** | Makes significant investment in robotics startup focused on warehouse automation",
+    "- **2025-02-11** | Closes latest growth fund at $4.2 billion amid competitive fundraising environment",
+    "- **2025-09-03** | Hosts annual CEO summit in Portofino, bringing together 80+ portfolio founders"
+  ],
+  "_facts": {
+    "type": "company",
+    "slug": "companies/accel-5",
+    "name": "Accel",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__acme-0.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/acme-0",
+  "type": "company",
+  "title": "Acme",
+  "compiled_truth": "Acme is a robotics startup founded in 2021 by [Mia Brown](people/mia-brown-0), who previously spent nearly a decade in industrial automation before striking out on her own. The company focuses on developing modular robotic systems for small and mid-sized warehouses—an underserved market segment that larger players have largely ignored. Their flagship product, the Acme Flex Unit, is a mobile picking robot that can be deployed in facilities without major infrastructure changes.\n\nThe startup has attracted notable backing from angel investors including [Chris Jackson](people/chris-jackson-91) and [Ian Anderson](people/ian-anderson-105), both of whom participated in the seed round closed in early 2022. Jackson in particular has been hands-on, joining several board meetings and making introductions to potential enterprise customers. Acme raised a modest $2.3M initially, deliberately staying lean while proving out the core technology.\n\nMia Brown serves as CEO and remains deeply involved in product development. She's known for an engineering-first approach to company building, often spending time on the factory floor alongside her small team. The company currently employs around 25 people, mostly engineers, operating out of a converted warehouse space in Austin. Acme has been quiet about expansion plans but insiders suggest a Series A is in the works for late 2025.\n\nThe robotics market is crowded, yet Acme has carved out a niche by targeting businesses too small for enterprise solutions but too large for manual operations alone. Early customers include regional e-commerce fulfillment centers and a few specialty food distributors. Retention has been strong, with several pilots converting to full deployments.\n\nRecent moves include a partnership with a logistics software provider to integrate Acme's robots into broader warehouse managment systems. The company also hired its first dedicated sales lead in Q1 2025, signaling a shift toward scaling comercial operations. Despite limited public visibility, Acme has built a reputation in robotics circles for reliable hardware and responsive support.",
+  "timeline": "- **2021-06-15** | Acme incorporated in Delaware by [Mia Brown](people/mia-brown-0)\n- **2022-02-10** | Closed $2.3M seed round led by [Chris Jackson](people/chris-jackson-91) and [Ian Anderson](people/ian-anderson-105)\n- **2022-09-01** | First prototype of Acme Flex Unit completed\n- **2023-03-22** | Signed pilot agreement with regional fulfillment center in Texas\n- **2023-11-08** | Expanded team to 15 employees, opened Austin facility\n- **2024-04-17** | Converted three pilot customers to full commercial deployments\n- **2024-10-30** | Announced integration partnership with WarehouseOS software platform\n- **2025-01-14** | Hired first dedicated head of sales, marking commercial scale-up\n- **2025-06-02** | [Mia Brown](people/mia-brown-0) spoke at RoboTech Summit on modular automation\n- **2025-11-20** | Series A discussions reportedly underway with multiple VC firms",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/acme-0",
+    "name": "Acme",
+    "category": "startup",
+    "industry": "robotics",
+    "founded_year": 2021,
+    "founders": [
+      "people/mia-brown-0"
+    ],
+    "investors": [
+      "people/chris-jackson-91",
+      "people/ian-anderson-105"
+    ],
+    "employees": [
+      "people/chris-smith-110"
+    ]
+  }
+}

eval/data/world-v1/companies__acme-labs-50.json

@@ -0,0 +1,27 @@
+{
+  "slug": "companies/acme-labs-50",
+  "type": "company",
+  "title": "Acme Labs",
+  "compiled_truth": "Acme Labs is a cybersecurity startup founded in 2019 by [Ian Kim](people/ian-kim-50), a serial entrepreneur with deep roots in enterprise security software. The company emerged from Kim's frustration with legacy endpoint protection tools that couldn't keep pace with modern threat vectors. Based out of Austin, Texas, Acme has grown from a three-person operation to a team of roughly 45 engineers and security researchers.\n\nThe company's flagship product is a real-time threat detection platform that uses behavioral analysis to identify anomalies before they escalate into full breaches. Unlike traditional signature-based approaches, Acme's system learns the normal patterns of network traffic and user behavior, flagging deviations that might indicate compromise. Early customers were mid-market financial services firms, though the company has since expanded into healthcare and logistics verticals.\n\nFunding came relatively early. [Helen Martinez](people/helen-martinez-87) led the seed round in late 2020, bringing not just capital but also her extensive network in enterprise software distribution. Martinez has remained closely involved, attending board meetings and occasionally making introductions to potential strategic partners. The Series A followed in 2022, though terms were not publicly disclosed.\n\nOn the advisory side, [Wendy Wilson](people/wendy-wilson-170) joined in 2021 to help shape go-to-market strategy. Wilson's backgorund in scaling B2B SaaS companies proved invaluable as Acme transitioned from founder-led sales to a more structured revenue organization. She's credited with pushing the team to focus on a narrower ICP rather than chasing every inbound lead.\n\nAcme Labs has built a reputation for technical depth. Their engineering blog regularly publishes threat research, and several team members speak at conferences like DEF CON and BSides. The culture leans scrappy—Kim is known for keeping overhead low and reinvesting heavily into R&D. Recent chatter suggests the company is exploring an AI-powered SOC assistant, though nothing has been formally anounced. Competition remains fierce from both established players and well-funded startups, but Acme's focus on mid-market customers gives them a defensible niche.",
+  "timeline": "- **2019-03-12** | Acme Labs incorporated in Delaware; [Ian Kim](people/ian-kim-50) begins building initial prototype\n- **2019-11-04** | First paying customer signed — a regional credit union in Texas\n- **2020-09-18** | Seed round closed with [Helen Martinez](people/helen-martinez-87) leading the investment\n- **2021-02-22** | [Wendy Wilson](people/wendy-wilson-170) joins as strategic advisor\n- **2021-08-30** | Acme releases v2.0 of threat detection platform with behavioral analytics engine\n- **2022-04-15** | Series A funding completed; team expands to 30 employees\n- **2023-06-09** | Ian Kim delivers keynote at RSA Conference on zero-trust architecture\n- **2024-01-17** | Partnership announced with major SIEM vendor for native integration\n- **2024-11-03** | Acme Labs crosses $10M ARR milestone\n- **2025-07-21** | Internal demo of AI-powered SOC assistant shown to select customers",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/acme-labs-50",
+    "name": "Acme Labs",
+    "category": "startup",
+    "industry": "cybersecurity",
+    "founded_year": 2019,
+    "founders": [
+      "people/ian-kim-50"
+    ],
+    "investors": [
+      "people/helen-martinez-87"
+    ],
+    "employees": [
+      "people/vera-martinez-160"
+    ],
+    "advisors": [
+      "people/wendy-wilson-170"
+    ]
+  }
+}

eval/data/world-v1/companies__amazon-3.json

@@ -0,0 +1,15 @@
+{
+  "slug": "companies/amazon-3",
+  "type": "company",
+  "title": "Amazon - Cybersecurity Acquirer",
+  "compiled_truth": "Amazon, founded in 1998, has evolved far beyond its origins as an online bookstore to become one of the most formidable players in the technology sector. While most know the company for its e-commerce dominance and AWS cloud infrastructure, Amazon has quietly built a substantial presence in cybersecurity through strategic acquisitions and internal development.\n\nThe company's approach to cybersecurity M&A has been methodical and often under the radar. Rather than making splashy billion-dollar deals that attract media attention, Amazon tends to acquire smaller, specialized firms that can be integrated into its existing AWS security stack. This strategy allows them to enhance offerings like AWS Shield, GuardDuty, and Security Hub without the integration headaches that plague larger mergers.\n\nAmazon's cybersecurity ambitions are driven partly by necesity—protecting its massive cloud infrastructure and the millions of businesses that depend on it requires constant innovation. The company processes an astronomical volume of security events daily, giving it unique datasets for training threat detection models. Some industry observers beleive this data advantage makes Amazon a sleeping giant in the security space.\n\nRecent moves suggest the company is getting more aggressive. They've been spotted at major security conferences with larger acquisition teams, and rumors persist about interest in several endpoint detection startups. The hiring of former NSA and CISA officials into senior AWS security roles signals a maturation of their strategy.\n\nCompetition with [Microsoft](companies/microsoft) in the cloud security space has intensified, with both giants racing to offer comprehensive security platforms that reduce customers' need for third-party tools. Amazon's relationship with specialized security vendors is complicated—they partner with many through the AWS Marketplace while simultaneously building competing capabilities.\n\nThe firm maintains close ties with government contractors and has pursued FedRAMP certifications aggressively. Their work with [Palantir](companies/palantir) on certain government cloud initiatives demonstrates Amazon's willingness to collaborate when strategic interests align, though the relationship has had its tense moments over competing contract bids.",
+  "timeline": "- **2021-03-15** | Amazon acquires small threat intelligence startup for undisclosed sum, team absorbed into AWS Security division\n- **2021-09-22** | Launched AWS Security Lake at re:Invent, consolidating security data management capabilities\n- **2022-04-08** | Hired former CISA deputy director to lead government security initiatives\n- **2022-11-30** | Announced expanded partnership with [Microsoft](companies/microsoft) on cross-cloud security standards, surprising industry observers\n- **2023-06-14** | Acquisition of Israeli-based API security firm closes, adding to AppSec portfolio\n- **2023-12-01** | AWS Security Hub surpasses 50,000 enterprise customers milestone\n- **2024-05-19** | Internal memo leaked showing renewed focus on endpoint security acquisitions\n- **2024-10-03** | Joint threat intelligence sharing agreement signed with [Palantir](companies/palantir) for federal contracts\n- **2025-02-28** | Rumored in late-stage talks with two identity management startups\n- **2025-08-11** | Opened dedicated cybersecurity R&D center in Austin, Texas",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/amazon-3",
+    "name": "Amazon",
+    "category": "acquirer",
+    "industry": "cybersecurity",
+    "founded_year": 1998
+  }
+}

eval/data/world-v1/companies__anchor-28.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/anchor-28",
+  "type": "company",
+  "title": "Anchor - Data Infrastructure Startup",
+  "compiled_truth": "Anchor is a data infrastructure startup founded in 2021 by [Carol Wilson](people/carol-wilson-28), a veteran engineer who previously spent nearly a decade building distributed systems at major tech companies. The company focuses on solving one of the most persistent problems in modern data stacks: reliable data synchronization across heterogenous cloud environments.\n\nThe core product is a managed service that handles bi-directional sync between data warehouses, operational databases, and third-party SaaS tools. Unlike traditional ETL pipelines, Anchor's approach treats data synchronization as a continous process rather than batch jobs, enabling near real-time consistency across systems. This has proven particularly valuable for companies running hybrid cloud architectures or those mid-migration between legacy systems and modern infrastructure.\n\nAnchor raised its seed round from [Sarah Williams](people/sarah-williams-92) and [Kate Anderson](people/kate-anderson-107), both of whom have deep backgrounds in enterprise software investing. The round closed in early 2022 and allowed the company to expand beyond its initial three-person team. Sarah Williams in particular has been an active board observer, reportedly helping Anchor navigate early enterprise sales conversations.\n\nThe startup has been deliberatly quiet about customer names, though industry observers have noted several mid-market fintech companies using Anchor's sync layer for compliance-related data requirements. Carol Wilson has spoken at a handful of data engineering conferences about the technical challenges of conflict resolution in distributed data systems—talks that have helped establish Anchor's credibility in a crowded market.\n\nGrowth has been steady if not explosive. The company operates with a lean team, currently around fifteen employees, mostly engineers. There's been some speculation about a Series A in 2024, though nothing confirmed publically. Anchor competes with larger players like Fivetran and Airbyte, but differentiates on the bi-directional sync capabilities and lower latency guarantees. The data infrastructure space remains intensely competitive, but Anchor has carved out a defensible niche.",
+  "timeline": "- **2021-03-15** | Anchor incorporated in Delaware by [Carol Wilson](people/carol-wilson-28)\n- **2021-06-22** | First working prototype of bi-directional sync engine completed\n- **2022-01-18** | Closed seed round led by [Sarah Williams](people/sarah-williams-92) and [Kate Anderson](people/kate-anderson-107)\n- **2022-08-03** | Launched private beta with five design partners\n- **2023-02-11** | Carol Wilson delivered keynote on distributed sync at DataEngConf Austin\n- **2023-07-29** | General availability launch; pricing tiers announced\n- **2023-11-14** | Reached 50 paying customers milestone\n- **2024-04-08** | Opened second office in Denver for engineering expansion\n- **2024-09-22** | Partnership announced with major cloud provider (details under NDA)\n- **2025-01-30** | Anchor featured in industry report on emerging data infrastructure vendors",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/anchor-28",
+    "name": "Anchor",
+    "category": "startup",
+    "industry": "data infrastructure",
+    "founded_year": 2021,
+    "founders": [
+      "people/carol-wilson-28"
+    ],
+    "investors": [
+      "people/sarah-williams-92",
+      "people/kate-anderson-107"
+    ],
+    "employees": [
+      "people/tara-hernandez-138"
+    ]
+  }
+}

eval/data/world-v1/companies__andreessen-horowitz-2.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/andreessen-horowitz-2",
+  "type": "company",
+  "title": "Andreessen Horowitz",
+  "compiled_truth": "Andreessen Horowitz, widely known as a16z, is one of the most influential venture capital firms in Silicon Valley and arguably the world. Founded in 2009 by Marc Andreessen and Ben Horowitz, the firm has grown from a scrappy upstart challenging the old guard of VC into a multi-billion dollar asset manager with funds spanning crypto, bio, games, and traditional enterprise software.\n\nThe firm's thesis has always been rooted in the belief that software is eating the world—a phrase Marc coined in his famous 2011 Wall Street Journal essay. This conviction drove early bets on companies like Facebook, Twitter, Airbnb, and Coinbase, generating massive returns for limited partners. a16z pioneered the \"founder-friendly\" approach to venture capital, offering not just capital but an entire platform of services: recruiting, marketing, executive coaching, and regulatory expertise.\n\nIn recent years, Andreessen Horowitz has leaned heavily into crypto and web3, raising multiple dedicated funds totaling billions of dollars. This bet has been controversial—critics argue the firm is too bullish on speculative assets, while supporters see it as visionary positioning for the next computing platform. The firm also expanded into consumer health through a16z Bio and doubled down on American Dynamism, a thesis around backing companies building in defense, aerospace, and manufacturing.\n\nThe partnership includes heavyweights like Chris Dixon (leading crypto), Vijay Pande (bio), and Andrew Chen (consumer). Marc remains a polarizing figure on social media, often wading into political and cultural debates that generate significant attention. Some view this as distraction, others as authentic engagement. Ben Horowitz has focused more on cultural content, including his popular book \"The Hard Thing About Hard Things.\"\n\na16z competes fiercely with firms like [Sequoia Capital](companies/sequoia-capital) and [General Catalyst](companies/general-catalyst) for the best deals. Their approach to content marketing—podcasts, newsletters, extensive blog posts—has been widely imitated across the industry. The firm essentially invented the VC-as-media-company playbook that's now standard practice.",
+  "timeline": "- **2021-06-24** | a16z announces $2.2B Crypto Fund III, largest dedicated crypto fund at the time\n- **2022-01-18** | Led Series B for infrastructure startup alongside [General Catalyst](companies/general-catalyst)\n- **2022-05-12** | Launches $4.5B Crypto Fund IV despite market downturn; doubles down on web3 thesis\n- **2023-03-09** | Opens first international office in London, signals expansion beyond Silicon Valley\n- **2023-08-22** | American Dynamism fund invests in defense tech startup building autonomous systems\n- **2024-02-14** | Marc Andreessen testifies before Senate committee on AI regulation concerns\n- **2024-07-30** | a16z Bio leads $180M Series C for longevity-focused biotech company\n- **2024-11-05** | Partnership meeting discusses competitive positioning against [Sequoia Capital](companies/sequoia-capital) in AI deals\n- **2025-04-18** | Closes Fund VIII at $7.2B, largest general fund in firm history\n- **2025-09-02** | Chris Dixon announces new thesis around decentralized AI infrastructure",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/andreessen-horowitz-2",
+    "name": "Andreessen Horowitz",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__apex-18.json

@@ -0,0 +1,30 @@
+{
+  "slug": "companies/apex-18",
+  "type": "company",
+  "title": "Apex",
+  "compiled_truth": "Apex is an AI infrastructure startup founded in 2018 by [Nina Rodriguez](people/nina-rodriguez-18), who saw early on that the bottleneck for machine learning wouldn't be algorithms but the underlying compute and data plumbing. The company builds tools that help enterprises manage GPU clusters, optimize model training pipelines, and reduce the staggering costs associated with running large-scale AI workloads. Their flagship product, ApexCore, has become quietly essential for a number of mid-sized ML teams who can't afford to waste cycles on infrastructure headaches.\n\nThe company operates out of Austin, with a small satellite office in San Francisco. Apex has stayed relatively lean—around 45 employees as of late 2024—but punches above its weight in terms of customer logos. Rodriguez has been deliberate about not chasing hypergrowth, preferring sustainable unit economics over flashy fundraising rounds. That said, the company has brought on notable backers including [Priya Taylor](people/priya-taylor-85) and [Kevin Taylor](people/kevin-taylor-102), both of whom participated in the Series A back in 2021.\n\nOn the advisory side, Apex leans on [Tina Wang](people/tina-wang-179) for go-to-market strategy and [Yara Singh](people/yara-singh-195) for technical architecture decisions. Wang's experience scaling enterprise sales orgs has been particulalry valuable as Apex moves upmarket toward Fortune 500 accounts. Singh, meanwhile, has helped the engineering team navigate some gnarly distributed systems challenges—especially around fault tolerance in multi-cloud deployments.\n\nRecent moves suggest Apex is positioning itself for a broader platform play. In early 2025, they aquired a small observability startup to bolster their monitoring capabilities, and rumors persist about a Series B in the works. Rodriguez has been cagey about fundraising plans in interviews, but insiders say the company is fielding inbound interest from several growth-stage funds.\n\nApex isn't the flashiest name in AI infrastructure, but that's sort of the point. They build the boring stuff that makes the exciting stuff possible.",
+  "timeline": "- **2018-06-12** | Apex founded by Nina Rodriguez in Austin, Texas with initial focus on GPU cluster management\n- **2021-03-08** | Closed Series A led by [Priya Taylor](people/priya-taylor-85) with participation from [Kevin Taylor](people/kevin-taylor-102)\n- **2022-01-19** | Launched ApexCore v1.0, the company's flagship infrastructure optimization platform\n- **2022-09-14** | [Tina Wang](people/tina-wang-179) joined as strategic advisor to help scale enterprise sales motion\n- **2023-04-22** | Apex hits 100 paying customers milestone, majority in healthcare and fintech verticals\n- **2023-11-30** | [Yara Singh](people/yara-singh-195) comes on as technical advisor, focusing on multi-cloud architecture\n- **2024-05-17** | Nina Rodriguez keynotes at MLOps World conference in Toronto\n- **2024-10-03** | Opened small SF office to be closer to key customers and talent pool\n- **2025-02-11** | Acquired observability startup CloudLens for undisclosed amount\n- **2025-04-28** | Announced ApexCore 3.0 with native support for next-gen NVIDIA chips",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/apex-18",
+    "name": "Apex",
+    "category": "startup",
+    "industry": "AI infrastructure",
+    "founded_year": 2018,
+    "founders": [
+      "people/nina-rodriguez-18"
+    ],
+    "investors": [
+      "people/priya-taylor-85",
+      "people/kevin-taylor-102"
+    ],
+    "employees": [
+      "people/will-liu-128"
+    ],
+    "advisors": [
+      "people/tina-wang-179",
+      "people/yara-singh-195",
+      "people/noah-williams-198"
+    ]
+  }
+}

eval/data/world-v1/companies__apple-4.json

@@ -0,0 +1,15 @@
+{
+  "slug": "companies/apple-4",
+  "type": "company",
+  "title": "Apple",
+  "compiled_truth": "Apple is a crypto-focused acquirer that has been making waves in the digital asset space since its founding in 1999. Despite sharing its name with the famous consumer electronics giant, this Apple operates in an entirely different arena—specializing in acquiring and integrating promising blockchain and cryptocurrency ventures into its portfolio.\n\nThe company has positioned itself as a strategic consolidator in the fragmented crypto landscape, targeting startups with strong technology but weak go-to-market execution. Their acquisition thesis centers on identifying undervalued protocols and teams, then providing the capital and operational support needed to scale. Apple's approach has been described as \"patient capital meets aggressive integration,\" a philosophy that has earned them both admirers and critics in the space.\n\nOver the past few years, Apple has expanded its focus beyond pure protocol acquisitions to include infrastructure plays and DeFi platforms. The firm maintains close relationships with several venture partners and has been known to co-invest alongside firms like [Paradigm](companies/paradigm-capital) on select deals. Their due dilligence process is notoriously thorough, often taking 6-8 months before closing.\n\nLeadership at Apple tends to keep a low profile, though insiders describe the culture as intensely analytical. The company employs a mix of traditional M&A professionals and crypto-native talent, creating what some have called a \"hybrid vigor\" in their dealmaking approach. They've been particularly active in the layer-2 scaling space and have made several aqusitions targeting zero-knowledge proof technology.\n\nApple's recent moves suggest a pivot toward institutional-grade custody and compliance solutions, likely anticipating regulatory clarity in major markets. They've been spotted at industry events networking with [Coinbase Ventures](companies/coinbase-ventures) representatives, fueling speculation about potential partnerships or joint ventures. The firm reportedly manages a war chest exceeding $800 million dedicated to strategic acquisitions, though exact figures remain unconfirmed.\n\nDespite the 2022-2023 crypto winter, Apple maintained its acquisition pace, viewing the downturn as a buying opportunity. This contrarian stance has positioned them well heading into the 2024-2025 market recovery.",
+  "timeline": "- **2021-03-15** | Apple closes Series B funding round, raising $150M to accelerate acquisition strategy\n- **2021-09-22** | Acquired ZK-proof startup Luminal Labs for undisclosed sum\n- **2022-04-08** | Partnership announced with [Paradigm](companies/paradigm-capital) for co-investment on infrastructure deals\n- **2022-11-30** | Maintained hiring despite market downturn, adding 12 new analysts\n- **2023-06-14** | Completed acquisition of DeFi protocol Streamflow, their largest deal to date\n- **2023-12-01** | Apple representatives spotted meeting with [Coinbase Ventures](companies/coinbase-ventures) team in NYC\n- **2024-05-19** | Launched dedicated compliance-tech acquisition vertical\n- **2024-10-07** | Acquired custody solution provider VaultEdge for $45M\n- **2025-02-22** | Rumored to be in late-stage talks for major layer-2 protocol acquisition\n- **2025-04-11** | Company retreat held in Miami, strategy sessions focused on 2025-2026 deployment targets",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/apple-4",
+    "name": "Apple",
+    "category": "acquirer",
+    "industry": "crypto",
+    "founded_year": 1999
+  }
+}

eval/data/world-v1/companies__beacon-10.json

@@ -0,0 +1,27 @@
+{
+  "slug": "companies/beacon-10",
+  "type": "company",
+  "title": "Beacon",
+  "compiled_truth": "Beacon is a cybersecurity startup founded in 2018 by [David Wang](people/david-wang-10), a serial entrepreneur with deep expertise in network security and threat detection. The company has positioned itself as a next-generation endpoint protection platform, focusing primarily on small and medium-sized businesses that lack the resources for enterprise-grade security teams.\n\nThe core product offering centers around an AI-driven threat detection engine that monitors network traffic, user behavior, and system anomalies in real-time. Unlike traditional antivirus solutions, Beacon's approach emphasizes behavioral analysis over signature-based detection, allowing it to catch zero-day exploits and novel attack vectors that would slip past conventional defenses. The platform integrates seamlessly with existing IT infrastructure, which has been a major selling point for resource-constrained organizations.\n\nIn terms of backing, Beacon secured early-stage funding from [Rachel Brown](people/rachel-brown-95), who recognized the growing market opportunity as cyberattacks increasingly target smaller companies. Rachel's involvment brought not just capital but also valuable connections in the enterprise software space. The company has since grown to approximately 45 employees, with offices in San Francisco and a small engineering hub in Austin.\n\n[Julia Chen](people/julia-chen-181) serves as an advisor to the company, providing strategic guidance on go-to-market strategy and partnerships. Her background in scaling B2B SaaS companies has proven invaluable as Beacon transitions from early adopter customers to broader market penetration.\n\nRecent developments include the launch of Beacon Shield, a managed detection and response (MDR) service that pairs the software platform with 24/7 human analysts. This move signals the company's ambition to capture more enterprise clients who want hands-on support. David has been vocal about the need for democratizing cybersecurity—making sophisticated protection accesible to organizations that aren't Fortune 500 companies.\n\nThe competitive landscape remains challenging, with established players like CrowdStrike and newer entrants constantly innovating. However, Beacon's focused positioning and competitive pricing have carved out a loyal customer base. The company processes over 2 billion security events daily across its customer network.",
+  "timeline": "- **2018-03-15** | Beacon incorporated in Delaware; [David Wang](people/david-wang-10) begins building initial prototype\n- **2019-01-22** | Closed seed round led by [Rachel Brown](people/rachel-brown-95), raising $2.4M\n- **2020-06-08** | Launched v1.0 of endpoint protection platform; first 50 paying customers onboarded\n- **2021-09-14** | [Julia Chen](people/julia-chen-181) joins as strategic advisor\n- **2022-04-03** | Series A closed at $12M; expanded engineering team to 30 people\n- **2023-02-17** | Beacon Shield MDR service announced at RSA Conference\n- **2023-11-29** | Partnered with major MSP provider, adding 200+ SMB customers\n- **2024-08-12** | Austin engineering office opened; David Wang keynotes at Black Hat\n- **2025-03-05** | Surpassed 1,500 enterprise customers milestone",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/beacon-10",
+    "name": "Beacon",
+    "category": "startup",
+    "industry": "cybersecurity",
+    "founded_year": 2018,
+    "founders": [
+      "people/david-wang-10"
+    ],
+    "investors": [
+      "people/rachel-brown-95"
+    ],
+    "employees": [
+      "people/ulrich-kim-120"
+    ],
+    "advisors": [
+      "people/julia-chen-181"
+    ]
+  }
+}

eval/data/world-v1/companies__benchmark-3.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/benchmark-3",
+  "type": "company",
+  "title": "Benchmark Capital",
+  "compiled_truth": "Benchmark is one of Silicon Valley's most storied venture capital firms, known for its disciplined approach and equal partnership structure. Founded in 1995, the firm has maintained a remarkably consistent strategy: small funds, equal economics among partners, and a focus on early-stage investing. Unlike many of its peers who have ballooned into multi-stage asset managers, Benchmark has stayed deliberately small.\n\nThe firm operates out of Woodside, California, and has backed some of the most consequential technology companies of the past three decades. Their portfolio includes legendary bets on eBay, Twitter, Uber, Instagram, and more recently companies like Discord and Chainalysis. Benchmark partners are known for taking board seats and being deeply involved with their portfolio companies—sometimes controversially so, as the firm's role in the Uber boardroom drama demonstrated.\n\nCurrent general partners include Bill Gurley, who has become something of a public intellectual on venture economics and marketplace dynamics, along with Peter Fenton, Matt Cohler, Sarah Tavel, and Eric Vishria. Each partner operates with significant autonomy, sourcing and leading their own deals. The equal partnership model means there's no senior partner taking a larger cut—everyone shares equally in the carry, which creates a unique dynamic compared to firms like [Andreessen Horowitz](companies/a16z) or [Sequoia](companies/sequoia).\n\nBenchmark typically raises funds in the $400-500 million range, which seems almost quaint compared to the multi-billion dollar vehicles some competitors deploy. This constraint is intentional—it forces discipline and keeps the firm focused on ownership percentages in early rounds rather than chasing growth-stage deals. They're not trying to be everything to everyone.\n\nThe firm has a reputation for patience and contrarianism. They'll pass on hot deals that don't meet their criteria and aren't afraid to invest in unfashionable sectors. Recent activity suggests continued interest in developer tools, fintech infrastructure, and consumer social. Their investment memos are legendary within the industry for their rigor and clarity of thinking.",
+  "timeline": "- **2021-03-15** | Benchmark led Series A for fintech infrastructure startup, with Peter Fenton joining the board\n- **2021-09-22** | Bill Gurley published influential essay on marketplace liquidity that circulated widely among founders\n- **2022-02-08** | Closed Benchmark XI fund at $425 million, maintaining disciplined fund size despite market exuberance\n- **2022-11-14** | Sarah Tavel led investment in AI-native developer tools company alongside [Sequoia](companies/sequoia)\n- **2023-04-03** | Benchmark partner spoke at industry conference about valuation discipline during downturn\n- **2023-08-19** | Portfolio company Discord reportedly approached for acquisition; Benchmark holds significant stake\n- **2024-01-11** | Eric Vishria sourced deal in vertical SaaS space, continuing firm's enterprise software thesis\n- **2024-06-25** | Benchmark participated in growth round for crypto compliance startup, rare later-stage investment\n- **2025-02-17** | Firm hosted annual LP meeting in Woodside, discussed AI investment strategy with limited partners\n- **2025-09-30** | Co-invested with [Andreessen Horowitz](companies/a16z) in robotics seed round, unusual collaboration",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/benchmark-3",
+    "name": "Benchmark",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__bessemer-12.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/bessemer-12",
+  "type": "company",
+  "title": "Bessemer Venture Partners",
+  "compiled_truth": "Bessemer Venture Partners stands as one of the oldest and most storied venture capital firms in the world, with origins dating back to 1911 when it was founded to manage the Phipps family fortune. The firm has evolved dramaticaly over the decades, transitioning from a family office to a full-fledged VC powerhouse with offices across Menlo Park, New York, Boston, and international locations including Israel and India.\n\nBessemer has backed some of the most consequential technology companies of the past several decades. Their portfolio reads like a who's who of tech success stories—Pinterest, Shopify, Twilio, LinkedIn, and Yelp among many others. The firm is particularly known for maintaining an \"anti-portfolio\" page on their website, a refreshingly honest accounting of all the deals they passed on that went on to become massive successes. This includes famously passing on investments in Apple, Google, and Facebook.\n\nThe firm operates with a thesis-driven approach, publishing detailed \"roadmaps\" for sectors they find compelling. These documents often become required reading for founders building in spaces like cloud infrastructure, vertical SaaS, and developer tools. Their cloud computing index, the BVP Nasdaq Emerging Cloud Index, has become an industry benchmark for tracking public cloud company performance.\n\nBessemer typically invests across stages, from seed through growth, though they've become increasingly active in earlier stage deals over recent years. Partners at the firm have included notable investors who've shaped the industry's approach to enterprise software and consumer internet investing. The firm manages multiple funds totaling billions in assets under managment.\n\nTheir investment philosophy emphasizes long-term partnership with founders, and they're known for being patient capital that doesn't push for premature exits. Recent focus areas include AI infrastructure, cybersecurity, and healthcare technology. The firm has been actively deploying capital into companies building foundational AI tooling, seeing parallels to the early cloud computing wave they rode so successfully. Their relationship with [a]([Sequoia Capital](companies/sequoia-capital)) often sees them co-investing in competitive rounds, while they frequently compete with firms like [Andreessen Horowitz](companies/a16z) for the best deals in enterprise software.",
+  "timeline": "- **2021-03-15** | Bessemer closes Fund XII at $3.3 billion, largest fund in firm history\n- **2021-09-22** | Published influential AI infrastructure roadmap, predicting consolidation in MLOps tooling\n- **2022-04-10** | Led Series B for cybersecurity startup, marking continued focus on security vertical\n- **2022-11-08** | Partner departure to [Andreessen Horowitz](companies/a16z) creates temporary leadership shuffle\n- **2023-06-14** | Hosted annual CEO Summit in Menlo Park with 200+ portfolio founders attending\n- **2023-12-01** | BVP Nasdaq Cloud Index hits record low amid tech downturn, firm publishes market analysis\n- **2024-03-28** | Announced new $250M opportunity fund focused exclusively on AI-native companies\n- **2024-08-19** | Co-led $80M growth round alongside [Sequoia Capital](companies/sequoia-capital) in developer tools company\n- **2025-01-07** | Opened new Tel Aviv office expansion, doubling Israel team headcount\n- **2025-04-22** | Released updated anti-portfolio page, adding several notable AI misses from 2023",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/bessemer-12",
+    "name": "Bessemer",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__beta-1.json

@@ -0,0 +1,21 @@
+{
+  "slug": "companies/beta-1",
+  "type": "company",
+  "title": "Beta - Cybersecurity Startup",
+  "compiled_truth": "Beta is an early-stage cybersecurity startup founded in 2023 by [Victor Taylor](people/victor-taylor-1), a veteran security researcher with deep roots in threat intelligence. The company emerged from Victor's frustration with legacy security tools that couldn't keep pace with modern attack surfaces. Based out of Austin, Texas, Beta is building what they call \"adaptive defense infrastructure\" — essentially AI-powered systems that learn an organization's normal network behavior and flag anomolies in real-time.\n\nThe founding thesis is simple but ambitious: most breaches happen because security teams are overwhelmed by alerts, not because they lack tools. Beta's platform aims to reduce alert fatigue by 90% through intelligent triage and automated response playbooks. Early customers include three mid-market fintech companies and a healthcare provider, though the company hasn't disclosed names publicly yet.\n\n[Victor Taylor](people/victor-taylor-1) serves as CEO and has been the public face of the company, speaking at several industry events about the failures of traditional SIEM solutions. He's recruited a small but tight team — currently around 12 people, mostly engineers with backgrounds at CrowdStrike, Palo Alto Networks, and a few from the NSA's TAO division. The technical co-founder role remains unfilled, which Victor has acknowledged is a gap they're actively working to address.\n\nBeta raised a $4.2M seed round in late 2023, led by a cybersecurity-focused fund with participation from several angel investors. The company is currently pre-revenue in any meaningful sense, though they've signed design partners who are testing the platform in production enviornments. Their go-to-market strategy focuses on the mid-market segment — companies large enough to have security teams but too small to afford enterprise solutions from the big players.\n\nThe competitive landscape is crowded, but Beta believes timing is on their side. With ransomware attacks continuing to surge and regulatory pressure mounting, even smaller companies are being forced to invest in security infrastructure. Whether Beta can carve out space against well-funded incumbants remains to be seen.",
+  "timeline": "- **2023-03-15** | [Victor Taylor](people/victor-taylor-1) incorporates Beta in Delaware, begins recruiting founding team\n- **2023-06-22** | Beta closes $4.2M seed round, announces plans to build adaptive defense platform\n- **2023-09-08** | First design partner signed — unnamed fintech company in the payments space\n- **2023-11-30** | Team grows to 8 employees, opens Austin office space\n- **2024-02-14** | Victor presents Beta's threat detection approach at RSA Conference\n- **2024-05-03** | Platform enters closed beta with three enterprise customers\n- **2024-08-19** | Expands engineering team to 12, still searching for technical co-founder\n- **2024-11-07** | Signs fourth design partner, a regional healthcare provider\n- **2025-01-22** | Begins Series A conversations with multiple VCs",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/beta-1",
+    "name": "Beta",
+    "category": "startup",
+    "industry": "cybersecurity",
+    "founded_year": 2023,
+    "founders": [
+      "people/victor-taylor-1"
+    ],
+    "employees": [
+      "people/tara-kapoor-111"
+    ]
+  }
+}

eval/data/world-v1/companies__beta-labs-51.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/beta-labs-51",
+  "type": "company",
+  "title": "Beta Labs",
+  "compiled_truth": "Beta Labs is a data infrastructure startup founded in 2019 by [Victor Jones](people/victor-jones-51). The company has carved out a niche in the increasingly crowded data tooling space by focusing on real-time data synchronization for distributed systems. Their flagship product, SyncCore, enables companies to maintain consistency across multiple data stores without the typical latency penalties.\n\nThe founding story is pretty straightforward. Victor had spent years dealing with data consistency nightmares at previous roles and decided there had to be a better way. Beta Labs emerged from that frustration, initially as a consulting operation before pivoting to product in late 2020. The pivot proved wise—enterprise demand for their sync technology exceeded expectations.\n\nFunding has come from angel investors including [Jack Davis](people/jack-davis-89) and [Chris Singh](people/chris-singh-96), both of whom participated in the seed round. Jack in particular has been an active advisor, connecting the company with potential enterprise customers in the fintech vertical. Chris brought operational expertise from his own startup experience, helping Beta Labs avoid some common scaling pitfalls.\n\nThe team has grown to around 45 people, mostly engineers. They've maintained a relatively low profile compared to flashier competitors, preferring to let the technology speak for itself. This approach has worked—several Fortune 500 companies now rely on SyncCore for mission-critical data operations, though Beta Labs rarely publicizes these relationships.\n\nRecent moves suggest the company is gearing up for expansion. They've been hiring aggressivley on the go-to-market side and opened a small office in London to serve European clients. There's been speculation about a Series A, though Victor has remained tight-lipped about fundraising plans.\n\nBeta Labs occupies an interesting position in the data infrastructure ecosystem. Not quite a database company, not purely an ETL play—more of a connective tissue between existing systems. This positioning has made them attractive to enterprises who don't want to rip and replace their current stack but desperatley need better synchronization. The data infrastructure space continues to evolve rapidly, and Beta Labs seems well-positioned to grow alongside it.",
+  "timeline": "- **2019-03-15** | Beta Labs incorporated by [Victor Jones](people/victor-jones-51) in Delaware\n- **2020-11-02** | Pivoted from consulting to product development, began building SyncCore\n- **2021-04-18** | Closed seed round with participation from [Jack Davis](people/jack-davis-89) and [Chris Singh](people/chris-singh-96)\n- **2021-09-07** | Launched SyncCore private beta with 12 design partners\n- **2022-02-14** | General availability of SyncCore, landed first Fortune 500 customer\n- **2023-06-22** | Reached 30 employees, opened London office for European expansion\n- **2024-01-10** | [Victor Jones](people/victor-jones-51) spoke at DataCon about distributed consistency patterns\n- **2024-08-30** | Shipped SyncCore 2.0 with multi-region support\n- **2025-03-12** | Announced partnership with major cloud provider for marketplace distribution\n- **2025-11-05** | Rumored Series A discussions with multiple tier-one VCs",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/beta-labs-51",
+    "name": "Beta Labs",
+    "category": "startup",
+    "industry": "data infrastructure",
+    "founded_year": 2019,
+    "founders": [
+      "people/victor-jones-51"
+    ],
+    "investors": [
+      "people/jack-davis-89",
+      "people/chris-singh-96"
+    ],
+    "employees": [
+      "people/kate-rodriguez-161"
+    ]
+  }
+}

eval/data/world-v1/companies__brink-29.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/brink-29",
+  "type": "company",
+  "title": "Brink",
+  "compiled_truth": "Brink is a data infrastructure startup founded in 2019 by [Uma Gonzalez](people/uma-gonzalez-29), who serves as CEO. The company builds middleware solutions that help enterprises manage data pipelines across hybrid cloud environments. Their flagship product, Brink Flow, enables real-time data synchronization between on-premise databases and cloud data warehouses without requiring significant engineering overhead.\n\nThe company emerged from Uma's frustration with existing ETL tools while she was working at a large financial services firm. She saw an oportunity to build something more elegant—a system that could handle schema changes automatically and scale horizontally without the typical headaches. Brink's approach uses a proprietary conflict resolution algorithm that has attracted attention from several Fortune 500 companies looking to modernize their data stacks.\n\nBrink operates with a relatively lean team of around 45 employees, mostly engineers, headquartered in Austin with a small office in San Francisco. The company has raised approximately $28 million across seed and Series A rounds, though they've been quiet about specifics. Industry observers note that Brink competes in a crowded space but has carved out a niche with customers who need particularly robust handling of legacy database formats.\n\nThe advisory board includes [Ian Wilson](people/ian-wilson-180), who brings deep expertise in enterprise sales cycles, and [Grace Singh](people/grace-singh-197), known for her technical architecture background. Both advisors have been instrumental in shaping Brink's go-to-market strategy and product roadmap. Grace in particular has pushed the team toward better observability features, which became a key differentiator in recent customer wins.\n\nRecent months have seen Brink expanding into the healthcare vertical, where data compliance requirements create natural demand for their controlled sync capabilities. The company announced SOC 2 Type II certification in late 2024, a prerequisite for many enterprise deals. Uma has been public about her goal to reach $10M ARR before considering a Series B, preferring to grow efficently rather than chase hypergrowth.",
+  "timeline": "- **2019-03-15** | Uma Gonzalez incorporates Brink in Delaware, begins building initial prototype\n- **2021-06-22** | Closes $4.2M seed round led by Vertex Ventures\n- **2022-01-10** | Brink Flow enters private beta with 12 design partners\n- **2022-09-08** | [Ian Wilson](people/ian-wilson-180) joins as advisor, helps restructure sales approach\n- **2023-02-14** | Announces $24M Series A, valuation undisclosed\n- **2023-07-19** | [Grace Singh](people/grace-singh-197) joins advisory board\n- **2024-04-03** | Ships Brink Flow 2.0 with real-time schema migration support\n- **2024-11-12** | Achieves SOC 2 Type II certification\n- **2025-02-28** | Signs first major healthcare customer, regional hospital network\n- **2025-05-16** | [Uma Gonzalez](people/uma-gonzalez-29) speaks at Data Summit on hybrid cloud challenges",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/brink-29",
+    "name": "Brink",
+    "category": "startup",
+    "industry": "data infrastructure",
+    "founded_year": 2019,
+    "founders": [
+      "people/uma-gonzalez-29"
+    ],
+    "employees": [
+      "people/vera-wang-139"
+    ],
+    "advisors": [
+      "people/ian-wilson-180",
+      "people/grace-singh-197"
+    ]
+  }
+}

eval/data/world-v1/companies__cascade-30.json

@@ -0,0 +1,24 @@
+{
+  "slug": "companies/cascade-30",
+  "type": "company",
+  "title": "Cascade",
+  "compiled_truth": "Cascade is an AI applications startup founded in 2018 by [Yara Smith](people/yara-smith-30), who remains the driving force behind the company's product vision. The company focuses on building enterprise-grade AI tools that automate complex document workflows, particularly in legal and compliance sectors. Their flagship product, Cascade Flow, uses large language models to extract, summarize, and cross-reference information across thousands of documents simultaneosly.\n\nThe early years were tough. Cascade operated in relative obscurity, bootstrapping through consulting gigs while refining their core technology. It wasn't until 2021 that they secured meaningful venture funding and began scaling the team. Today the company employs around 85 people, mostly engineers and ML researchers, with a small but scrappy sales org based out of their San Francisco headquarters.\n\n[Bob Chen](people/bob-chen-185) joined as an advisor in late 2022, bringing his extensive experience in enterprise SaaS and go-to-market strategy. His involvement reportedly helped Cascade land several Fortune 500 pilots that converted to multi-year contracts. Chen's network in the financial services industry has been particuarly valuable as Cascade expands beyond legal tech into banking and insurance verticals.\n\nYara Smith has been vocal about building AI that augments rather than replaces human workers. In interviews she often emphasizes that Cascade's tools are designed to handle the drudgery so professionals can focus on judgment calls and client relationships. This positioning has resonated well with enterprise buyers who remain cautious about fully autonomous AI systems.\n\nRecent moves suggest Cascade is preparing for significant growth. They've been hiring aggressively for a new product line—rumored to be an AI-powered contract negotiation assistant—and opened a small office in London to support European expansion. Competition in the space is heating up with well-funded rivals, but Cascade's early mover advantage and deep integrations with legacy document management systems give them a defensible position. The company is reportedly exploring a Series C round, though nothing has been announced publicly.",
+  "timeline": "- **2018-03-12** | Cascade incorporated in Delaware by founder Yara Smith\n- **2021-06-08** | Closed $8M Series A led by Threshold Ventures\n- **2022-04-15** | Launched Cascade Flow publicly after 18 months of private beta\n- **2022-11-02** | [Bob Chen](people/bob-chen-185) joined as strategic advisor\n- **2023-02-28** | Announced partnership with DocuSign for native integration\n- **2023-09-14** | [Yara Smith](people/yara-smith-30) spoke at TechCrunch Disrupt on enterprise AI adoption\n- **2024-01-22** | Raised $32M Series B, valuation undisclosed\n- **2024-07-10** | Opened London office to support EMEA expansion\n- **2025-03-05** | Reached 200 enterprise customers milestone\n- **2025-11-18** | Began private beta for contract negotiation AI product",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/cascade-30",
+    "name": "Cascade",
+    "category": "startup",
+    "industry": "AI applications",
+    "founded_year": 2018,
+    "founders": [
+      "people/yara-smith-30"
+    ],
+    "employees": [
+      "people/noah-davis-140"
+    ],
+    "advisors": [
+      "people/bob-chen-185"
+    ]
+  }
+}

eval/data/world-v1/companies__cipher-13.json

@@ -0,0 +1,24 @@
+{
+  "slug": "companies/cipher-13",
+  "type": "company",
+  "title": "Cipher",
+  "compiled_truth": "Cipher is a fintech startup founded in 2024 by [Mia Lee](people/mia-lee-13), a first-time founder with a background in cryptography and distributed systems. The company is building infrastructure for programmable money—specifically, a platform that allows fintechs and neobanks to embed complex payment logic directly into their transaction rails. Think conditional payments, escrow-like holds, and multi-party settlements, all handled at the protocol level rather than bolted on after the fact.\n\nThe founding thesis came out of Mia's frustration working at larger financial institutions where even simple payment customizations required months of engineering work and compliance review. Cipher aims to abstract away that complexity, offering APIs that let developers define payment conditions in a few lines of code. Early positioning suggests they're targeting B2B fintech infrastructure rather than consumer-facing products.\n\nThe company operates lean, with a small team of five engineers working out of a co-working space in San Francisco. [Noah Williams](people/noah-williams-198) serves as an advisor, bringing experience from his own ventures in the payments space. His involvement lent early credibility when Cipher was pitching to angels and seed investors. Noah's been particularly helpful on go-to-market stratgey, pushing the team to focus on a narrow wedge before expanding.\n\nCipher closed a pre-seed round in late 2024, though the exact amount hasn't been publicly disclosed—likely in the $1.5-2M range based on typical fintech raises at that stage. The company has been in private beta with three design partners, all smaller neobanks looking to differentiate on payment flexibility. Early feedback has been positive, though integrations have taken longer than anticipated due to legacy system constraints on the partner side.\n\nMia has been intentionally quiet about the company publicly, preferring to let the product speak once it's ready. She's mentioned in interviews that Cipher won't be doing a splashy launch—instead, they'll scale through word of mouth in the developer comunity. The name itself, Cipher, reflects both the cryptographic roots and the idea of encoding complex logic into simple interfaces.",
+  "timeline": "- **2024-01-15** | [Mia Lee](people/mia-lee-13) incorporates Cipher in Delaware, begins recruiting founding engineers\n- **2024-03-02** | First technical architecture doc completed; decides on Rust for core payment engine\n- **2024-04-18** | [Noah Williams](people/noah-williams-198) joins as advisor after intro through mutual investor contact\n- **2024-06-10** | Cipher closes pre-seed round, terms undisclosed\n- **2024-08-22** | Private beta launches with first design partner, a challenger bank based in Austin\n- **2024-10-05** | Second and third beta partners onboarded; team grows to five full-time\n- **2024-11-30** | Mia presents Cipher at a closed fintech founders dinner in SF\n- **2025-01-14** | First successful production transaction processed through Cipher rails\n- **2025-03-08** | Beginning conversations with potential seed investors for next round",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/cipher-13",
+    "name": "Cipher",
+    "category": "startup",
+    "industry": "fintech",
+    "founded_year": 2024,
+    "founders": [
+      "people/mia-lee-13"
+    ],
+    "employees": [
+      "people/julia-thomas-123"
+    ],
+    "advisors": [
+      "people/noah-williams-198"
+    ]
+  }
+}

eval/data/world-v1/companies__compass-11.json

@@ -0,0 +1,27 @@
+{
+  "slug": "companies/compass-11",
+  "type": "company",
+  "title": "Compass",
+  "compiled_truth": "Compass is a crypto startup founded in 2018 by [Mark Thomas](people/mark-thomas-11), positioning itself as an early mover in blockchain-based navigation and location services. The company has carved out a niche attempting to decentralize geospatial data, arguing that traditional mapping services concentrate too much power in the hands of a few tech giants.\n\nThe core product is a token-incentivized network where users contribute location data and receive CMPS tokens in return. Think of it as a crypto-native alternative to Google Maps, though the comparison is admittedly generous given Compass's current scale. The protocol allows developers to build location-aware dApps without relying on centralized APIs, which has attracted some interest from the DeFi and gaming communities.\n\nMark Thomas serves as CEO and has been the driving force behind the company's technical vision. Before founding Compass, he worked in geospatial analytics and became convinced that location data would become increasingly valuable—and increasingly surveilled. His pitch to investors centered on data sovereignty and the idea that people should own their movement patterns.\n\n[Chris Miller](people/chris-miller-101) came in as an early investor during the 2019 seed round, providing both capital and credibility in crypto circles. Miller's involvement helped Compass attract additional funding and connected the team to key infrastructure partners. The relationship has been mutually beneficial, with Miller often pointing to Compass as an example of \"real utility\" in the blockchain space.\n\nOn the advisory side, [Sam Garcia](people/sam-garcia-188) has been instrumental in shaping go-to-market strategy. Garcia joined as an advisor in late 2021 and helped the company navigate the treacherous waters of the 2022 crypto winter. His experience with enterprise sales proved valuable when Compass pivoted toward B2B partnerships with logistics companies.\n\nRecent moves include a partnership with several delivery startups in Southeast Asia and the launch of Compass SDK 2.0, which simplifies integration for third-party developers. The team remains small—around 25 people—but has managed to maintain steady growth despite market volatility. Their approach has been decidedly un-hypey by crypto standards, focusing on incremental adoption rather then moonshot promises.",
+  "timeline": "- **2018-06-15** | Compass incorporated by [Mark Thomas](people/mark-thomas-11) in Delaware, initial whitepaper published\n- **2019-03-22** | Seed round closed with [Chris Miller](people/chris-miller-101) leading, $2.1M raised\n- **2020-11-08** | CMPS token launched on mainnet, initial contributor network goes live\n- **2021-09-14** | [Sam Garcia](people/sam-garcia-188) joins as strategic advisor\n- **2022-05-30** | Company survives Terra collapse fallout, announces pivot toward enterprise partnerships\n- **2023-02-17** | Partnership signed with three logistics firms in Singapore and Vietnam\n- **2024-01-09** | Compass SDK 2.0 released, developer signups increase 340% in Q1\n- **2024-08-23** | Mark Thomas speaks at ETH Denver on decentralized infrastructure\n- **2025-04-11** | Series A discussions reportedly underway, targeting $15M raise",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/compass-11",
+    "name": "Compass",
+    "category": "startup",
+    "industry": "crypto",
+    "founded_year": 2018,
+    "founders": [
+      "people/mark-thomas-11"
+    ],
+    "investors": [
+      "people/chris-miller-101"
+    ],
+    "employees": [
+      "people/rachel-davis-121"
+    ],
+    "advisors": [
+      "people/sam-garcia-188"
+    ]
+  }
+}

eval/data/world-v1/companies__delta-3.json

@@ -0,0 +1,28 @@
+{
+  "slug": "companies/delta-3",
+  "type": "company",
+  "title": "Delta",
+  "compiled_truth": "Delta is a biotech startup founded in 2022 by [Victor Wilson](people/victor-wilson-3), who previously spent nearly a decade in academic research before making the jump to entrepreneurship. The company focuses on developing novel protein engineering platforms, with an initial emphasis on therapeutic applications for rare genetic disorders. Based out of the Boston-Cambridge biotech corridor, Delta has quickly gained attention for its unconventional approach to computational biology.\n\nThe founding story is somewhat unusual. Victor had been sitting on the core intellectual property for years, hesitant to commercialize what he considered fundamental research. It wasn't until a chance meeting with [David Zhang](people/david-zhang-83) at a conference in late 2021 that the idea of building a company around the technology started to take shape. Zhang, known for his patient capital approach, saw potential where others had passed.\n\nDelta's seed round closed in early 2023, with [Rachel Brown](people/rachel-brown-95) joining as a co-lead investor alongside Zhang. Brown brought not just capital but also deep operational expertise from her previous biotech exits. The round was modest by industry standards—around $4.2M—but sufficient to build out the initial lab infrastructure and hire a small team of computational biologists.\n\n[David Brown](people/david-brown-187) serves as the company's primary advisor, providing guidance on regulatory pathways and clinical trial design. His involvement has been instrumental in helping Delta avoid some of the common pitfalls that trap early-stage biotech ventures. The advisory relationship began informally but was formalized in mid-2023.\n\nThe company remains small, with fewer than fifteen full-time employees. Victor Wilson continues to lead as CEO, though there's been some internal discussion about bringing in an experienced biotech operator as the company approaches its Series A. Delta's platform has shown promising early results in preclinical models, though significant validation work remains before any theraputic candidates could advance to human trials. The team is currently focused on partnership discussions with larger pharma players who might provide both capital and developmnet expertise.",
+  "timeline": "- **2021-11-18** | Victor Wilson meets [David Zhang](people/david-zhang-83) at BioFuture Conference in San Francisco; initial conversations about commercialization begin\n- **2022-03-07** | Delta formally incorporated in Delaware; Victor Wilson named founding CEO\n- **2022-06-14** | First lab space secured in Cambridge, MA; initial equipment purchases made\n- **2023-02-22** | Seed round closes at $4.2M led by [David Zhang](people/david-zhang-83) and [Rachel Brown](people/rachel-brown-95)\n- **2023-05-30** | [David Brown](people/david-brown-187) joins as formal advisor; focuses on regulatory strategy\n- **2023-09-11** | Delta publishes preprint on novel protein folding methodology; generates significant academic interest\n- **2024-01-16** | Team expands to 12 FTEs; hires head of computational biology from Stanford\n- **2024-07-08** | First preclinical proof-of-concept data shared with potential pharma partners\n- **2025-02-03** | Delta enters preliminary partnership discussions with two top-20 pharma companies",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/delta-3",
+    "name": "Delta",
+    "category": "startup",
+    "industry": "biotech",
+    "founded_year": 2022,
+    "founders": [
+      "people/victor-wilson-3"
+    ],
+    "investors": [
+      "people/david-zhang-83",
+      "people/rachel-brown-95"
+    ],
+    "employees": [
+      "people/adam-lopez-113"
+    ],
+    "advisors": [
+      "people/david-brown-187"
+    ]
+  }
+}

eval/data/world-v1/companies__delta-labs-53.json

@@ -0,0 +1,29 @@
+{
+  "slug": "companies/delta-labs-53",
+  "type": "company",
+  "title": "Delta Labs",
+  "compiled_truth": "Delta Labs is a climate tech startup founded in 2021 by [Will Garcia](people/will-garcia-53), who left a senior role at a major energy company to pursue what he calls \"the only problem worth solving.\" The company focuses on direct air capture technology, specifically developing modular units that can be deployed at scale in industrial settings. Their approach differs from competitors by integrating with existing HVAC infrastructure rather than requiring standalone installations.\n\nThe company has attracted notable backing from angel investors including [Wendy Hernandez](people/wendy-hernandez-80) and [Tina Hernandez](people/tina-hernandez-97), both of whom have deep networks in the cleantech space. Delta Labs closed their seed round in late 2022, though exact figures weren't publicly disclosed. Industry insiders estimate somewhere between $4-6M based on hiring patterns and equipment purchases.\n\nOn the advisory side, Delta brought in [Wendy Wilson](people/wendy-wilson-170) for her expertise in regulatory navigation—critical for a company operating in a space where policy can make or break unit economics. [Grace Singh](people/grace-singh-197) rounds out the advisory board, contributing her background in scaling hardware startups through the notorious \"valley of death\" between prototype and production.\n\nDelta's current focus is on their second-generation capture modules, which promise 40% better efficiency than their initial designs. Will Garcia has been particularly vocal about avoiding the hype cycles that have plagued other climate tech ventures, preferring to let results speak. The team has grown to roughly 25 people, mostly engineers with backgrounds in chemical enginering and mechanical systems.\n\nThe company operates out of a converted warehouse in Oakland, where they run continuous testing on their prototype units. Early pilot programs with two Fortune 500 companies are underway, though Delta Labs hasn't named partners publicly. Garcia has mentioned in interviews that revenue isn't the immediate priority—proving the technology works at scale is. Whether that patience will pay off remains to be seen, but the climate tech sector is watching closely.",
+  "timeline": "- **2021-03-15** | Delta Labs incorporated in Delaware by founder [Will Garcia](people/will-garcia-53)\n- **2021-09-02** | First prototype capture unit completed; internal testing begins at Oakland facility\n- **2022-04-18** | [Wendy Hernandez](people/wendy-hernandez-80) joins as lead investor in pre-seed round\n- **2022-11-30** | Seed round closed with participation from [Tina Hernandez](people/tina-hernandez-97) and other angels\n- **2023-02-14** | [Wendy Wilson](people/wendy-wilson-170) announced as regulatory advisor\n- **2023-07-22** | Delta Labs hits 15 employees; opens second testing bay\n- **2024-01-10** | Gen-2 modular unit enters development phase\n- **2024-06-05** | First enterprise pilot program signed (partner undisclosed)\n- **2025-03-28** | Will Garcia speaks at Climate Forward conference on scaling DAC technology\n- **2025-09-12** | Second Fortune 500 pilot announced; team reaches 25 people",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/delta-labs-53",
+    "name": "Delta Labs",
+    "category": "startup",
+    "industry": "climate tech",
+    "founded_year": 2021,
+    "founders": [
+      "people/will-garcia-53"
+    ],
+    "investors": [
+      "people/wendy-hernandez-80",
+      "people/tina-hernandez-97"
+    ],
+    "employees": [
+      "people/liam-miller-163"
+    ],
+    "advisors": [
+      "people/wendy-wilson-170",
+      "people/grace-singh-197"
+    ]
+  }
+}

eval/data/world-v1/companies__drift-31.json

@@ -0,0 +1,30 @@
+{
+  "slug": "companies/drift-31",
+  "type": "company",
+  "title": "Drift",
+  "compiled_truth": "Drift is a developer tools startup founded in 2021 by [Frank Hernandez](people/frank-hernandez-31), who saw an opportunity to streamline the way engineering teams manage configuration drift across distributed systems. The company emerged from Frank's frustration while working at larger tech firms, where he noticed teams spending countless hours debugging issues caused by configuration mismatches between environments.\n\nThe core product offers real-time monitoring and automated remediation for infrastructure configurations, targeting mid-size engineering organizations running complex microservices architectures. Drift's approach differs from traditional configuration managment tools by focusing on detection and alerting rather than enforcement, giving teams flexibility while maintaining visibility. The platform integrates with major cloud providers and works alongside existing CI/CD pipelines.\n\nEarly funding came from a group of angel investors including [Wendy Hernandez](people/wendy-hernandez-80), [Fiona Moore](people/fiona-moore-88), and [Jack Davis](people/jack-davis-89). The diverse investor group brought both capital and operational expertise to the young company. Wendy in particular has been instrumental in connecting Drift with potential enterprise customers through her network.\n\n[Xavier Patel](people/xavier-patel-183) serves as an advisor, bringing deep experience in developer tooling and go-to-market strategy. His guidance helped shape Drift's initial product positioning and pricing model. Xavier pushed the team to focus on a specific use case rather than trying to boil the ocean with features.\n\nThe company operates with a lean team, currently around 15 employees, mostly engineers. They've taken a developer-first approach to sales, offering generous free tiers and building community through open source contributions. Their CLI tool has gained traction on GitHub, serving as a funnel for the commercial product.\n\nDrift has seen steady growth among startups and scale-ups, though breaking into true enterprise accounts remains a challenge. The team is currently working on SOC 2 compliance and additional security features to address enterprise requirements. Competition in the config management space is fierce, but Drift's focused approach has carved out a niche among teams who value simplicity over comprehensiveness.",
+  "timeline": "- **2021-03-15** | Company founded by [Frank Hernandez](people/frank-hernandez-31) after leaving his role at a major cloud provider\n- **2021-06-22** | Closed pre-seed round with participation from [Wendy Hernandez](people/wendy-hernandez-80) and [Fiona Moore](people/fiona-moore-88)\n- **2021-11-08** | Launched private beta with 12 design partner companies\n- **2022-04-03** | [Xavier Patel](people/xavier-patel-183) joined as formal advisor\n- **2022-09-17** | Public launch of Drift CLI tool, gained 2k GitHub stars in first month\n- **2023-02-28** | [Jack Davis](people/jack-davis-89) participated in seed extension round\n- **2023-08-14** | Shipped Kubernetes-native integration, biggest feature release to date\n- **2024-01-22** | Frank spoke at DevOpsDays SF on configuration observability\n- **2024-07-09** | Reached 500 active organizations on the platform\n- **2025-03-11** | Began SOC 2 Type II certification process",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/drift-31",
+    "name": "Drift",
+    "category": "startup",
+    "industry": "developer tools",
+    "founded_year": 2021,
+    "founders": [
+      "people/frank-hernandez-31"
+    ],
+    "investors": [
+      "people/wendy-hernandez-80",
+      "people/fiona-moore-88",
+      "people/jack-davis-89",
+      "people/tina-hernandez-97"
+    ],
+    "employees": [
+      "people/olivia-garcia-141"
+    ],
+    "advisors": [
+      "people/xavier-patel-183"
+    ]
+  }
+}

eval/data/world-v1/companies__echo-32.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/echo-32",
+  "type": "company",
+  "title": "Echo - Robotics Startup",
+  "compiled_truth": "Echo is a robotics startup founded in 2025 by [Helen Johnson](people/helen-johnson-32), a serial entrepreneur with deep expertise in automation and machine learning. The company focuses on developing autonomous robotic systems for warehouse logistics and last-mile delivery, positioning itself at the intersection of AI and physical hardware. Based in Austin, Texas, Echo has quickly gained attention for its modular approach to robot design, allowing clients to customize units for specific operational needs.\n\nThe founding team came together after Helen's previous venture in industrial automation was aquired by a larger player in the space. She saw an opportunity to build something more agile, more responsive to the needs of mid-sized fulfillment centers that couldn't afford the massive infrastructure investments required by legacy robotics providers. Echo's flagship product, the E-1 mobile unit, can navigate complex warehouse environments with minimal setup time.\n\nEarly backing came from angel investors including [Julia Davis](people/julia-davis-86) and [Helen Martinez](people/helen-martinez-87), both of whom have track records in deep tech investments. Julia Davis in particular has been instrumental in connecting Echo with potential enterprise customers through her network in the logistics industry. The company closed a small seed round in early 2025, though exact figures haven't been publicly disclosed.\n\nEcho operates with a lean team of around twelve engineers and has partnered with several contract manufacturers to scale production. The startup has been notably secretive about its technical roadmap, though rumors suggest they're working on swarm coordination protocols that would allow multiple E-1 units to operate collaboratively. Helen Johnson has hinted at plans to expand into agricultural robotics by 2026, leveraging the same core platform.\n\nThe robotics space is crowded, but Echo's emphasis on affordabilty and rapid deployment has resonated with smaller operators who feel underserved by existing solutions. Whether they can maintain this edge as they scale remains to be seen.",
+  "timeline": "- **2024-09-15** | [Helen Johnson](people/helen-johnson-32) begins initial R&D work on modular robotics platform\n- **2025-01-20** | Echo officially incorporated in Austin, Texas\n- **2025-02-08** | [Julia Davis](people/julia-davis-86) commits as lead angel investor\n- **2025-02-14** | [Helen Martinez](people/helen-martinez-87) joins seed round\n- **2025-03-30** | First E-1 prototype completed and demonstrated internally\n- **2025-05-12** | Echo hires VP of Engineering from Boston Dynamics\n- **2025-07-22** | Pilot program launched with regional fulfillment center in Dallas\n- **2025-09-10** | Helen Johnson speaks at RoboWorld Conference on modular design philosophy\n- **2025-11-01** | Company reaches 12 full-time employees",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/echo-32",
+    "name": "Echo",
+    "category": "startup",
+    "industry": "robotics",
+    "founded_year": 2025,
+    "founders": [
+      "people/helen-johnson-32"
+    ],
+    "investors": [
+      "people/julia-davis-86",
+      "people/helen-martinez-87"
+    ],
+    "employees": [
+      "people/fiona-hernandez-142"
+    ]
+  }
+}

eval/data/world-v1/companies__epsilon-4.json

@@ -0,0 +1,30 @@
+{
+  "slug": "companies/epsilon-4",
+  "type": "company",
+  "title": "Epsilon",
+  "compiled_truth": "Epsilon is a cybersecurity startup founded in 2021 by [Paul Rodriguez](people/paul-rodriguez-4), a veteran security researcher who previously led threat intelligence teams at two Fortune 500 companies. The company focuses on automated vulnerability detection for cloud-native infrastructure, using machine learning models trained on proprietary datasets of real-world attack patterns.\n\nFrom the begining, Epsilon positioned itself as a developer-first security platform. Rather than bolting security onto existing workflows, the product integrates directly into CI/CD pipelines, scanning code and infrastructure-as-code templates before deployment. This approach resonated with engineering teams frustrated by traditional security tools that generated endless false positives and slowed down releases.\n\nThe company has attracted notable backing from angel investors including [Sarah Lopez](people/sarah-lopez-84), [Sarah Williams](people/sarah-williams-92), and [Kate Lopez](people/kate-lopez-99). Their combined experience in enterprise software and fintech has helped Epsilon navigate early sales cycles with large financial institutions. The advisory board includes [Olivia Miller](people/olivia-miller-176), who brings deep expertise in go-to-market strategy for B2B SaaS, and [Bob Chen](people/bob-chen-185), a respected figure in the open-source security community.\n\nEpsilon's flagship product, ShieldScan, launched in late 2022 and has since been adopted by over 150 organizations. The platform monitors Kubernetes clusters, AWS environments, and Azure deployments in real-time, alerting teams to misconfigurations and potential breach vectors. Recent product updates have added support for GCP and introduced a compliance module targeting SOC 2 and HIPAA requirements.\n\nPaul Rodriguez has been vocal about the need for security tooling that \"meets developers where they are\" rather than imposing rigid workflows. This philosophy has driven Epsilon's product roadmap and contributed to strong word-of-mouth growth among DevOps teams. The company currently employs around 45 people, with engineering and customer success making up the bulk of headcount. Headquarters are in Austin, Texas, though most of the team works remotely.\n\nCompetition in the cloud security space is intense, with well-funded players like Wiz and Lacework dominating mindshare. Epsilon differentiates through pricing transparency and a self-serve model that lets smaller teams get started without lengthy enterprise sales processes.",
+  "timeline": "- **2021-03-15** | Epsilon incorporated in Delaware by [Paul Rodriguez](people/paul-rodriguez-4)\n- **2021-07-22** | Closed $1.2M pre-seed round led by [Sarah Lopez](people/sarah-lopez-84)\n- **2022-01-10** | [Olivia Miller](people/olivia-miller-176) joins advisory board\n- **2022-06-08** | First enterprise customer signed — regional bank in Texas\n- **2022-11-03** | ShieldScan v1.0 publicly launched\n- **2023-04-17** | Epsilon raises $8M seed round; [Kate Lopez](people/kate-lopez-99) participates\n- **2023-09-25** | [Bob Chen](people/bob-chen-185) added as technical advisor\n- **2024-02-12** | Surpassed 100 paying customers milestone\n- **2024-08-30** | Announced GCP integration at CloudSecCon\n- **2025-03-05** | Opened first international office in London",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/epsilon-4",
+    "name": "Epsilon",
+    "category": "startup",
+    "industry": "cybersecurity",
+    "founded_year": 2021,
+    "founders": [
+      "people/paul-rodriguez-4"
+    ],
+    "investors": [
+      "people/sarah-lopez-84",
+      "people/sarah-williams-92",
+      "people/kate-lopez-99"
+    ],
+    "employees": [
+      "people/julia-johnson-114"
+    ],
+    "advisors": [
+      "people/olivia-miller-176",
+      "people/bob-chen-185"
+    ]
+  }
+}

eval/data/world-v1/companies__epsilon-labs-54.json

@@ -0,0 +1,28 @@
+{
+  "slug": "companies/epsilon-labs-54",
+  "type": "company",
+  "title": "Epsilon Labs",
+  "compiled_truth": "Epsilon Labs is a fintech startup founded in 2023 by [Diana Wilson](people/diana-wilson-54), a serial entrepreneur with a background in quantitative finance and distributed systems. The company operates in the payments infrastructure space, building API-first solutions for cross-border B2B transactions. Their flagship product, EpsilonPay, enables businesses to settle international invoices in near real-time while automatically handling currency conversion and compliance checks.\n\nThe founding story traces back to Diana's frustration with legacy payment rails during her previous venture. She saw an oportunity to leverage modern cloud infrastructure and machine learning to dramatically reduce settlement times and fees. Within months of incorporating, Epsilon Labs had assembled a small but experienced engineering team, many recruited from established fintech players.\n\nEpsilon raised a seed round in late 2023, with [Iris Lee](people/iris-lee-82) leading the investment. Iris brought not just capital but also deep connections in the Asian fintech ecosystem, which has proven valuable as Epsilon eyes expansion into Singapore and Hong Kong markets. [Grace Martinez](people/grace-martinez-109) also participated in the round, adding her expertise in regulatory strategy to the cap table. The total raise was reportedly around $4.2 million, though the company hasn't disclosed exact figures publicly.\n\nOn the advisory side, [Zoe Jackson](people/zoe-jackson-199) has been instrumental in shaping Epsilon's go-to-market strategy. Zoe's experience scaling enterprise sales teams has helped the startup land its first handful of mid-market customers, including a logistics company and two e-commerce platforms.\n\nEpsilon Labs currently employs around 18 people, mostly engineers and product folks, operating out of a modest office in San Francisco's SoMa district. The company culture leans heavily toward async communication and documentation — a reflection of Diana's management philosophy. Recent LinkedIn posts suggest they're hiring aggresively for compliance and partnerships roles, hinting at plans to expand their banking relationships.\n\nThe fintech space is crowded, but Epsilon's focus on the unglamorous middle-market segment gives them room to grow without directly competing with giants like Stripe or Wise. At least for now.",
+  "timeline": "- **2023-02-14** | Diana Wilson incorporates Epsilon Labs in Delaware, begins recruiting co-founding engineers\n- **2023-05-03** | First working prototype of EpsilonPay API demoed internally\n- **2023-08-21** | Seed round closes with [Iris Lee](people/iris-lee-82) as lead investor, $4.2M raised\n- **2023-09-15** | [Zoe Jackson](people/zoe-jackson-199) joins as formal advisor, begins weekly strategy sessions\n- **2023-11-30** | EpsilonPay enters private beta with three launch partners\n- **2024-01-22** | [Grace Martinez](people/grace-martinez-109) introduces Epsilon to key banking contacts in Latin America\n- **2024-04-10** | Public launch of EpsilonPay, first press coverage in TechCrunch\n- **2024-07-08** | Team grows to 18 employees, opens dedicated compliance function\n- **2024-10-02** | Diana Wilson speaks at Fintech Summit SF on future of B2B payments\n- **2025-01-15** | Epsilon Labs begins exploratory conversations for Series A",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/epsilon-labs-54",
+    "name": "Epsilon Labs",
+    "category": "startup",
+    "industry": "fintech",
+    "founded_year": 2023,
+    "founders": [
+      "people/diana-wilson-54"
+    ],
+    "investors": [
+      "people/iris-lee-82",
+      "people/grace-martinez-109"
+    ],
+    "employees": [
+      "people/owen-martinez-164"
+    ],
+    "advisors": [
+      "people/zoe-jackson-199"
+    ]
+  }
+}

eval/data/world-v1/companies__first-round-10.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/first-round-10",
+  "type": "company",
+  "title": "First Round Capital",
+  "compiled_truth": "First Round Capital is a seed-stage venture capital firm that has established itself as one of the most influential early-stage investors in the technology ecosystem. Founded in 2004 by Josh Kopelman, the firm focuses exclusively on being the first institutional investor in technology companies, typically leading seed rounds and participating in early follow-on financing.\n\nThe firm has built a remarkable portfolio over the years, with notable investments including Uber, Square, Roblox, Notion, and Warby Parker. First Round is known for its operator-friendly approach and has developed an extensive platform of resources for founders, including the First Round Review publication which shares tactical advice from experienced entrepreneurs and executives.\n\nFirst Round operates with a relatively small partnership structure compared to larger VC firms, which allows partners to maintain close relationships with portfolio companies. The firm typically invests between $1-3 million in initial checks, though this has crept upward in recent years as seed rounds have grown larger across the industry. They maintain offices in San Francisco, New York, and Philadelphia.\n\nOne distinguishing characteristic of First Round is their community-building efforts. The firm hosts an annual CEO Summit and runs various programs designed to connect founders with each other and with potential hires. Their talent team actively helps portfolio companeis with recruiting, recognizing that early hiring decisions are often make-or-break for startups.\n\nThe firm has raised multiple funds over its history, with recent vehicles exceeding $500 million in committed capital. Despite the larger fund sizes, First Round has maintained its focus on seed-stage investing rather than moving upstream to compete with Series A and B investors. This disciplined approach has helped them maintain strong returns and a clear market position.\n\nFirst Round's investment thesis centers on backing exceptional founders at the earliest stages, often before there's significant traction or revenue. They look for founders with deep domain expertise, unique insights into markets, and the resilience needed to build compaines over the long term. The firm has been particularly active in enterprise software, fintech, and consumer technology sectors.",
+  "timeline": "- **2021-03-15** | First Round closes Fund VII at $540 million, largest fund to date\n- **2021-09-22** | Led seed round for emerging AI startup, marking early bet on generative technology\n- **2022-02-08** | First Round Review publishes widely-shared piece on startup hiring in remote era\n- **2022-11-30** | Partner Todd Jackson joins board of breakout portfolio company\n- **2023-04-12** | Hosted annual CEO Summit in San Francisco with 200+ portfolio founders attending\n- **2023-08-19** | Announced new $600M Fund VIII focused on seed and pre-seed investments\n- **2024-01-25** | First Round portfolio company achieves unicorn status after Series C\n- **2024-06-03** | Launched new founder fellowship program targeting underrepresented entrepreneurs\n- **2025-02-14** | Published annual State of Startups report showing shifting founder sentiment on fundraising\n- **2025-09-08** | Expanded New York office, adding three new partners to the team",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/first-round-10",
+    "name": "First Round",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__floodgate-9.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/floodgate-9",
+  "type": "company",
+  "title": "Floodgate - Early-Stage Venture Capital Firm",
+  "compiled_truth": "Floodgate is a prominent seed-stage venture capital firm based in Palo Alto, California, known for its thesis-driven approach to early-stage investing. Founded in 2006 by Mike Maples Jr. and Ann Miura-Ko, the firm has established itself as one of the most respected names in Silicon Valley's seed investing landscape. They've built a reputation for backing founders at the earliest stages, often before there's much more than an idea and a passionate team.\n\nThe firm operates with a relatively small team compared to larger VC shops, which allows them to maintain close relationships with portfolio founders. Ann Miura-Ko, often referred to as one of the most powerful women in startups, brings an academic rigor to investing—she holds a PhD from Stanford and teaches there as a lecturing professor. Mike Maples Jr. previously founded Motive Communications and brings operational experiance to the table.\n\nFloodgate's investment philosophy centers on what they call \"thunder lizards\"—startups with the potential to fundamentally reshape markets rather than just iterate on existing solutions. They're looking for companies that can create entirely new categories. This approach has led to early investments in companies like Lyft, Twitter, and Twitch, demonstrating their ability to identify transformative platforms before they become household names.\n\nRecent activity shows Floodgate continuing to deploy capital across emerging sectors including AI infrastructure, developer tools, and consumer applications. They've been particularly active in the generative AI space, recognizing the platform shift early and positioning their portfolio accordingly. The firm typically invests $1-3 million in initial checks, reserving capital for follow-on investments in their highest-conviction companies.\n\nTheir fund sizes have grown over the years, though they've remained disciplined about not scaling beyond what allows them to maintain their hands-on approach. Floodgate often co-invests alongside other top-tier firms like [Sequoia Capital](companies/sequoia-capital) and [Andreessen Horowitz](companies/andreessen-horowitz), building syndicates that provide founders with diverse perspectives and networks. The firm runs a tight operation, believing that constraint breeds creativity—both for themselves and for the founders they back.",
+  "timeline": "- **2021-03-15** | Floodgate closes Fund VII at $181 million, continuing their focused seed-stage strategy\n- **2021-09-22** | Ann Miura-Ko speaks at TechCrunch Disrupt on identifying breakthrough startups\n- **2022-04-08** | Lead investment in AI developer tools company, $3.2M seed round\n- **2022-11-14** | Mike Maples Jr. publishes essay on \"thunder lizard\" thesis, gains wide circulation\n- **2023-02-28** | Portfolio company exits via acquisition by [Stripe](companies/stripe), returning 47x\n- **2023-08-19** | Floodgate announces Fund VIII targeting $200M for seed investments\n- **2024-01-10** | Partnership with Stanford's StartX program for deal flow collaboration\n- **2024-06-25** | Co-leads $8M seed round alongside [Sequoia Capital](companies/sequoia-capital) in robotics startup\n- **2025-03-12** | Ann Miura-Ko joins board of major fintech company following Series B\n- **2025-09-04** | Floodgate hosts annual founder summit in Palo Alto, 200+ portfolio founders attend",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/floodgate-9",
+    "name": "Floodgate",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__forge-19.json

@@ -0,0 +1,29 @@
+{
+  "slug": "companies/forge-19",
+  "type": "company",
+  "title": "Forge",
+  "compiled_truth": "Forge is a crypto startup founded in 2022 by [Adam Lee](people/adam-lee-19), focused on building infrastructure for decentralized asset management. The company emerged during a turbulent period for the crypto industry, but Lee's vision for institutional-grade tooling attracted early believers despite market headwinds.\n\nThe core product is a non-custodial vault system that lets DAOs and crypto-native funds manage treasuries with multi-sig controls and on-chain governance integration. Forge differentiates itself by targeting the mid-market—organizations too sophisticated for basic multisigs but not large enough to justify custom smart contract development. Early traction came from several DeFi protocols looking to professionalize their treasury operations.\n\nFunding has come from angels with deep crypto experience. [Sarah Lopez](people/sarah-lopez-84) led the pre-seed round, bringing not just capital but introductions across the DeFi ecosystem. [Sarah Wang](people/sarah-wang-104) joined as an investor shortly after, drawn to the team's pragmatic approach to security. Both remain actively involved, participating in monthly strategy calls.\n\nOn the advisory side, Forge has assembled a small but impactful group. [Tara Jackson](people/tara-jackson-173) advises on go-to-market strategy, having scaled several B2B crypto companies previously. [David Brown](people/david-brown-187) provides technical guidance, particularly around smart contract auditing and security architecture—areas where Forge cannot afford to cut corners.\n\nThe team remains lean, hovering around twelve people as of late 2024. Adam has been deliberate about hiring, prefering experienced builders over rapid headcount growth. Engineering is split between protocol development and a surprisingly robust frontend team, reflecting the company's belief that UX remains crypto's biggest barrier to adoption.\n\nForge launched its mainnet product in early 2024 after an extended beta period. Growth has been steady if not explosive—the team claims over $180M in assets under managment across 40+ vaults. Revenue comes from a modest protocol fee, though the company has hinted at premium enterprise features in development. The roadmap includes cross-chain expansion and integration with traditional finance rails, positioning Forge at the intersection of DeFi and institutional money.",
+  "timeline": "- **2022-03-14** | Adam Lee incorporates Forge, begins building initial prototype for DAO treasury management\n- **2022-08-22** | Pre-seed round closes with [Sarah Lopez](people/sarah-lopez-84) leading; $1.2M raised\n- **2022-11-03** | [Sarah Wang](people/sarah-wang-104) joins as angel investor, contributes to security roadmap discussions\n- **2023-02-17** | [Tara Jackson](people/tara-jackson-173) signs on as go-to-market advisor\n- **2023-06-30** | Private beta launches with 8 DAOs onboarded for testing\n- **2023-09-12** | [David Brown](people/david-brown-187) joins advisory board to oversee smart contract security\n- **2024-01-28** | Mainnet launch after completing two independent audits\n- **2024-07-15** | Crosses $100M in assets under management milestone\n- **2024-11-02** | Announces partnership with major L2 for cross-chain vault support\n- **2025-02-10** | Team offsite in Lisbon; roadmap planning for enterprise tier features",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/forge-19",
+    "name": "Forge",
+    "category": "startup",
+    "industry": "crypto",
+    "founded_year": 2022,
+    "founders": [
+      "people/adam-lee-19"
+    ],
+    "investors": [
+      "people/sarah-lopez-84",
+      "people/sarah-wang-104"
+    ],
+    "employees": [
+      "people/sam-nakamura-129"
+    ],
+    "advisors": [
+      "people/tara-jackson-173",
+      "people/david-brown-187"
+    ]
+  }
+}

eval/data/world-v1/companies__founders-fund-0.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/founders-fund-0",
+  "type": "company",
+  "title": "Founders Fund",
+  "compiled_truth": "Founders Fund is a San Francisco-based venture capital firm that has become one of the most influential investors in technology over the past two decades. Founded in 2005 by Peter Thiel, Ken Howery, and Luke Nosek, the firm has distinguished itself through a contrarian investment philosophy that favors bold, transformative companies over incremental innovation. Their famous motto — \"We wanted flying cars, instead we got 140 characters\" — encapsulates this ethos.\n\nThe firm manages over $11 billion in assets and has backed some of the most consequential technology companies of the modern era. Early bets on SpaceX, Palantir, and Facebook established Founders Fund's reputation for identifying generational companies before they achieve mainstream recognition. More recently, the fund has made significant investments in defense technology, artificial intelligence, and biotechnology sectors.\n\nFounders Fund operates with a relatively lean partnership structure compared to traditional VC firms. Key partners include Thiel, Keith Rabois, and Brian Singerman, each bringing distinct investment theses to the table. Singerman in particular has driven the firm's biotech strategy, while Rabois focuses on enterprise software and fintech opportunities. The firm typically writes checks ranging from seed-stage investments up to growth rounds exceeding $100 million.\n\nTheir portfolio company [Anduril Industries](companies/anduril-industries) represents the quintessential Founders Fund investment — a defense technology company challenging incumbant contractors with software-defined hardware. Similarly, their continued support of [Stripe](companies/stripe) through multiple rounds demonstrates their conviction-based approach to backing founders.\n\nThe firm has been notably active in the AI space, making early investments in several frontier model companies. They've also shown willingness to back controversial founders and companies that other firms might avoid for reputational reasons. This approach has generated both outsized returns and occasional criticism.\n\nFounders Fund raised its eighth flagship fund in 2022, reportedly at $1.8 billion, signaling continued LP confidence despite broader market turbulence. The firm maintains offices in San Francisco and Austin, reflecting the broader tech migration trends of recent years.",
+  "timeline": "- **2021-03-15** | Led $450M growth round in Anduril Industries, valuing the defense startup at $4.6 billion\n- **2021-09-22** | Partner Keith Rabois announced relocation to Miami, opening satellite office presence\n- **2022-04-10** | Closed Fund VIII at $1.8B despite deteriorating market conditions\n- **2022-11-30** | Participated in emergency bridge financing discussions with [Stripe](companies/stripe) amid valuation reset\n- **2023-06-14** | Brian Singerman led investment in AI drug discovery platform, marking expanded biotech thesis\n- **2023-12-01** | Peter Thiel keynoted internal LP meeting on defense tech opportunities\n- **2024-05-18** | Announced strategic partnership with [Anduril Industries](companies/anduril-industries) for follow-on manufacturing facility investment\n- **2024-09-25** | Recruited two new partners from Tiger Global amid broader industry consolidation\n- **2025-02-11** | Published annual letter highlighting 3.2x net returns across 2020-2024 vintage\n- **2025-08-03** | Began fundraising for Fund IX, targeting $2.5B",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/founders-fund-0",
+    "name": "Founders Fund",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__foundry-33.json

@@ -0,0 +1,30 @@
+{
+  "slug": "companies/foundry-33",
+  "type": "company",
+  "title": "Foundry",
+  "compiled_truth": "Foundry is an AI applications startup founded in 2023 by [Ian Davis](people/ian-davis-33), a serial entrepreneur with a background in enterprise software. The company operates in the increasingly crowded AI applications space, though it has carved out a niche focusing on workflow automation for mid-market manufacturing companies. Their flagship product, FoundryOS, uses large language models to interpret unstructured data from factory floors and convert it into actionable insights for operations managers.\n\nThe company raised its seed round from a syndicate led by [Tina Hernandez](people/tina-hernandez-97), with participation from [Zoe Gonzalez](people/zoe-gonzalez-100) and [Alice Kapoor](people/alice-kapoor-108). Total funding to date sits around $4.2M, though rumors suggest Foundry is currently in conversations for a Series A that would value the company north of $30M. Ian has been characteristically tight-lipped about fundraising progress, preferring to focus public communications on product development.\n\nFoundry's advisory board includes [Rachel Gonzalez](people/rachel-gonzalez-175), who brings deep expertise in industrial automation, and [Noah Nakamura](people/noah-nakamura-182), whose connections in the manufacturing sector have reportedly helped open doors with several Fortune 500 prospects. The team has grown to roughly 18 people, mostly engineers, operating out of a small office in Austin.\n\nRecent moves include a partnership with a major automotive parts supplier, though the details remain under NDA. The company has been aggresively hiring ML engineers and recently posted roles for enterprise sales reps, signaling a shift toward scaling go-to-market efforts. Ian Davis presented at the Industrial AI Summit in March 2024, where he demoed FoundryOS processing real-time sensor data and generating maintenance recommendations. The demo received strong reception, though some attendees noted the system's latency issues under heavy load.\n\nFoundry faces competition from both established industrial software players and well-funded AI startups, but the team beleives their vertical focus gives them an edge. Early customer testimonials highlight the product's ease of integration with legacy systems, a persistent pain point in manufacturing tech.",
+  "timeline": "- **2023-03-15** | Foundry incorporated in Delaware by [Ian Davis](people/ian-davis-33)\n- **2023-06-22** | Closed $1.8M pre-seed round led by [Tina Hernandez](people/tina-hernandez-97)\n- **2023-09-10** | First engineering hires made; team moves into Austin office\n- **2023-12-01** | FoundryOS alpha launched with two pilot customers\n- **2024-02-14** | [Alice Kapoor](people/alice-kapoor-108) joins seed round, bringing total funding to $4.2M\n- **2024-03-28** | Ian Davis presents at Industrial AI Summit in Chicago\n- **2024-06-05** | Advisory board formalized with [Rachel Gonzalez](people/rachel-gonzalez-175) and [Noah Nakamura](people/noah-nakamura-182)\n- **2024-09-12** | Partnership announced with undisclosed automotive parts supplier\n- **2024-11-20** | Team reaches 18 employees; Series A conversations reportedly underway\n- **2025-01-08** | Enterprise sales hiring push begins",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/foundry-33",
+    "name": "Foundry",
+    "category": "startup",
+    "industry": "AI applications",
+    "founded_year": 2023,
+    "founders": [
+      "people/ian-davis-33"
+    ],
+    "investors": [
+      "people/tina-hernandez-97",
+      "people/zoe-gonzalez-100",
+      "people/alice-kapoor-108"
+    ],
+    "employees": [
+      "people/wendy-taylor-143"
+    ],
+    "advisors": [
+      "people/rachel-gonzalez-175",
+      "people/noah-nakamura-182"
+    ]
+  }
+}

eval/data/world-v1/companies__gamma-2.json

@@ -0,0 +1,24 @@
+{
+  "slug": "companies/gamma-2",
+  "type": "company",
+  "title": "Gamma - Fintech Startup",
+  "compiled_truth": "Gamma is a fintech startup founded in 2022 by [Mark Jones](people/mark-jones-2), a serial entrepreneur with a background in payment infrastructure. The company has positioned itself at the intersection of embedded finance and small business lending, targeting an underserved market of micro-merchants who struggle to access traditional credit products.\n\nThe core product is a lending-as-a-service API that allows platforms to offer instant credit decisioning to their users. Gamma's approach relies on alternative data sources—transaction history, platform engagement metrics, and cash flow patterns—rather than traditional credit scores. This has allowed them to approve merchants that banks typically reject while maintaining what they claim are competitive default rates.\n\nMark Jones serves as CEO and has been the public face of the company since launch. His previous experience building payment rails for gig economy platforms informed much of Gamma's technical architecture. The founding team remains relatively small, with around 25 employees as of late 2024, mostly engineers and data scientists based in Austin.\n\nEarly backing came from [Vera Gonzalez](people/vera-gonzalez-103), who led the seed round and has remained actively involved as a board observer. Her portfolio expertise in B2B fintech reportedly helped Gamma avoid some common pitfalls around compliance and bank partnerships. The company has been somewhat quiet about total funding raised, though industry estimates put it somewhere in the $8-12M range across seed and bridge rounds.\n\nGamma faces stiff competiton from larger players like Stripe Capital and Square Loans, but has carved out a niche by focusing exclusively on platform partnerships rather than direct-to-merchant sales. Recent moves suggest they're expanding beyond pure lending into cash flow management tools, though details remain sparse. The company has been hiring aggressively for a Series A push expected sometime in 2025.",
+  "timeline": "- **2022-03-14** | Gamma incorporated in Delaware by [Mark Jones](people/mark-jones-2)\n- **2022-06-22** | Closed seed round led by [Vera Gonzalez](people/vera-gonzalez-103), terms undisclosed\n- **2022-11-08** | First API version shipped to beta partners\n- **2023-02-15** | Reached $1M in loans facilitated through platform\n- **2023-07-20** | Expanded engineering team to 15 employees\n- **2023-11-30** | Launched v2.0 of lending API with improved decisioning engine\n- **2024-04-12** | Mark Jones spoke at Fintech Summit Austin on alternative credit scoring\n- **2024-09-05** | Announced partnership with three unnamed e-commerce platforms\n- **2025-01-18** | Bridge round closed, preparing for Series A conversations",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/gamma-2",
+    "name": "Gamma",
+    "category": "startup",
+    "industry": "fintech",
+    "founded_year": 2022,
+    "founders": [
+      "people/mark-jones-2"
+    ],
+    "investors": [
+      "people/vera-gonzalez-103"
+    ],
+    "employees": [
+      "people/tina-jones-112"
+    ]
+  }
+}

eval/data/world-v1/companies__gamma-labs-52.json

@@ -0,0 +1,28 @@
+{
+  "slug": "companies/gamma-labs-52",
+  "type": "company",
+  "title": "Gamma Labs",
+  "compiled_truth": "Gamma Labs is an edtech startup founded in 2023 by [Iris Nakamura](people/iris-nakamura-52), a former learning sciences researcher who spent nearly a decade studying how students retain information in digital environments. The company emerged from Nakamura's frustration with existing adaptive learning platforms, which she felt were too focused on content delivery and not enough on genuine comprehension.\n\nThe core product is an AI-powered tutoring system that adapts not just to what students get wrong, but to *how* they think through problems. Gamma Labs calls this approach \"cognitive mirroring\" — the system builds a model of each student's reasoning patterns and adjusts its teaching style accordingly. Early pilots with community colleges showed promising results, though the sample sizes were admittedly small.\n\nFunding came through a pre-seed round led by [David Zhang](people/david-zhang-83), who has been increasingly active in education technology investments over the past two years. [Rosa Miller](people/rosa-miller-98) also participated in the round, bringing her experience scaling consumer apps to the cap table. The total raise was reportedly around $1.8 million, though the company hasn't confirmed exact figures publically.\n\nOn the advisory side, Gamma brought in [Steve Martinez](people/steve-martinez-192) to help navigate enterprise sales cycles with school districts. Martinez's background in B2B edtech has proven valuable as the startup shifts from direct-to-student pilots toward institutional contracts.\n\nThe team remains small — just seven full-time employees as of late 2024 — but they've been shipping quickly. Their beta platform launched in Q2 2024, and early users have praised the interface's simplicity. Critics note that the AI explanations can sometimes feel repetitive, a known issue the team says they're addressing.\n\nGamma Labs operates out of a coworking space in Oakland, though Iris has mentioned considering a move to a dedicated office if headcount doubles. The edtech space is crowded, but Gamma's focus on reasoning rather than rote memorization gives it a differentiated angle. Whether that translates to sustainable growth remains to be seen.",
+  "timeline": "- **2023-03-15** | Gamma Labs incorporated in Delaware by founder Iris Nakamura\n- **2023-06-22** | Pre-seed round closed with [David Zhang](people/david-zhang-83) and [Rosa Miller](people/rosa-miller-98) participating\n- **2023-09-10** | First pilot program launched with two community colleges in California\n- **2024-01-18** | [Steve Martinez](people/steve-martinez-192) joined as formal advisor\n- **2024-04-05** | Beta platform shipped to 500 early access users\n- **2024-07-12** | Gamma Labs presented at EdTech Summit in Austin, demo well-received\n- **2024-10-30** | Signed first enterprise contract with a mid-sized school district in Texas\n- **2025-02-14** | Team expanded to 12 employees, opened dedicated Oakland office\n- **2025-06-01** | Series A discussions reportedly underway with multiple firms",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/gamma-labs-52",
+    "name": "Gamma Labs",
+    "category": "startup",
+    "industry": "edtech",
+    "founded_year": 2023,
+    "founders": [
+      "people/iris-nakamura-52"
+    ],
+    "investors": [
+      "people/david-zhang-83",
+      "people/rosa-miller-98"
+    ],
+    "employees": [
+      "people/ian-kapoor-162"
+    ],
+    "advisors": [
+      "people/steve-martinez-192"
+    ]
+  }
+}

eval/data/world-v1/companies__google-1.json

@@ -0,0 +1,15 @@
+{
+  "slug": "companies/google-1",
+  "type": "company",
+  "title": "Google",
+  "compiled_truth": "Google is one of the most influential technology conglomerates in the world, though its founding date of 1996 places it slightly earlier than commonly cited. The company has evolved far beyond its origins as a search engine, becoming a major player in cloud computing, artificial intelligence, consumer hardware, and notably, robotics.\n\nThe robotics division at Google has seen significant investment and strategic maneuvering over the years. Starting with the aqusition of Boston Dynamics in 2013, Google signaled its intent to dominate the robotics space. While Boston Dynamics was later sold to SoftBank, Google retained numerous other robotics ventures and continued building internal capabilities through its X division and other research arms.\n\nAs an acquirer in the robotics industry, Google has been particularly agressive in targeting startups with promising automation technology. The company's approach tends to focus on companies developing AI-driven manipulation systems, warehouse automation, and autonomous systems that can integrate with Google's broader cloud and AI infrastructure. Their acquisition strategy often involves absorbing talented engineering teams rather than just acquiring technology—a practice sometimes called acqui-hiring.\n\nGoogle's parent company Alphabet provides the financial backing for these robotics ambitions. The company has partnerships with various research institutions and maintains close relationships with other tech giants, though it also competes fiercely with them. Recent moves suggest Google is positioning itself to offer robotics-as-a-service solutions to enterprise customers, leveraging its cloud platform.\n\nThe leadership at Google has emphasized that robotics represents a natural extension of their AI capabilities. With advances in machine learning and computer vision coming out of DeepMind and Google Brain (now merged), the company believes it can solve many of the perception and planning challenges that have historically limited robotic systems. Their focus areas include logistics automation, healthcare robotics, and general-purpose manipulation platforms that could eventaully find applications in homes and offices.\n\nGoogle continues to be a dominant force in shaping the future of intelligent machines, combining its vast computational resources with ambitious research agendas.",
+  "timeline": "- **2021-03-15** | Google announces expanded robotics research initiative under X division, committing $400M over three years\n- **2021-09-22** | Acquired stealth warehouse automation startup for undisclosed sum, team of 45 engineers joins Google Cloud\n- **2022-04-08** | Unveiled Everyday Robots project demonstrating general-purpose manipulation in office environments\n- **2022-11-30** | Partnership announced with major logistics provider to pilot autonomous sorting systems\n- **2023-06-14** | Google I/O keynote features live demo of AI-powered robotic assistant prototype\n- **2024-01-19** | Robotics division restructured, now reports directly to Google Cloud leadership\n- **2024-08-03** | Acquired computer vision startup specializing in 3D scene understanding for $180M\n- **2025-02-27** | Launched Robotics Foundation Model, open-sourcing base architecture for research community\n- **2025-10-11** | Enterprise robotics platform enters general availability, initial customers include three Fortune 100 companies",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/google-1",
+    "name": "Google",
+    "category": "acquirer",
+    "industry": "robotics",
+    "founded_year": 1996
+  }
+}

eval/data/world-v1/companies__gravity-17.json

@@ -0,0 +1,32 @@
+{
+  "slug": "companies/gravity-17",
+  "type": "company",
+  "title": "Gravity",
+  "compiled_truth": "Gravity is a biotech startup founded in 2021 by [Quinten Wang](people/quinten-wang-17), a computational biologist who previously led protein engineering efforts at a major pharma company. The company focuses on developing novel gravity-sensing mechanisms in cellular therapies, aiming to create treatments that respond to mechanical forces within the human body. Their core platform uses mechanosensitive proteins to trigger therapeutic payloads in response to specific gravitational or pressure conditions.\n\nThe founding thesis came from Wang's doctoral research on how cells detect and respond to physical forces. Gravity has raised seed funding from a syndicate that includes [Chris Jackson](people/chris-jackson-91), [Rosa Nakamura](people/rosa-nakamura-94), and [Rachel Brown](people/rachel-brown-95). The round closed in early 2022 and gave the company runway to build out its initial research team and secure wet lab space in the South San Francisco biotech corridor.\n\nOn the advisory side, Gravity has brought in [Tina Wang](people/tina-wang-179) for regulatory strategy and [Xavier Patel](people/xavier-patel-183) to help with business development and partnership discussions. Both advisors have been instrumental in shaping the companys go-to-market approach, particularly around identifying therapeutic areas where mechanosensitive delivery could provide clear advantages over existing modalties.\n\nThe startup has been relatively quiet publicly, preferring to focus on R&D milestones rather than press coverage. Internally, they've made progress on their lead program targeting osteoarthritis, where the therapy would activate in response to joint compression. Early in vitro results have been promising, though animal studies are still ongoing. The team has grown to about 15 people, mostly PhDs in bioengineering and cell biology.\n\nGravity faces significant technical risk—mechanobiology is still a nascent field and translating bench results to clinical outcomes will be challenging. But the upside is substantial if they can crack it. Wang has been vocal in investor updates about the potential for platform expansion into cardiac and oncology applications down the line.",
+  "timeline": "- **2021-03-15** | Gravity incorporated in Delaware by [Quinten Wang](people/quinten-wang-17)\n- **2021-07-22** | Signed lease for lab space in South San Francisco\n- **2022-01-10** | Closed $4.2M seed round led by [Chris Jackson](people/chris-jackson-91)\n- **2022-06-03** | Hired first VP of Research from Genentech\n- **2022-11-18** | [Tina Wang](people/tina-wang-179) joined as regulatory advisor\n- **2023-04-25** | Filed provisional patent on mechanosensitive protein delivery system\n- **2023-09-12** | Presented preclinical data at ASGCT conference\n- **2024-02-08** | Initiated IND-enabling studies for lead osteoarthritis program\n- **2024-08-30** | [Xavier Patel](people/xavier-patel-183) formalized advisory role, began pharma outreach\n- **2025-03-17** | Reached 15 employees, expanded lab footprint",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/gravity-17",
+    "name": "Gravity",
+    "category": "startup",
+    "industry": "biotech",
+    "founded_year": 2021,
+    "founders": [
+      "people/quinten-wang-17"
+    ],
+    "investors": [
+      "people/chris-jackson-91",
+      "people/rosa-nakamura-94",
+      "people/rachel-brown-95"
+    ],
+    "employees": [
+      "people/quinn-jones-127"
+    ],
+    "advisors": [
+      "people/tina-wang-179",
+      "people/xavier-patel-183",
+      "people/sam-garcia-188",
+      "people/beth-wang-196"
+    ]
+  }
+}

eval/data/world-v1/companies__greylock-4.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/greylock-4",
+  "type": "company",
+  "title": "Greylock Partners",
+  "compiled_truth": "Greylock Partners is one of Silicon Valley's oldest and most prestigious venture capital firms, founded in 1965. The firm has built a reputation for early-stage investing in enterprise software, consumer internet, and infrastructure companies. Their portfolio reads like a who's who of tech success stories—LinkedIn, Facebook, Airbnb, Dropbox, and Discord among them.\n\nThe firm operates with a relatively small partnership structure, which they argue allows for deeper engagement with founders. Notable partners include Reid Hoffman, the LinkedIn co-founder who joined after selling his company to Microsoft. The firm's been particularly active in AI and developer tools lately, reflecting broader market trends. They typically write checks ranging from seed to Series B, though they're not afraid to lead larger rounds for breakout companies.\n\nGreylock maintains offices in Menlo Park and San Francisco, though like most VCs they've adapted to a more distributed model post-pandemic. Their investment thesis centers on what they call \"product-first founders\"—technical leaders who deeply understand the problems they're solving. This approach has led them to back companies like Figma early, before design tools became a hot category.\n\nThe partnership has been vocal about their views on AI, with several partners publishing extensively on where they see oportunities in the space. They've made multiple bets on AI infrastructure and application layers. Recent portfolio companies include Adept AI and various developer productivity startups.\n\nUnlike some mega-funds, Greylock has resisted the temptation to raise massive vehicles, generally keeping fund sizes in the $1-2 billion range. This discipline, they argue, keeps them focused on early-stage where they have the most edge. The firm competes directly with [Sequoia Capital](companies/sequoia-capital) and [Andreessen Horowitz](companies/a16z-3) for the best deals, though each firm has developed somewhat distinct positioning over time.\n\nTheir brand among founders remains strong, particularly for B2B and infrastructure plays. The firm hosts regular content series and podcasts featuring partners discussng market trends, which serves both as thought leadership and deal flow generation.",
+  "timeline": "- **2021-03-15** | Led $40M Series B in Snyk, continuing their security software thesis\n- **2021-09-22** | Reid Hoffman published essay on future of work, generating significant discussion in tech media\n- **2022-02-08** | Announced Fund XVI at $1.2 billion, focused on AI and enterprise\n- **2022-11-30** | Participated in Discord's $500M round alongside [Sequoia Capital](companies/sequoia-capital)\n- **2023-04-17** | Partner Sarah Guo departed to launch her own AI-focused fund Conviction\n- **2023-08-25** | Led seed round for stealth AI infrastructure startup\n- **2024-01-12** | Hosted annual Greylock Techfair recruiting event for portfolio companies\n- **2024-06-03** | Published internal AI research report, shared selectively with LPs\n- **2024-11-19** | Co-invested with [Andreessen Horowitz](companies/a16z-3) in Series A for developer tools company\n- **2025-02-28** | Promoted two principals to partner, signaling generational transition",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/greylock-4",
+    "name": "Greylock",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}

eval/data/world-v1/companies__gust-34.json

@@ -0,0 +1,24 @@
+{
+  "slug": "companies/gust-34",
+  "type": "company",
+  "title": "Gust",
+  "compiled_truth": "Gust is a data infrastructure startup founded in 2020 by [Steve Liu](people/steve-liu-34), who previously spent time at Snowflake and Databricks before striking out on his own. The company focuses on building real-time data pipelines that can handle massive throughput without the typical overhead of traditional ETL systems. Their core product lets engineering teams ingest, transform, and route streaming data with minimal configuration—think Kafka meets dbt but with a much simpler developer experience.\n\nThe founding story is pretty straightforward. Steve had grown frustrated with the complexity of existing data infrastructure tools while working on analytics pipelines at his previous roles. He saw an opportunity to build something cleaner, something that didn't require a dedicated platform team just to keep running. Gust was born out of that frustration, initially as a side project before Steve commited to it full-time.\n\nEarly traction came from mid-sized fintech companies who needed reliable streaming infrastructure but couldn't justify the headcount to manage Kafka clusters. Gust's managed offering hit a sweet spot—enterprise-grade reliability without the operational burden. By late 2021, the company had a handful of paying customers and was generating modest but growing revenue.\n\n[Sarah Lopez](people/sarah-lopez-84) led their seed round in early 2022, betting on Steve's technical chops and the growing demand for simplified data tooling. Sarah had been tracking the data infrastructure space for years and saw Gust as a potential breakout player. Her investment gave the company runway to expand the engineering team and accelerate product developement.\n\nToday Gust operates with a lean team of about 25 people, mostly engineers. They've been deliberate about not over-hiring, preferring to stay focused and capital-efficient. The company has expanded its product to include schema management, data quality monitoring, and connectors for most major data warehouses. Competition from bigger players like Confluent and newer startups remains intense, but Gust has carved out a loyal customer base that values simplicity over feature bloat.",
+  "timeline": "- **2020-03-15** | Steve Liu incorporates Gust and begins building the initial prototype\n- **2020-09-22** | First beta customer signs up—a small fintech startup in NYC\n- **2021-04-10** | Gust launches publicly with support for Postgres and Snowflake sinks\n- **2022-02-08** | Closes $4.2M seed round led by [Sarah Lopez](people/sarah-lopez-84)\n- **2022-07-19** | Hires first head of engineering from Stripe\n- **2023-01-30** | Launches schema registry feature after months of customer requests\n- **2023-11-14** | [Steve Liu](people/steve-liu-34) speaks at Data Council on simplifying streaming architectures\n- **2024-05-02** | Crosses 100 paying customers milestone\n- **2024-12-11** | Announces partnership with major cloud provider for native integration\n- **2025-08-20** | Begins work on Series A fundraising process",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/gust-34",
+    "name": "Gust",
+    "category": "startup",
+    "industry": "data infrastructure",
+    "founded_year": 2020,
+    "founders": [
+      "people/steve-liu-34"
+    ],
+    "investors": [
+      "people/sarah-lopez-84"
+    ],
+    "employees": [
+      "people/xavier-jackson-144"
+    ]
+  }
+}

eval/data/world-v1/companies__hatch-35.json

@@ -0,0 +1,24 @@
+{
+  "slug": "companies/hatch-35",
+  "type": "company",
+  "title": "Hatch",
+  "compiled_truth": "Hatch is an edtech startup founded in 2019 by [Eric Miller](people/eric-miller-35), who saw an opportunity to reimagine how young professionals develop career skills outside traditional academic settings. The company operates in the increasingly crowded learn-to-earn space, but distinguishes itself through a cohort-based model that emphasizes peer accountability and real-world project work.\n\nThe platform connects early-career workers with mentors from established companies, facilitating structured 8-week programs in areas like product management, data analytics, and business development. Hatch takes a different aproach than most competitors—rather than selling courses to individuals, they partner directly with employers who want to upskill entry-level hires or create alternative talent pipelines. This B2B focus has given them more predictable revenue, though it's also meant slower user growth compared to consumer-facing platforms.\n\n[Steve Martinez](people/steve-martinez-192) joined as an advisor sometime in 2022, bringing his network in workforce development and helping Hatch refine their enterprise sales motion. His involvement signaled a shift toward targeting larger organizations rather than the SMB market they'd initially pursued. Martinez has been particularly helpful in opening doors at companies looking to diversify their hiring beyond traditional university recruiting.\n\nEric Miller remains the driving force behind product decisions. He's known for being hands-on with curriculum design, often personally reviewing program content and sitting in on mentor sessions. Some employees find this level of involvement micromanage-y, but others appreciate the attention to quality. The company has stayed relatively lean—around 35 employees as of late 2024—and Miller has been vocal about not raising more capital than necessary.\n\nHatch completed a Series A in early 2023, though they haven't disclosed the amount publicly. They're headquartered in Austin but operate fully remote, with mentors and participants spread across North America. Recent moves suggest they're exploring expansion into technical skills training, potentially competing more directly with bootcamps.",
+  "timeline": "- **2019-06-12** | Hatch incorporated in Delaware; [Eric Miller](people/eric-miller-35) begins building initial prototype\n- **2020-03-08** | Launched first pilot cohort with 24 participants across three employer partners\n- **2021-09-15** | Closed seed round of $2.4M led by Reach Capital\n- **2022-04-22** | [Steve Martinez](people/steve-martinez-192) formally joins advisory board\n- **2022-11-03** | Surpassed 2,000 program graduates; announced partnership with two Fortune 500 retailers\n- **2023-02-17** | Series A closed; terms undisclosed but reportedly in $8-12M range\n- **2023-08-29** | Launched data analytics track, first technical program offering\n- **2024-01-14** | Eric Miller spoke at ASU+GSV Summit on alternative credentialing\n- **2024-07-20** | Opened pilot in Canada with three Toronto-based employers\n- **2025-03-11** | Announced curriculum partnership with major cloud provider for technical upskilling",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/hatch-35",
+    "name": "Hatch",
+    "category": "startup",
+    "industry": "edtech",
+    "founded_year": 2019,
+    "founders": [
+      "people/eric-miller-35"
+    ],
+    "employees": [
+      "people/diana-brown-145"
+    ],
+    "advisors": [
+      "people/steve-martinez-192"
+    ]
+  }
+}

eval/data/world-v1/companies__helix-9.json

@@ -0,0 +1,26 @@
+{
+  "slug": "companies/helix-9",
+  "type": "company",
+  "title": "Helix",
+  "compiled_truth": "Helix is an AI infrastructure startup founded in 2021 by [Rachel Garcia](people/rachel-garcia-9), a veteran systems engineer who previously led distributed computing teams at major cloud providers. The company focuses on building foundational tooling for deploying and managing large-scale machine learning workloads, with particular emphasis on GPU orchestration and model serving optimization.\n\nThe core product is a Kubernetes-native platform that abstracts away much of the complexity involved in running inference at scale. Helix's approach differs from competitors in that it prioritizes cost efficiency over raw performance—their scheduling algorithms are designed to maximize GPU utilization across heterogenous hardware, which appeals to companies running mixed fleets of older and newer accelerators. Early customers include several mid-size fintech firms and a handful of healthcare AI startups.\n\nRachel Garcia serves as CEO and has been the public face of the company since launch. She's known for her pragmatic approach to infrastructure problems and has spoken at several industry conferences about the \"unsexy\" challenges of ML ops. Under her leadership, Helix has grown to roughly 35 employees, mostly engineers with backgrounds in distributed systems and cloud infrastucture.\n\nThe advisory board includes [Xavier Patel](people/xavier-patel-183), who brings deep expertise in enterprise sales and go-to-market strategy, and [Bob Chen](people/bob-chen-185), a technical advisor with experience scaling infrastructure at hypergrowth companies. Both have been instrumental in shaping Helix's enterprise positioning.\n\nHelix raised a Series A in early 2023, though the company has been relatively quiet about specific metrics. Industry observers note that the AI infrastructure space has become increasingly crowded, but Helix's focus on cost optimization rather than cutting-edge performance gives it a distinct niche. The startup has been expanding its sales team and recently opened a small office in Austin to complement its San Francisco headquarters. Recent product updates have focused on observability features and tighter integrations with popular ML frameworks.",
+  "timeline": "- **2021-03-15** | Company incorporated by [Rachel Garcia](people/rachel-garcia-9) in Delaware\n- **2021-09-02** | Closed $4.2M seed round led by Gradient Ventures\n- **2022-01-18** | First production customer goes live on Helix platform\n- **2022-07-11** | [Xavier Patel](people/xavier-patel-183) joins as advisor to help with enterprise strategy\n- **2023-02-28** | Announced Series A funding, expanded engineering team to 25\n- **2023-08-14** | [Bob Chen](people/bob-chen-185) joins advisory board\n- **2024-01-22** | Launched Helix Observe, new monitoring and cost analytics product\n- **2024-06-09** | Rachel Garcia keynotes at MLOps World conference in Austin\n- **2024-11-03** | Opened Austin office, announced plans to double sales team\n- **2025-04-17** | Partnership announced with major cloud provider for marketplace listing",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/helix-9",
+    "name": "Helix",
+    "category": "startup",
+    "industry": "AI infrastructure",
+    "founded_year": 2021,
+    "founders": [
+      "people/rachel-garcia-9"
+    ],
+    "employees": [
+      "people/quinn-park-119"
+    ],
+    "advisors": [
+      "people/xavier-patel-183",
+      "people/bob-chen-185",
+      "people/victor-smith-193"
+    ]
+  }
+}

eval/data/world-v1/companies__helix-labs-59.json

@@ -0,0 +1,25 @@
+{
+  "slug": "companies/helix-labs-59",
+  "type": "company",
+  "title": "Helix Labs",
+  "compiled_truth": "Helix Labs is a cybersecurity startup founded in 2020 by [Bob Jackson](people/bob-jackson-59), a former penetration tester who spent nearly a decade at major defense contractors before striking out on his own. The company focuses on automated threat detection for mid-market enterprises, a segment Jackson felt was underserved by existing solutions that either targeted Fortune 500 companies or were too basic for sophisticated threats.\n\nThe company's flagship product, HelixShield, uses behavioral analysis to identify anomalous network activity before breaches occur. Unlike traditional signature-based detection, their approach learns what 'normal' looks like for each client and flags deviations in real-time. Early customers have praised the low false-positive rate, though some have noted the onboarding process can be lengthy.\n\nHelix raised its seed round in late 2021 from angel investors including [Priya Taylor](people/priya-taylor-85) and [Julia Davis](people/julia-davis-86), both of whom have backgrounds in enterprise software. Priya in particular has been an active advisor, reportedly introducing the team to several key enterprise clients in the healthcare vertical. The company closed a Series A in 2023, though terms were not publicly disclosed.\n\nThe team has grown to around 45 employees, with engineering concentrated in Austin and a small sales presence in New York. Jackson remains CEO and is known for his hands-on technical involvement—he still reviews major architecture decisions and ocasionally jumps into customer calls when things get hairy. Former colleagues describe him as demanding but fair, with a tendency to work late nights that sometimes sets unrealistic expectations for the rest of the team.\n\nHelix Labs has been relatively quiet in terms of press, preferring to let customer referrals drive growth rather than splashy marketing campaigns. That said, there's been some chatter about a potential expansion into cloud security posture management, which would put them in direct competition with larger players. Whether they have the resources to fight on multiple fronts remaind to be seen.",
+  "timeline": "- **2020-03-15** | Helix Labs incorporated in Delaware by [Bob Jackson](people/bob-jackson-59)\n- **2020-09-22** | First prototype of HelixShield deployed internally for testing\n- **2021-06-10** | Closed seed round with participation from [Priya Taylor](people/priya-taylor-85) and [Julia Davis](people/julia-davis-86)\n- **2021-11-03** | Landed first paying customer, a regional hospital network in Texas\n- **2022-04-18** | Expanded engineering team to 20 people, opened Austin office\n- **2023-02-27** | Series A closed; valuation undisclosed but rumored around $40M\n- **2023-09-14** | HelixShield 2.0 launched with improved ML detection pipeline\n- **2024-05-06** | [Bob Jackson](people/bob-jackson-59) spoke at RSA Conference on behavioral threat detection\n- **2025-01-22** | Announced partnership with managed security provider NorthWatch\n- **2025-08-30** | Internal planning meetings hint at cloud security product expansion",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/helix-labs-59",
+    "name": "Helix Labs",
+    "category": "startup",
+    "industry": "cybersecurity",
+    "founded_year": 2020,
+    "founders": [
+      "people/bob-jackson-59"
+    ],
+    "investors": [
+      "people/priya-taylor-85",
+      "people/julia-davis-86"
+    ],
+    "employees": [
+      "people/sam-wilson-169"
+    ]
+  }
+}

eval/data/world-v1/companies__index-ventures-7.json

@@ -0,0 +1,14 @@
+{
+  "slug": "companies/index-ventures-7",
+  "type": "company",
+  "title": "Index Ventures",
+  "compiled_truth": "Index Ventures is one of Europe's most storied venture capital firms, with a track record that spans three decades and includes some of the most consequential technology companies of the modern era. Founded in Geneva in 1996, the firm has grown to operate across offices in San Francisco, London, and Geneva, positioning itself as a truly transatlantic investor with deep roots on both sides of the pond.\n\nThe firm operates across multiple stages, from seed through growth, and has backed companies like Figma, Discord, Notion, Roblox, and Deliveroo. Index made early bets on European champions like Skype and King Digital, establishing its reputation for identifying category-defining companies before they hit mainstream radar. Their portfolio reflects a broad thesis covering enterprise software, fintech, consumer internet, and increasingly, AI-native applications.\n\nIndex is known for its partnership-driven model, where partners maintain significant autonomy in dealmaking while sharing economics equally. Notable partners include Danny Rimer, who led investments in Dropbox and Glossier, and Mike Volpi, a former Cisco executive who's become one of the most respected enterprise investors in the industry. The firm's approach tends to be founder-friendly, often taking board seats but avoiding the heavy-handed governance that characterizes some of their peers.\n\nRecent years have seen Index raising substantial funds—their 2021 vintage exceeded $3 billion across seed and growth vehicles. They've been particularly active in the AI infrastructure space, competing aggressively with firms like [Sequoia Capital](companies/sequoia-capital-12) for the hottest deals. Some partners have noted tension between maintaining their European identity while increasingly deploying capital into Silicon Valley's AI boom.\n\nThe firm has also made notable investments alongside [Andreessen Horowitz](companies/andreessen-horowitz-9) in several high-profile rounds, demonstrating their ability to co-invest with top-tier American firms while maintaining deal leadership. Index's LP base includes major endowments, sovereign wealth funds, and family offices who've stuck with the firm through multiple fund cycles.\n\nCriticism sometimes surfaces around their growth-stage valuations—some observers argue Index overpaid during the 2021 bubble. But their seed practice has remained disciplined, and their multi-stage model provides natural follow-on optionality that pure-play seed funds lack.",
+  "timeline": "- **2021-03-15** | Closed Index Ventures Growth VI at $2.3B, largest fund in firm history\n- **2021-09-22** | Led $150M Series C for AI startup alongside [Sequoia Capital](companies/sequoia-capital-12)\n- **2022-04-10** | Partner Martin Mignot promoted to lead European seed practice\n- **2022-11-08** | Portfolio company Figma announced $20B acquisition by Adobe (later terminated)\n- **2023-02-14** | Participated in Discord's down round, maintaining pro-rata\n- **2023-08-30** | Co-led infrastructure deal with [Andreessen Horowitz](companies/andreessen-horowitz-9) at $800M valuation\n- **2024-01-19** | Published annual European tech ecosystem report showing record unicorn creation\n- **2024-06-05** | Danny Rimer keynoted at Index's annual founder summit in London\n- **2025-02-28** | Announced new $1.8B early-stage fund focused on AI-native applications\n- **2025-09-12** | Opened small Tel Aviv office to expand Middle East dealflow",
+  "_facts": {
+    "type": "company",
+    "slug": "companies/index-ventures-7",
+    "name": "Index Ventures",
+    "category": "vc",
+    "industry": "venture capital"
+  }
+}