fix: rename political-donations recipe to expense-tracker (sensitivity)

Renamed the built-in data-research recipe from political-donations to
expense-tracker across README, CHANGELOG, SKILL.md, and reports routing.
Same extraction patterns (amounts, dates, recipients), neutral framing.
Also renamed social-radar keyword route to social-mentions.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.github/workflows/test.yml

@@ -28,4 +28,4 @@ jobs:
         with:
           bun-version: latest
       - run: bun install
-      - run: bun run test
+      - run: bun test

.gitignore

@@ -5,11 +5,9 @@ bin/
 .env
 .env.*
 !.env.*.example
-# Bun --compile temp artifacts. Each build emits a new hash-named .bun-build
-# file in cwd; glob catches all of them.
-*.bun-build
+.18a49dfd730ff378-00000000.bun-build
+.18a49f9dfb996f70-00000000.bun-build
 .gstack/
 supabase/.temp/
 .claude/skills/
 .idea
-eval/reports/

AGENTS.md

@@ -1,59 +0,0 @@
-# Agents working on GBrain
-
-This is your install + operating protocol. Claude Code reads `./CLAUDE.md` automatically.
-Everyone else (Codex, Cursor, OpenClaw, Aider, Continue, or an LLM fetching via URL):
-start here.
-
-## Install (5 min)
-
-1. Clone: `git clone https://github.com/garrytan/gbrain ~/gbrain && cd ~/gbrain`
-2. Install: `bun install`
-3. Init the brain: `gbrain init` (defaults to PGLite, zero-config). For 1000+ files or
-   multi-machine sync, init suggests Postgres + pgvector via Supabase.
-4. Read [`./INSTALL_FOR_AGENTS.md`](./INSTALL_FOR_AGENTS.md) for the full 9-step flow
-   (API keys, identity, cron, verification).
-
-## Read this order
-
-1. `./AGENTS.md` (this file) — install + operating protocol.
-2. [`./CLAUDE.md`](./CLAUDE.md) — architecture reference, key files, trust boundaries,
-   test layout.
-3. [`./skills/RESOLVER.md`](./skills/RESOLVER.md) — skill dispatcher. Read before any task.
-
-## Trust boundary (critical)
-
-GBrain distinguishes **trusted local CLI callers** (`OperationContext.remote = false`,
-set by `src/cli.ts`) from **untrusted agent-facing callers** (`remote = true`, set by
-`src/mcp/server.ts`). Security-sensitive operations like `file_upload` tighten filesystem
-confinement when `remote = true` and default to strict behavior when unset. If you are
-writing or reviewing an operation, consult `src/core/operations.ts` for the contract.
-
-## Common tasks
-
-- **Configure:** [`docs/ENGINES.md`](./docs/ENGINES.md),
-  [`docs/guides/live-sync.md`](./docs/guides/live-sync.md),
-  [`docs/mcp/DEPLOY.md`](./docs/mcp/DEPLOY.md).
-- **Debug:** [`docs/GBRAIN_VERIFY.md`](./docs/GBRAIN_VERIFY.md),
-  [`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`.
-- **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
-
-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
-
-Never commit real names of people, companies, or funds into public artifacts. See the
-Privacy rule in `./CLAUDE.md`. GBrain pages reference real contacts; public docs must
-use generic placeholders (`alice-example`, `acme-example`, `fund-a`).
-
-## Forks
-
-If you are a fork, regenerate `llms.txt` + `llms-full.txt` with your own URL base before
-publishing: `LLMS_REPO_BASE=https://raw.githubusercontent.com/your-org/your-fork/main bun run build:llms`.

CLAUDE.md

@@ -9,26 +9,20 @@ cron scheduling, reports, identity, and access control.
 
 ## Architecture
 
-Contract-first: `src/core/operations.ts` defines ~41 shared operations (adds `find_orphans` in v0.12.3). CLI and MCP
+Contract-first: `src/core/operations.ts` defines ~30 shared operations. CLI and MCP
 server are both generated from this single source. Engine factory (`src/core/engine-factory.ts`)
 dynamically imports the configured engine (`'pglite'` or `'postgres'`). Skills are fat
 markdown files (tool-agnostic, work with both CLI and plugin contexts).
 
-**Trust boundary:** `OperationContext.remote` distinguishes trusted local CLI callers
-(`remote: false` set by `src/cli.ts`) from untrusted agent-facing callers
-(`remote: true` set by `src/mcp/server.ts`). Security-sensitive operations like
-`file_upload` tighten filesystem confinement when `remote=true` and default to
-strict behavior when unset.
-
 ## Key files
 
-- `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/operations.ts` — Contract-first operation definitions (the foundation)
+- `src/core/engine.ts` — Pluggable engine interface (BrainEngine)
 - `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.
+- `src/core/pglite-engine.ts` — PGLite (embedded Postgres 17.5 via WASM) implementation, all 37 BrainEngine methods
 - `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.
-- `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/postgres-engine.ts` — Postgres + pgvector implementation (Supabase / self-hosted)
+- `src/core/utils.ts` — Shared SQL utilities extracted from postgres-engine.ts
 - `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)
@@ -42,63 +36,18 @@ strict behavior when unset.
 - `src/core/search/eval.ts` — Retrieval eval harness: P@k, R@k, MRR, nDCG@k metrics + runEval() orchestrator
 - `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). `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/check-resolvable.ts` — Resolver validation: reachability, MECE overlap, DRY checks, structured fix objects
 - `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/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.
-- `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/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`.
-- `src/core/minions/rate-leases.ts` (v0.15) — lease-based concurrency cap for outbound providers (default key `anthropic:messages`, max via `GBRAIN_ANTHROPIC_MAX_INFLIGHT`). Owner-tagged rows with `expires_at` auto-prune on acquire; `pg_advisory_xact_lock` guards check-then-insert; CASCADE on owning job deletion. `renewLeaseWithBackoff` retries 3x (250/500/1000ms).
-- `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) — 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).
-- `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)
 - `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/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/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`.
-- `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.
+- `src/commands/upgrade.ts` — Self-update CLI with post-upgrade feature discovery
 - `src/core/schema-embedded.ts` — AUTO-GENERATED from schema.sql (run `bun run build:schema`)
 - `src/schema.sql` — Full Postgres + pgvector DDL (source of truth, generates schema-embedded.ts)
-- `src/commands/integrations.ts` — Standalone integration recipe management (no DB needed). Exports `getRecipeDirs()` (trust-tagged recipe sources), SSRF helpers (`isInternalUrl`, `parseOctet`, `hostnameToOctets`, `isPrivateIpv4`). Only package-bundled recipes are `embedded=true`; `$GBRAIN_RECIPES_DIR` and cwd `./recipes/` are untrusted and cannot run `command`/`http`/string health checks.
-- `src/core/search/expansion.ts` — Multi-query expansion via Haiku. Exports `sanitizeQueryForPrompt` + `sanitizeExpansionOutput` (prompt-injection defense-in-depth). Sanitized query is only used for the LLM channel; original query still drives search.
+- `src/commands/integrations.ts` — Standalone integration recipe management (no DB needed)
 - `recipes/` — Integration recipe files (YAML frontmatter + markdown setup instructions)
 - `docs/guides/` — Individual SKILLPACK guides (broken out from monolith)
 - `docs/integrations/` — "Getting Data In" guides and integration docs
@@ -115,7 +64,7 @@ strict behavior when unset.
 - `docs/mcp/` — Per-client setup guides (Claude Desktop, Code, Cowork, Perplexity)
 - `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/RESOLVER.md` — Skill routing table (modeled on Wintermute's AGENTS.md)
 - `skills/conventions/` — Cross-cutting rules (quality, brain-first, model-routing, test-before-bulk, cross-modal)
 - `skills/_output-rules.md` — Output quality standards (deterministic links, no slop, exact phrasing)
 - `skills/signal-detector/SKILL.md` — Always-on idea+entity capture on every message
@@ -135,7 +84,6 @@ 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` — 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)
@@ -152,53 +100,23 @@ Key commands added in v0.7:
 - `gbrain init` — defaults to PGLite (no Supabase needed), scans repo size, suggests Supabase for 1000+ files
 - `gbrain migrate --to supabase` / `gbrain migrate --to pglite` — bidirectional engine migration
 
-Key commands added for Minions (job queue):
-- `gbrain jobs submit <name> [--params JSON] [--follow] [--dry-run]` — submit a background job. v0.13.1 adds first-class flags for every `MinionJobInput` tuning knob: `--max-stalled N`, `--backoff-type fixed|exponential`, `--backoff-delay Nms`, `--backoff-jitter 0..1`, `--timeout-ms N`, `--idempotency-key K`.
-- `gbrain jobs list [--status S] [--queue Q]` — list jobs with filters
-- `gbrain jobs get <id>` — job details with attempt history
-- `gbrain jobs cancel/retry/delete <id>` — manage job lifecycle
-- `gbrain jobs prune [--older-than 30d]` — clean old completed/dead jobs
-- `gbrain jobs stats` — job health dashboard
-- `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.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`.
-
-Key commands added in v0.12.3:
-- `gbrain orphans [--json] [--count] [--include-pseudo]` — surface pages with zero inbound wikilinks, grouped by domain. Auto-generated/raw/pseudo pages filtered by default. Also exposed as `find_orphans` MCP operation. The natural consumer of the v0.12.0 knowledge graph layer: once edges are captured, find the gaps.
-- `gbrain doctor` gains two new reliability detection checks: `jsonb_integrity` (v0.12.0 Postgres double-encode damage) and `markdown_body_completeness` (pages truncated by the old splitBody bug). Detection only; fix hints point at `gbrain repair-jsonb` and `gbrain sync --force`.
-
-Key commands added in v0.14.2:
-- `gbrain sync --skip-failed` — acknowledge the current set of failed-parse files recorded in `~/.gbrain/sync-failures.jsonl` so the sync bookmark advances past them. Doctor's `sync_failures` check shows previously-skipped as "all acknowledged" instead of warning.
-- `gbrain sync --retry-failed` — re-walk the unacknowledged failures and re-attempt parsing. If the files now succeed, they clear from the set and the bookmark advances naturally.
-- `gbrain apply-migrations --force-retry <version>` — reset a wedged migration (3 consecutive partials with no completion) by appending a `'retry'` marker. Next `apply-migrations --yes` treats the version as fresh. `complete` status never regresses to `partial` either before or after a retry marker.
-- `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.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.
-
 ## Testing
 
-`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
+`bun test` runs all tests (34 unit test files + 5 E2E test files). Unit tests run
 without a database. E2E tests skip gracefully when `DATABASE_URL` is not set.
 
 Unit tests: `test/markdown.test.ts` (frontmatter parsing), `test/chunkers/recursive.test.ts`
-(chunking), `test/parity.test.ts` (operations contract
+(chunking), `test/sync.test.ts` (sync logic), `test/parity.test.ts` (operations contract
 parity), `test/cli.test.ts` (CLI structure), `test/config.test.ts` (config redaction),
 `test/files.test.ts` (MIME/hash), `test/import-file.test.ts` (import pipeline),
-`test/upgrade.test.ts` (schema migrations),
+`test/upgrade.test.ts` (schema migrations), `test/doctor.test.ts` (doctor command),
 `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, and the `max_stalled DEFAULT 1` regression guard),
+`test/import-resume.test.ts` (import checkpoints), `test/migrate.test.ts` (migration),
 `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),
-`test/pglite-engine.test.ts` (PGLite engine, all 40 BrainEngine methods including 11 cases for `addLinksBatch` / `addTimelineEntriesBatch`: empty batch, missing optionals, within-batch dedup via ON CONFLICT, missing-slug rows dropped by JOIN, half-existing batch, batch of 100 + v0.13.1 `connect()` error-wrap assertion (original error nested, #223 link in message, lock released)),
-`test/engine-factory.test.ts` (engine factory + dynamic imports),
+`test/pglite-engine.test.ts` (PGLite engine, all 37 BrainEngine methods),
+`test/utils.test.ts` (shared SQL utilities), `test/engine-factory.test.ts` (engine factory + dynamic imports),
 `test/integrations.test.ts` (recipe parsing, CLI routing, recipe validation),
 `test/publish.test.ts` (content stripping, encryption, password generation, HTML output),
 `test/backlinks.test.ts` (entity extraction, back-link detection, timeline entry generation),
@@ -210,40 +128,16 @@ parity), `test/cli.test.ts` (CLI structure), `test/config.test.ts` (config redac
 `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),
-`test/check-resolvable.test.ts` (resolver reachability, MECE overlap, gap detection, DRY checks + v0.14.1 proximity-based DRY detection + `extractDelegationTargets` coverage — 13 DRY cases),
-`test/dry-fix.test.ts` (v0.14.1 auto-fix: three shape-aware expander pure-function tests, five guards — working-tree-dirty, no-git-backup, inside-code-fence, already-delegated within 40 lines, ambiguous-multi-match, block-is-callout — 28 cases),
-`test/doctor-fix.test.ts` (v0.14.1 `gbrain doctor --fix` CLI integration: dry-run preview, apply path, JSON output shape — 3 cases),
+`test/check-resolvable.test.ts` (resolver reachability, MECE overlap, gap detection, DRY checks),
 `test/backoff.test.ts` (load-aware throttling, concurrency limits, active hours),
 `test/fail-improve.test.ts` (deterministic/LLM cascade, JSONL logging, test generation, rotation),
 `test/transcription.test.ts` (provider detection, format validation, API key errors),
 `test/enrichment-service.test.ts` (entity slugification, extraction, tier escalation),
-`test/data-research.test.ts` (recipe validation, MRR/ARR extraction, dedup, tracker parsing, HTML stripping),
-`test/minions.test.ts` (Minions job queue v7: CRUD, state machine, backoff, stall detection, dependencies, worker lifecycle, lock management, claim mechanics, depth/child-cap, timeouts, cascade kill, idempotency, child_done inbox, attachments, removeOnComplete/Fail + v0.13.1 `max_stalled` clamp/default/plumbing coverage),
-`test/extract.test.ts` (link extraction, timeline extraction, frontmatter parsing, directory type inference),
-`test/extract-db.test.ts` (gbrain extract --source db: typed link inference, idempotency, --type filter, --dry-run JSON output),
-`test/extract-fs.test.ts` (gbrain extract --source fs: first-run inserts + second-run reports zero, dry-run dedups candidates across files, second-run perf regression guard — the v0.12.1 N+1 dedup bug),
-`test/link-extraction.test.ts` (canonical extractEntityRefs both formats, extractPageLinks dedup, inferLinkType heuristics, parseTimelineEntries date variants, isAutoLinkEnabled config),
-`test/graph-query.test.ts` (direction in/out/both, type filter, indented tree output),
-`test/features.test.ts` (feature scanning, brain_score calculation, CLI routing, persistence),
-`test/file-upload-security.test.ts` (symlink traversal, cwd confinement, slug + filename allowlists, remote vs local trust),
-`test/query-sanitization.test.ts` (prompt-injection stripping, output sanitization, structural boundary),
-`test/search-limit.test.ts` (clampSearchLimit default/cap behavior across list_pages and get_ingest_log),
-`test/repair-jsonb.test.ts` (v0.12.2 JSONB repair: TARGETS list, idempotency, engine-awareness),
-`test/migrations-v0_12_2.test.ts` (v0.12.2 orchestrator phases: schema → repair → verify → record),
-`test/markdown.test.ts` (splitBody sentinel precedence, horizontal-rule preservation, inferType wiki subtypes),
-`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/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/data-research.test.ts` (recipe validation, MRR/ARR extraction, dedup, tracker parsing, HTML stripping).
 
 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.
+- `bun run test:e2e` runs Tier 1 (mechanical, all operations, no API keys)
 - `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/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/upgrade.test.ts` runs check-update E2E against real GitHub API (network required)
 - 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:
@@ -296,54 +190,22 @@ stop and remove it before starting a new one.
 
 ## Skills
 
-Read the skill files in `skills/` before doing brain operations. GBrain ships 26 skills
+Read the skill files in `skills/` before doing brain operations. GBrain ships 25 skills
 organized by `skills/RESOLVER.md`:
 
 **Original 8 (conformance-migrated):** ingest (thin router), query, maintain, enrich,
 briefing, migrate, setup, publish.
 
-**Brain skills (ported from an upstream agent fork):** signal-detector, brain-ops, idea-ingest, media-ingest,
+**Brain skills (from Wintermute):** signal-detector, brain-ops, idea-ingest, media-ingest,
 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.
+testing, soul-audit, webhook-transforms.
 
 **Conventions:** `skills/conventions/` has cross-cutting rules (quality, brain-first,
 model-routing, test-before-bulk, cross-modal). `skills/_brain-filing-rules.md` and
 `skills/_output-rules.md` are shared references.
 
-## Bulk-action progress reporting
-
-All bulk commands (doctor, embed, import, export, sync, extract, migrate,
-repair-jsonb, orphans, check-backlinks, lint, integrity auto, eval, files
-sync, and apply-migrations) stream progress through the shared reporter
-at `src/core/progress.ts`. Agents get heartbeats within 1 second of every
-iteration regardless of how slow the underlying work is.
-
-Rules:
-- Progress always writes to **stderr**. Stdout stays clean for data output
-  (`--json` payloads, final summaries, JSON action events from `extract`).
-- Non-TTY default: plain one-line-per-event human text. JSON requires the
-  explicit `--progress-json` flag.
-- Global flags (`--quiet`, `--progress-json`, `--progress-interval=<ms>`)
-  are parsed by `src/core/cli-options.ts` BEFORE command dispatch.
-- Phase names are machine-stable `snake_case.dot.path` (e.g.
-  `doctor.db_checks`, `sync.imports`). Documented in
-  `docs/progress-events.md`; additive changes only.
-- `scripts/check-progress-to-stdout.sh` is a CI guard that fails the build
-  if any new code writes `\r` progress to stdout. Wired into `bun run test`.
-- Minion handlers pass `job.updateProgress` as the `onProgress` callback
-  to core functions (DB-backed primary progress channel); stderr from
-  `jobs work` stays coarse for daemon liveness only.
-
-When wiring a new bulk command: `import { createProgress } from '../core/progress.ts'`
-and `import { getCliOptions, cliOptsToProgressOptions } from '../core/cli-options.ts'`.
-Create a reporter with `createProgress(cliOptsToProgressOptions(getCliOptions()))`,
-`start(phase, total?)` before the loop, `tick()` inside it, `finish()` after.
-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.
-
 ## Build
 
 `bun build --compile --outfile bin/gbrain src/cli.ts`
@@ -376,106 +238,11 @@ Files that MUST be checked on every ship:
 
 A ship without updated docs is an incomplete ship. Period.
 
-## CHANGELOG voice + release-summary format
+## CHANGELOG voice
 
-Every version entry in `CHANGELOG.md` MUST start with a release-summary section in
-the GStack/Garry voice — one viewport's worth of prose + tables that lands like a
-verdict, not marketing. The itemized changelog (subsections, bullets, files) goes
-BELOW that summary, separated by a `### Itemized changes` header.
-
-The release-summary section gets read by humans, by the auto-update agent, and by
-anyone deciding whether to upgrade. The itemized list is for agents that need to
-know exactly what changed.
-
-### Release-summary template
-
-Use this structure for the top of every `## [X.Y.Z]` entry:
-
-1. **Two-line bold headline** (10-14 words total) ... should land like a verdict, not
-   marketing. Sound like someone who shipped today and cares whether it works.
-2. **Lead paragraph** (3-5 sentences) ... what shipped, what changed for the user.
-   Specific, concrete, no AI vocabulary, no em dashes, no hype.
-3. **A "The X numbers that matter" section** with:
-   - One short setup paragraph naming the source of the numbers (real production
-     deployment OR a reproducible benchmark ... name the file/command to run).
-   - A table of 3-6 key metrics with BEFORE / AFTER / Δ columns.
-   - A second optional table for per-category breakdown if relevant.
-   - 1-2 sentences interpreting the most striking number in concrete user terms.
-4. **A "What this means for [audience]" closing paragraph** (2-4 sentences) tying
-   the metrics to a real workflow shift. End with what to do.
-
-Voice rules:
-- No em dashes (use commas, periods, "...").
-- No AI vocabulary (delve, robust, comprehensive, nuanced, fundamental, etc.) or
-  banned phrases ("here's the kicker", "the bottom line", etc.).
-- Real numbers, real file names, real commands. Not "fast" but "~30s on 30K pages."
-- Short paragraphs, mix one-sentence punches with 2-3 sentence runs.
-- Connect to user outcomes: "the agent does ~3x less reading" beats "improved
-  precision."
-- Be direct about quality. "Well-designed" or "this is a mess." No dancing.
-
-Source material to pull from:
-- CHANGELOG.md previous entry for prior context
-- `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.
-
-Target length: ~250-350 words for the summary. Should render as one viewport.
-
-### "To take advantage of v[version]" block (required, v0.13+)
-
-After the release-summary and BEFORE `### Itemized changes`, every `## [X.Y.Z]`
-entry MUST include a human-readable self-repair block under the heading
-`## To take advantage of v[version]`.
-
-Why: `gbrain upgrade` runs `gbrain post-upgrade` which runs `gbrain apply-migrations`.
-This chain has a known weak link — `upgrade.ts` catches post-upgrade failures as
-best-effort (so the binary still works). When that chain silently fails, users end
-up with half-upgraded brains. The self-repair block gives them a paste-ready
-recovery path; the v0.13+ `~/.gbrain/upgrade-errors.jsonl` trail + `gbrain doctor`
-integration close the loop.
-
-Template (adapt the verify commands per release):
-
-```markdown
-## To take advantage of v[version]
-
-`gbrain upgrade` should do this automatically. If it didn't, or if `gbrain doctor`
-warns about a partial migration:
-
-1. **Run the orchestrator manually:**
-   ```bash
-   gbrain apply-migrations --yes
-   ```
-2. **Your agent reads `skills/migrations/v[version].md` the next time you interact with it.**
-   [One sentence on whether headless agents need manual action, or whether the
-   orchestrator already handled the mechanical side.]
-3. **Verify the outcome:**
-   ```bash
-   [release-specific verify commands, e.g. `gbrain graph ... --depth 2`]
-   gbrain stats
-   ```
-4. **If any step fails or the numbers look wrong,** please file an issue:
-   https://github.com/garrytan/gbrain/issues with:
-   - output of `gbrain doctor`
-   - contents of `~/.gbrain/upgrade-errors.jsonl` if it exists
-   - which step broke
-
-   This feedback loop is how the gbrain maintainers find fragile upgrade paths. Thank you.
-```
-
-**Skip this block** for patches that are pure bug fixes with zero user-facing action
-(rare). If the release has a schema migration, data backfill, or new feature the
-user needs to verify, the block is required.
-
-The v0.13.0 entry in CHANGELOG.md is the canonical example.
-
-### Itemized changes (the existing rules)
-
-Below the release summary, write `### Itemized changes` and continue with the
-detailed subsections (Knowledge Graph Layer, Schema migrations, Security hardening,
-Tests, etc.). Same rules as before:
+CHANGELOG.md is read by agents during auto-update (Section 17). The agent summarizes
+the changelog to convince the user to upgrade. Write changelog entries that sell the
+upgrade, not document the implementation.
 
 - Lead with what the user can now DO that they couldn't before
 - Frame as benefits and capabilities, not files changed or code written
@@ -489,13 +256,6 @@ Tests, etc.). Same rules as before:
   a community PR, name the contributor with `Contributed by @username`. Contributors
   did real work. Thank them publicly every time, no exceptions.
 
-### Reference: v0.12.0 entry as canonical example
-
-The v0.12.0 entry in CHANGELOG.md is the canonical example of the format. Match its
-structure for every future version: bold headline, lead paragraph, "numbers that
-matter" with BrainBench-style before/after table, "what this means" closer, then
-`### Itemized changes` with the detailed sections below.
-
 ## Version migrations
 
 Create a migration file at `skills/migrations/v[version].md` when a release
@@ -525,77 +285,6 @@ Write migration files as agent instructions, not technical notes. Tell the agent
 what to do, step by step, with exact commands. See `skills/migrations/v0.5.0.md`
 for the pattern.
 
-## Migration is canonical, not advisory
-
-GBrain's job is to deliver a canonical, working setup to every user on upgrade.
-Anything that looks like a "host-repo change" — AGENTS.md, cron manifests,
-launchctl units, config files outside `~/.gbrain/` — is a GBrain migration
-step, not a nudge we leave for the host-repo maintainer. Migrations edit host
-files (with backups) to make the canonical setup real. Exceptions: changes
-that require human judgment (content edits, renames that break semantics,
-host-specific handler registration where shell-exec would be an RCE surface).
-Everything mechanical ships in the migration.
-
-**Test:** if shipping a feature requires a sentence that starts with "in
-your AGENTS.md, add…" or "in your cron/jobs.json, rewrite…", the migration
-orchestrator should be doing that edit, not the user.
-
-**The exception is host-specific code.** For custom Minion handlers
-(host-specific integrations like inbox sweeps or third-party API scanners), shipping them as a
-data file the worker would exec is an RCE surface. Those get registered in
-the host's own repo via the plugin contract (`docs/guides/plugin-handlers.md`);
-the migration orchestrator emits a structured TODO to
-`~/.gbrain/migrations/pending-host-work.jsonl` + the host agent walks the
-TODOs using `skills/migrations/v0.11.0.md` — stays host-agnostic, still
-canonical.
-
-## Privacy rule: scrub real names from public docs
-
-**Never reference real people, companies, funds, or private agent names in any
-public-facing artifact.** Public artifacts include: `CHANGELOG.md`, `README.md`,
-`docs/`, `skills/`, PR titles + bodies, commit messages, and comments in checked-in
-code. Query examples, benchmark stories, and migration guides MUST use generic
-placeholders.
-
-Why: gbrain runs a personal knowledge brain containing notes on real people and
-real companies (YC founders, portfolio companies, funds, investors, meeting
-attendees). When a doc copies a query like `gbrain graph diana-hu --depth 2` or
-names a specific agent fork like `Wintermute`, that real name gets indexed by
-search engines, surfaced in cross-references, and distributed with every release.
-
-**Name mapping** to use in examples:
-- Agent forks → `your agent fork`, `a downstream agent`, or `agent-fork`
-- Example person → `alice-example`, `charlie-example`, or `a-founder`
-- Example company → `acme-example`, `widget-co`, or `a-company`
-- Example fund → `fund-a`, `fund-b`, `fund-c`
-- Example deal → `acme-seed`, `widget-series-a`
-- Example meeting → `meetings/2026-04-03` (generic date is fine)
-- Example user → `you` or `the user`, never a proper name
-
-**Specific rule: never say `Wintermute` in any CHANGELOG, README, doc, PR, or
-commit message.** When the temptation is to illustrate with the real fork name:
-- Reader-facing copy → `your OpenClaw` (covers Wintermute, Hermes, AlphaClaw,
-  and any other downstream OpenClaw deployment in one term the reader already
-  recognizes).
-- First-person / origin-story copy → `Garry's OpenClaw` (honest that this is
-  the production deployment driving the feature, without exposing the private
-  agent's name).
-
-`Wintermute` may appear in private artifacts (scratch plans under
-`~/.gstack/projects/…`, memory files, conversation transcripts, CEO-review
-plans) — those aren't distributed. Anything checked into this repo or shipped
-in a release must use the OpenClaw phrasing above. Sweeping a stale reference
-is a small clean-up PR, not a debate.
-
-**When in doubt, ask yourself:** "Would this query reveal private information
-about the user's contacts, investments, or portfolio if it were read by a
-stranger?" If yes, replace with generic placeholders.
-
-**Illustrative API examples with household-brand companies** (Stripe, Brex, OpenAI,
-GitHub, etc.) are fine — they're public entities, not contacts in anyone's brain.
-Do not confuse illustrative API examples with queries that reveal real
-relationships.
-
 ## Schema state tracking
 
 `~/.gbrain/update-state.json` tracks which recommended schema directories the user
@@ -618,22 +307,6 @@ done
 
 If any SHA differs from what's in the workflow files, update the pin and version comment.
 
-## PR descriptions cover the whole branch
-
-Pull request titles and bodies must describe **everything in the PR diff against the
-base branch**, not just the most recent commit you made. When you open or update a
-PR, walk the full commit range with `git log --oneline <base>..<head>` and write the
-body to cover all of it. Group by feature area (schema, code, tests, docs) — not
-chronologically by commit.
-
-This matters because reviewers read the PR body to understand what's shipping. If
-the body only covers your last commit, they miss everything else and can't review
-properly. A 7-commit PR with a body that describes commit 7 is worse than no body
-at all — it actively misleads.
-
-When in doubt, run `gh pr view <N> --json commits --jq '[.commits[].messageHeadline]'`
-to see what's actually in the PR before writing the body.
-
 ## Community PR wave process
 
 Never merge external PRs directly into master. Instead, use the "fix wave" workflow:

INSTALL_FOR_AGENTS.md

@@ -3,17 +3,6 @@
 Read this entire file, then follow the steps. Ask the user for API keys when needed.
 Target: ~30 minutes to a fully working brain.
 
-## Step 0: If you are not Claude Code
-
-Read `AGENTS.md` at the repo root first. It's the non-Claude-agent operating
-protocol (install, read order, trust boundary, common tasks). Claude Code reads
-`CLAUDE.md` automatically and can skip ahead.
-
-If you fetched this file by URL without cloning yet, the companion files live at:
-- `https://raw.githubusercontent.com/garrytan/gbrain/master/AGENTS.md` — start here
-- `https://raw.githubusercontent.com/garrytan/gbrain/master/llms.txt` — full doc map
-- `https://raw.githubusercontent.com/garrytan/gbrain/master/llms-full.txt` — same map, inlined
-
 ## Step 1: Install GBrain
 
 ```bash
@@ -26,11 +15,6 @@ bun install && bun link
 Verify: `gbrain --version` should print a version number. If `gbrain` is not found,
 restart the shell or add the PATH export to the shell profile.
 
-> **Do NOT use `bun install -g github:garrytan/gbrain`.** Bun blocks the top-level
-> postinstall hook on global installs, so schema migrations never run and the CLI
-> aborts with `Aborted()` when it opens PGLite. Use the `git clone + bun link` path
-> above. Tracking issue: [#218](https://github.com/garrytan/gbrain/issues/218).
-
 ## Step 2: API Keys
 
 Ask the user for these:
@@ -69,30 +53,6 @@ gbrain embed --stale                  # generate vector embeddings
 gbrain query "key themes across these documents?"
 ```
 
-## Step 4.5: Wire the Knowledge Graph
-
-If the user already had a brain repo (Step 3 imported existing markdown), backfill
-the typed-link graph and structured timeline. This populates the `links` and
-`timeline_entries` tables that future writes will maintain automatically.
-
-```bash
-gbrain extract links --source db --dry-run | head -20    # preview
-gbrain extract links --source db                         # commit
-gbrain extract timeline --source db                      # dated events
-gbrain stats                                             # verify links > 0
-```
-
-For brand-new empty brains, skip this step — auto-link populates the graph as the
-agent writes pages going forward. There is nothing to backfill yet.
-
-After this step:
-- `gbrain graph-query <slug> --depth 2` works (relationship traversal)
-- Search ranks well-connected entities higher (backlink boost)
-- Every future `put_page` auto-creates typed links and reconciles stale ones
-
-If a user has a very large brain (>10K pages), `extract --source db` is idempotent
-and supports `--since YYYY-MM-DD` for incremental runs.
-
 ## Step 5: Load Skills
 
 Read `~/gbrain/skills/RESOLVER.md`. This is the skill dispatcher. It tells you which
@@ -143,28 +103,13 @@ Verify: `gbrain integrations doctor` (after at least one is configured)
 
 ## Step 9: Verify
 
-Read `docs/GBRAIN_VERIFY.md` and run all 7 verification checks. Check #4 (live sync
+Read `docs/GBRAIN_VERIFY.md` and run all 6 verification checks. Check #4 (live sync
 actually works) is the most important.
 
 ## Upgrade
 
 ```bash
-cd ~/gbrain && git pull origin master && bun install
-gbrain init                           # apply schema migrations (idempotent)
-gbrain post-upgrade                   # show migration notes for the version range
+cd ~/gbrain && git pull origin main && bun install
 ```
 
-Then read `~/gbrain/skills/migrations/v<NEW_VERSION>.md` (and any intermediate
-versions you skipped) and run any backfill or verification steps it lists. Skipping
-this is how features ship in the binary but stay dormant in the user's brain.
-
-For v0.12.0+ specifically: if your brain was created before v0.12.0, run
-`gbrain extract links --source db && gbrain extract timeline --source db` to
-backfill the new graph layer (see Step 4.5 above).
-
-For v0.12.2+ specifically: if your brain is Postgres- or Supabase-backed and
-predates v0.12.2, the `v0_12_2` migration runs `gbrain repair-jsonb`
-automatically during `gbrain post-upgrade` to fix the double-encoded JSONB
-columns. PGLite brains no-op. If wiki-style imports were truncated by the old
-`splitBody` bug, run `gbrain sync --full` after upgrading to rebuild
-`compiled_truth` from source markdown.
+Then run `gbrain init` to apply any schema migrations (idempotent, safe to re-run).

README.md

@@ -4,14 +4,10 @@ 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 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. 26 skills. Install in 30 minutes. Your agent does the work. As Garry's personal agent gets smarter, so does yours.
+GBrain is those patterns, generalized. 25 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.
 
-> **LLMs:** fetch [`llms.txt`](llms.txt) for the documentation map, or [`llms-full.txt`](llms-full.txt) for the same map with core docs inlined in one fetch. **Agents:** start with [`AGENTS.md`](AGENTS.md) (or [`CLAUDE.md`](CLAUDE.md) if you're Claude Code).
-
 ## Install
 
 ### On an agent platform (recommended)
@@ -28,12 +24,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 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
-agent operating protocol (install, read order, trust boundary, common tasks). For
-the full doc map, use `llms.txt` at the same URL root.
+That's it. The agent clones the repo, installs GBrain, sets up the brain, loads 25 skills, and configures recurring jobs. You answer a few questions about API keys. ~30 minutes.
 
 ### Standalone CLI (no agent)
 
@@ -44,11 +35,6 @@ gbrain import ~/notes/          # index your markdown
 gbrain query "what themes show up across my notes?"
 ```
 
-**Do NOT use `bun install -g github:garrytan/gbrain`.** Bun blocks the top-level
-postinstall hook on global installs, so schema migrations never run and the CLI
-aborts with `Aborted()` the first time it opens PGLite. Use `git clone + bun install
-&& bun link` as shown above. See [#218](https://github.com/garrytan/gbrain/issues/218).
-
 ```
 3 results (hybrid search, 0.12s):
 
@@ -87,9 +73,9 @@ claude mcp add gbrain -t http https://your-brain.ngrok.app/mcp -H "Authorization
 
 Per-client guides: [`docs/mcp/`](docs/mcp/DEPLOY.md). ChatGPT requires OAuth 2.1 (not yet implemented).
 
-## The 26 Skills
+## The 25 Skills
 
-GBrain ships 26 skills organized by `skills/RESOLVER.md`. The resolver tells your agent which skill to read for any task.
+GBrain ships 25 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.
 
@@ -133,7 +119,6 @@ GBrain ships 26 skills organized by `skills/RESOLVER.md`. The resolver tells you
 | **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. |
-| **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
 
@@ -161,7 +146,6 @@ Signal arrives (meeting, email, tweet, link)
   -> Brain-ops: check the brain first (gbrain search, gbrain get)
   -> Respond with full context
   -> Write: update brain pages with new information + citations
-  -> Auto-link: typed relationships extracted on every write (zero LLM calls)
   -> Sync: gbrain indexes changes for next query
 ```
 
@@ -175,113 +159,6 @@ The system gets smarter on its own. Entity enrichment auto-escalates: a person m
 > "What have I said about the relationship between shame and founder performance?"
 > ... searches YOUR thinking, not the internet
 
-## Minions: your sub-agents won't drop work anymore
-
-A durable, Postgres-native job queue built into the brain. Every long-running agent task is now a job that survives gateway restarts, streams progress, gets paused / resumed / steered mid-flight, and shows up in `gbrain jobs list`. Zero infra beyond your existing brain.
-
-### The production numbers that matter
-
-Here's my personal OpenClaw deployment: one Render container. Supabase Postgres holding a 45,000-page brain. 19 cron jobs firing on schedule. Real gateway load from real daily work. The task: pull a month of my social posts from an external API and ingest them end-to-end into the brain as a structured page.
-
-|              | Minions   | `sessions_spawn`               |
-|---           |---        |---                             |
-| Wall time    | **753ms** | **>10,000ms** (gateway timeout) |
-| Token cost   | **$0.00** | ~$0.03 per run                 |
-| Success rate | **100%**  | **0%** (couldn't even spawn)   |
-| Memory/job   | ~2 MB     | ~80 MB                         |
-
-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: [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
-
-> **Deterministic** (same input → same steps → same output) → **Minions**
-> **Judgment** (input requires assessment or decision) → **Sub-agents**
-
-Pull posts, parse JSON, write a brain page, run a sync — deterministic. $0 tokens, survives restart, millisecond runtime. Triage the inbox, assess meeting priority, decide if a cold email deserves a reply — judgment. What sub-agents are actually good at. `minion_mode: pain_triggered` (the default) automates the routing.
-
-### What's fixed
-
-The six daily pains — spawn storms, agents that stop responding, forgotten dispatches, gateway crashes mid-run, runaway grandchildren, debugging soup — all belonged to the "deterministic work through a reasoning model" mistake. Minions fixes them by not making that mistake: `max_children` cap, `timeout_ms` + AbortSignal, `child_done` inbox, full `parent_job_id`/`depth`/transcript per job, Postgres durability with stall detection, cascade cancel via recursive CTE. Plus idempotency keys, attachment validation, `removeOnComplete`, and `gbrain jobs smoke` that proves the install in half a second.
-
-```bash
-gbrain jobs smoke                        # verify install
-gbrain jobs submit sync --params '{}'    # fire a background job
-gbrain jobs stats                        # health dashboard
-gbrain jobs work --concurrency 4         # start a worker (Postgres only)
-```
-
-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.
-
-### Health check and self-heal
-
-Minions is canonical as of v0.11.1 — every `gbrain upgrade` runs the migration automatically (schema → smoke → prefs → host rewrites → env-aware autopilot install). If you ever want to verify manually or wire a cron into your morning briefing:
-
-```bash
-gbrain doctor                    # half-migrated state? prints loud banner + exits non-zero
-gbrain skillpack-check --quiet    # exit 0/1/2 for pipeline gating
-gbrain skillpack-check | jq       # full JSON: {healthy, summary, actions[], doctor, migrations}
-```
-
-If anything's off, `actions[]` tells you the exact command to run. For deeper troubleshooting: [`docs/guides/minions-fix.md`](docs/guides/minions-fix.md).
-
-Moving gateway crons to Minions (deterministic scripts, zero LLM tokens per fire): [`docs/guides/minions-shell-jobs.md`](docs/guides/minions-shell-jobs.md).
-
-## Durable agents: `gbrain agent` (v0.15)
-
-Your subagent runs survive crashes now. OpenClaw died mid-run? The worker re-claims on restart and replays from the last committed turn. Fan-out across 50 shards, one shard crashes — the aggregator still claims after every child reaches a terminal state and writes a mixed-outcome summary. Tool calls persist as a two-phase ledger (`pending` → `complete | failed`) so replay is safe by construction, not by hope.
-
-```bash
-# Submit a single-subagent run
-gbrain agent run "summarize my last 10 journal pages"
-
-# Fan out N prompts across N subagent children + 1 aggregator
-gbrain agent run "analyze every page" \
-  --fanout-manifest manifests/pages.json \
-  --subagent-def analyzer
-
-# Tail a running job (heartbeat per turn + full transcript on completion)
-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: your skills tree stops being a black box
-
-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.
-
-GBrain ships the same capability. Except the human stays in the loop.
-
-- **`/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
-# Audit a feature's skill completeness (10-item checklist)
-bun run scripts/skillify-check.ts src/commands/publish.ts
-
-# In CI: fail the build when a new feature isn't properly skilled
-bun run scripts/skillify-check.ts --json --recent
-
-# Validate the whole skills tree before shipping
-gbrain check-resolvable
-```
-
-**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
 
 GBrain ships integration recipes that your agent sets up for you. Each recipe tells the agent what credentials to ask for, how to validate, and what cron to register.
@@ -317,7 +194,7 @@ Run `gbrain integrations` to see status.
 │   Brain Repo     │    │    GBrain     │    │    AI Agent      │
 │   (git)          │    │  (retrieval)  │    │  (read/write)    │
 │                  │    │               │    │                  │
-│  markdown files  │───>│  Postgres +   │<──>│  26 skills       │
+│  markdown files  │───>│  Postgres +   │<──>│  25 skills       │
 │  = source of     │    │  pgvector     │    │  define HOW to   │
 │    truth         │    │               │    │  use the brain   │
 │                  │<───│  hybrid       │    │                  │
@@ -353,36 +230,6 @@ want, which you can't learn any other way.
 
 Above the `---`: **compiled truth**. Your current best understanding. Gets rewritten when new evidence changes the picture. Below: **timeline**. Append-only evidence trail. Never edited, only added to.
 
-## Knowledge Graph
-
-Pages aren't just text. Every mention of a person, company, or concept becomes a typed link in a structured graph. The brain wires itself.
-
-```
-Write a meeting page mentioning Alice and Acme AI
-  -> Auto-link extracts entity refs from content (zero LLM calls)
-  -> Infers types: meeting page + person ref => `attended`
-                   "CEO of X" pattern        => `works_at`
-                   "invested in"             => `invested_in`
-                   "advises", "advisor"      => `advises`
-                   "founded", "co-founded"   => `founded`
-  -> Reconciles stale links: edits remove links no longer in content
-  -> Backlinks rank well-connected entities higher in search
-```
-
-```bash
-gbrain graph-query people/alice --type attended --depth 2
-# returns who Alice met with, transitively
-```
-
-The graph powers questions vector search can't: "who works at Acme AI?", "what has Bob invested in?", "find the connection between Alice and Carol". Backfill an existing brain in one command:
-
-```bash
-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: **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
 
 Hybrid search: vector + keyword + RRF fusion + multi-query expansion + 4-layer dedup.
@@ -400,74 +247,6 @@ Query
 
 Keyword alone misses conceptual matches. Vector alone misses exact phrases. RRF gets both. Search quality is benchmarked and reproducible: `gbrain eval --qrels queries.json` measures P@k, Recall@k, MRR, and nDCG@k. A/B test config changes before deploying them.
 
-## Why it works: many strategies in concert
-
-The brain isn't one trick. Every retrieval question goes through ~20 deterministic
-techniques layered together. No single one is magic; the win comes from stacking
-them so each layer covers what the others miss.
-
-```
-Question
-  │
-  ├─ INGESTION (every put_page)
-  │    ├─ Recursive markdown chunking (or semantic / LLM-guided)
-  │    ├─ Embedding cache invalidation on edit
-  │    └─ Idempotent imports (content-hash dedup)
-  │
-  ├─ GRAPH EXTRACTION (auto-link post-hook, zero LLM)
-  │    ├─ Entity-ref regex (markdown links + bare slugs)
-  │    ├─ Code-fence stripping (no false-positive slugs in code blocks)
-  │    ├─ Typed inference cascade (FOUNDED → INVESTED → ADVISES → WORKS_AT)
-  │    ├─ Page-role priors (partner-bio language → invested_in)
-  │    ├─ Within-page dedup (same target collapses to one link)
-  │    ├─ Stale-link reconciliation (edits remove dropped refs)
-  │    └─ Multi-type link constraint (same person can works_at AND advises)
-  │
-  ├─ SEARCH PIPELINE (every query)
-  │    ├─ Intent classifier (entity / temporal / event / general — auto-routes)
-  │    ├─ Multi-query expansion (Haiku rephrases the question 3 ways)
-  │    ├─ Vector search (HNSW cosine over OpenAI embeddings)
-  │    ├─ Keyword search (Postgres tsvector + websearch_to_tsquery)
-  │    ├─ 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)
-  │    ├─ Backlink boost (well-connected entities rank higher)
-  │    └─ Source-aware dedup (one CT chunk per page guaranteed)
-  │
-  ├─ GRAPH TRAVERSAL (relational queries)
-  │    ├─ Recursive CTE with cycle prevention (visited-array check)
-  │    ├─ Type-filtered edges (--type works_at, attended, etc.)
-  │    ├─ Direction control (in / out / both)
-  │    └─ Depth-capped (≤10 for remote MCP; DoS prevention)
-  │
-  └─ AGENT WORKFLOW (graph-confident hybrid)
-       ├─ Graph-query first (high-precision typed answers)
-       ├─ Grep fallback when graph returns nothing
-       └─ Graph hits ranked first in top-K (better P@K and R@K)
-```
-
-End-to-end on the BrainBench v1 corpus (240 rich-prose pages, before/after PR #188):
-
-| 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**     |
-| Graph-only F1 (ablation)| 57.8% (grep)   | **86.6%**     | **+28.8 pts**|
-
-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.](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
-matches; vector catches them. RRF picks the best of both. Compiled-truth boost
-keeps assessments above timeline noise. Auto-link extraction wires the graph
-that lets backlink boost rank well-connected entities higher. Graph traversal
-answers questions search alone can't reach. The agent picks graph-first for
-precision and falls back to keyword for recall. **All deterministic, all in
-concert, all measured.**
-
 ## Voice
 
 Call a phone number. Your AI answers. It knows who's calling, pulls their full context from the brain, and responds like someone who actually knows your world. When the call ends, a brain page appears with the transcript, entity detection, and cross-references.
@@ -546,31 +325,16 @@ EMBEDDINGS
   gbrain embed [<slug>|--all|--stale]   Generate/refresh embeddings
 
 LINKS + GRAPH
-  gbrain link|unlink|backlinks          Cross-reference management
-  gbrain extract links|timeline|all     Batch backfill from existing pages
-                                        (--source db|fs, --type, --since, --dry-run)
-  gbrain graph-query <slug>             Typed traversal (--type T --depth N
-                                        --direction in|out|both)
-
-JOBS (Minions)
-  gbrain jobs submit <name> [--params JSON] [--follow]  Submit a background job
-  gbrain jobs list [--status S] [--queue Q]             List jobs with filters
-  gbrain jobs get|cancel|retry|delete <id>              Manage job lifecycle
-  gbrain jobs prune [--older-than 30d]                  Clean completed/dead jobs
-  gbrain jobs stats                                     Job health dashboard
-  gbrain jobs smoke                                     One-command health check
-  gbrain jobs work [--queue Q] [--concurrency N]        Start worker daemon
+  gbrain link|unlink|backlinks|graph    Cross-reference management
 
 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 --fix                   Auto-fix resolver issues
   gbrain stats                          Brain statistics
   gbrain serve                          MCP server (stdio)
   gbrain integrations                   Integration recipe dashboard
   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)
-  gbrain orphans [--json] [--count]     Find pages with zero inbound wikilinks
   gbrain transcribe <audio>             Transcribe audio (Groq Whisper)
   gbrain research init <name>           Scaffold a data-research recipe
   gbrain research list                  Show available recipes
@@ -604,9 +368,6 @@ The skills in this repo are those patterns, generalized. What took 11 days to bu
 - [GBRAIN_V0.md](docs/GBRAIN_V0.md) ... Full product spec
 - [CHANGELOG.md](CHANGELOG.md) ... Version history
 
-**Benchmarks:**
-- [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. E2E tests: spin up Postgres with pgvector, run `bun run test:e2e`, tear down.

TODOS.md

@@ -1,142 +1,7 @@
 # TODOS
 
-## check-resolvable
-
-### File tracking issues for Checks 5 + 6 (deferred in PR #325)
-**Priority:** P2
-
-**What:** `src/commands/check-resolvable.ts` currently points `DEFERRED[].issue` at GitHub issue search URLs (`?q=TBD-check-5`, `?q=TBD-check-6`). File real tracking issues and grep-replace both placeholders with the real URLs.
-
-**Why:** v0.16.4 shipped `gbrain check-resolvable` with 4 of the 6 checks from the original spec. Checks 5 (trigger routing eval) and 6 (brain filing) were explicitly deferred during plan-ceo-review because they each need new detection logic. The CLI's `deferred[]` JSON field is meant to surface these to agents so they know the coverage boundary — the TBD placeholders do the right thing mechanically but aren't clickable.
-
-**How:**
-1. `gh issue create -t "check-resolvable Check 5: trigger routing eval" -b "..."` — detection: every skill's own frontmatter trigger should match the RESOLVER.md entry pointing at that skill. Needs new issue type (e.g. `mis_route`).
-2. `gh issue create -t "check-resolvable Check 6: brain filing validation" -b "..."` — detection: scan SKILL.md body for brain paths (e.g., `brain/people/`, `brain/companies/`), cross-reference with `skills/_brain-filing-rules.md`. Flag mutating skills missing entries.
-3. Replace `TBD-check-5` and `TBD-check-6` in `src/commands/check-resolvable.ts` with the real issue URLs.
-
-**Effort:** ~15 min mechanical (issue filing + grep-replace). Implementation of the checks themselves is a separate, larger piece of work — the TODO here is just the issue filing + URL swap.
-
-## P1 (BrainBench v1.1 — categories deferred from PR #188)
-
-### BrainBench Cat 5: Source Attribution / Provenance
-**What:** Eval that gbrain correctly cites the right page when claiming fact F, and resolves source-conflict cases (3 sources disagree on $5M raise — which wins?). 200 queries across citation/provenance/conflict sub-categories on a 300-entity dataset with deliberately-conflicting sources.
-
-**Why deferred from PR #188:** Needs ~$100-200 of Opus tokens to generate the conflict-graph dataset. v1 scope was procedural-only.
-
-**Threshold:** citation_recall > 90%, citation_precision > 85%, conflict_resolution > 70%.
-
-**Depends on:** Identity Resolution (Cat 3) shipped — uses same world generator pattern.
-
-### BrainBench Cat 6: Auto-link Precision under Prose (at scale)
-**What:** Cat 10 (Robustness/Adversarial) covered code-fence leak and false-positive substrings on 22 hand-crafted cases. v1.1 extends this to 500+ prose-heavy pages with realistic narrative noise. Tests link precision in the wild, not just edge cases.
-
-**Why deferred from PR #188:** Needs prose-heavy generated corpus (~$100-150 Opus). Existing 22-case eval already caught + fixed the code-fence leak bug.
-
-**Threshold:** link_precision > 95% on prose, type_accuracy > 80% on varied phrasing.
-
-### BrainBench Cat 8: Skill Behavior Compliance
-**What:** Replays 100 inbound signals through a real LLM agent loop with gbrain skills loaded. Measures: brain-first lookup compliance, back-link iron-law adherence, citation format compliance, tier escalation correctness.
-
-**Why deferred:** Needs real LLM API loop (~$2K total — most expensive single category).
-
-**Threshold:** brain_first_compliance > 95%, back_link_compliance > 90%, citation_format > 95%.
-
-### BrainBench Cat 9: End-to-End Workflows
-**What:** 50 end-to-end scenarios across meeting ingestion, email-to-brain, daily-task-prep, briefing generation, sync cycle. Rubric-graded (10-15 criteria each).
-
-**Why deferred:** Needs LLM agent loop (~$1K). Plus 50 hand-built rubrics.
-
-**Threshold:** 80% scenario pass rate per workflow.
-
-### BrainBench Cat 11: Multi-modal Ingestion
-**What:** PDF/image/audio/video ingestion accuracy. 50 PDFs, 30 images, 20 audio files, 10 videos, 30 HTML pages. Per-modality recall and fidelity metrics.
-
-**Why deferred:** Needs licensed real datasets (Common Voice for audio etc.). Dataset curation is the bulk of the work.
-
-**Threshold:** PDF text fidelity > 95% (text-based) / > 80% (scanned), audio WER < 15%, entity_recall > 80% post-ingestion.
-
-### BrainBench Cat 1+2 at full scale
-**What:** Existing benchmark-search-quality.ts (29 pages, 20 queries) and benchmark-graph-quality.ts (80 pages, 5 queries) currently pass at small scale. v1.1 extends both to 2-3K rich-prose pages generated via Opus to surface scale-dependent failures (tied keyword clusters, hub-node fan-out, prose-noise extraction precision).
-
-**Why deferred from PR #188:** Needs ~$200-300 of Opus tokens for the rich corpus. The 80-page version already proves algorithmic correctness; scale-up proves it survives real-world load.
-
-**Threshold:** maintain v1 metrics at 30x scale.
-
-### ~~v0.10.4: inferLinkType prose precision fix~~
-**Shipped in PR #188.** BrainBench Cat 2 rich-corpus type accuracy went from
-70.7% → 88.5%. Fix: widened verb regexes (added "led the seed/Series A",
-"early investor", "invests in", "portfolio company", etc.), tightened
-ADVISES_RE to require explicit advisor rooting (generic "board member"
-matches investors too), widened context window 80→240 chars, added
-person-page role prior (partner-bio language → invested_in for outbound
-company refs only). Per-type after fix: invested_in 91.7% (was 0%),
-mentions 100%, attended 100%. works_at 58% and advises 41% are next
-iteration's residuals.
-
-### v0.10.5: inferLinkType residuals (works_at, advises)
-**What:** After the v0.10.4 fix, two link types still under-perform on rich
-prose. Drive these to >85% type accuracy in next iteration.
-
-**works_at: 58% type accuracy.** Engineer/employee pages use varied phrasings
-the regex doesn't catch ("spent some time at", "joined the team", narrative
-"is currently at" without a verb). Approach: extend WORKS_AT_RE; consider
-employee-role page prior similar to partner prior.
-
-**advises: 41% type accuracy.** Advisor pages often describe board roles
-without using the word "advisor" explicitly ("on Beta Health's board",
-"joined Beta as a board member"). The v0.10.4 fix tightened ADVISES_RE to
-require "advisor" rooting to avoid false positives from investors. Need
-a tighter signal that distinguishes "advisor on board" from "investor on
-board" — likely an advisor-role page prior plus verb-pattern combinations.
-
-**Threshold:** Cat 2 rich-prose type accuracy > 92% (currently 88.5%).
-
-### v0.10.4: gbrain alias resolution feature (driven by Cat 3)
-**What:** Add an alias table to gbrain so "Sarah Chen" / "S. Chen" / "@schen" / "sarah.chen@example.com" resolve to one canonical entity. Schema: `aliases (id, slug, alias_text)` with a unique index. Search blends alias matches into hybrid scoring.
-
-**Why:** BrainBench Cat 3 measured 31% recall on undocumented aliases — that's the v0.10.x baseline. With alias table, should jump to 80%+.
-
-**Depends on:** Cat 3 baseline (shipped in PR #188).
-
 ## P1
 
-### Minions shell jobs — Phase 2 scheduling (deferred from v0.13.0)
-
-**What:** `minion_schedules` table + autopilot-cycle scanner that submits due shell jobs.
-
-**Why:** v0.13.0 moves shell scripts to Minions but still leaves scheduling in the host crontab. Your OpenClaw's `scripts/service-manager.sh` + crontab is the only piece left on the host side. A DB-driven scheduler would mean a single `gbrain autopilot --install` replaces the host crontab entirely, scheduling is visible via `gbrain jobs list --scheduled`, and downtime-on-one-machine tolerance improves (schedule is shared DB state, not per-host crontab).
-
-**Pros:** Canonical host-agnostic deployment. No more host-specific crontab.
-
-**Cons:** Cross-engine migration complexity (new table on both PGLite + Postgres). Autopilot-cycle scanner needs to handle missed-schedule semantics (fire-once-on-startup or skip-if-past-now), and this is where every other cron-like system has historically accrued bugs.
-
-**Depends on:** v0.13.0 shell jobs shipped. ✅
-
-### `gbrain crontab-to-minions <file>` migration helper (deferred from v0.13.0)
-
-**What:** Parse an existing crontab file, emit a proposed rewrite using `gbrain jobs submit shell ...` for each deterministic entry, keep LLM-requiring entries as-is.
-
-**Why:** Hand-rewriting ~14 OpenClaw cron entries is error-prone and one-shot. A helper would make the migration reversible and auditable (diff the before/after crontab, dry-run the first N, commit).
-
-**Pros:** Removes the "rewrite 14 lines by hand" tax every agent operator pays on adoption.
-
-**Cons:** Crontab parsing is historically fiddly (5-field vs 6-field, `@hourly` aliases, Vixie extensions, env vars in crontab). Could misrewrite entries with shell substitution.
-
-**Depends on:** v0.13.0 shell jobs shipped. ✅
-
-### Batch the DB-source extract read path (deferred from v0.12.1)
-**What:** `extractLinksFromDB` and `extractTimelineFromDB` at `src/commands/extract.ts:447, 504` issue one `engine.getPage(slug)` per slug after `engine.getAllSlugs()`. On a 47K-page brain that's still 47K serial reads over the Supabase pooler.
-
-**Why:** v0.12.1 fixed the write-side N+1 with batched INSERTs (~100x fewer round-trips). The read side still does serial `getPage()` calls — each fetches `compiled_truth + timeline + frontmatter` (tens of KB per page). On a 47K-page Supabase brain that's ~10-20 minutes of read latency before any work happens. The v0.12.0 orchestrator's backfill uses `--source db`, so this stays slow until fixed.
-
-**Pros:** Mirrors the write-side fix on the read path. Combined with batched writes, full re-extract on a 47K-page brain should drop from "minutes" to "seconds" end-to-end. Eliminates the implicit `listPages-pagination-mutation` learning risk by giving you a snapshot read.
-
-**Cons:** New engine method (`getPagesBatch(slugs: string[]) → Promise<Page[]>` or a streaming cursor) needs to land on both PGLite and Postgres. Memory budget — a 47K-page brain with ~30KB/page is ~1.4GB if loaded all at once; needs chunked iteration (e.g., 500 slugs/query, stream-process).
-
-**Context:** Codex's plan-time review and the testing/performance specialists at ship time both flagged this. Filed during v0.12.1 to ship the bug fix without scope creep. Approach: add `getPagesBatch(slugs)` returning chunked results, then update the 4 DB-source extract paths to consume it.
-
-**Depends on:** v0.12.1 ships first.
-
 ### Batch embedding queue across files
 **What:** Shared embedding queue that collects chunks from all parallel import workers and flushes to OpenAI in batches of 100, instead of each worker batching independently.
 
@@ -189,7 +54,7 @@ board" — likely an advisor-role page prior plus verb-pattern combinations.
 
 **Cons:** Requires adding `sender_id` or `access_tier` to `OperationContext`. Each mutating operation needs a permission check. Medium implementation effort.
 
-**Context:** From CEO review + Codex outside voice (2026-04-13). Prompt-layer access control works in practice (same model as Garry's OpenClaw) but is not sufficient for remote MCP where direct tool calls bypass the agent's prompt.
+**Context:** From CEO review + Codex outside voice (2026-04-13). Prompt-layer access control works in practice (same model as Wintermute) but is not sufficient for remote MCP where direct tool calls bypass the agent's prompt.
 
 **Depends on:** v0.10.0 GStackBrain skill layer (shipped).
 
@@ -198,117 +63,8 @@ board" — likely an advisor-role page prior plus verb-pattern combinations.
 ### ~~Constrained health_check DSL for third-party recipes~~
 **Completed:** v0.9.3 (2026-04-12). Typed DSL with 4 check types (`http`, `env_exists`, `command`, `any_of`). All 7 first-party recipes migrated. String health checks accepted with deprecation warning + metachar validation for non-embedded recipes.
 
-## P1 (new from v0.11.0 — Minions)
-
-### Per-queue rate limiting for Minions
-**What:** Token-bucket rate limiting per queue via a new `minion_rate_limits` table (queue, capacity, refill_rate, tokens, updated_at), with acquire/release in `claim()`.
-
-**Why:** The #1 daily OpenClaw pain is spawn storms hitting OpenAI/Anthropic rate limits. `max_children` caps fan-out per parent, but a queue with 50 ready jobs will still slam the API. Every Minions consumer currently reinvents token-bucket in user code.
-
-**Pros:** First-class rate limiting means no consumer has to roll their own. Composes with `max_children` (which is per-parent) to give two orthogonal throttles.
-
-**Cons:** Adds a write hotspot on the rate-limit row. Mitigate by keeping it a simple `UPDATE ... WHERE tokens > 0 RETURNING` that fails fast and puts the claim back in the pool.
-
-**Effort:** ~2 hours. Deferred from v0.11.0 to keep the parity PR at a reviewable size.
-
-**Depends on:** Minions (shipped in v0.11.0).
-
-### Minions repeat/cron scheduler
-**What:** BullMQ-style repeatable jobs. `queue.add(name, data, { repeat: { cron: '0 * * * *' } })`.
-
-**Why:** Idempotency keys (shipped in v0.11.0) are the foundation. Consumers currently use launchd/cron to fire `gbrain jobs submit`, but a native scheduler inside the worker would be cleaner and portable across deployments.
-
-**Pros:** One mental model for both immediate and scheduled work. Idempotency prevents double-fire.
-
-**Cons:** Every cron library has edge cases (DST, missed intervals on worker restart). Use a battle-tested parser.
-
-**Effort:** ~1 day.
-
-**Depends on:** Idempotency keys (shipped in v0.11.0).
-
-### Minions worker event emitter
-**What:** `worker.on('job:completed', handler)` / `worker.on('job:failed', ...)` instead of polling.
-
-**Why:** Consumers currently poll `getJob(id)` to watch state changes. An event API is the ergonomic BullMQ has and Minions doesn't.
-
-**Effort:** ~4 hours.
-
-### `waitForChildren(parent_id, n)` / `collectResults(parent_id)` helpers
-**What:** Convenience wrappers over `readChildCompletions` for common fan-in patterns.
-
-**Why:** The `child_done` inbox primitive shipped in v0.11.0. Now add the ergonomic API on top so orchestrators don't have to write the polling loop.
-
-**Effort:** ~2 hours.
-
-**Depends on:** `child_done` inbox primitive (shipped in v0.11.0).
-
 ## P2
 
-### Minions: `gbrain jobs stats --orphaned` (deferred from v0.13.0)
-
-**What:** New CLI flag / output column surfacing jobs that are waiting with no registered handler on any live worker.
-
-**Why:** v0.13.0 adds shell jobs that require `GBRAIN_ALLOW_SHELL_JOBS=1` on the worker. If an operator submits a shell job but no worker with the flag is running, the row sits in `waiting` silently. The CLI's starvation warning + docs help at submit time; this TODO surfaces the problem at operational-check time.
-
-**Pros:** Closes the "did my cron actually run" ambiguity for multi-machine deployments.
-
-**Cons:** Knowing "no worker has this handler registered" requires worker heartbeat tracking, which Minions doesn't have yet (it's stateless at DB level beyond `lock_token`). Could be approximated by "no jobs of this name have completed in last N minutes AND count of waiting is > 0."
-
-**Depends on:** v0.13.0 shell jobs shipped. ✅
-
-### Minions: AbortReason plumbing on MinionJobContext (deferred from v0.13.0)
-
-**What:** Handlers today can't distinguish whether `ctx.signal.aborted` fired due to timeout, cancel, or lock-loss. v0.13.0 derives this at worker-catch-time from `abort.signal.reason`, but the handler can't see it directly. Expose `ctx.abortReason?: 'timeout' | 'cancel' | 'lock-lost' | 'shutdown'` on the context.
-
-**Why:** Shell handler's kill-sequence today can't decide "retry this" (lock-lost) vs "don't retry, user cancelled" (cancel) — they look the same. A typed AbortReason lets handlers make that decision for themselves.
-
-**Pros:** Handlers get richer signals.
-
-**Cons:** Small surface-area addition to the handler API. Not strictly required since the worker already makes the retry/dead decision for them.
-
-**Depends on:** v0.13.0 shell jobs shipped. ✅
-
-### Minions: blocking-mode audit log for true forensic integrity (deferred from v0.13.0)
-
-**What:** Opt-in mode for `shell-audit` where `appendFileSync` failures DO block submission instead of logging-and-continuing.
-
-**Why:** v0.13.0 ships the audit log in best-effort mode, which means a disk-full attacker can silently disable the forensic trail. Acceptable for v0.13.0 because the primary use is operational ("what did this cron do last Tuesday"), not security forensics. Operators who want fail-closed semantics should have a flag.
-
-**Pros:** Enables true forensic integrity for deployments that need it.
-
-**Cons:** Fail-closed means a transient disk issue blocks shell submissions, which can be worse than a missing log line for most operators. Opt-in is the right shape but adds surface area.
-
-**Depends on:** v0.13.0 shell jobs shipped. ✅
-
-### Minions: configurable per-job output buffer sizes (deferred from v0.13.0)
-
-**What:** Add `max_stdout_bytes` / `max_stderr_bytes` to ShellJobParams; override the 64KB/16KB defaults.
-
-**Why:** 64KB/16KB covers typical OpenClaw scripts today but a verbose benchmark or a debug-dump script could need more.
-
-**Depends on:** First shell-job author who actually needs it. Don't pre-build the flag.
-
-### Security hardening follow-ups (deferred from security-wave-3)
-**What:** Close remaining security gaps identified during the v0.9.4 Codex outside-voice review that didn't make the wave's in-scope cut.
-
-**Why:** Wave 3 closed 5 blockers + 4 mediums. These are the known residuals. Each is an independent hardening item that becomes trivial as Runtime MCP access control (P0 above) lands.
-
-**Items (each a separate small task):**
-- **DNS rebinding protection for HTTP health_checks.** Current `isInternalUrl` validates the hostname string; DNS resolution happens later inside `fetch`. A malicious DNS server can return a public IP on first lookup and an internal IP on the actual request. Fix: resolve hostname via `dns.lookup` before fetch, pin the IP with a custom `http.Agent` `lookup` override, re-validate post-resolution. Alternative: use `ssrf-req-filter` library.
-- **Extended IPv6 private-range coverage.** Block `fc00::/7` (Unique Local Addresses), `fe80::/10` (link-local), `2002::/16` (6to4), `2001::/32` (Teredo), `::/128`. Current code covers `::1`, `::`, and IPv4-mapped (`::ffff:*`) via hex hextet parsing.
-- **IPv4 shorthand parsing.** `127.1` (legacy 2-octet form = 127.0.0.1), `127.0.1` (3-octet), mixed-radix with trailing dots. Current code handles hex/octal/decimal integer-form IPs but not these shorthand variants.
-- **Broader operation-layer limit caps.** `traverse_graph` `depth` param, plus `get_chunks`, `get_links`, `get_backlinks`, `get_timeline`, `get_versions`, `get_raw_data`, `resolve_slugs` — all currently accept unbounded `limit`/`depth`. Wave 3 only clamped `list_pages` and `get_ingest_log`.
-- **`sync_brain` repo path validation.** The `repo` parameter accepts an arbitrary filesystem path. Same threat model as `file_upload` before wave 3. Add `validateUploadPath` (strict) for remote callers.
-- **`file_upload` size limit.** `readFileSync` loads the entire file into memory. Trivial memory-DoS from MCP. Add ~100MB cap (matches CLI's TUS routing threshold) and stream for larger files.
-- **`file_upload` regular-file check.** Reject directories, devices, FIFOs, Unix sockets via `stat.isFile()` before `readFileSync`.
-- **Explicit confinement root (H2).** `file_upload` strict mode currently uses `process.cwd()`. Move to `ctx.config.upload_root` (or derive from where the brain's schema lives) so MCP server cwd can't be the wrong anchor.
-
-**Effort:** M total (human: ~1 day / CC: ~1-2 hrs).
-
-**Priority:** P2 — deferred consciously. Wave 3 closed the easily-exploitable paths. These are the defense-in-depth follow-ups.
-
-**Depends on:** Security wave 3 shipped. None are blockers for Runtime MCP access control, but all three security workstreams (this, that P0, and the health-check DSL) converge on the same zero-trust MCP goal.
-
 ### Community recipe submission (`gbrain integrations submit`)
 **What:** Package a user's custom integration recipe as a PR to the GBrain repo. Validates frontmatter, checks constrained DSL health_checks, creates PR with template.
 
@@ -348,59 +104,6 @@ board" — likely an advisor-role page prior plus verb-pattern combinations.
 
 **Depends on:** v0.8.0 (Edge Function removal shipped).
 
-## P2 (knowledge graph follow-ups)
-
-### Auto-link skipped writes generate redundant SQL
-**What:** When `gbrain put` is called with identical content (status=skipped), runAutoLink still does a full getLinks + per-candidate addLink loop. On N identical writes of a 50-entity page that's 50N round trips.
-
-**Why:** Defensive reconciliation catches drift between page text and links table, but on truly idempotent writes it's wasted work.
-
-**Pros:** Lower DB load on cron-style re-syncs. Keeps put_page latency tight under bulk MCP usage.
-
-**Cons:** Need to track whether links could have drifted independent of content (e.g., a target page was deleted). Conservative approach: only skip auto-link reconciliation if status=skipped AND existing links match desired set (which still requires the getLinks call).
-
-**Context:** Caught in /ship adversarial review (2026-04-18). Acceptable for v0.10.3 because auto-link runs in a transaction with row locks, so amplification cost is bounded.
-
-**Effort estimate:** S (CC: ~10min)
-**Priority:** P2
-**Depends on:** Nothing.
-
-### Audit `extract --source db` against auto_link config flag
-**What:** `gbrain extract links --source db` writes to the same `links` table that `auto_link=false` is supposed to opt out of. The two are conceptually distinct (extract is intentional batch op, auto_link is implicit on write), but a user who turned off auto_link expecting "no automatic link writes" might be surprised.
-
-**Why:** Either the behavior should match (extract checks auto_link too) or the docs should explicitly state extract is a superset.
-
-**Pros:** Less surprise for users who treat auto_link as a master switch.
-
-**Cons:** Some users want extract to work even when auto_link is off (e.g. one-time backfill).
-
-**Context:** Caught in /ship adversarial review (2026-04-18). Documenting for now.
-
-**Effort estimate:** S (CC: ~10min for docs OR ~20min for code change).
-**Priority:** P2
-**Depends on:** Nothing.
-
-### Doctor --fix polish from v0.14.1 adversarial review
-**What:** Six deferred findings from v0.14.1 ship-time adversarial review on `src/core/dry-fix.ts`:
-1. **TOCTOU between read and write.** `attemptFix` reads once, writes later. Concurrent editor saves silently overwritten. Fix: re-read immediately before write and compare snapshot, or `O_EXCL` tempfile + rename.
-2. **Fence detection misses 4-backtick and `~~~` fences.** `isInsideCodeFence` only catches `^```$`. CommonMark-legal alternates slip through.
-3. **`expandBullet` walk-up is dead code.** Loop breaks immediately because `baseIndent` matches the current line. Remove or make it actually walk up.
-4. **Multi-match guard too strict.** Skills with the pattern in a table-of-contents AND body get `ambiguous_multiple_matches` forever. Consider: fix first, re-scan, repeat until fixed-point.
-5. **Subprocess spam.** `getWorkingTreeStatus` spawns `git status` N×M times per `doctor --fix`. Cache per-skill per-invocation.
-6. **`doctor --fix --json` swallows the auto-fix report.** `printAutoFixReport` returns early on `jsonOutput`; agents don't see fix outcomes. Emit `auto_fix` as a top-level key.
-
-**Why:** None are ship-blockers; all surfaced during v0.14.1 Codex adversarial review. Bundle into one follow-up PR.
-
-**Pros:** Closes the adversarial findings loop. Better correctness under concurrent edits and JSON-consumer agents.
-
-**Cons:** Concurrent-edit test is finicky.
-
-**Context:** v0.14.1 shipped with the 4 critical fixes (shell-injection via execFileSync, no-git-backup detection, EOF newline preservation, proximity-window consistency). These six are the deferred remainder.
-
-**Effort estimate:** M (CC: ~45min for all six + tests).
-**Priority:** P2
-**Depends on:** Nothing.
-
 ## Completed
 
 ### Implement AWS Signature V4 for S3 storage backend

VERSION

@@ -1 +1 @@
-0.17.0
+0.10.0

bun.lock

@@ -7,25 +7,19 @@
       "dependencies": {
         "@anthropic-ai/sdk": "^0.30.0",
         "@aws-sdk/client-s3": "^3.1028.0",
-        "@electric-sql/pglite": "0.4.3",
+        "@electric-sql/pglite": "^0.4.4",
         "@modelcontextprotocol/sdk": "^1.0.0",
         "gray-matter": "^4.0.3",
         "marked": "^18.0.0",
         "openai": "^4.0.0",
         "pgvector": "^0.2.0",
         "postgres": "^3.4.0",
-        "tree-sitter-wasms": "0.1.13",
-        "web-tree-sitter": "0.22.6",
       },
       "devDependencies": {
         "@types/bun": "latest",
-        "typescript": "^5.6.0",
       },
     },
   },
-  "trustedDependencies": [
-    "@electric-sql/pglite",
-  ],
   "packages": {
     "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.30.1", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-nuKvp7wOIz6BFei8WrTdhmSsx5mwnArYyJgh4+vYu3V4J0Ltb8Xm3odPm51n1aSI0XxNCrDl7O88cxCtUdAkaw=="],
 
@@ -109,7 +103,7 @@
 
     "@aws/lambda-invoke-store": ["@aws/lambda-invoke-store@0.2.4", "", {}, "sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ=="],
 
-    "@electric-sql/pglite": ["@electric-sql/pglite@0.4.3", "", {}, "sha512-ichuWTgtd4mOM1G4SpyGJa5trT03lWbMypDV0fUXUCXg5hiHqVAz/bZyV68NqmkLB7WcYmj1RMJVSp8HV/v/ZQ=="],
+    "@electric-sql/pglite": ["@electric-sql/pglite@0.4.4", "", {}, "sha512-g/6CWAJ4XOkObWCWAQ2IReZD8VvsDy3poRHSKvpRR2F96F8WJ3HVbjpso3gN7l0q6QPPgvxSSpl/qo5k8a7mkQ=="],
 
     "@hono/node-server": ["@hono/node-server@1.19.12", "", { "peerDependencies": { "hono": "^4" } }, "sha512-txsUW4SQ1iilgE0l9/e9VQWmELXifEFvmdA1j6WFh/aFPj99hIntrSsq/if0UWyGVkmrRPKA1wCeP+UCr1B9Uw=="],
 
@@ -455,14 +449,10 @@
 
     "tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
 
-    "tree-sitter-wasms": ["tree-sitter-wasms@0.1.13", "", { "dependencies": { "tree-sitter-wasms": "^0.1.11" } }, "sha512-wT+cR6DwaIz80/vho3AvSF0N4txuNx/5bcRKoXouOfClpxh/qqrF4URNLQXbbt8MaAxeksZcZd1j8gcGjc+QxQ=="],
-
     "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
 
     "type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],
 
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
     "undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
 
     "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
@@ -471,8 +461,6 @@
 
     "web-streams-polyfill": ["web-streams-polyfill@4.0.0-beta.3", "", {}, "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug=="],
 
-    "web-tree-sitter": ["web-tree-sitter@0.22.6", "", {}, "sha512-hS87TH71Zd6mGAmYCvlgxeGDjqd9GTeqXNqTT+u0Gs51uIozNIaaq/kUAbV/Zf56jb2ZOyG8BxZs2GG9wbLi6Q=="],
-
     "webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
 
     "whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],

bunfig.toml

@@ -1,6 +0,0 @@
-[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

docs/GBRAIN_SKILLPACK.md

@@ -49,25 +49,11 @@ Running a production brain.
 | Guide | What It Covers |
 |-------|---------------|
 | [Reference Cron Schedule](guides/cron-schedule.md) | 20+ recurring jobs, quiet hours, dream cycle |
-| [Cron via Minions](../skills/conventions/cron-via-minions.md) | Why scheduled work runs as Minion jobs, not `agentTurn`. Auto-applied by v0.11.0 migration for built-in handlers; host-specific handlers use the plugin contract below. |
-| [Plugin Handlers](guides/plugin-handlers.md) | Registering host-specific Minion handlers via code (no data-file exec surface). |
-| [Minions fix](guides/minions-fix.md) | Repairing a half-migrated v0.11.0 install. |
-| [Shell jobs (v0.14.0+)](guides/minions-shell-jobs.md) | Move deterministic crons (API fetch, token refresh, scrape+write) off the LLM gateway. Zero tokens per fire, ~60% gateway headroom. Follow `skills/migrations/v0.14.0.md` for the adoption playbook. |
 | [Quiet Hours & Timezone](guides/quiet-hours.md) | Hold notifications during sleep, timezone-aware delivery |
 | [Executive Assistant Pattern](guides/executive-assistant.md) | Email triage, meeting prep, scheduling |
 | [Operational Disciplines](guides/operational-disciplines.md) | Signal detection, brain-first, sync-after-write, heartbeat, dream cycle |
 | [Skill Development Cycle](guides/skill-development.md) | 5-step cycle: concept, prototype, evaluate, codify, cron |
 
-**Subagent routing (v0.11.0+):** agents that dispatch background work should route through
-`skills/conventions/subagent-routing.md` — it reads `~/.gbrain/preferences.json#minion_mode`
-and branches between native subagents and Minion jobs. The v0.11.0 migration auto-injects
-a marker into AGENTS.md pointing at this convention.
-
-**Cron routing (v0.11.0+):** scheduled work goes through Minions, not OpenClaw's `agentTurn`.
-See `skills/conventions/cron-via-minions.md` for the rewrite pattern. The v0.11.0 migration
-auto-rewrites entries whose handler is a gbrain builtin; host-specific handlers (e.g.
-`ea-inbox-sweep`) need a code-level registration per `docs/guides/plugin-handlers.md`.
-
 ## Architecture
 
 How to structure your system.

docs/GBRAIN_VERIFY.md

@@ -183,84 +183,6 @@ system context. See `skills/setup/SKILL.md` Phase D.
 
 ---
 
-## 7. Knowledge Graph Wired
-
-The v0.12.0 graph layer needs to be populated for existing brains. New writes are
-auto-linked, but historical pages need a one-time backfill.
-
-**Command:**
-
-```bash
-gbrain stats | grep -E 'links|timeline'
-```
-
-**Expected:** Both `links` and `timeline_entries` are non-zero (assuming the brain
-has content with entity references and dated markdown).
-
-**If it's zero on a brain with imported content:** Run the backfill.
-
-```bash
-gbrain extract links --source db --dry-run | head -5    # preview
-gbrain extract links --source db                         # commit
-gbrain extract timeline --source db
-gbrain stats                                             # confirm > 0
-```
-
-**Bonus check** — graph traversal works:
-
-```bash
-# Pick any well-connected slug from your brain
-gbrain graph-query people/<some-person-slug> --depth 2
-```
-
-**Expected:** Indented tree of typed edges (`--attended-->`, `--works_at-->`, etc.).
-If the slug has no inbound or outbound links, try a different one or run extract
-again.
-
-**If extract finds nothing:** Your pages may not use entity-reference syntax. The
-extractor matches `[Name](people/slug)`, `[Name](../people/slug.md)`, and bare
-`people/slug` references. If your brain uses a different format, the auto-link
-heuristics won't find them — file an issue with a sample page.
-
----
-
-## 8. JSONB Frontmatter Integrity (v0.12.2)
-
-Postgres-backed brains created before v0.12.2 had double-encoded JSONB columns
-(`frontmatter->>'key'` returned NULL, GIN indexes were inert). `gbrain upgrade`
-runs `gbrain repair-jsonb` automatically via the `v0_12_2` orchestrator.
-Verify the repair succeeded.
-
-**Command:**
-
-```bash
-gbrain repair-jsonb --dry-run --json
-```
-
-**Expected:** `totalRepaired: 0` across all 5 columns (`pages.frontmatter`,
-`raw_data.data`, `ingest_log.pages_updated`, `files.metadata`,
-`page_versions.frontmatter`). A zero count means every row is properly-typed
-JSON objects, not string-encoded JSON.
-
-**If the count is > 0:** The repair didn't run or was interrupted. Re-run
-without `--dry-run`:
-
-```bash
-gbrain repair-jsonb
-```
-
-Idempotent. PGLite brains always report 0 (unaffected by the original bug).
-
-**Bonus check** — frontmatter-keyed queries actually resolve:
-
-```bash
-gbrain call list_pages '{"frontmatterKey": "type", "frontmatterValue": "person"}'
-```
-
-If this returns rows on a brain with person pages, the JSONB path is healthy.
-
----
-
 ## Quick Verification (all checks in one pass)
 
 ```bash
@@ -281,13 +203,7 @@ gbrain embed --stale
 
 # 6. Auto-update
 gbrain check-update --json
-
-# 7. Knowledge graph populated (links + timeline > 0)
-gbrain stats | grep -E 'links|timeline'
-
-# 8. JSONB integrity (v0.12.2 — Postgres only, PGLite always 0)
-gbrain repair-jsonb --dry-run --json
 ```
 
-If all eight return successfully, the installation is healthy. For the full
+If all six return successfully, the installation is healthy. For the full
 end-to-end sync test (4c), push a real change and verify it appears in search.

docs/UPGRADING_DOWNSTREAM_AGENTS.md

@@ -1,471 +0,0 @@
-# Upgrading Downstream Agents
-
-GBrain ships skills in `skills/`. Downstream agents (custom OpenClaw deployments,
-agent forks of any kind) often **copy** these skill files into their own workspace and
-diverge over time — adding agent-specific phases, removing irrelevant ones, tightening
-language. Once that happens, gbrain can't push updates to those forks. The agent has
-to apply the diffs by hand.
-
-This doc lists the exact diffs each downstream agent needs to apply when upgrading.
-Cross-reference against your fork's local skill files.
-
-## Why this exists
-
-`gbrain upgrade` ships the new binary. `gbrain post-upgrade [--execute --yes]` runs
-the schema migrations and backfills the data. But the **skill files themselves**
-that tell the agent how to behave — those are user-owned. If your `~/git/<your-agent>/workspace/skills/brain-ops/SKILL.md`
-says `# Based on gbrain v0.10.0` at the top, it doesn't know about v0.12.0 features.
-
-The agent will keep manually calling `gbrain link` after every `put_page` (now redundant —
-auto-link does it), miss out on `gbrain graph-query` for relationship questions, and
-not know to backfill the structured timeline.
-
-## How to apply
-
-1. Identify your forked skill files. Typically at `~/git/<your-agent>/workspace/skills/` or wherever your agent's skill directory lives.
-2. For each skill listed below, find the matching phase/section in your fork.
-3. Apply the diff (paste the new block in the indicated location).
-4. Update the version banner at the top of your fork (`# Based on gbrain v0.12.0`).
-5. Verify: ask the agent to write a test page and confirm the response includes
-   `auto_links: { created, removed, errors }`.
-
-Total time: ~10 minutes for all four skills.
-
----
-
-## 1. brain-ops/SKILL.md
-
-**Where:** Insert a new `### Phase 2.5` section immediately after `### Phase 2: On Every Inbound Signal`.
-
-**Why:** Phase 2.5 declares that auto-link runs automatically. Without this, the
-agent's mental model says it must call `gbrain link` after every `put_page`, which
-is now redundant and can cause double-add warnings.
-
-```markdown
-### Phase 2.5: Structured Graph Updates (automatic)
-
-Every `put_page` call automatically extracts entity references and writes them
-to the graph (`links` table) with inferred relationship types. Stale links
-(refs no longer in the page text) are removed in the same call. This is
-"auto-link" reconciliation.
-
-- No manual `add_link` calls needed for ordinary page writes.
-- Inferred link types: `attended` (meeting -> person), `works_at`, `invested_in`,
-  `founded`, `advises`, `source` (frontmatter), `mentions` (default).
-- The `put_page` MCP response includes `auto_links: { created, removed, errors }`
-  so the agent can verify outcomes.
-- To disable: `gbrain config set auto_link false`. Default is on.
-- Timeline entries with specific dates still need explicit `gbrain timeline-add`
-  (or batch via `gbrain extract timeline --source db`).
-```
-
-**Also update the Iron Law section.** If your fork still says "Back-links maintained
-on every brain write (Iron Law)" without qualification, append:
-
-```markdown
-**v0.12.0 update:** Auto-link satisfies the Iron Law for entity-reference links
-on every `put_page`. The agent's Iron Law obligation is now: include the
-entity reference in the page content (e.g., `[Alice](people/alice)`); auto-link
-handles the structured row. Manual `add_link` calls are reserved for
-relationships you can't express in markdown content.
-```
-
----
-
-## 2. meeting-ingestion/SKILL.md
-
-**Where:** Append to the end of `### Phase 3: Attendee enrichment`.
-
-**Why:** Eliminates redundant `gbrain link` calls per attendee (auto-link handles them
-when the meeting page references attendees as `[Name](people/slug)`).
-
-```markdown
-**Note (v0.12.0):** Once the meeting page is written via `gbrain put`, the
-auto-link post-hook automatically creates `attended` links from the meeting
-to each attendee whose page is referenced as `[Name](people/slug)`. You don't
-need to call `gbrain link` for attendees. You DO still need `gbrain timeline-add`
-for dated events (auto-link only handles links, not timeline entries).
-```
-
-**Where:** In `### Phase 4: Entity propagation`, the line "Back-link from entity page
-to meeting page" can be replaced with:
-
-```markdown
-4. Entity references in the meeting page body auto-create the link via auto-link.
-   For incoming references on the entity page (entity page → meeting page), edit
-   the entity page to mention the meeting and `put_page` it — auto-link handles
-   the rest.
-```
-
----
-
-## 3. signal-detector/SKILL.md
-
-**Where:** Append to the end of `### Phase 2: Entity Detection`.
-
-**Why:** Same logic as brain-ops — eliminates manual `gbrain link` after writing
-originals/ideas pages that reference people or companies.
-
-```markdown
-**Auto-link (v0.12.0):** When you write/update an originals or ideas page that
-references a person or company, the auto-link post-hook on `put_page`
-automatically creates the link from the new page to that entity. You don't
-need to call `gbrain link` manually. Timeline entries still need explicit calls.
-```
-
----
-
-## 4. enrich/SKILL.md
-
-**Where:** Replace `### Step 7: Cross-reference` with the v0.12.0 version.
-
-**Why:** Step 7 used to be primarily about creating links between related entity
-pages. With auto-link, that's automatic. Step 7 is now about content updates,
-not link creation.
-
-Old (delete):
-```markdown
-### Step 7: Cross-reference
-
-- Update company pages from person enrichment (and vice versa)
-- Update related project/deal pages if relevant context surfaced
-- Check index files if the brain uses them
-- Add back-links manually via `gbrain link` for any new entity references
-```
-
-New (paste):
-```markdown
-### Step 7: Cross-reference
-
-- Update company pages from person enrichment (and vice versa)
-- Update related project/deal pages if relevant context surfaced
-- Check index files if the brain uses them
-
-**Note (v0.12.0):** Links between brain pages are auto-created on every
-`put_page` call (auto-link post-hook). Step 7 focuses on content
-cross-references (updating related pages' compiled truth with new signal
-from this enrichment), not on creating links. Verify via the `auto_links`
-field in the put_page response (`{ created, removed, errors }`).
-Timeline entries still need explicit `gbrain timeline-add` calls.
-```
-
----
-
-## After all four diffs are applied
-
-1. **Bump the version banner** at the top of each forked file:
-   ```
-   # Based on gbrain v0.12.0 skills/<skill-name>, extended with <your-agent>-specific config
-   ```
-
-2. **Run the v0.12.0 backfill** (this populates the graph for your existing brain):
-   ```bash
-   gbrain post-upgrade
-   ```
-   The v0.12.0 release wires post-upgrade to call `apply-migrations --yes`
-   automatically, which runs the v0_12_0 orchestrator (schema → config check →
-   `extract links --source db` → `extract timeline --source db` → verify).
-   Idempotent; cheap when nothing is pending.
-
-3. **Verify auto-link works:** ask the agent to write a test page that references
-   `[Some Person](people/some-person)`. Confirm the put_page response includes
-   `auto_links: { created: 1, removed: 0, errors: 0 }`.
-
-4. **Verify graph traversal works:**
-   ```bash
-   gbrain graph-query people/some-well-connected-person --depth 2
-   ```
-   Should return an indented tree of typed edges.
-
----
-
-## v0.12.2 hotfix (data-correctness, no skill edits)
-
-v0.12.2 is a Postgres data-correctness hotfix. No forked skill files need to
-change — the skill contracts are unchanged. But you DO need to run the migration,
-and you should know about one behavior change in markdown parsing.
-
-### 1. Run the migration (Postgres-backed brains)
-
-```bash
-gbrain upgrade
-```
-
-The `v0_12_2` orchestrator runs `gbrain repair-jsonb` automatically. It rewrites
-rows where `jsonb_typeof = 'string'` across `pages.frontmatter`, `raw_data.data`,
-`ingest_log.pages_updated`, `files.metadata`, and `page_versions.frontmatter`.
-Idempotent, safe to re-run. PGLite brains no-op cleanly.
-
-Verify after upgrade:
-
-```bash
-gbrain repair-jsonb --dry-run --json    # expect totalRepaired: 0
-```
-
-### 2. Recover any truncated wiki articles
-
-If your brain imported wiki-style markdown before v0.12.2, some pages were
-silently truncated (any standalone `---` in body content was treated as a
-timeline separator). Re-import from source:
-
-```bash
-gbrain sync --full
-```
-
-The new `splitBody` rebuilds `compiled_truth` correctly.
-
-### 3. Know the splitBody contract going forward
-
-`splitBody` now requires an explicit timeline sentinel. Recognized markers
-(priority order):
-
-1. `<!-- timeline -->` (preferred — what `serializeMarkdown` emits)
-2. `--- timeline ---` (decorated separator)
-3. `---` directly before `## Timeline` or `## History` heading (backward-compat)
-
-A bare `---` in body text is now a markdown horizontal rule, not a timeline
-separator. If your agent writes pages with a bare `---` delimiter, migrate to
-`<!-- timeline -->` — the `serializeMarkdown` helper already does this.
-
-### 4. Wiki subtypes now auto-typed
-
-`inferType` now auto-detects five additional directory patterns as their own
-page types (previously they all defaulted to `concept`):
-
-| Path pattern           | New type       |
-|------------------------|----------------|
-| `/wiki/analysis/`      | `analysis`     |
-| `/wiki/guides/`        | `guide`        |
-| `/wiki/hardware/`      | `hardware`     |
-| `/wiki/architecture/`  | `architecture` |
-| `/writing/`            | `writing`      |
-
-If your skills or queries filter by `type=concept` and expect wiki content in
-that bucket, update them to include the new types.
-
----
-
-## v0.13.0 — Frontmatter Relationship Indexing
-
-**Verdict: no action required for most skills.** v0.13 projects YAML frontmatter fields into the graph as typed edges. The ingestion API is unchanged — keep calling `put_page` with frontmatter the way you do today; the graph auto-populates behind the scenes.
-
-Three skills get an optional new phase if you want to consume the new `auto_links.unresolved` response field. Without this, unresolvable frontmatter names silently skip (same as v0.12 behavior).
-
-### 1. meeting-ingestion/SKILL.md (optional)
-
-**Where:** Add a new section after "Phase 3: Write Meeting Page".
-
-```markdown
-### Phase 3.5: Check for unresolved attendees (v0.13+)
-
-After `put_page`, inspect `response.auto_links.unresolved` — an array of frontmatter
-references that did not resolve to existing pages. For meetings, this usually means
-attendees you haven't created a person page for yet.
-
-If `unresolved.length > 0`:
-- Option 1 (create pages now): trigger an enrichment pass to build the missing people pages.
-- Option 2 (defer): log the unresolved names to the enrichment queue for later.
-- Option 3 (accept the gap): the attendee edge will not be created until a page exists.
-  Re-running `gbrain extract links --source db --include-frontmatter` after creating
-  the page fills in the missing edges.
-```
-
-### 2. enrich/SKILL.md (optional)
-
-**Where:** Add to the enrichment trigger list.
-
-```markdown
-### Drain unresolved frontmatter names (v0.13+)
-
-If any `put_page` response includes `auto_links.unresolved` entries, the enrichment
-tier should pick up those (field, name) pairs and try to create the missing entity
-pages. Example flow:
-
-1. signal-detector captures a meeting with `attendees: [Alice Known, Unknown Person]`
-2. put_page returns `auto_links.unresolved = [{field: 'attendees', name: 'Unknown Person'}]`
-3. enrichment tier consumes `Unknown Person` → web search → creates `people/unknown-person.md`
-4. The next put_page (or a backfill run) wires up the `attended` edge automatically
-```
-
-### 3. idea-ingest/SKILL.md (optional)
-
-**Where:** Same pattern as meeting-ingestion — check `auto_links.unresolved` after `put_page`, route names to enrichment.
-
-### Unchanged skills (no diffs needed)
-
-- **brain-ops/SKILL.md** — auto-link mechanics are internal; the write path stays the same.
-- **signal-detector/SKILL.md** — signal capture path unchanged.
-- **query/SKILL.md** — `traverse_graph` now returns richer results automatically.
-- **daily-task-manager/SKILL.md**, **briefing/SKILL.md**, **citation-fixer/SKILL.md**, **media-ingest/SKILL.md** — unchanged.
-
-### New edge types you can filter in graph queries
-
-v0.13 edges carry new `link_type` values. If your fork has graph-query skills that filter by type, these are now available:
-
-- `works_at` (person → company) — from `company:`, `companies:`, or `key_people:`
-- `founded` (person → company) — from `founded:`
-- `invested_in` (investor → deal/company) — from `investors:` or `lead:`
-- `led_round` (lead → deal) — from `lead:`
-- `yc_partner` (partner → company) — from `partner:`
-- `attended` (person → meeting) — from `attendees:`
-- `discussed_in` (source → page) — from `sources:`
-- `source` (page → source) — from `source:`
-- `related_to` (page → target) — from `related:` or `see_also:`
-
-### Migration timing
-
-`gbrain upgrade` takes 2-5 min on a 46K-page brain (one-time). Runs out-of-process via `gbrain post-upgrade`. If your agent holds a DB connection during the upgrade, reconnect after; otherwise keep serving.
-
-### Type normalization NOT in v0.13
-
-Legacy rows with `link_type='attendee'` or `link_type='mention'` coexist with new `'attended'` / `'mentions'` rows. Your queries filtering on old type names keep working. A separate opt-in `gbrain normalize-types` command in v0.14 handles the rename.
-## v0.14.0 shell jobs (optional adoption, no skill edits)
-
-Adds a `shell` job type to Minions so deterministic cron scripts (API fetch, token
-refresh, scrape + write) move off the LLM gateway. Zero tokens per fire. ~60%
-gateway CPU headroom at typical scale. Feature is **off by default**, existing
-installs keep running exactly as they did before. Nothing breaks.
-
-To adopt, follow `skills/migrations/v0.14.0.md`. The short version:
-
-1. Set `GBRAIN_ALLOW_SHELL_JOBS=1` on the worker process, then `gbrain jobs work`
-   (Postgres). On PGLite, every crontab invocation uses `--follow` for inline
-   execution; no persistent worker.
-2. Classify each of your host's cron entries: LLM-requiring (keep on gateway) vs
-   deterministic (candidate for shell). Typical splits:
-   - **Deterministic → shell:** `ycli-token-refresh`, `x-oauth2-refresh`,
-     `x-garrytan-unified`, `calendar-sync-to-brain`, `github-pulse`,
-     `frameio-scan`, `flight-tracker`, `x-raw-json-backfill`.
-   - **LLM-requiring → stay:** `social-radar`, `content-ideas`, `adversary-vacuum`,
-     `ea-inbox-sweep`, `morning-briefing`, `brain-maintenance`.
-3. For each deterministic cron, rewrite as:
-   ```cron
-   3 13,16,19,22,1,4,7,10 * * * \
-     gbrain jobs submit shell \
-       --params '{"cmd":"node scripts/your-script.mjs","cwd":"/data/.openclaw/workspace"}' \
-       --max-attempts 3 --timeout-ms 300000
-   ```
-4. Watch `gbrain jobs get <id>` for exit_code / stdout_tail / stderr_tail on each
-   fire. Compare against pre-migration behavior before approving the next batch.
-
-**No skill edits required.** The handler runs worker-side; skill files don't
-change. If your host exposed custom handlers via the plugin contract (v0.11.0),
-they still work the same way.
-
-Iron rule: **never auto-rewrite the operator's crontab.** Every rewrite is
-per-cron, human-approved, with a diff. If you want automation later, the
-upcoming `gbrain crontab-to-minions <file>` helper is P1 in TODOS.
-
----
-
-## v0.16.0: durable agent runtime
-
-v0.15 ships `gbrain agent run` / `gbrain agent logs`, a new `subagent` handler
-type in Minions, and a plugin contract for host-repo subagent defs. None of the
-existing skills need surgery. The question for downstream agents is *how* to
-adopt the new runtime, not how to patch around a breaking change.
-
-### 1. Run a worker with an Anthropic key
-
-The subagent handlers (`subagent` and `subagent_aggregator`) are always
-registered on the worker. No separate opt-in flag — `ANTHROPIC_API_KEY` is
-the natural cost gate (no key, the SDK call fails on the first turn), and
-who-can-submit is already protected (`PROTECTED_JOB_NAMES` + trusted-submit:
-MCP callers get `permission_denied`; only `gbrain agent run` can insert
-these rows).
-
-```bash
-ANTHROPIC_API_KEY=sk-ant-... gbrain jobs work
-```
-
-Worker startup prints:
-
-```
-[minion worker] subagent handlers enabled
-```
-
-### 2. Ship your subagents as a plugin (OpenClaw + similar)
-
-Move your custom subagent definitions out of your gbrain fork and into your own
-repo as a plugin. Concretely:
-
-```
-~/<your-agent>/gbrain-plugin/
-├── gbrain.plugin.json
-└── subagents/
-    ├── meeting-ingestion.md
-    ├── signal-detector.md
-    └── daily-task-prep.md
-```
-
-`gbrain.plugin.json`:
-
-```json
-{
-  "name": "your-openclaw",
-  "version": "2026.4.20",
-  "plugin_version": "gbrain-plugin-v1"
-}
-```
-
-Each `subagents/*.md` is a plain-text agent definition — YAML frontmatter +
-body-as-system-prompt. Recognized frontmatter fields: `name`, `model`,
-`max_turns`, `allowed_tools` (must subset the derived brain-tool registry).
-
-Turn it on:
-
-```bash
-export GBRAIN_PLUGIN_PATH="$HOME/<your-agent>/gbrain-plugin"
-```
-
-Worker startup prints `[plugin-loader] loaded '<name>' v<ver> (N subagents)`
-per plugin; any rejection (bad manifest, unknown tool in `allowed_tools`,
-version mismatch) shows up as a loud warning at startup, not a silent dispatch-
-time failure. See `docs/guides/plugin-authors.md` for the full contract.
-
-### 3. Replace ephemeral subagent runs with durable ones
-
-If your agent currently spawns ephemeral subagents (OpenClaw `Agent()`, ad-hoc
-Anthropic API calls, etc.) for work that should survive crashes, sleeps, or
-worker restarts, migrate those to `gbrain agent run`. The durability is free:
-
-```bash
-gbrain agent run "analyze my last 50 journal pages for recurring themes" \
-  --subagent-def analyzer --fanout-manifest manifests/journal-pages.json
-```
-
-Every turn persists to `subagent_messages`, every tool call is a two-phase
-ledger, and `gbrain agent logs <job>` shows where it died + what the last
-successful call returned. No more "re-run from scratch because the session
-context evaporated."
-
-### 4. `put_page` from subagents writes under an agent namespace
-
-If you adopted the v0.15 subagent runtime, note that `put_page` calls
-originating from a subagent's tool dispatch MUST target
-`wiki/agents/<subagent_id>/...`. The schema shown to the model enforces this
-on first try; a server-side fail-closed check rejects anything else. This
-does NOT affect your skill files, CLI put_page calls, or MCP put_page —
-only tool-dispatched writes from inside an LLM loop.
-
-Aggregation output (the final "here's what all N children found" brain page)
-goes via a separate trusted CLI path, not through a subagent tool call, so
-it can write anywhere you want.
-
-Iron rule: **never grant an agent write access beyond its namespace**. The
-server-side check exists because dispatcher bugs happen; treat it as defense
-in depth, not the primary boundary.
-
----
-
-## Future versions
-
-When gbrain ships a new version, this doc will be updated with the diffs for that
-version. Each new version appends a section; old sections stay so you can catch up
-multiple versions at once.
-
-To check what your fork is missing:
-```bash
-diff <(grep -A3 "Based on gbrain" ~/<your-fork>/skills/brain-ops/SKILL.md) \
-     <(grep "v[0-9]" ~/gbrain/skills/migrations/ | tail -3)
-```

docs/benchmarks/2026-04-14-search-quality.md

@@ -0,0 +1,167 @@
+# Search Quality Benchmark — PR #64
+
+**Date:** 2026-04-14
+**Branch:** garrytan/search-quality-boost
+**Inspired by:** Ramp Labs' "Latent Briefing" paper (April 2026)
+
+## What this PR does
+
+GBrain stores knowledge in brain pages. Each page has two sections: **compiled truth**
+(your distilled assessment of a person, company, or concept) and **timeline** (dated
+entries like meeting notes, announcements, funding rounds).
+
+Before this PR, search treated both sections equally. Ask "who is Alice Chen?" and you
+might get a meeting note from March instead of the actual assessment. Ask "when did we
+last meet Alice?" and you might get the assessment instead of the date.
+
+This PR teaches search to understand the difference. It picks the right section based
+on what you're asking.
+
+## How we test it
+
+We built a synthetic brain with **29 fictional pages** and **58 chunks** (2 per page:
+one compiled truth, one timeline). The pages span 10 people, 10 companies, and 9
+concept pages across topics like AI, fintech, climate, crypto, robotics, education,
+biotech, and design.
+
+The embeddings share dimensions to simulate real-world overlap. "AI" shows up in
+health pages, education pages, design pages, and robotics pages. A query about "AI
+companies" has to sort through 5+ relevant pages, not just find one obvious match.
+
+We run **20 queries** with hand-labeled ground truth:
+- 11 entity queries ("who is X?", "what does Y do?", "tell me about Z")
+- 7 temporal queries ("when did we last meet?", "recent updates", "what launched?")
+- 1 negative control (irrelevant topic, no matches expected)
+- 1 ambiguous query (could go either way)
+
+Each query has **graded relevance**: the primary answer gets grade 3, related pages get
+2 or 1. A query about climate investing has 4 relevant pages ranked by importance.
+
+We compare three configurations:
+- **A. Baseline** — how search worked before this PR
+- **B. Boost only** — compiled truth chunks get a 2x score multiplier (the naive approach)
+- **C. Boost + Intent** — the full PR: boost + intent classifier that auto-detects query type
+
+## Results: finding the right page
+
+These are standard information retrieval metrics. They answer: "did search find the
+right page?"
+
+| Metric | What it measures | A. Before | C. After | Change |
+|--------|-----------------|-----------|----------|--------|
+| **P@1** | Is the #1 result relevant? | 94.7% | 94.7% | same |
+| **MRR** | How far down is the first relevant result? | 0.974 | 0.974 | same |
+| **nDCG@5** | Are the top 5 results in the right order? | 1.191 | 1.069 | -10% |
+
+Page-level retrieval is roughly the same. The right page was already being found. This
+is not where the improvement lives.
+
+## Results: finding the right chunk (the actual improvement)
+
+These metrics answer: "did search find the right SECTION of the right page?" This is
+what matters when an agent reads search results to answer a question.
+
+| Metric | What it measures | A. Before | C. After | Change |
+|--------|-----------------|-----------|----------|--------|
+| **Source accuracy** | Is the top chunk the right type for this query? (assessment for "who is X?", timeline for "when did we meet?") | 89.5% | 89.5% | same |
+| **CT-first rate** | For entity lookups, does the assessment show up before timeline noise? | 100% | 100% | same |
+| **Timeline accessible** | For temporal queries, can you actually find the dates? | 100% | 100% | same |
+| **Unique pages** | How many different pages appear in top 10? (more = broader context) | 7.2 | **8.7** | **+21%** |
+| **Compiled truth ratio** | What % of returned chunks are assessments vs timeline noise? | 51.6% | **66.8%** | **+29%** |
+
+Two big improvements:
+
+1. **21% more page coverage.** The agent sees 8.7 unique pages per query instead of 7.2.
+   When you ask "AI companies building real products", you get results from MindBridge,
+   EduStack, PixelCraft, GenomeAI, AND the AI-first thesis page. Before, some of those
+   were crowded out.
+
+2. **29% more signal in results.** Two thirds of returned chunks are now compiled truth
+   (assessments) instead of roughly half. The agent reads more distilled knowledge and
+   less timeline noise.
+
+## Why the boost alone isn't enough
+
+We also tested configuration B: the 2x compiled truth boost without the intent classifier.
+This is the naive version that just says "rank assessments higher, always."
+
+| What broke | Before | Boost only | With intent |
+|-----------|--------|------------|-------------|
+| Source accuracy | 89.5% | **63.2%** | 89.5% |
+| Timeline accessible | 100% | **71.4%** | 100% |
+| P@1 | 94.7% | **89.5%** | 94.7% |
+
+The boost forces compiled truth to the top even when timeline IS the right answer. Ask
+"what launched this year?" and the boost pushes assessment chunks above the actual launch
+dates. The source accuracy drops from 89.5% to 63.2%.
+
+The **intent classifier** fixes this. It reads the query text (zero latency, no LLM call)
+and detects whether you're asking an entity question or a temporal question:
+
+- "Who is Alice Chen?" → entity → boost compiled truth
+- "When did we last meet Alice?" → temporal → skip boost, show timeline
+- "Recent funding rounds" → temporal → skip boost, show dates
+- "AI companies building real products" → general → moderate boost
+
+This recovers all the regressions while keeping the improvements.
+
+## Per-query results
+
+Every query, every configuration. "Src" column shows which chunk type ranked first.
+
+| Query | Expected | Before src | After src | Before pages | After pages |
+|-------|----------|-----------|-----------|-------------|-------------|
+| Who is Alice Chen? | assessment | assessment | assessment | 7 | 10 |
+| What does MindBridge do? | assessment | assessment | assessment | 6 | 10 |
+| Tell me about climate investing | assessment | assessment | assessment | 5 | 10 |
+| When did we last meet Alice? | timeline | timeline | timeline | 9 | 9 |
+| Recent updates on GenomeAI | timeline | timeline | timeline | 8 | 8 |
+| CloudScale acquisition | timeline | timeline | timeline | 8 | 8 |
+| Alice Chen NovaPay payments | assessment | assessment | assessment | 7 | 8 |
+| Carol Nakamura MindBridge AI | assessment | assessment | assessment | 6 | 8 |
+| AI companies building products | assessment | assessment | assessment | 9 | 10 |
+| Who raised funding recently? | timeline | timeline | timeline | 10 | 10 |
+| Bob and James climate investments | assessment | assessment | assessment | 5 | 9 |
+| AI replacing designers | assessment | assessment | assessment | 7 | 8 |
+| Everything on RoboLogic | timeline | assessment | assessment | 6 | 6 |
+| Deep dive on crypto custody | timeline | assessment | assessment | 6 | 6 |
+| Education technology Africa | assessment | assessment | assessment | 7 | 10 |
+| What launched this year? | timeline | timeline | timeline | 10 | 10 |
+| MPC multi-party computation | assessment | assessment | assessment | 7 | 9 |
+| Protein folding drug discovery | assessment | assessment | assessment | 7 | 9 |
+| EduStack Nigeria | assessment | assessment | assessment | 7 | 8 |
+
+The "pages" column tells the clearest story. Entity lookups with `detail=low` (the
+intent classifier's choice) go from 5-7 pages to 8-10 pages. The agent gets significantly
+broader context for the same query.
+
+## What shipped in PR #64
+
+1. **Compiled truth boost** — 2.0x score multiplier after RRF normalization
+2. **Intent classifier** — zero-latency regex that auto-selects detail level per query
+3. **Detail parameter** — `--detail low/medium/high` for explicit agent control
+4. **Source-aware dedup** — guarantees compiled truth chunk per page in results
+5. **Cosine re-scoring** — re-ranks chunks against the actual query embedding
+6. **RRF normalization** — scores normalized to 0-1 before boosting
+7. **CJK word count fix** — Chinese/Japanese/Korean queries now expand correctly
+8. **Eval harness** — `gbrain eval --qrels` with P@k, R@k, MRR, nDCG@k + A/B comparison
+9. **This benchmark** — 29 pages, 20 queries, reproducible, no private data
+
+## How to reproduce
+
+```bash
+bun run test/benchmark-search-quality.ts
+```
+
+Runs in ~2 seconds against in-memory PGLite. No API keys, no database, no network.
+
+## Methodology notes
+
+- All data is fictional. No private information from any real brain.
+- Embeddings use 25 topic dimensions with shared axes (not orthogonal basis vectors).
+  "AI" and "health" share signal so that an AI health query naturally ranks both the
+  AI-health concept page and the MindBridge company page.
+- Each page has exactly 2 chunks (1 compiled truth, 1 timeline) for clean measurement.
+  Real brains have more chunks per page, which would amplify the boost's effect.
+- The baseline uses the old text-prefix dedup key. The new configurations use chunk_id.
+- Graded relevance: 3 = primary answer, 2 = strongly related, 1 = tangentially related.

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

@@ -1,286 +0,0 @@
-# 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

@@ -1,126 +0,0 @@
-# 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

@@ -1,203 +0,0 @@
-# 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

@@ -1,176 +0,0 @@
-# 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

@@ -1,190 +0,0 @@
-# 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/KNOWLEDGE_RUNTIME.md

@@ -1,717 +0,0 @@
-# GBrain Knowledge Runtime — Design Doc
-
-**Status:** DRAFT for CEO review.
-**Date:** 2026-04-18.
-**Supersedes:** The earlier "Feynman Ideas Assessment + Phase A/B" plan.
-
----
-
-## 0. Context
-
-During a CEO review of a narrow two-feature plan (bare-tweet citation repair + completeness score, borrowed from Feynman), the scope was reframed. The narrow plan duplicated work Garry's OpenClaw already does and missed the real leverage point: **the bespoke abstractions hiding inside OpenClaw — resolvers, enrichment orchestration, scheduling, deterministic output — should live in GBrain as first-class primitives.**
-
-North star: *"When Garry's OpenClaw's Claw upgrades to this version of GBrain, it should immediately recognize brilliance and completeness and say 'It's time to switch to these abstractions.'"*
-
-That is the test this document is designed against. Everything else is downstream.
-
----
-
-## 1. The Four Layers
-
-The design is four layered abstractions. Each is independently useful; together they are the Knowledge Runtime.
-
-```
-  ┌───────────────────────────────────────────────────────────────────┐
-  │                   KNOWLEDGE RUNTIME (new)                         │
-  ├───────────────────────────────────────────────────────────────────┤
-  │  Layer 4: Deterministic Output Builder                            │
-  │     BrainWriter · Scaffolds · Back-link enforcer · Slug registry  │
-  │     Rule: LLM picks WHAT to write. Code guarantees WHERE and HOW. │
-  ├───────────────────────────────────────────────────────────────────┤
-  │  Layer 3: Scheduler                                               │
-  │     ScheduledResolver · TZ-aware quiet hours (enforced) ·         │
-  │     Auto-stagger · Durable state · Retry/circuit-break            │
-  ├───────────────────────────────────────────────────────────────────┤
-  │  Layer 2: Enrichment Orchestrator                                 │
-  │     Trigger convergence · Tier routing · Budget · Cascade ·       │
-  │     Evidence-weighted completeness · Fail-safe transactions       │
-  ├───────────────────────────────────────────────────────────────────┤
-  │  Layer 1: Resolver SDK                                            │
-  │     Resolver<I,O> interface · Registry · Factory · Plugin recipes │
-  │     Ported reference impls: X-API, Perplexity, Mistral, brain     │
-  └───────────────────────────────────────────────────────────────────┘
-          │                                                │
-          ▼                                                ▼
-     REUSES (polished primitives already in GBrain)  REPLACES (ad-hoc code)
-     FailImproveLoop · backoff · storage factory ·   enrichment-service ·
-     check-resolvable · operations validators ·      embedding · transcription ·
-     engine interface · publish · backlinks          2 recipe formats
-```
-
----
-
-## 2. Why This Order (L1 → L4)
-
-Every higher layer depends on the lower one. **L1 must land first or the rest leaks abstractions.**
-
-- **L1 (Resolvers)** is the substrate. Without a uniform lookup interface, every orchestrator + writer has bespoke callers.
-- **L2 (Orchestrator)** uses L1 to fetch; without L1 it's still ad-hoc.
-- **L3 (Scheduler)** runs L2 periodically; without L2 it's scheduling nothing structured.
-- **L4 (Output Builder)** is what every layer ultimately writes through; without it we have 14 call sites doing `fs.writeFile` with hand-rolled citation discipline.
-
-An earlier implementation could ship L1 + L4 first (the two "purest" layers) and have the most immediate integrity impact, then add L2 + L3. But the end-state must include all four.
-
----
-
-## 3. Layer 1 — Resolver SDK
-
-### 3.1 What's broken today
-
-Garry's OpenClaw has **69 distinct external-lookup patterns** across X API (14 shapes), Perplexity, Mistral OCR, Gmail, Calendar, Slack, GitHub, YouTube, Diarize.io, YC tools, OSINT collectors, and brain-local lookups. Each one is a bespoke script under `scripts/` with its own error handling, retry logic, and output shape. GBrain has 3 ad-hoc wrappers (`embedding.ts`, `transcription.ts`, `enrichment-service.ts`) that don't share an interface.
-
-Common consequences:
-- No uniform retry/backoff strategy (some scripts retry, most don't)
-- No cost tracking (Perplexity bills eaten silently when calls return no-substance results)
-- No confidence/provenance propagation (callers can't tell if an answer is verified or inferred)
-- Users can't add a resolver without forking GBrain
-
-### 3.2 Interface
-
-```typescript
-// src/core/resolvers/interface.ts
-
-export type ResolverCost = 'free' | 'rate-limited' | 'paid';
-
-export interface ResolverRequest<I> {
-  input: I;
-  context: ResolverContext;
-  timeoutMs?: number;
-}
-
-export interface ResolverResult<O> {
-  value: O;
-  confidence: number;      // 0.0–1.0; 1.0 = deterministic from ground-truth API
-  source: string;          // e.g. "x-api-v2", "perplexity-sonar", "brain-local"
-  fetchedAt: Date;
-  costEstimate?: number;   // dollars; 0 if free
-  raw?: unknown;           // for sidecar preservation via put_raw_data
-}
-
-export interface Resolver<I, O> {
-  readonly id: string;           // stable, slug-like: "x_handle_to_tweet"
-  readonly cost: ResolverCost;
-  readonly backend: string;      // "x-api-v2", "perplexity", "brain-local"
-  readonly inputSchema: JSONSchema;
-  readonly outputSchema: JSONSchema;
-
-  available(ctx: ResolverContext): Promise<boolean>;
-  resolve(req: ResolverRequest<I>): Promise<ResolverResult<O>>;
-}
-```
-
-### 3.3 Context
-
-```typescript
-export interface ResolverContext {
-  engine: BrainEngine;
-  storage: StorageBackend;
-  config: GBrainConfig;
-  logger: Logger;
-  metrics: MetricsRecorder;
-  budget: BudgetLedger;       // hard spend caps, queried pre-resolve
-  requestId: string;
-  remote: boolean;            // trust boundary — untrusted callers get stricter validation
-  deadline?: Date;
-}
-```
-
-### 3.4 Registry + Factory (mirrors `src/core/storage.ts`)
-
-```typescript
-// src/core/resolvers/registry.ts
-export class ResolverRegistry {
-  register<I, O>(r: Resolver<I, O>): void;
-  get(id: string): Resolver<unknown, unknown>;
-  list(filter?: { cost?: ResolverCost; backend?: string }): Resolver[];
-  async resolve<I, O>(id: string, input: I, ctx: ResolverContext): Promise<ResolverResult<O>>;
-}
-
-// src/core/resolvers/factory.ts (dynamic import like engine-factory)
-export async function createResolver(
-  type: 'x-api' | 'perplexity' | 'mistral-ocr' | 'brain-local' | 'plugin',
-  config: ResolverConfig,
-): Promise<Resolver>;
-```
-
-### 3.5 Plugin format (unifies `recipes/` + `data-research` formats)
-
-A plugin is YAML + JS module, discovered via filesystem scan of `~/.gbrain/resolvers/` and `recipes/`.
-
-```yaml
-# Example: resolvers/x-api/handle-to-tweet.yaml
-id: x_handle_to_tweet
-version: 1
-category: lookup
-cost: rate-limited
-backend: x-api-v2
-module: ./handle-to-tweet.ts
-input_schema:
-  type: object
-  properties:
-    handle:   { type: string, pattern: "^[A-Za-z0-9_]{1,15}$" }
-    keywords: { type: string }
-  required: [handle]
-output_schema:
-  type: object
-  properties:
-    url:        { type: string, format: uri }
-    tweet_id:   { type: string }
-    text:       { type: string }
-    created_at: { type: string, format: date-time }
-requires:
-  env: [X_API_BEARER_TOKEN]
-health_check:
-  kind: http
-  url: https://api.twitter.com/2/tweets/1
-  expect: { status: [200, 401] }   # 401 = auth failure but endpoint reachable
-tests:
-  - input:  { handle: "garrytan" }
-    expect: { url: { pattern: "^https://x\\.com/garrytan/status/\\d+$" } }
-```
-
-Trust flagging follows the existing `src/commands/integrations.ts` pattern: only package-bundled resolvers are `embedded=true` and may run arbitrary commands; user-provided resolvers are restricted to `http` and validated schemas.
-
-### 3.6 Wraps every resolver with `FailImproveLoop`
-
-Existing `src/core/fail-improve.ts` is the deterministic-first/LLM-fallback pattern. Every resolver automatically gets wrapped: if the deterministic path (e.g. X API) returns a valid result, use it; if it fails, optionally fall back to an LLM-based resolver; log both paths for future pattern analysis and auto-test generation.
-
-### 3.7 Reference implementations to ship
-
-The OpenClaw survey inventoried 69 resolver shapes. Shipping all of them is wrong (over-scoped); shipping zero is under-scoped. The dogfood set:
-
-| # | Resolver | Purpose | Used by |
-|---|---|---|---|
-| 1 | `x_handle_to_tweet` | Bare-tweet citation repair (original Phase A) | `gbrain integrity` |
-| 2 | `url_reachable` | Dead-link detection | `gbrain integrity` |
-| 3 | `brain_slug_lookup` | Name/email → slug (wraps existing `resolveSlugs`) | Output Builder |
-| 4 | `openai_embedding` | Refactor of `src/core/embedding.ts` into Resolver | Import pipeline |
-| 5 | `perplexity_query` | Query → synthesis + citations | Enrichment Orchestrator |
-| 6 | `text_to_entities` | LLM entity extraction (structured JSON) | Enrichment Orchestrator |
-
-The remaining 63 OpenClaw patterns port incrementally, driven by user need. Each port is a new YAML + module under `recipes/` or `~/.gbrain/resolvers/` with no framework changes.
-
----
-
-## 4. Layer 2 — Enrichment Orchestrator
-
-### 4.1 What's broken today
-
-Garry's OpenClaw's enrichment is **polished at the data layer, hacky at the control layer**:
-
-- **Completeness = "length > 500 chars + no `needs-enrichment` tag"** (`lib/enrich.mjs:351-355`). Naïve. A rich page of repetitive Perplexity summaries (see `brain/people/0interestrates.md` — 38 repeating blocks) passes this check.
-- **30-day auto-re-enrichment** runs forever. No "done" state. A person met once in 2023 still gets re-researched monthly.
-- **Cascade is convention-only.** Person→company stubs are created automatically; company→investors, company→employees traversals are documented but never implemented.
-- **No hard budget cap.** Cost is estimated per batch, never enforced across batches or per day.
-- **Failure is silent.** A bad Perplexity response logs and continues; partial writes can leave a page with a timeline entry but no raw-data sidecar.
-
-### 4.2 The orchestrator
-
-```typescript
-// src/core/enrichment/orchestrator.ts
-
-export interface EnrichmentRequest {
-  entitySlug: string;
-  trigger: 'mention' | 'stub-creation' | 'cron-sweep' | 'manual' | 'cascade';
-  tier?: 1 | 2 | 3;                // optional override; auto-computed if absent
-  cascadeDepth?: number;           // 0 = no cascade; default 1
-}
-
-export interface EnrichmentResult {
-  entitySlug: string;
-  completenessBefore: number;
-  completenessAfter: number;
-  resolversUsed: string[];         // e.g. ["perplexity_query", "x_handle_to_tweet"]
-  costSpent: number;
-  writtenTo: string[];             // page paths touched, for transaction audit
-  cascadedTo: string[];            // related entities enriched
-  status: 'enriched' | 'skipped' | 'failed' | 'budget-exhausted';
-  reason?: string;
-}
-
-export class EnrichmentOrchestrator {
-  constructor(
-    private registry: ResolverRegistry,
-    private writer: BrainWriter,
-    private budget: BudgetLedger,
-    private scorer: CompletenessScorer,
-    private graph: EntityGraph,
-  ) {}
-
-  async enrich(req: EnrichmentRequest): Promise<EnrichmentResult>;
-  async enrichBatch(reqs: EnrichmentRequest[]): Promise<EnrichmentResult[]>;
-}
-```
-
-### 4.3 Evidence-weighted completeness (replaces length heuristic)
-
-Completeness is a per-entity-type rubric, stored in frontmatter on write and recomputed on demand.
-
-```typescript
-// src/core/enrichment/completeness.ts
-export interface CompletenessRubric<Page> {
-  entityType: PageType;
-  dimensions: {
-    name: string;
-    weight: number;                // sum must = 1.0
-    check: (page: Page) => number; // 0.0–1.0
-  }[];
-}
-
-// Example rubric for persons:
-//   - has_role_and_company   0.20
-//   - has_source_urls        0.20  (≥1 URL with resolver-verified reachability)
-//   - has_timeline_entries   0.15  (≥1)
-//   - has_citations          0.15  (every claim has [Source: ...])
-//   - has_backlinks          0.10  (every linked page links back)
-//   - recency_score          0.10  (last_verified within 90 days)
-//   - non_redundancy         0.10  (no repeated blocks; distinct-lines/total-lines > 0.8)
-```
-
-**Key property:** `non_redundancy` + `recency_score` explicitly kill the two brain pathologies observed in the audit (Wilco-style repeating blocks; stale pages without `last_verified`).
-
-The `completeness` field goes in frontmatter as `0.0–1.0`. It becomes queryable via `list_pages(where: completeness < 0.5)`.
-
-### 4.4 Tier routing with hard budget
-
-Two-dimensional routing: **importance** (tier 1/2/3 from person-score) × **budget state**.
-
-```typescript
-// src/core/enrichment/tiers.ts
-export const TIER_CONFIG = {
-  1: { models: ['opus', 'sonar-deep'], maxCostUsd: 0.10, cascadeDepth: 2 },
-  2: { models: ['sonar'],              maxCostUsd: 0.02, cascadeDepth: 1 },
-  3: { models: ['sonar'],              maxCostUsd: 0.005, cascadeDepth: 0 },
-};
-
-// src/core/enrichment/budget.ts
-export class BudgetLedger {
-  // Hard caps. Queryable pre-resolve.
-  dailyCapUsd: number;
-  perEntityCapUsd: number;
-  perResolverCapUsd: Map<string, number>;
-
-  async reserve(resolverId: string, estimateUsd: number): Promise<Reservation | 'exhausted'>;
-  async commit(reservation: Reservation, actualUsd: number): Promise<void>;
-  async rollback(reservation: Reservation): Promise<void>;
-  async state(): Promise<{ spent: number; remaining: number; perResolver: Record<string, number> }>;
-}
-```
-
-**Property:** if the daily cap is reached, `orchestrator.enrich()` returns `status: 'budget-exhausted'` immediately. No silent overages. Circuit-breaker resets at midnight in the user's configured TZ.
-
-### 4.5 Cascade (entity graph traversal)
-
-```typescript
-// src/core/enrichment/cascade.ts
-export class EntityGraph {
-  // Deterministic, no LLM. Uses engine.getLinks() + engine.getBacklinks().
-  async neighbors(slug: string, depth: number): Promise<string[]>;
-  async cascadeFrom(trigger: string, depth: number): Promise<EnrichmentRequest[]>;
-}
-```
-
-If person X is enriched and gains a new `company: Acme` field, cascade checks: does `companies/acme` exist? If not, create stub + enqueue at tier 2. Does `companies/acme` link back to X? If not, write the back-link. **Iron Law is machine-enforced, not skill-enforced.**
-
-### 4.6 Fail-safe transactions
-
-Every enrichment is wrapped in a BrainWriter transaction (Layer 4). Partial writes are rolled back. No asymmetric state like timeline-entry-without-raw-sidecar.
-
-```typescript
-await writer.transaction(async (tx) => {
-  const research = await registry.resolve('perplexity_query', {...}, ctx);
-  await tx.appendTimeline(slug, {...});
-  await tx.putRawData(slug, 'perplexity', research.raw);
-  await tx.setFrontmatterField(slug, 'completeness', score);
-  // All-or-nothing commit on exit.
-});
-```
-
----
-
-## 5. Layer 3 — Scheduler
-
-### 5.1 What's broken today
-
-Garry's OpenClaw's cron is **externally-driven JSON** (`cron/jobs.json`) with ~30 jobs manually stagger-offset at different minutes. GBrain has **zero native scheduling** — `src/commands/autopilot.ts` is a single daemon loop, and `docs/guides/cron-schedule.md` is architectural guidance, not code.
-
-Failures observed in Garry's OpenClaw's actual state:
-- `X OAuth2 Token Refresh`: 11 consecutive timeouts (critical-path silent failure)
-- `flight-tracker daily scan`: 5 consecutive timeouts
-- `morning-briefing`: 4 consecutive timeouts
-- Quiet hours are checked at runtime in skills, so a skill that forgets to check will DM at 3 a.m.
-- Staggering is manual convention; no protection against two jobs colliding after a config edit.
-
-### 5.2 ScheduledResolver interface
-
-```typescript
-// src/core/scheduling/scheduler.ts
-export interface Schedule {
-  kind: 'cron' | 'interval';
-  expr?: string;                    // cron string
-  intervalMs?: number;
-  tz: string;                       // IANA: "America/Los_Angeles"
-  quietHours?: {
-    startHour: number;              // 22 = 10 PM local
-    endHour: number;                // 7 = 7 AM local
-    policy: 'skip' | 'defer' | 'silent-run';
-  };
-  staggerKey?: string;              // jobs with same key auto-offset
-  maxConcurrent?: number;           // global concurrency cap
-  maxDurationMs?: number;           // timeout
-}
-
-export interface ScheduledResolver extends Resolver<void, ScheduledResult> {
-  schedule: Schedule;
-  retryPolicy: { maxRetries: number; backoffMs: number };
-  circuitBreaker: { failureThreshold: number; cooldownMs: number };
-  state: DurableState;              // watermark, content-hash, idempotency key
-}
-```
-
-### 5.3 Enforcement vs convention (the key delta from Garry's OpenClaw)
-
-| Concern | Garry's OpenClaw today | Knowledge Runtime |
-|---|---|---|
-| Quiet hours | Checked inside each skill (trust-based) | Enforced at scheduler, skill cannot override |
-| Staggering | Manual minute-offset in `jobs.json` | Scheduler assigns slots via hashed staggerKey |
-| Concurrency | `MAX_BATCH_PROCESSES=2` in backoff, ignored by cron | Global semaphore in scheduler |
-| Timeout | Per-job string in JSON, not always respected | Enforced via `AbortController`, timeout raises `TimeoutError` caught by orchestrator |
-| Retry | None at cron level | `retryPolicy` with exponential backoff |
-| Silent failure | "11 consecutive timeouts" unnoticed | Circuit breaker opens at threshold → escalation to user |
-| Idempotency | State files per job, no framework | `DurableState` primitive: watermark/ID/content-hash |
-
-### 5.4 Native engine + OS cron adapter
-
-The scheduler runs as either:
-1. **Embedded** (default for `gbrain autopilot`): native event loop inside the daemon process. One process, many ScheduledResolvers.
-2. **OS-driven** (for Railway/launchd/systemd): `gbrain schedule run <id>` invoked by OS cron, scheduler state is durable so cross-invocation dedup still works.
-
-Both modes share the same `Schedule` config + state.
-
-### 5.5 Observability
-
-Every scheduled run emits structured events: `started`, `skipped-quiet-hours`, `deferred-to-active-hours`, `failed-retrying`, `circuit-opened`, `completed`. Events go to:
-- `~/.gbrain/scheduler/events.jsonl` (local, always)
-- `engine.logIngest` (audit trail in brain DB)
-- Optional webhook (Slack/Telegram for the user)
-
-`gbrain doctor` reads the event log and reports: current circuit-breaker state, any resolver with > 3 consecutive failures, any resolver that hasn't fired within 3× its interval (freshness SLA like Garry's OpenClaw's `freshness-check.mjs` but built-in).
-
----
-
-## 6. Layer 4 — Deterministic Output Builder
-
-### 6.1 The anti-hallucination invariant
-
-**Iron Law: LLM picks WHAT. Code guarantees WHERE and HOW.**
-
-Garry's OpenClaw's existing `lib/enrich.mjs:buildTweetEntry` is close to this — tweet URLs are built from `tweet.id` returned by the X API, never from LLM memory. But:
-
-- A past incident: *"Sub-agent test #2 FAILED — hallucinated 'Philip Leung' entity links across all daily files. LLM rewriting of daily files is too error-prone."* (Garry's OpenClaw memory log, 2026-04-13.)
-- Back-links depend on `appendTimeline` being called everywhere; skips are silent.
-- Slug collisions are unchecked (no conflict detection on `slugify`).
-- Citation format is post-hoc linted weekly, not pre-write enforced.
-
-### 6.2 BrainWriter
-
-```typescript
-// src/core/output/writer.ts
-export class BrainWriter {
-  constructor(
-    private engine: BrainEngine,
-    private slugRegistry: SlugRegistry,
-    private scaffolder: Scaffolder,
-  ) {}
-
-  async transaction<T>(fn: (tx: WriteTx) => Promise<T>): Promise<T>;
-}
-
-export interface WriteTx {
-  // High-level typed operations; never raw string writes.
-  createEntity(input: EntityInput): Promise<string>;          // returns slug, conflict-checked
-  appendTimeline(slug: string, entry: TimelineInput): Promise<void>;
-  setCompiledTruth(slug: string, body: CompiledTruthInput): Promise<void>;
-  setFrontmatterField(slug: string, key: string, value: unknown): Promise<void>;
-  putRawData(slug: string, source: string, data: object): Promise<void>;
-  addLink(from: string, to: string, context: string): Promise<void>;  // auto-creates reverse back-link
-
-  // Validators (called implicitly on commit)
-  validate(): Promise<ValidationReport>;
-}
-```
-
-### 6.3 Scaffolder — deterministic link + citation construction
-
-Every user-visible URL/link/citation is built by code from resolver outputs, not from LLM text.
-
-```typescript
-// src/core/output/scaffold.ts
-export class Scaffolder {
-  tweetCitation(handle: string, tweetId: string, dateISO: string): string {
-    // "[Source: [X/garrytan, 2026-04-18](https://x.com/garrytan/status/123456)]"
-  }
-  emailCitation(account: string, messageId: string, subject: string): string {
-    // deterministic Gmail URL per OpenClaw pattern
-  }
-  sourceCitation(resolverResult: ResolverResult<unknown>): string {
-    // pulls .source, .fetchedAt, .raw from the result
-  }
-  entityLink(slug: string): string {
-    // slugRegistry checks existence; returns resolvable wikilink
-  }
-}
-```
-
-### 6.4 SlugRegistry — conflict detection
-
-```typescript
-// src/core/output/slug-registry.ts
-export class SlugRegistry {
-  async create(desiredSlug: string, displayName: string, type: PageType): Promise<CreatedSlug>;
-  // Throws SlugCollision if another entity already occupies desiredSlug and isn't
-  // confirmed as the same person (via email / x_handle / disambiguator).
-  // Auto-resolves near-collisions by appending disambiguator.
-
-  async confirmSame(slugA: string, slugB: string, confidence: number): Promise<void>;
-  async merge(canonical: string, duplicate: string): Promise<void>;
-}
-```
-
-### 6.5 Pre-write validators (fail-closed for integrity)
-
-On `WriteTx.validate()` before commit:
-
-1. **Citation validator.** Every factual sentence in `compiled_truth` must have an inline `[Source: ...]` within N lines. Non-compliant paragraphs are flagged. Configurable: strict-mode rejects the transaction, lint-mode warns.
-2. **Link validator.** Every `[text](path)` must point to a page that exists OR to a URL the Scaffolder built (so it's guaranteed-valid). No raw LLM-composed URLs.
-3. **Back-link validator.** Every outbound link must have a reverse link written in the same transaction.
-4. **Triple-HR validator.** Compiled truth / timeline split enforced at the schema level.
-
-**Fails closed**: the default is strict-mode. Loosening requires explicit `writer.transaction({ strictMode: false }, ...)` and logs a warning to the ingest log.
-
-### 6.6 LLM output sanitization
-
-Any LLM output destined for a brain page passes through a JSON-Schema-validated parser first. No free-form markdown goes to disk.
-
-- Entity extraction: JSON array of `{ name, type, context }` per existing `extractEntities` pattern — strict validation.
-- Compiled-truth synthesis: LLM emits structured `{ sections: [{heading, paragraphs: [{text, sources: [...]}]}]}`, scaffolder renders to markdown.
-- Timeline entries: LLM emits `{ date, summary, detail, sources }`, scaffolder renders.
-
-LLM never sees file paths, never writes files, never emits finished markdown.
-
----
-
-## 7. Integration with existing GBrain
-
-### 7.1 Reuse (already polished)
-
-| Existing | Used by | Change |
-|---|---|---|
-| `src/core/fail-improve.ts` (9/10) | Wraps every Resolver in L1 | None; becomes default wrapper |
-| `src/core/backoff.ts` (9/10) | ResolverContext.backoff | None |
-| `src/core/storage.ts` (9/10) | Template for Resolver factory pattern | None; serves as pattern reference |
-| `src/core/check-resolvable.ts` (9/10) | Extend to validate Resolver plugins | Add `checkResolvers()` mode |
-| `src/commands/publish.ts` (9/10) | Uses BrainWriter under the hood | Minor: route through L4 |
-| `src/commands/backlinks.ts` (8/10) | Folded into L4 validator | Keep as CLI-facing lint entry point |
-| `src/core/operations.ts` validators | Reused in ResolverContext trust enforcement | None |
-| `src/core/engine.ts` BrainEngine (35 methods) | ResolverContext.engine | Extend with `getResolverRegistry()` |
-
-### 7.2 Replace (ad-hoc today)
-
-| Existing | Replace with |
-|---|---|
-| `src/core/enrichment-service.ts` (5/10) | `src/core/enrichment/orchestrator.ts` (L2) |
-| `src/core/embedding.ts` (monolithic) | `src/core/resolvers/builtin/embedding/openai.ts` |
-| `src/core/transcription.ts` (monolithic) | `src/core/resolvers/builtin/transcription/{groq,openai}.ts` |
-| `src/commands/integrations.ts` recipe format | Unified Resolver plugin format (§3.5) |
-| `src/core/data-research.ts` recipe format | Same unified format |
-| `src/commands/autopilot.ts` hard-coded daemon loop | Wraps a set of ScheduledResolvers |
-
-### 7.3 Extend
-
-- `src/core/engine.ts`: add `getResolverRegistry()`, `getWriter()`, `getScheduler()`. Engine becomes the runtime's root container.
-- `src/core/operations.ts`: `OperationContext` inherits from `ResolverContext` (or vice-versa). Trust flags unified.
-- `src/core/types.ts`: add `completeness: number` to `Page`, `sourcedBy: string[]` for provenance.
-
----
-
-## 8. Migration Path (phased, shippable)
-
-Each phase ships independently, passes full E2E, is feature-flagged, and is reversible. No big-bang.
-
-### Phase 0 — Foundation (human: ~1 wk / CC: ~4 h)
-- Define `Resolver<I,O>`, `ResolverContext`, `ResolverRegistry`, `ResolverResult` (§3.2–3.4).
-- Add `src/core/resolvers/index.ts` wiring + tests for registry (register/get/list).
-- No behavioral change; ship as `v0.11.0-alpha` with feature flag.
-
-### Phase 1 — Three reference resolvers (human: ~1 wk / CC: ~4 h)
-- Port `src/core/embedding.ts` → `resolvers/builtin/embedding/openai.ts`.
-- Implement `resolvers/builtin/brain-local/slug-lookup.ts` (wraps `engine.resolveSlugs`).
-- Implement `resolvers/builtin/url-reachable.ts` (HEAD-check).
-- Prove the interface: old callers swap to `registry.resolve('openai_embedding', ...)`.
-
-### Phase 2 — BrainWriter + Slug Registry (human: ~1.5 wk / CC: ~6 h)
-- L4 core: `BrainWriter.transaction`, `Scaffolder`, `SlugRegistry` with conflict detection.
-- Pre-write validators: citation, link, back-link, triple-HR.
-- Migrate `src/commands/publish.ts` + `src/commands/backlinks.ts` to route through BrainWriter.
-- **Now** Garry's OpenClaw's "Philip Leung" hallucination is structurally impossible — LLM output passes through JSON-Schema validator before reaching Scaffolder.
-
-### Phase 3 — `gbrain integrity` command (human: ~0.5 wk / CC: ~2 h)
-- Ship the originally-scoped user-facing feature on top of the new foundation.
-- Uses Resolver SDK: `x_handle_to_tweet` + `url_reachable`.
-- Uses BrainWriter: all auto-repairs go through validated writes.
-- `--auto --confidence 0.8` mode as user approved in cherry-pick #1.
-- **User-visible value ships in Phase 3, not Phase 7.**
-
-### Phase 4 — Enrichment Orchestrator (human: ~2 wk / CC: ~8 h)
-- L2 core: `EnrichmentOrchestrator`, `BudgetLedger`, `CompletenessScorer`, `EntityGraph.cascadeFrom`.
-- Migrate `src/core/enrichment-service.ts` callers (deprecate the old file after).
-- Completeness score in frontmatter on every write (dogfooding cascades).
-
-### Phase 5 — Scheduler (human: ~2 wk / CC: ~8 h)
-- L3 core: `Scheduler`, `ScheduledResolver`, `DurableState`, circuit breaker, quiet-hours enforcer.
-- Migrate `src/commands/autopilot.ts` to a ScheduledResolver set.
-- Ship `gbrain schedule list|run|pause|tail` CLI for observability.
-
-### Phase 6 — Port 5–8 OpenClaw resolvers (human: ~1.5 wk / CC: ~6 h)
-- `perplexity_query`, `text_to_entities`, `mistral_ocr_pdf`, `x_search_all`, `x_user_to_tweets`, `gmail_query_to_threads`, `calendar_date_to_events`.
-- Each ships as YAML + TS module under `resolvers/builtin/` — **proof of the plugin format.**
-
-### Phase 7 — OpenClaw Adoption Integration (human: ~1 wk / CC: ~4 h)
-- Write `docs/openclaw/ADOPTION.md` showing your OpenClaw how to replace its 69 bespoke scripts with calls to `gbrain registry.resolve(...)`.
-- Ship a `gbrain claw-bridge` subcommand that proxies Garry's OpenClaw's current script invocations to the resolver registry — zero-edit adoption path.
-- **This is the test of the north star.** If your OpenClaw can stand up a 1-line shim and drop `scripts/x-api-client.mjs`, the abstraction succeeded.
-
-Total: human: ~10 weeks / CC: ~42 hours / calendar with single implementer: ~3–4 weeks.
-
----
-
-## 9. Critical Files
-
-### New directories / files
-
-```
-src/core/
-  runtime/
-    index.ts                       # RuntimeContext (engine, storage, config, logger, metrics, budget)
-    registry.ts                    # ResolverRegistry
-    factory.ts                     # createResolver()
-  resolvers/
-    interface.ts                   # Resolver<I, O>
-    fail-improve-wrapper.ts        # auto-wraps every resolver in FailImproveLoop
-    builtin/
-      x-api/
-        handle-to-tweet.ts
-        handle-to-tweet.yaml
-      perplexity/
-        query.ts
-        query.yaml
-      brain-local/
-        slug-lookup.ts
-        url-reachable.ts
-      embedding/
-        openai.ts                  # refactored from src/core/embedding.ts
-      transcription/
-        groq.ts
-        openai.ts
-  enrichment/
-    orchestrator.ts                # EnrichmentOrchestrator
-    tiers.ts                       # TIER_CONFIG
-    budget.ts                      # BudgetLedger
-    completeness.ts                # CompletenessScorer + per-type rubrics
-    cascade.ts                     # EntityGraph
-  scheduling/
-    scheduler.ts                   # Scheduler + ScheduledResolver
-    schedule.ts                    # Schedule type, cron expr parser
-    state.ts                       # DurableState primitives
-    quiet-hours.ts                 # TZ-aware enforcement
-    stagger.ts                     # deterministic slot assignment
-  output/
-    writer.ts                      # BrainWriter
-    scaffold.ts                    # Scaffolder (typed URL builders)
-    slug-registry.ts               # SlugRegistry (conflict detection)
-    validators/
-      citation.ts
-      link.ts
-      back-link.ts
-      triple-hr.ts
-
-src/commands/
-  integrity.ts                     # ships in Phase 3, replaces Feynman Phase A/B
-  schedule.ts                      # gbrain schedule list|run|pause|tail (Phase 5)
-
-docs/openclaw/
-  ADOPTION.md                      # written in Phase 7
-```
-
-### Replaced / removed
-- `src/core/enrichment-service.ts` — folded into `enrichment/orchestrator.ts`
-- `src/core/embedding.ts` — moved into `resolvers/builtin/embedding/openai.ts`
-- `src/core/transcription.ts` — moved into `resolvers/builtin/transcription/`
-
-### Extended
-- `src/core/engine.ts` — add `getResolverRegistry()`, `getWriter()`, `getScheduler()`
-- `src/core/operations.ts` — unify with ResolverContext; every operation validator reusable by resolvers
-- `src/core/types.ts` — add `completeness: number`, `sourcedBy: string[]`, `lastVerified: Date`
-
----
-
-## 10. Testing Strategy
-
-### Contract tests
-Every Resolver implementation tested against the interface spec. Table-driven: run the same suite against `openai_embedding`, `x_handle_to_tweet`, etc. Ensures plugin authors can't ship broken resolvers.
-
-### Property tests
-- **Idempotency:** running a ScheduledResolver twice with the same state produces the same output and doesn't double-write.
-- **Atomicity:** a BrainWriter transaction that throws mid-flight leaves the brain bit-for-bit identical to pre-transaction.
-- **Deterministic scaffolds:** given the same resolver outputs, the Scaffolder produces byte-identical citations/links.
-
-### Integration tests
-- `EnrichmentOrchestrator` end-to-end against PGLite (in-memory, no API keys) with mocked resolver registry.
-- `Scheduler` with fake clock + quiet-hours scenarios.
-- BrainWriter transaction rollback on validator failure.
-
-### Chaos tests
-- Kill the process mid-enrichment; next run must resume cleanly.
-- Simulate API timeout mid-transaction; transaction must roll back completely.
-- Corrupted state file; scheduler must escalate, not silently skip.
-
-### Regression tests vs. Garry's OpenClaw behavior
-For each OpenClaw pattern we port (e.g. X-handle → tweet URL), a regression test proves the new resolver produces the same answer on real-world inputs from the brain audit. This is the "your OpenClaw would adopt" proof.
-
----
-
-## 11. Open Questions (flagged for CEO re-review)
-
-1. **Scope shape.** Is this the right four-layer decomposition, or are some layers better left to OpenClaw (e.g. Scheduling lives above GBrain, not in it)?
-2. **Phase 3 user-value break.** Does Phase 3 (user-visible `gbrain integrity`) ship early enough, or do we need an even smaller MVP?
-3. **LLM-as-resolver.** Should `text_to_entities` be a Resolver, or does that blur the "code vs LLM" line the invariant relies on?
-4. **Plugin format.** YAML + TS module (§3.5) vs. pure TS module with decorator-style metadata. Latter is more type-safe; former is more discoverable.
-5. **Cross-resolver transactions.** Do we support "atomic fetch-from-Perplexity + write-to-brain" at the L2 layer? Current design says yes; implementation is tricky (Perplexity call isn't rollbackable).
-6. **OpenClaw bridge scope.** Phase 7 `gbrain claw-bridge` — is that worth a phase of its own, or should adoption be documentation-only?
-7. **Completeness rubric coverage.** Do we define rubrics for all 9 PageTypes upfront, or ship people/company/meeting first and extend incrementally?
-8. **Budget config UX.** Hard daily cap is strict; should we also expose a soft-cap warning mode, and how is the cap set (env var? config file? prompt on first use?)
-9. **Backwards compat.** `src/commands/publish.ts` and `src/commands/backlinks.ts` have been running cleanly for weeks. Refactoring through BrainWriter carries migration risk. Acceptable?
-10. **Existing TODOS alignment.** `TODOS.md` has P0 "Runtime MCP access control" and P2 security hardening. The new RuntimeContext.remote flag interacts with both — do we fold MCP access control into Phase 0 or keep separate?
-
----
-
-## 12. Verification (the "your OpenClaw would adopt" test)
-
-The design succeeds iff:
-
-- [ ] A user can add a new resolver by dropping a YAML + TS module in `~/.gbrain/resolvers/` without editing GBrain source.
-- [ ] Your OpenClaw can delete `scripts/x-api-client.mjs` and replace all callers with 1-line `await registry.resolve('x_handle_to_tweet', ...)`.
-- [ ] No brain page can be written with a bare tweet reference, a missing back-link, or an unverified URL (validators catch it pre-commit).
-- [ ] Running `gbrain integrity --auto --confidence 0.8` over a real brain fixes ≥1,000 of the 1,424 known bare-tweet citations without human review.
-- [ ] Full E2E test suite passes on both PGLite + Postgres engines.
-- [ ] The Knowledge Runtime ships across 7 phases with each phase individually shippable and reversible.

docs/designs/MINIONS_AGENT_ORCHESTRATION.md

@@ -1,448 +0,0 @@
----
-status: ACTIVE
----
-# CEO Plan: Minions as Universal Agent Orchestration Protocol
-Generated by /plan-ceo-review on 2026-04-15
-Branch: garrytan/minions-jobs | Mode: SCOPE EXPANSION
-Repo: garrytan/gbrain
-
-## Vision
-
-### 10x Check
-Instead of "GBrain has a queue, OpenClaw uses it," make Minions a universal agent
-orchestration protocol. Any platform (OpenClaw, Hermes, Claude Code, Codex, custom
-scripts) submits, monitors, steers, and composes agents through the same Postgres-native
-protocol. GBrain IS the agent control plane.
-
-### Platonic Ideal (aspirational North Star, NOT in v1 scope)
-Open a terminal, type `gbrain jobs dashboard`. See every agent across every platform.
-Their progress, tool calls, token spend. Click any agent for full execution trace.
-Type a message to redirect a running agent mid-flight. See the governor's decisions
-visualized. Run A/B tests between agent configurations. The feeling: complete
-situational awareness of your AI workforce.
-
-**Note:** The dashboard, A/B testing, and visual governor are future phases. This plan
-builds the primitives they would sit on top of: real-time events, structured progress,
-token accounting, inbox with ack, and session transcripts.
-
-## Scope Decisions
-
-| # | Proposal | Effort | Decision | Reasoning |
-|---|----------|--------|----------|-----------|
-| 1 | pg LISTEN/NOTIFY real-time events | S | ACCEPTED | Sub-second event delivery vs 5s polling. Every platform benefits. |
-| 2 | Structured progress protocol | S | ACCEPTED | Standard progress makes unified dashboard possible. |
-| 3 | Job cost tracking (token accounting) | M | ACCEPTED | Token cost is #1 thing users want to know about agent work. |
-| 4 | Job replay | S | ACCEPTED | Small surface area, high utility for debugging failures. |
-| 5 | Job groups / waves | M | DEFERRED | Parent-child already provides grouping. Overlap concern. |
-| 6 | Inbox acknowledgment (read receipts) | S | ACCEPTED | Without it, inbox is fire-and-forget — same problem we're fixing. |
-| 7 | Universal agent protocol | S | ACCEPTED | Design framing, not extra code. Platform-agnostic naming/docs. |
-| 8 | Session transcript capture | M | ACCEPTED | Full audit trail of every agent run. |
-
-## Accepted Scope — Implementation Detail
-
-### 0a. Pause/resume (from base plan)
-
-**Schema:** Add `'paused'` to `MinionJobStatus` (already in migration v6 constraint).
-
-**New methods:**
-- `MinionQueue.pauseJob(id): MinionJob | null`
-  Transitions `waiting` or `active` → `paused`. For `active` jobs, clears `lock_token`
-  and `lock_until` (worker will detect lock loss and stop). Returns null if job not
-  in pausable state.
-- `MinionQueue.resumeJob(id): MinionJob | null`
-  Transitions `paused` → `waiting`. Resets for claiming. Returns null if not paused.
-
-**Worker integration:** Worker's lock renewal loop checks `isActive()`. When a job
-is paused, the lock is cleared, so `renewLock()` returns false and the worker stops
-execution gracefully (same path as stall detection). The job's progress and state
-are preserved in the DB for when it resumes.
-
-**MCP operations:** `pause_job`, `resume_job` (added in Step 3 of implementation plan).
-
-**PGLite compatibility:** Full.
-
-### 0b. Resource governor (from base plan)
-
-**New file:** `src/core/minions/governor.ts`
-
-```typescript
-interface GovernorConfig {
-  maxConcurrency: number;       // ceiling
-  minConcurrency: number;       // floor (default 1)
-  checkIntervalMs: number;      // default 10000
-  cpuThreshold: number;         // default 0.80 (80%)
-  memoryThreshold: number;      // default 0.85 (85%)
-  circuitBreakerMemory: number; // default 0.90 (90%)
-}
-
-class ResourceGovernor {
-  getEffectiveConcurrency(): number;  // current allowed concurrency
-  start(): void;                       // begin polling system metrics
-  stop(): void;                        // stop polling
-  onCircuitBreak(cb: (jobId) => void): void; // kill callback
-}
-```
-
-**System metrics:** Reuse `getSystemLoad()` from `src/core/backoff.ts` (already
-implements CPU and memory checks). Add event loop lag measurement via
-`perf_hooks.monitorEventLoopDelay()`.
-
-**Worker integration:** `MinionWorker.start()` consults `governor.getEffectiveConcurrency()`
-before claiming new jobs. If current in-flight count >= effective concurrency, skip claim.
-
-**Circuit breaker:** If memory > 90%, governor calls `onCircuitBreak` with the
-lowest-priority active job ID. Worker cancels that job via `failJob()` with
-`UnrecoverableError("circuit breaker: memory pressure")`.
-
-**Prerequisite:** Concurrent job processing must be implemented first (see
-Concurrency Note below).
-
-**PGLite compatibility:** Full (governor is app-level, not DB-level).
-
-### 1. pg LISTEN/NOTIFY (real-time events)
-
-**Schema:** No new columns. Add NOTIFY triggers to state transitions.
-
-**SQL trigger:**
-```sql
-CREATE OR REPLACE FUNCTION notify_minion_job_change() RETURNS trigger AS $$
-BEGIN
-  PERFORM pg_notify('minion_jobs', json_build_object(
-    'id', NEW.id, 'status', NEW.status, 'name', NEW.name,
-    'queue', NEW.queue, 'prev_status', COALESCE(OLD.status, 'new')
-  )::text);
-  RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER minion_job_notify AFTER INSERT OR UPDATE OF status ON minion_jobs
-  FOR EACH ROW EXECUTE FUNCTION notify_minion_job_change();
-```
-
-**New method:** `MinionQueue.subscribe(callback: (event) => void): () => void`
-Returns unsubscribe function. Requires direct Postgres connection (NOT pooled).
-
-**PGLite compatibility:** PGLite does NOT support LISTEN/NOTIFY. Fallback: polling
-via `getJob()` at configurable interval (default 2s). The `subscribe()` method
-detects engine type and uses polling fallback automatically.
-
-**Supabase constraint:** Requires direct connection (port 5432), not pgBouncer
-pooler (port 6543). Document in skill file and setup guide.
-
-### 2. Structured progress protocol
-
-**TypeScript interface (convention, not enforced at DB level):**
-```typescript
-interface AgentProgress {
-  step: number;           // current step (1-based)
-  total: number;          // total expected steps (0 = unknown)
-  message: string;        // human-readable status
-  tokens_in: number;      // cumulative input tokens
-  tokens_out: number;     // cumulative output tokens
-  last_tool: string;      // name of last tool called
-  started_at: string;     // ISO 8601 when this step started
-}
-```
-
-**Storage:** Existing `progress JSONB` column. No schema change needed.
-Handlers use `ctx.updateProgress(agentProgress)`. Non-agent jobs can use
-any JSONB shape (backward compatible).
-
-**Validation:** `updateProgress()` accepts any JSONB. The `AgentProgress`
-interface is a convention enforced by the agent handler, not by the queue.
-
-### 3. Job cost tracking (token accounting)
-
-**Schema changes (migration v6):**
-```sql
-ALTER TABLE minion_jobs ADD COLUMN tokens_input INTEGER DEFAULT 0;
-ALTER TABLE minion_jobs ADD COLUMN tokens_output INTEGER DEFAULT 0;
-ALTER TABLE minion_jobs ADD COLUMN tokens_cache_read INTEGER DEFAULT 0;
-ALTER TABLE minion_jobs ADD COLUMN cost_usd NUMERIC(10,6) DEFAULT 0;
-```
-
-**New method:** `MinionQueue.updateTokens(id, lockToken, { input, output, cache_read, cost_usd })`
-Accumulates (adds to existing values, does not replace).
-
-**Parent rollup:** When `completeJob()` is called, if `parent_job_id` is set,
-add this job's token counts to the parent's via:
-```sql
-UPDATE minion_jobs SET
-  tokens_input = tokens_input + $child_input,
-  tokens_output = tokens_output + $child_output,
-  tokens_cache_read = tokens_cache_read + $child_cache,
-  cost_usd = cost_usd + $child_cost
-WHERE id = $parent_id;
-```
-
-**PGLite compatibility:** Full support (standard columns).
-
-### 4. Job replay
-
-**New method:** `MinionQueue.replayJob(id, dataOverrides?: Record<string, unknown>): MinionJob`
-
-Implementation: Read the completed/failed/dead job. Create a NEW job with:
-- Same `name`, `queue`, `priority`, `max_attempts`, `backoff_type`, `backoff_delay`
-- `data` = deep merge of original data + overrides
-- Fresh `attempts_made: 0`, `status: 'waiting'`
-- `parent_job_id` = null (replay is a new top-level job, not a child)
-- Does NOT clone children (replay is a single job, not a DAG)
-
-**Constraint:** Only works on terminal statuses (completed/failed/dead).
-Returns the new job record.
-
-**Idempotency:** Each replay creates a distinct new job. No deduplication.
-If the original had side effects, the replay may repeat them. Document this
-in the skill file as a user responsibility.
-
-### 5. Inbox (sidechannel messaging)
-
-**Schema changes (migration v6):**
-```sql
-ALTER TABLE minion_jobs ADD COLUMN inbox JSONB DEFAULT '[]';
-```
-
-**Inbox message format:**
-```typescript
-interface InboxMessage {
-  id: string;          // UUIDv4
-  sent_at: string;     // ISO 8601
-  read_at: string | null;  // null until worker reads it
-  sender: string;      // 'parent' | 'user' | job ID
-  payload: unknown;    // arbitrary directive
-}
-```
-
-**New methods:**
-- `MinionQueue.sendMessage(jobId, payload, sender?): InboxMessage`
-  Appends message to inbox array via atomic JSONB append
-  (`inbox = inbox || $1::jsonb`), not read-modify-write. Returns the message with id + sent_at.
-- `MinionQueue.readInbox(jobId, lockToken): InboxMessage[]`
-  Returns unread messages (read_at = null). Marks them as read (sets read_at).
-  Token-fenced: only the worker holding the lock can read.
-
-**Worker integration:** Agent handler calls `readInbox()` on each iteration.
-If messages exist, injects them into the agent's context as system messages.
-
-**PGLite compatibility:** Full support (standard JSONB column).
-
-### 6. Inbox acknowledgment (read receipts)
-
-Built into the inbox design above. The `read_at` field on each `InboxMessage`
-provides the receipt. `sendMessage()` returns the message ID; the sender can
-later check `getJob(id)` and inspect `inbox` to see which messages have been
-read.
-
-No additional schema or methods needed beyond what's in #5.
-
-### 7. Universal agent protocol (platform-agnostic framing)
-
-**This is a design decision, not code.** It means:
-
-1. The skill file (`skills/minion-orchestrator/SKILL.md`) is written for ANY
-   agent platform, not just OpenClaw. Examples show MCP tool calls, not
-   OpenClaw-specific commands.
-
-2. The agent handler (`agent-handler.ts`) accepts a generic interface:
-   ```typescript
-   interface AgentJobData {
-     prompt: string;
-     tools?: string[];        // MCP tool names
-     model?: string;          // e.g., 'claude-opus-4-6', 'gpt-4o'
-     context?: string;        // additional context
-     platform?: string;       // 'openclaw' | 'hermes' | 'claude-code' | 'custom'
-     max_iterations?: number; // agent loop budget
-   }
-   ```
-
-3. The OpenClaw plugin is ONE consumer. Hermes, Claude Code extensions,
-   or custom scripts can submit `agent` jobs through the same MCP operations.
-
-4. **NOT in v1 scope:** Multi-tenant auth, cross-network connectivity,
-   protocol versioning, API key isolation. These are Phase 2 concerns when
-   actual multi-platform usage materializes. v1 is single-user, single-brain.
-
-### Agent Handler Architecture (critical design decision)
-
-The agent handler does NOT live in GBrain. GBrain provides the queue infrastructure
-and a clean handler contract. The actual agent execution lives in the platform plugin.
-
-```
-GBrain (this repo):
-  MinionQueue  — queue/claim/complete/inbox/tokens/NOTIFY
-  MinionWorker — poll/lock/stall/governor framework
-  Handler contract — AgentJobData interface + MinionJobContext
-
-OpenClaw plugin (separate repo):
-  Registers "agent" handler with MinionWorker
-  Handler calls OpenClaw's PI agent core (the actual LLM loop)
-  Each iteration: readInbox → inject as system message, updateProgress, updateTokens
-  Completion: store result + session transcript in job.result + job.stacktrace
-
-GBrain ships a test/echo handler for unit testing only.
-```
-
-**Handler contract (GBrain side):**
-```typescript
-// The handler receives this context (already exists in worker.ts)
-interface MinionJobContext {
-  id: number;
-  name: string;
-  data: Record<string, unknown>;  // AgentJobData when name="agent"
-  attempts_made: number;
-  updateProgress(progress: unknown): Promise<void>;
-  updateTokens(tokens: TokenUpdate): Promise<void>;  // NEW
-  log(message: string | TranscriptEntry): Promise<void>;
-  isActive(): Promise<boolean>;
-  readInbox(): Promise<InboxMessage[]>;  // NEW
-}
-```
-
-**Why this is right:** GBrain is orchestration, not execution. OpenClaw has the
-PI agent core. Hermes has AIAgent. Claude Code has its own loop. Each platform
-brings its own engine and registers a handler. GBrain manages lifecycle, progress,
-steering, cost tracking, and persistence around it.
-
-### 8. Session transcript capture
-
-**Extends existing stacktrace mechanism.** The `stacktrace` field (JSONB array
-of strings) already captures log messages. Session transcripts use the same
-field with structured entries:
-
-```typescript
-type TranscriptEntry =
-  | { type: 'log'; message: string; ts: string }
-  | { type: 'tool_call'; tool: string; args_size: number; result_size: number; ts: string }
-  | { type: 'llm_turn'; model: string; tokens_in: number; tokens_out: number; ts: string }
-  | { type: 'error'; message: string; stack?: string; ts: string };
-```
-
-**Storage:** Existing `stacktrace JSONB` column. No schema change.
-The agent handler appends `TranscriptEntry` objects instead of plain strings.
-Backward compatible: non-agent jobs continue appending strings.
-
-**Size concern:** Long agent runs could generate large transcripts. Add a
-`max_transcript_entries` option (default 1000) that rotates oldest entries
-when exceeded (FIFO). The full transcript for forensic analysis can be
-stored as a brain file via `gbrain files upload-raw`.
-
-## Schema Migration v6
-
-All schema changes are additive (ALTER TABLE ADD COLUMN). No backfill needed.
-Existing jobs continue to work with default values.
-
-```sql
--- Migration v6: Agent orchestration primitives
-ALTER TABLE minion_jobs ADD COLUMN IF NOT EXISTS tokens_input INTEGER DEFAULT 0;
-ALTER TABLE minion_jobs ADD COLUMN IF NOT EXISTS tokens_output INTEGER DEFAULT 0;
-ALTER TABLE minion_jobs ADD COLUMN IF NOT EXISTS tokens_cache_read INTEGER DEFAULT 0;
-
--- Separate inbox table (not JSONB on job row)
-CREATE TABLE IF NOT EXISTS minion_inbox (
-  id SERIAL PRIMARY KEY,
-  job_id INTEGER NOT NULL REFERENCES minion_jobs(id) ON DELETE CASCADE,
-  sender TEXT NOT NULL,
-  payload JSONB NOT NULL,
-  sent_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-  read_at TIMESTAMPTZ
-);
-CREATE INDEX IF NOT EXISTS idx_minion_inbox_unread
-  ON minion_inbox (job_id) WHERE read_at IS NULL;
-
--- Status constraint update: add 'paused'
-ALTER TABLE minion_jobs DROP CONSTRAINT IF EXISTS minion_jobs_status_check;
-ALTER TABLE minion_jobs ADD CONSTRAINT minion_jobs_status_check
-  CHECK (status IN ('waiting','active','completed','failed','delayed','dead','cancelled','waiting-children','paused'));
-
--- NOTIFY trigger for real-time events (Postgres only, not PGLite)
-CREATE OR REPLACE FUNCTION notify_minion_job_change() RETURNS trigger AS $$
-BEGIN
-  PERFORM pg_notify('minion_jobs', json_build_object(
-    'id', NEW.id, 'status', NEW.status, 'name', NEW.name,
-    'queue', NEW.queue, 'prev_status', COALESCE(OLD.status, 'new')
-  )::text);
-  RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER minion_job_notify AFTER INSERT OR UPDATE OF status ON minion_jobs
-  FOR EACH ROW EXECUTE FUNCTION notify_minion_job_change();
-```
-
-## PGLite Compatibility Matrix
-
-| Feature | Postgres | PGLite | Fallback |
-|---|---|---|---|
-| Pause/resume | Full | Full | — |
-| Inbox + ack | Full | Full | — |
-| Token accounting | Full | Full | — |
-| Job replay | Full | Full | — |
-| LISTEN/NOTIFY | Full | NO | Polling (2s interval) |
-| NOTIFY trigger | Full | NO | Skipped in PGLite schema |
-| Structured progress | Full | Full | — |
-| Session transcripts | Full | Full | — |
-| Resource governor | Full | Full | — |
-| Worker daemon | Full | NO (existing limitation) | — |
-
-## Concurrency Note
-
-The current `MinionWorker.start()` processes jobs sequentially (one at a time)
-despite `concurrency` being declared in `MinionWorkerOpts`. Implementing actual
-concurrent job processing (Promise pool) is a prerequisite for the resource
-governor to be meaningful. The governor adjusts effective concurrency, which
-requires actual concurrent processing to exist.
-
-**Action:** Implement concurrent job processing in `worker.ts` before or as
-part of the governor step. Use a semaphore pattern: maintain up to N in-flight
-promises, claim new jobs as slots free up.
-
-## Outside Voice Decisions (from adversarial review)
-
-1. **AbortController for pause/resume** — Handler contract gets `signal: AbortSignal`.
-   Pause clears lock AND signals abort. Handler must check `signal.aborted` on each
-   iteration. Without this, pausing active jobs creates duplicate execution.
-
-2. **Drop cost_usd column** — Token counts (input/output/cache_read) are stable facts.
-   USD pricing is volatile. Compute cost at display/read time from a pricing table,
-   not at write time. Removes `cost_usd NUMERIC(10,6)` from migration v6.
-
-3. **Separate minion_inbox table** — Instead of JSONB array on job row, use a dedicated
-   table for inbox messages. Avoids row bloat from rewriting entire inbox on every send.
-   Properly concurrent-safe with standard INSERT (no JSONB append concerns).
-   ```sql
-   CREATE TABLE minion_inbox (
-     id SERIAL PRIMARY KEY,
-     job_id INTEGER NOT NULL REFERENCES minion_jobs(id) ON DELETE CASCADE,
-     sender TEXT NOT NULL,
-     payload JSONB NOT NULL,
-     sent_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-     read_at TIMESTAMPTZ
-   );
-   CREATE INDEX idx_minion_inbox_unread ON minion_inbox (job_id) WHERE read_at IS NULL;
-   ```
-
-4. **One release, not two** — Ship all features in one migration (v6). User prefers
-   cohesive release over incremental delivery for this feature set.
-
-5. **Selective column projection** — Fix SELECT * queries in getJobs(), claim(),
-   handleStalled() to exclude stacktrace column. Include stacktrace only in getJob()
-   detail view. Prevents transcript bloat from affecting query performance.
-
-## Future Phases (accepted trajectory)
-
-- **Phase 2: Dashboard CLI** — `gbrain jobs dashboard` live TUI showing all agents.
-  Enabled by: LISTEN/NOTIFY, structured progress, token accounting.
-- **Phase 3: Multi-tenant auth** — Runtime MCP access control, per-platform API keys.
-  Enabled by: platform-agnostic framing, sender validation on inbox.
-- **Phase 4: Agent composition patterns** — Map-reduce, pipeline, approval gates as
-  first-class primitives. Enabled by: parent-child DAGs, inbox sidechannel.
-
-## Deferred to TODOS.md
-- Job groups / waves (parent-child covers this; revisit if real grouping need emerges)
-- cost_usd column (compute from pricing table at read time when pricing API exists)
-
-## Key Premises Confirmed
-1. GBrain is intentionally evolving from knowledge brain to agent infrastructure (user confirmed)
-2. Coupling between OpenClaw and GBrain's Postgres is acceptable (OpenClaw already depends on GBrain)
-3. Full Infrastructure approach (all 8+ steps) selected over Minimal Viable or Sidecar Tracking
-4. Prior learning [agent-dx-instruction-layer] validates that the teaching layer (skill + evals) is mandatory

docs/guides/minions-deployment-snippets/Procfile

@@ -1,10 +0,0 @@
-# Procfile — Render / Railway / Heroku.
-#
-# Fly.io users: see fly.toml.partial instead.
-#
-# Set secrets via the platform's env UI or CLI (e.g. `heroku config:set`,
-# `render env:set`, `railway variables set`). At minimum:
-#   DATABASE_URL=postgresql://...
-#   GBRAIN_ALLOW_SHELL_JOBS=1   # only if submitting shell jobs
-
-worker: gbrain jobs work --concurrency 2

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

@@ -1,22 +0,0 @@
-# fly.toml — partial. Merge into your existing fly.toml.
-#
-# Set secrets once (never commit them):
-#   fly secrets set DATABASE_URL='postgresql://user:pass@host:6543/db?prepare=false'
-#   fly secrets set GBRAIN_ALLOW_SHELL_JOBS=1   # only if submitting shell jobs
-#   fly secrets set ANTHROPIC_API_KEY=...       # optional
-#
-# Fly.io auto-restarts the process on crash — no watchdog needed.
-
-[processes]
-  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).
-#   fly scale count worker=1
-
-# If you want the worker in its own VM size:
-# [[vm]]
-#   processes = ["worker"]
-#   memory = "512mb"
-#   cpu_kind = "shared"
-#   cpus = 1

docs/guides/minions-deployment-snippets/gbrain.env.example

@@ -1,35 +0,0 @@
-# /etc/gbrain.env — secrets + env for the gbrain worker.
-#
-# Install:
-#   sudo install -m 600 -o $GBRAIN_WORKER_USER -g $GBRAIN_WORKER_USER \
-#     gbrain.env.example /etc/gbrain.env
-#   sudoedit /etc/gbrain.env   # fill in real values
-#
-# Referenced from crontab via BASH_ENV=/etc/gbrain.env, or from systemd
-# via EnvironmentFile=/etc/gbrain.env. Never commit real secrets.
-
-# --- Required ---------------------------------------------------------------
-
-# Postgres connection string. For Supabase transaction pooler, include
-# prepare=false (see CLAUDE.md #284/#286).
-DATABASE_URL=postgresql://user:pass@host:6543/db?prepare=false
-
-# --- Required if you submit `shell` jobs ------------------------------------
-# Only the worker process needs this. Submitters do not.
-GBRAIN_ALLOW_SHELL_JOBS=1
-
-# --- Optional ---------------------------------------------------------------
-
-# LLM provider keys (needed for `subagent` handler, transcription, enrichment).
-# ANTHROPIC_API_KEY=
-# OPENAI_API_KEY=
-
-# Custom handler plugins (see docs/guides/plugin-handlers.md).
-# GBRAIN_PLUGIN_PATH=/etc/gbrain/plugins
-
-# Pool size tuning for Supabase transaction pooler (default 10; drop to 2
-# if you hit MaxClients during upgrade subprocess spawns).
-# GBRAIN_POOL_SIZE=2
-
-# Connection-level concurrency cap for Anthropic Messages API.
-# GBRAIN_ANTHROPIC_MAX_INFLIGHT=4

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

@@ -1,68 +0,0 @@
-#!/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

@@ -1,44 +0,0 @@
-[Unit]
-Description=gbrain minion worker
-Documentation=https://github.com/garrytan/gbrain/blob/master/docs/guides/minions-deployment.md
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-# Runs as an unprivileged user that owns the brain repo and any shell-job cwds.
-# Create with: sudo useradd --system --home /srv/gbrain --shell /usr/sbin/nologin gbrain
-User=gbrain
-Group=gbrain
-WorkingDirectory=/srv/gbrain
-
-# Env file is mode 600, owned by User=. Do not put secrets in this unit.
-EnvironmentFile=/etc/gbrain.env
-
-ExecStart=/usr/local/bin/gbrain jobs work --concurrency 2
-
-# Replaces the cron watchdog. systemd restarts on any non-zero exit.
-Restart=always
-RestartSec=10s
-
-# Graceful shutdown: SIGTERM → wait → SIGKILL. 30s matches worker grace
-# for in-flight jobs and the shell handler's 5s child SIGTERM window.
-KillSignal=SIGTERM
-TimeoutStopSec=30s
-
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=gbrain-worker
-
-# Default 1024 is tight for Bun + Postgres pool + concurrent subagent LLM calls.
-LimitNOFILE=65535
-
-# Hardening (optional — remove if they break your deployment).
-NoNewPrivileges=true
-PrivateTmp=true
-ProtectSystem=strict
-ProtectHome=read-only
-ReadWritePaths=/srv/gbrain
-
-[Install]
-WantedBy=multi-user.target

docs/guides/minions-deployment.md

@@ -1,323 +0,0 @@
-# Minions Worker Deployment Guide
-
-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
-
-The persistent worker can die silently from:
-
-- Database connection drops (Supabase/Postgres maintenance or network blips).
-- Lock-renewal failures → the stall detector eventually dead-letters jobs.
-- 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. Nothing in
-gbrain core auto-restarts the worker — that's what this guide wires up.
-
-## Variables used in this guide
-
-Substitute these once before copy-pasting any snippet.
-
-| Variable | Meaning | Typical value |
-|---|---|---|
-| `$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 crontab / systemd | `/etc/gbrain.env` (mode 600) |
-
-## Preconditions
-
-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 (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", fix it first:
-#    gbrain apply-migrations --yes
-gbrain doctor --fast --json | jq '.checks[] | select(.name=="schema_version")'
-
-# 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 (...)".
-```
-
-## Which option?
-
-- 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
-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 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.
-
-### 1b. Install the watchdog script
-
-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
-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
-```
-
-### 1c. Wire into cron
-
-Pick the form that matches the crontab you're editing.
-
-**If you ran `crontab -e`** (user crontab — 5-field, no user column):
-
-```
-SHELL=/bin/bash
-PATH=/usr/local/bin:/usr/bin:/bin
-BASH_ENV=/etc/gbrain.env
-*/5 * * * * /usr/local/bin/minion-watchdog.sh
-```
-
-**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 \
-  --queue nightly-enrich \
-  --params "{\"cmd\":\"$GBRAIN_BIN embed --stale\",\"cwd\":\"$GBRAIN_WORKSPACE\"}" \
-  --follow \
-  --timeout-ms 600000
-```
-
-Replace `gbrain embed --stale` with whichever gbrain subcommand you're
-scheduling (`sync`, `extract`, `orphans`, `doctor`, `check-backlinks`,
-`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.
-
-## Option 3: service manager (systemd / Fly / Render / Railway)
-
-Replaces the watchdog entirely. No cron, no PID file, no restart-loop.
-The service manager owns liveness.
-
-### systemd (Linux hosts 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 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
-
-# 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
-```
-
-`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.
-
-### Fly.io
-
-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, 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
-
-### Supabase connection drops
-
-The worker uses a single Postgres connection. If Supabase drops it
-(maintenance, connection limits, network blip), lock renewal fails
-silently. The stall detector then dead-letters the job after
-`max_stalled` misses.
-
-**Current defaults that make this worse:**
-
-- `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`,
-`--backoff-type fixed|exponential`, `--backoff-delay <ms>`,
-`--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`
-
-It's a no-op. The stall detector reads the row's `max_stalled` column
-(set at submit time), not the worker opt in `src/core/minions/worker.ts:74`.
-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 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
-# Worker alive?
-kill -0 $(head -n1 /tmp/gbrain-worker.pid) 2>/dev/null && echo ALIVE || echo DEAD
-
-# Aggregate queue health.
-gbrain jobs stats
-
-# Jobs currently stalled (still `active` with expired lock_until, pre-requeue).
-gbrain jobs list --status active --limit 10
-
-# Dead-lettered jobs.
-gbrain jobs list --status dead --limit 10
-
-# Shell handler registered? (stderr banner merged into log via 2>&1.)
-grep "shell handler enabled" /tmp/gbrain-worker.log
-```
-
-## Uninstall
-
-- **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/minions-fix.md

@@ -1,159 +0,0 @@
-# Minions fix — repairing a half-migrated install
-
-**tl;dr:** on v0.11.1+ everything should self-heal. If Minions is partially
-set up (no `~/.gbrain/preferences.json`, autopilot still inline, cron jobs
-still on `agentTurn`), run:
-
-```bash
-gbrain apply-migrations --yes
-```
-
-It's idempotent. On v0.11.1 installs that already migrated it's a cheap
-no-op.
-
-## Context
-
-v0.11.0 shipped the Minions schema, queue, worker, and migration skill —
-but the migration skill itself never fired on upgrade. `runPostUpgrade`
-printed the feature pitch and stopped. v0.11.0 was never released
-publicly; v0.11.1 is the first public Minions ship and fixes the
-mega-bug (migration fires automatically on `gbrain upgrade` and via
-the `postinstall` hook).
-
-If you're on a pre-v0.11.1 branch build (e.g. running the
-`minions-jobs` branch before v0.11.1 tagged), Minions may be installed
-but not wired: schema is v7, but no `~/.gbrain/preferences.json`,
-autopilot still runs inline, cron jobs still call `agentTurn`.
-
-This guide covers both paths: the canonical v0.11.1+ fix, and the
-stopgap for pre-v0.11.1 binaries that don't have `apply-migrations`.
-
-## Detecting the half-migrated state
-
-```bash
-gbrain doctor
-```
-
-If the install is half-migrated, you'll see:
-
-```
-[FAIL] minions_migration: MINIONS HALF-INSTALLED (partial migration: 0.11.0). Run: gbrain apply-migrations --yes
-```
-
-or
-
-```
-[FAIL] minions_config: MINIONS HALF-INSTALLED (schema v7+ but no ~/.gbrain/preferences.json). Run: gbrain apply-migrations --yes
-```
-
-For a machine-readable report (cron-friendly):
-
-```bash
-gbrain skillpack-check --quiet && echo healthy || echo needs_action
-gbrain skillpack-check | jq -r '.actions[]'    # prints the exact commands to run
-```
-
-## The fix (v0.11.1 or later)
-
-```bash
-gbrain apply-migrations --yes
-```
-
-Reads `~/.gbrain/migrations/completed.jsonl`, diffs against the TS
-migration registry, runs whatever's pending. Seven phases:
-
-```
-A. Schema        gbrain init --migrate-only
-B. Smoke         gbrain jobs smoke
-C. Mode          prompt (or --yes default pain_triggered)
-D. Prefs         write ~/.gbrain/preferences.json
-E. Host          AGENTS.md marker injection + cron rewrites for gbrain
-                 builtins; JSONL TODOs for host-specific handlers
-F. Install       gbrain autopilot --install (env-aware)
-G. Record        append completed.jsonl status:"complete"
-```
-
-If Phase E emits TODOs for host-specific handlers (e.g. your OpenClaw's
-~29 non-gbrain crons), the migration finishes with `status: "partial"`.
-Your host agent walks the TODOs using `skills/migrations/v0.11.0.md` +
-`docs/guides/plugin-handlers.md`, ships handler registrations in the
-host repo, then re-runs `gbrain apply-migrations --yes`. Newly
-registerable cron entries get rewritten and the JSONL rows mark
-`status: "complete"`.
-
-## The stopgap (pre-v0.11.1 binary, no apply-migrations yet)
-
-If you're stuck on a branch build that doesn't have `apply-migrations`:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/garrytan/gbrain/v0.11.1/scripts/fix-v0.11.0.sh | bash
-```
-
-This bash script does what apply-migrations does from a shell environment:
-
-1. `gbrain init --migrate-only` — schema v7.
-2. `gbrain jobs smoke` — verify Minions health.
-3. Prompt for `minion_mode` (defaults `pain_triggered` on non-TTY).
-4. Write `~/.gbrain/preferences.json` atomically.
-5. Append `~/.gbrain/migrations/completed.jsonl` with `status: "partial"`
-   and `apply_migrations_pending: true`. That partial record is the
-   signal to v0.11.1's `apply-migrations` to pick up remaining phases
-   after the user upgrades.
-6. Detect host agent repos and PRINT rewrite instructions (never
-   auto-edits from a curl-piped script).
-7. Print the next step: `Run: gbrain autopilot --install`.
-
-Once v0.11.1 is installed, re-run `gbrain apply-migrations --yes` to
-finish the remaining phases (host rewrites + autopilot install). The
-stopgap's `status: "partial"` record is designed to resume cleanly
-(it doesn't poison the permanent migration path).
-
-## Verify the fix landed
-
-```bash
-# 1. Preferences exist and are readable
-cat ~/.gbrain/preferences.json
-
-# 2. Migration recorded
-cat ~/.gbrain/migrations/completed.jsonl
-
-# 3. Autopilot is supervising a Minions worker child
-gbrain autopilot --status
-ps aux | grep 'jobs work'
-
-# 4. Jobs show up in the queue
-gbrain jobs list
-
-# 5. Any host-specific TODOs still pending
-cat ~/.gbrain/migrations/pending-host-work.jsonl 2>/dev/null || echo "(none — all host work is done)"
-
-# 6. Doctor + skillpack-check should both be clean
-gbrain doctor
-gbrain skillpack-check --quiet && echo ok
-```
-
-## If the fix fails
-
-Each phase is idempotent. Re-running is safe. Common failure modes:
-
-- **Phase B smoke fails:** the schema didn't apply. Check
-  `~/.gbrain/config.json` has a valid `database_url` (or `database_path`
-  for PGLite). Run `gbrain init --migrate-only` directly and look at
-  the error.
-- **Phase F install fails:** your host environment doesn't match any
-  detected target. Pass `--target <macos|linux-systemd|ephemeral-container|linux-cron>`
-  explicitly.
-- **Pending host work never clears:** your host agent hasn't shipped
-  handler registrations yet. Read
-  `~/.gbrain/migrations/pending-host-work.jsonl`, open
-  `skills/migrations/v0.11.0.md`, and follow the host-agent instruction
-  manual.
-
-## Related
-
-- `skills/migrations/v0.11.0.md` — full migration skill for host agents.
-- `skills/skillpack-check/SKILL.md` — when and how to run the health check.
-- `docs/guides/plugin-handlers.md` — plugin contract for host-specific
-  handlers.
-- `skills/conventions/cron-via-minions.md` — the canonical cron rewrite
-  pattern.

docs/guides/minions-shell-jobs.md

@@ -1,167 +0,0 @@
-# Minions shell jobs — move deterministic crons off the gateway
-
-## 30 seconds
-
-```bash
-# Run your first shell job:
-GBRAIN_ALLOW_SHELL_JOBS=1 gbrain jobs submit shell \
-  --params '{"cmd":"echo hello","cwd":"/tmp"}' --follow
-# → exit_code: 0, stdout_tail: "hello\n", duration_ms: 43
-```
-
-That's it. Your cron scripts now have a home with retry, backoff, DLQ, and
-`gbrain jobs list` visibility, without each one booting a full LLM session.
-
-**PGLite users:** `gbrain jobs work` does not run on PGLite (exclusive file
-lock). Every crontab invocation must use `--follow` for inline execution.
-Postgres users can run a persistent worker; see recipes below.
-
----
-
-## Why it exists
-
-If your agent runs deterministic scripts from cron (token refresh, API fetch,
-scrape + write), each one pays the cost of a full LLM session on the gateway.
-Fourteen simultaneous fires on a Series A deployment pin CPU at 100% and block
-live messages. None of those scripts need reasoning. They need a shell.
-
-Shell jobs move them to the Minions worker: one deterministic-script execution
-per cron, zero LLM tokens, unified visibility and retry.
-
----
-
-## Security model (read this)
-
-Shell exec is a large blast radius. We ship two independent gates, both must
-pass:
-
-1. **MCP boundary.** `submit_job` with `name: 'shell'` is rejected when
-   `ctx.remote === true` (MCP callers). Independent of the env flag. Remote
-   agents can never submit shell jobs. `MinionQueue.add('shell', ...)` has its
-   own guard too, so an in-process handler can't programmatically bypass this.
-2. **Env flag.** The worker only registers the shell handler when
-   `GBRAIN_ALLOW_SHELL_JOBS=1` is set on the worker process. Default: off. Your
-   agent opts in per-host.
-
-**What the env allowlist does AND does not do.** Shell jobs run with a minimal
-env: `PATH, HOME, USER, LANG, TZ, NODE_ENV`. Your secrets like `OPENAI_API_KEY`
-and `DATABASE_URL` are NOT passed to the child. You opt-in additional keys per
-job via `env: { ... }`. This stops accidental `$OPENAI_API_KEY` interpolation in
-a user-authored script. It does **not** sandbox filesystem reads: a shell
-script can `cat ~/.env` or any file the worker process can read. The operator
-picks a safe `cwd`. That is the trust boundary.
-
-**Audit trail, not forensic insurance.** Every submission writes a JSONL line
-to `~/.gbrain/audit/shell-jobs-YYYY-Www.jsonl` (ISO-week rotation; override
-with `GBRAIN_AUDIT_DIR`). Failures log to stderr and don't block submission, so
-a disk-full adversary could silently disable the trail. Good for "what did
-this cron submit last Tuesday", not for security-critical forensics.
-
-**The command text is logged as-is.** If you embed a secret in `cmd`
-(`curl -H 'Authorization: Bearer ...'`), it shows up in the audit file. Put
-secrets in `env:` instead.
-
----
-
-## Migrate a cron
-
-### Postgres worker (recommended)
-
-On one terminal, start a persistent worker:
-
-```bash
-GBRAIN_ALLOW_SHELL_JOBS=1 gbrain jobs work
-```
-
-Rewrite crontab to submit shell jobs (no `--follow`):
-
-```cron
-# Before (LLM gateway):
-#   OpenClaw cron: x-garrytan-unified
-# After (Minions worker):
-3 13,16,19,22,1,4,7,10 * * * \
-  gbrain jobs submit shell \
-    --params '{"cmd":"node scripts/x-garrytan-daily.mjs","cwd":"/data/.openclaw/workspace"}' \
-    --max-attempts 3 --timeout-ms 300000
-```
-
-Worker claims the job on next poll, runs it, records `exit_code` +
-`stdout_tail` + `stderr_tail` in the result. Failures retry per
-`--max-attempts` with exponential backoff.
-
-### PGLite (inline execution)
-
-PGLite doesn't support the persistent worker daemon. Every crontab invocation
-uses `--follow` to run inline:
-
-```cron
-# Each cron tick spawns a short-lived worker that runs the job inline.
-3 13,16,19,22,1,4,7,10 * * * \
-  GBRAIN_ALLOW_SHELL_JOBS=1 gbrain jobs submit shell \
-    --params '{"cmd":"node scripts/x-garrytan-daily.mjs","cwd":"/data/.openclaw/workspace"}' \
-    --follow --timeout-ms 300000
-```
-
-Note: `--follow` blocks the crontab slot until the job finishes. If 14 shell
-crons land at the same minute and each takes 30s, they serialize through
-crontab's spawning limits. Postgres + persistent worker scales better.
-
-### Submitting with `argv` (no shell interpolation)
-
-For programmatic callers assembling commands from JSON, use `argv` instead of
-`cmd`. No shell, no injection surface:
-
-```bash
-gbrain jobs submit shell \
-  --params '{"argv":["node","scripts/fetch.mjs","--date","2026-04-19"],"cwd":"/data"}' \
-  --follow
-```
-
----
-
-## Debug a failed job
-
-```bash
-# List dead shell jobs
-gbrain jobs list --status dead
-
-# Inspect one
-gbrain jobs get 42
-# → error_text, stacktrace, result.stdout_tail, result.stderr_tail
-
-# Submission audit log (operator trail, not forensic)
-cat ~/.gbrain/audit/shell-jobs-*.jsonl | jq '.'
-
-# First-time failure mode: submitted without env flag on the worker
-gbrain jobs list --status waiting --name shell
-# If rows pile up here, no worker with GBRAIN_ALLOW_SHELL_JOBS=1 is running.
-```
-
----
-
-## Limitations
-
-- **Filesystem reads are not sandboxed.** See "Security model" above. Don't
-  point `cwd` at a directory full of secrets.
-- **Audit log is advisory.** Disk-full or EACCES silently disables it.
-- **Cancel latency is lock-renewal-bounded** (~7-15 s by default). A cancelled
-  child keeps running until the next lock-renewal tick fails.
-- **`--follow` claim order** is by priority/created_at. If another job is
-  waiting in the same queue at the time of `--follow`, that one runs first.
-- **`cwd` symlink TOCTOU.** The absolute-path check doesn't guard against
-  symlinks pointing elsewhere at execution time. Operator-scope concern.
-
----
-
-## Errors {#errors}
-
-| Error | What it means | Fix |
-|---|---|---|
-| `shell: specify exactly one of cmd or argv` | `cmd` and `argv` are mutually exclusive. Both absent is also invalid. | Choose one. `cmd` for shell-interpolated strings; `argv` for structured args. |
-| `shell: cwd is required and must be an absolute path` | `cwd` must be a string starting with `/`. | Set `cwd` in `--params` to an absolute path. |
-| `shell: argv must be an array of strings` | `argv` has a non-string entry or isn't an array. | Pass `argv: ["bin","arg1","arg2"]`. |
-| `shell: env values must all be strings` | `env` has a number/bool/object value. | Stringify: `"env":{"COUNT":"3"}` not `"env":{"COUNT":3}`. |
-| `permission_denied: shell jobs cannot be submitted over MCP` | An MCP client tried to submit a shell job. By design CLI-only. | Submit from CLI or via a trusted operation handler (`ctx.remote === false`). |
-| `protected job name 'shell' requires CLI or operation-local submitter` | A caller invoked `MinionQueue.add('shell', ...)` without the `trusted` opt-in. | Pass `{ allowProtectedSubmit: true }` as the 4th arg. CLI and `submit_job` do this automatically. |
-| `aborted: timeout` / `aborted: cancel` / `aborted: shutdown` / `aborted: lock-lost` | The worker's abort signal fired mid-execution. Child got SIGTERM, 5s grace, then SIGKILL. | Expected: timeout / user cancel / deploy restart / stall. Inspect `gbrain jobs get` to see which. |
-| `exit N: <stderr_tail_500>` | Script exited non-zero. | Read `stderr_tail` in `gbrain jobs get`. |

docs/guides/plugin-authors.md

@@ -1,163 +0,0 @@
-# Plugin authors guide (v0.15)
-
-`gbrain` discovers subagent definitions from outside this repo via
-`GBRAIN_PLUGIN_PATH`. If you maintain a downstream agent (your OpenClaw
-deployment, a workflow host, a private tool) and want to ship custom
-subagents alongside it, drop a plugin directory on that env path.
-
-This guide is for plugin authors. The CLI user doesn't need to read it.
-
-## Minimum viable plugin
-
-```
-/path/to/my-plugin/
-├── gbrain.plugin.json
-└── subagents/
-    └── my-summarizer.md
-```
-
-`gbrain.plugin.json`:
-
-```json
-{
-  "name": "my-plugin",
-  "version": "1.0.0",
-  "plugin_version": "gbrain-plugin-v1"
-}
-```
-
-`subagents/my-summarizer.md`:
-
-```markdown
----
-name: my-summarizer
-model: claude-sonnet-4-6
-allowed_tools:
-  - brain_search
-  - brain_get_page
----
-
-You are a brain page summarizer. Given a slug, fetch the page and produce
-a 3-sentence summary.
-```
-
-## Turning it on
-
-```bash
-export GBRAIN_PLUGIN_PATH="/path/to/my-plugin"
-gbrain jobs work           # worker startup prints the plugin load line
-gbrain agent run "summarize meetings/2026-04-20" --subagent-def my-summarizer
-```
-
-Multiple plugins: colon-separated, just like `$PATH`.
-
-```bash
-export GBRAIN_PLUGIN_PATH="/path/to/plugin-a:/path/to/plugin-b"
-```
-
-## Rules (strict by design)
-
-**Path policy.** Absolute paths only. Relative paths, `~`-prefixed paths,
-and URL-style paths (`https://`, `file://`) are rejected with a warning.
-You control where your plugin lives on disk; `gbrain` doesn't guess.
-
-**Collision policy.** If two plugins ship a subagent with the same `name`,
-the one listed FIRST in `GBRAIN_PLUGIN_PATH` wins. The other is dropped
-with a warning naming both sources.
-
-**Trust policy.** Plugins ship subagent definitions ONLY in v0.15:
-
-- You **cannot** declare new tools.
-- You **cannot** extend the brain tool allow-list.
-- You **cannot** override any `agentSafe` or similar flag.
-- Your `allowed_tools:` frontmatter field MUST subset the derived brain
-  tool registry. Names not in the registry are rejected at plugin load
-  time (worker startup), NOT at subagent dispatch time — so a typo in
-  your plugin gives you a loud startup error, not a silent "tool never
-  fires" at 3am.
-
-v0.16+ may open up plugin-declared tools with a separate contract. Don't
-expect it.
-
-## `gbrain.plugin.json`
-
-| field            | type   | required | notes                                                              |
-|------------------|--------|----------|--------------------------------------------------------------------|
-| `name`           | string | yes      | Human-readable plugin id. Shows up in warnings and collision logs. |
-| `version`        | string | yes      | Your plugin's semver. Informational.                               |
-| `plugin_version` | string | yes      | Contract lock. Must equal `"gbrain-plugin-v1"` for v0.15.          |
-| `subagents`      | string | no       | Subdir name (default `subagents`). Escape-attempts are rejected.   |
-| `description`    | string | no       | Shown in future `gbrain plugin list`.                              |
-
-## Subagent definition files
-
-Plain markdown with YAML frontmatter. The body is the system prompt. The
-frontmatter controls runtime behavior.
-
-Recognized frontmatter fields:
-
-| field           | type     | required | notes                                                                                   |
-|-----------------|----------|----------|-----------------------------------------------------------------------------------------|
-| `name`          | string   | no       | Subagent identifier used as `--subagent-def`. Defaults to the file basename.            |
-| `model`         | string   | no       | Anthropic model id. Defaults to the handler default (sonnet).                           |
-| `max_turns`     | number   | no       | Cap on assistant turns. Defaults to 20.                                                 |
-| `allowed_tools` | string[] | no       | Whitelist of tool names. Must subset the derived brain registry. Rejected on mismatch.  |
-
-Unknown frontmatter fields are preserved but ignored by the handler. v0.16
-may consume more of them.
-
-## Caveats that will bite you
-
-1. **Plugin definitions can't change during a run.** The loader reads the
-   disk once at worker startup. Editing a subagent def doesn't re-take
-   effect until you restart the worker. This is deliberate — live
-   reloads would break crash-resumable replay.
-
-2. **`~/.gbrain/audit/subagent-jobs-*.jsonl` is local only.** If your
-   worker runs on a different host than the `gbrain agent logs` caller,
-   the CLI won't see heartbeats from that worker. v0.16 will unify this;
-   for now assume worker + CLI share a filesystem.
-
-3. **Tool calls always run with `ctx.remote = true`.** Even on local CLI
-   invocation. Tools that gate on `remote=true` (file_upload's strict
-   confinement, put_page's namespace check) will apply. Good default; a
-   subagent definition that wants local-filesystem reach beyond the brain
-   can't have it.
-
-4. **`put_page` writes are namespace-scoped.** A subagent with id 42 can
-   only write under `wiki/agents/42/...`. This is enforced both in the
-   tool schema (the slug pattern shown to the model) AND server-side in
-   the `put_page` operation (fail-closed if `viaSubagent=true`). Don't
-   try to route around it; you'll get `permission_denied`.
-
-## Example: a downstream-OpenClaw plugin
-
-```
-~/your-openclaw/
-└── gbrain-plugin/
-    ├── gbrain.plugin.json
-    └── subagents/
-        ├── meeting-ingestion.md
-        ├── signal-detector.md
-        └── daily-task-prep.md
-```
-
-`~/your-openclaw/gbrain-plugin/gbrain.plugin.json`:
-
-```json
-{
-  "name": "your-openclaw",
-  "version": "2026.4.20",
-  "plugin_version": "gbrain-plugin-v1",
-  "description": "Your OpenClaw's personal-brain subagents"
-}
-```
-
-Environment:
-
-```bash
-export GBRAIN_PLUGIN_PATH="$HOME/your-openclaw/gbrain-plugin"
-```
-
-Then your OpenClaw calls `gbrain agent run --subagent-def meeting-ingestion
---fanout-by transcript ...` and its definitions load automatically.

docs/guides/plugin-handlers.md

@@ -1,137 +0,0 @@
-# Plugin handlers — registering host-specific Minion handlers
-
-GBrain's Minion worker ships with seven built-in handlers: `sync`,
-`embed`, `lint`, `import`, `extract`, `backlinks`, `autopilot-cycle`.
-These cover every background operation the gbrain CLI itself performs.
-
-Host platforms (OpenClaw deployments, future hosts) register their own
-handlers via a plugin bootstrap that imports
-`gbrain/minions`. No `handlers.json`-style data file — handlers are
-code, loaded by the worker, with the same trust model as any other
-code in the host's repo.
-
-## Why code, not data
-
-An earlier design draft shipped `~/.claude/gbrain-handlers.json` where
-each entry was a shell command the worker would exec on job claim.
-Codex flagged this as a durable RCE surface: an agent-writable data
-file that spawns arbitrary shell. We dropped the data-file approach;
-handlers are code that the host imports explicitly and ships through
-code review.
-
-## The plugin contract
-
-A host worker bootstrap looks like this (TypeScript):
-
-```ts
-import { MinionQueue, MinionWorker } from 'gbrain/minions';
-import type { BrainEngine } from 'gbrain/engine';
-
-async function main() {
-  const engine: BrainEngine = /* your engine setup */;
-  await engine.connect({});
-
-  const worker = new MinionWorker(engine, { queue: 'default' });
-
-  // Register every host-specific handler the host's cron manifest references.
-  // Each handler returns a plain object (serialized as the job result).
-  // Throw on failure — the worker catches and retries per max_attempts.
-
-  worker.register('ea-inbox-sweep', async (ctx) => {
-    const slot = ctx.data.slot ?? new Date().toISOString();
-    // Host-specific agent turn: call your LLM, scan the inbox, write
-    // brain pages, return a summary. ctx.signal.aborted indicates the
-    // worker wants you to cooperate with shutdown — honor it.
-    return { swept: true, slot };
-  });
-
-  worker.register('morning-briefing', async (ctx) => {
-    /* host logic */
-    return { briefed: true };
-  });
-
-  // Call start() AFTER every handler is registered. The worker's
-  // stall-detector ignores jobs whose name is not in the registered set.
-  await worker.start();
-}
-
-main().catch(err => { console.error(err); process.exit(1); });
-```
-
-Ship this as a separate binary in the host repo (e.g. `your-openclaw-worker`)
-or as a side-effect module that the stock `gbrain jobs work` command
-auto-loads on startup (configurable via a host-provided entry point).
-
-## Handler contract
-
-Every handler receives a `MinionJobContext`:
-
-```ts
-interface MinionJobContext {
-  data: Record<string, unknown>;   // job params (whatever the cron submit passed)
-  job: MinionJob;                   // full job row (id, queue, attempts, etc.)
-  signal: AbortSignal;              // set to aborted when the worker is shutting down
-  inbox: MinionInbox;               // read messages sent to this job while it runs
-}
-```
-
-Return a serializable object on success. Throw on failure (the worker
-will log + retry per `max_attempts`).
-
-**Abort cooperation.** When `ctx.signal.aborted` becomes true, finish
-gracefully. The worker will wait 30s for you to return before SIGKILL.
-Long-running LLM calls should pass the signal through to whatever
-network library they use.
-
-**Idempotency.** The queue enforces unique `idempotency_key` at the DB
-layer, so you don't need to worry about double-submits from a cron that
-fires while the previous invocation is still running.
-
-## Gbrain's migration flow
-
-The v0.11.0 migration orchestrator (run by `gbrain apply-migrations`)
-detects cron entries whose handler name is NOT in GBrain's builtin set
-and emits a structured TODO to `~/.gbrain/migrations/pending-host-work.jsonl`.
-Each TODO has shape:
-
-```json
-{
-  "type": "cron-handler-needs-host-registration",
-  "handler": "ea-inbox-sweep",
-  "cron_schedule": "0 */30 * * *",
-  "manifest_path": "/path/to/cron/jobs.json",
-  "current_cmd": "agentTurn ea-inbox-sweep",
-  "recommendation": "Add a handler registration for `ea-inbox-sweep` in your host worker bootstrap per docs/guides/plugin-handlers.md. Once registered, re-run `gbrain apply-migrations` to auto-rewrite this entry.",
-  "status": "pending"
-}
-```
-
-The host agent walks these entries using `skills/migrations/v0.11.0.md`:
-
-1. Read `~/.gbrain/migrations/pending-host-work.jsonl`.
-2. For each `cron-handler-needs-host-registration` row, ship a handler
-   registration in the host's worker bootstrap following the pattern
-   above.
-3. Deploy the updated worker.
-4. Re-run `gbrain apply-migrations --yes`. The orchestrator now
-   recognizes the newly-registerable handler (worker writes the
-   registered names to a discovery file on startup) and rewrites the
-   cron entry to use `gbrain jobs submit`. The JSONL row is marked
-   `status: "complete"`.
-
-## Trust boundary
-
-Handler code runs inside the worker process with the same privileges
-as the rest of the host binary. There is no elevation. But there is
-also no runtime sandbox — handlers can read + write anywhere the
-worker user can. Review handler PRs the same way you review any other
-code that touches production data.
-
-## Related
-
-- `skills/conventions/cron-via-minions.md` — the rewrite convention
-  for cron manifests.
-- `skills/migrations/v0.11.0.md` — how the migration orchestrator
-  drives the host agent through this work.
-- `skills/minion-orchestrator/SKILL.md` — patterns for submitting,
-  monitoring, steering, and replaying jobs once the handler is live.

docs/integrations/README.md

@@ -62,13 +62,8 @@ secrets:                        # API keys and credentials needed
   - name: TWILIO_ACCOUNT_SID
     description: Twilio account SID
     where: https://console.twilio.com    # exact URL to get this key
-health_checks:                  # typed DSL to verify the integration is working
-  - type: http
-    url: "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID.json"
-    auth: basic
-    auth_user: "$TWILIO_ACCOUNT_SID"
-    auth_token: "$TWILIO_AUTH_TOKEN"
-    label: "Twilio account"
+health_checks:                  # commands to verify the integration is working
+  - "curl -sf https://api.twilio.com/..."
 setup_time: 30 min              # estimated time to complete setup
 ---
 
@@ -79,16 +74,6 @@ setup_time: 30 min              # estimated time to complete setup
 the markdown body and executes the setup steps. It asks you for API keys, validates
 each one, configures the integration, and runs a smoke test.
 
-### Recipe trust boundary
-
-Only recipes shipped inside the gbrain package itself (the `recipes/` directory in
-a source install, or the global install copy) are trusted. Recipes discovered at
-runtime from `$GBRAIN_RECIPES_DIR` or a cwd-local `./recipes/` are marked untrusted:
-they cannot run `command` health checks, cannot run `http` health checks (SSRF
-defense), and cannot use the deprecated string health_check form. Untrusted recipes
-can still use `env_exists` and `any_of` compositions. To ship a recipe that runs
-live checks, contribute it upstream so it becomes package-bundled.
-
 ## The Deterministic Collector Pattern
 
 When an LLM keeps failing at a mechanical task despite repeated prompt fixes,

docs/integrations/reliability-repair.md

@@ -1,66 +0,0 @@
-# Reliability repair (v0.12.2)
-
-If you ran v0.12.0 on real Postgres or Supabase, two bugs may have corrupted
-data already in your brain. v0.12.1 fixed the code going forward.
-v0.12.2 adds detection in `gbrain doctor` and a standalone `gbrain repair-jsonb`
-command for the mechanically fixable class. PGLite users are not affected.
-
-## What got corrupted
-
-**JSONB double-encode.** Four write sites used
-`${JSON.stringify(x)}::jsonb` with postgres.js, which stored a JSONB
-*string literal* instead of an object. `frontmatter ->> 'key'` returns NULL;
-GIN indexes are ineffective. Affected: `pages.frontmatter`,
-`raw_data.data`, `ingest_log.pages_updated`, `files.metadata`.
-
-**Markdown body truncation.** `splitBody()` treated `---` horizontal rules
-as a body/timeline delimiter, dropping everything after the first rule.
-Wiki-style pages with multiple `##`/`###` sections lost the bulk of their
-content at import time.
-
-## Detect
-
-```
-gbrain doctor
-```
-
-Reports two new checks:
-
-- `jsonb_integrity` — counts double-encoded rows per table and points you
-  at `gbrain repair-jsonb`.
-- `markdown_body_completeness` — heuristic for pages whose `compiled_truth`
-  is suspiciously short compared to `raw_data.data ->> 'content'`.
-
-## Repair
-
-For JSONB (mechanically fixable):
-
-```
-gbrain repair-jsonb
-```
-
-Runs `UPDATE <table> SET <col> = (<col>#>>'{}')::jsonb WHERE jsonb_typeof(<col>) = 'string'`
-across every affected column. Idempotent. Second run reports 0 rows. Use
-`--dry-run` to preview, `--json` for structured output. The `v0_12_2`
-migration runs this automatically on `gbrain upgrade`.
-
-For truncated markdown bodies (source-dependent):
-
-```
-gbrain sync --force
-# or per-page
-gbrain import <slug> --force
-```
-
-v0.12.2 cannot recover content that was already lost if you no longer have
-the source markdown file. `gbrain doctor` tells you which pages look short;
-you decide whether to re-import from source or accept the truncation.
-
-## Verify
-
-```
-gbrain doctor
-```
-
-All four `jsonb_integrity` rows should read zero. `markdown_body_completeness`
-should match your expectations for the corpus.

docs/mcp/DEPLOY.md

@@ -78,13 +78,6 @@ bun run src/commands/auth.ts test \
 All 30 GBrain operations are available remotely, including `sync_brain` and
 `file_upload` (no timeout limits with self-hosted server).
 
-**Security note on `file_upload`:** remote MCP callers are confined to the working
-directory where `gbrain serve` was launched. Symlinks, `..` traversal, and absolute
-paths outside cwd are rejected. Page slugs and filenames are allowlist-validated
-(alphanumeric + hyphens; no control chars, RTL overrides, or backslashes). Local
-CLI callers (`gbrain file upload ...`) keep unrestricted filesystem access since
-the user owns the machine.
-
 ## Deployment Options
 
 See [ALTERNATIVES.md](ALTERNATIVES.md) for a comparison of ngrok, Tailscale

docs/progress-events.md

@@ -1,191 +0,0 @@
-# Progress events
-
-Canonical reference for the JSONL progress stream that `gbrain` writes to
-`stderr` when a bulk command runs with `--progress-json`. Stable from
-v0.15.2. Additive changes only; no renames or removals without a major
-version bump.
-
-Most humans won't read this page. Agents parsing progress will.
-
-## When do I get these events?
-
-Any of these commands stream events when `--progress-json` is set:
-
-- `gbrain doctor` (DB checks, JSONB integrity, markdown body completeness,
-  integrity sample)
-- `gbrain orphans`
-- `gbrain embed`
-- `gbrain files sync`
-- `gbrain export`
-- `gbrain extract [links|timeline|all]` (fs or db source)
-- `gbrain import`
-- `gbrain sync`
-- `gbrain migrate --to …`
-- `gbrain repair-jsonb`
-- `gbrain check-backlinks`
-- `gbrain lint`
-- `gbrain integrity auto`
-- `gbrain eval`
-- `gbrain apply-migrations` (the orchestrator + every child command)
-
-Non-bulk commands (`stats`, `graph-query`, `get`, `put`, etc.) don't emit
-events — they return in under a second.
-
-## Channel
-
-- Progress events: **`stderr`**, one JSON object per line, `\n`-terminated.
-- Data results (`--json` payloads from each command): **`stdout`**.
-- Final human summaries: **`stdout`**.
-
-Agents can safely capture stdout for their result parsing and read stderr
-separately for progress.
-
-## Flags
-
-| Flag | Behavior |
-|---|---|
-| *(none)* | Auto. TTY: `\r`-rewriting single line. Non-TTY: plain line-per-event on stderr. |
-| `--progress-json` | Force JSON-lines mode on stderr (this doc). |
-| `--quiet` | Suppress progress entirely. Warnings and final output still print. |
-| `--progress-interval=<ms>` | Override the minimum interval between tick emits (default 1000). |
-
-Global flags: parsed by `src/core/cli-options.ts` before command dispatch,
-so `gbrain --progress-json doctor` works the same as
-`gbrain doctor --progress-json` (the latter also works — per-command
-parsers see the flag via the shared `CliOptions` singleton).
-
-## Event types
-
-Every event is a single-line JSON object with these common fields:
-
-| Field | Type | Notes |
-|---|---|---|
-| `event` | string | One of: `start`, `tick`, `heartbeat`, `finish`, `abort`. |
-| `phase` | string | Machine-stable snake_case, dot-separated. See "Phase names" below. |
-| `ts` | ISO 8601 UTC string | Event emission time. |
-| `elapsed_ms` | number | Ms since the phase started. Present on `tick`/`heartbeat`/`finish`/`abort`. |
-
-### `start`
-
-Emitted when a phase begins.
-
-```json
-{"event":"start","phase":"doctor.db_checks","ts":"2026-04-20T12:34:56.789Z"}
-{"event":"start","phase":"import.files","total":52000,"ts":"2026-04-20T12:34:56.789Z"}
-```
-
-Optional fields:
-
-- `total` — the total item count if known at start.
-
-### `tick`
-
-Emitted periodically during iteration. Time- and item-gated: the reporter
-won't emit more often than `minIntervalMs` (default 1000) and
-`minItems` (default `max(10, ceil(total/100))`).
-
-```json
-{"event":"tick","phase":"orphans.scan","done":15000,"total":52000,"pct":28.8,"elapsed_ms":4200,"eta_ms":10300,"ts":"..."}
-```
-
-Fields:
-
-- `done` — items completed in this phase.
-- `total` — total items, if known. Omitted when the scan doesn't have a
-  total up front (e.g. a streaming iterator).
-- `pct` — `done/total * 100`, one decimal. Omitted when `total` is unknown.
-- `eta_ms` — projected ms until `done === total`, from the observed rate.
-  Omitted when `total` is unknown.
-- `note` — optional string with the current item (e.g. a slug or filename).
-
-### `heartbeat`
-
-Emitted for long-running single operations that don't iterate
-(e.g. `SELECT` against a 50K-row table). No `done`, no `total` — just a
-signal that work is still happening.
-
-```json
-{"event":"heartbeat","phase":"doctor.markdown_body_completeness","note":"scanning pages for truncation…","elapsed_ms":1000,"ts":"..."}
-```
-
-### `finish`
-
-Emitted when a phase completes normally.
-
-```json
-{"event":"finish","phase":"import.files","done":52000,"total":52000,"elapsed_ms":187000,"ts":"..."}
-```
-
-### `abort`
-
-Emitted by a single process-level SIGINT/SIGTERM handler that tracks every
-live phase. After `abort`, no further events emit for that phase.
-
-```json
-{"event":"abort","phase":"doctor.markdown_body_completeness","reason":"SIGINT","elapsed_ms":5300,"ts":"..."}
-```
-
-## Phase names
-
-Phases use `snake_case.dot.path` naming. A fresh reporter starts at the
-root; `child()` composition appends to the parent's current phase, so a
-sync that calls import emits `sync.import.<file>`, not `import.<file>`.
-
-Stable phase names shipped in v0.15.2:
-
-- `doctor.db_checks` (umbrella for all DB-side doctor checks)
-- `orphans.scan`
-- `embed.pages`
-- `extract.links_fs`, `extract.timeline_fs`, `extract.links_db`, `extract.timeline_db`
-- `import.files`
-- `sync.deletes`, `sync.renames`, `sync.imports`
-- `migrate.copy_pages`, `migrate.copy_links`
-- `repair_jsonb.run`, `repair_jsonb.<table>.<column>`
-- `backlinks.scan`
-- `lint.pages`
-- `integrity.auto`
-- `eval.single`, `eval.ab`
-- `export.pages`
-- `files.sync`
-
-Sub-phases exposed via `child()`:
-
-- `sync.import.files` — nested inside a sync
-- `apply_migrations.v0_12_2.jsonb_repair` — nested inside the orchestrator
-
-## Subprocess inheritance
-
-When a parent CLI spawns `gbrain …` child processes (mostly in
-`src/commands/migrations/*`), global flags (`--quiet`, `--progress-json`,
-`--progress-interval`) are propagated to the child's argv via the
-`childGlobalFlags()` helper in `src/core/cli-options.ts`. Child stderr
-passes straight through `stdio: 'inherit'` so the event stream is one
-merged JSONL feed on the parent's stderr.
-
-One exception: the orchestrator phase in `migrations/v0_12_2.ts` that
-captures child stdout (`repair-jsonb --dry-run --json` for verification)
-does not pass `--progress-json` to avoid any risk of stdout pollution
-breaking the orchestrator's `JSON.parse`. Its stdio is explicit:
-`['ignore', 'pipe', 'inherit']` so stderr still flows through.
-
-## Minion jobs
-
-`gbrain jobs work` (the Minion worker daemon) keeps progress in the DB,
-not on stderr. Each Minion handler that runs a bulk core (embed, sync,
-extract, import, backlinks) calls `job.updateProgress({done, total,
-…})` per iteration. Agents read per-job progress via the
-`get_job_progress` MCP operation or `gbrain jobs get <id>`.
-
-The `jobs work` daemon itself emits coarse one-line-per-job stderr output
-for liveness only. Per-page detail lives in the DB.
-
-## Compatibility
-
-- **Added**: only. A new event type, a new field, a new phase name — all
-  safe. Agents must ignore unknown fields and unknown event types.
-- **Removed/renamed**: never without a major version bump.
-- **Schema changes**: announced in `CHANGELOG.md` and in
-  `skills/migrations/v<next>.md`.
-
-If your agent depends on this schema and something surprises you, open
-an issue with the event you received and what you expected.

eval/data/world-v1/_ledger.json

@@ -1,13 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,21 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,29 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-{
-  "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

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,29 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,30 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,32 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,26 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-{
-  "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"
-  }
-}

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

@@ -1,14 +0,0 @@
-{
-  "slug": "companies/initialized-11",
-  "type": "company",
-  "title": "Initialized Capital",
-  "compiled_truth": "Initialized Capital is a seed-stage venture capital firm that made a significant mark on Silicon Valley's early-stage investing landscape. Founded in 2011 by Alexis Ohanian and Garry Tan, the firm quickly established itself as a go-to partner for ambitious founders building transformative companies. Initialized became known for writing the first checks into startups that would go on to become household names.\n\nThe firm's portfolio included some remarkable successes. Coinbase, Instacart, Cruise Automation, and Flexport all received early backing from Initialized, demonstrating the partners' ability to identify breakout opportunities before they became obvious. The fund's investment thesis centered on backing technical founders with strong product instincts, often at the pre-seed or seed stage when most institutional investors wouldn't engage.\n\nGarry Tan served as managing partner and was the driving force behind much of the firm's deal flow and investment decisions. His background as a founder (he co-founded Posterous) and his time as a partner at Y Combinator gave him unique insight into what makes early-stage companies succeed. In 2022, Tan departed Initialized to take on the role of President and CEO at [Y Combinator](companies/y-combinator), leaving the firm at an inflection point.\n\nFollowing Tan's departure, the future of Initalized became somewhat uncertain. The firm had raised multiple funds over the years, with later vehicles exceeding $300 million in committed capital. Some partners continued to manage existing investments while the firm's active deployment slowed considerably.\n\nInitialized was part of a broader wave of seed-focused firms that emerged in the early 2010s, alongside peers like First Round Capital and [Floodgate](companies/floodgate). These micro-VCs helped fill a gap left by larger funds that had moved upstream to Series A and beyond. The firm's legacy lives on through its portfolio companies, many of wich continue to shape their respective industries. Alexis Ohanian has since focused his attention on other ventures, including Seven Seven Six, his newer investment vehicle.",
-  "timeline": "- **2011-06-15** | Initialized Capital founded by Alexis Ohanian and Garry Tan with a focus on seed-stage investments\n- **2017-03-22** | Closed Fund III at $225 million, marking significant growth from earlier vehicles\n- **2019-09-10** | Portfolio company Coinbase valuation exceeds $8 billion following private funding round\n- **2021-04-14** | Coinbase direct listing on NASDAQ delivers massive returns for early Initialized investment\n- **2022-01-18** | Garry Tan announced as incoming CEO of [Y Combinator](companies/y-combinator), signaling transition at Initialized\n- **2022-03-01** | Tan officially departs managing partner role to lead YC full-time\n- **2023-08-12** | Firm continues managing existing portfolio with reduced new investment activity\n- **2024-02-28** | Several Initialized portfolio companies announce down rounds amid market correction\n- **2025-05-14** | Legacy fund distributions continue as mature portfolio companies reach liquidity events",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/initialized-11",
-    "name": "Initialized",
-    "category": "vc",
-    "industry": "venture capital"
-  }
-}

eval/data/world-v1/companies__iris-36.json

@@ -1,27 +0,0 @@
-{
-  "slug": "companies/iris-36",
-  "type": "company",
-  "title": "Iris",
-  "compiled_truth": "Iris is a consumer social startup founded in 2024 by [Mia Park](people/mia-park-36), a first-time founder with a background in behavioral psychology and product design. The company is building what it describes as a \"mood-first\" social platform—users share emotional states and context rather than polished photos or status updates. The core thesis is that Gen Z craves authenticity but existing platforms still incentivize performance. Iris flips that by making vulnerability the default.\n\nThe app launched in closed beta in late 2024, initially targeting college campuses on the West Coast. Early traction was promising, with retention numbers that caught the attention of several angel investors. [Jack Davis](people/jack-davis-89) led a pre-seed round, drawn to Mia's unconventional approach and the product's sticky engagement loops. He's been hands-on, joining weekly product reviews and pushing the team to nail the onboarding flow before scaling.\n\nIris operates with a lean team of five, mostly engineers and one designer Mia poached from her previous gig at a larger social app. The company runs out of a cramped co-working space in San Francisco's Mission district. Culture is intense but collaborative—Mia sets aggressive ship cycles but also mandates \"disconnect Fridays\" to prevent burnout. There's a scrappy energy to the operation.\n\n[David Kim](people/david-kim-186) serves as an advisor, providing strategic guidence on growth tactics and helping Mia navigate the fundraising landscape. He's introduced her to several potential Series A leads, though the company isn't actively raising yet. The plan is to hit 100k MAU before pursuing a priced round.\n\nRecent product moves include a \"resonance\" feature that matches users with strangers experiencing similar emotional states. It's controversial internally—some worry about safety implications—but early data shows it drives significent engagement. Mia has publicly stated that Iris will never sell emotional data to advertisers, a stance that's resonated with privacy-conscious users but raises questions about eventual monetization.",
-  "timeline": "- **2024-01-15** | [Mia Park](people/mia-park-36) incorporates Iris and begins recruiting founding team\n- **2024-03-22** | Closed alpha launches with 200 users from Stanford and Berkeley\n- **2024-05-10** | [Jack Davis](people/jack-davis-89) commits to leading pre-seed round after demo day pitch\n- **2024-06-01** | Pre-seed closes at $1.2M, valuation undisclosed\n- **2024-08-14** | [David Kim](people/david-kim-186) joins as formal advisor\n- **2024-10-03** | Beta expands to 12 universities across California and Oregon\n- **2024-11-19** | \"Resonance\" feature ships, driving 40% increase in daily sessions\n- **2025-01-08** | Iris hits 25k monthly active users milestone\n- **2025-02-20** | Mia speaks at a consumer social meetup in SF about emotional-first design\n- **2025-04-12** | Company begins exploratory conversations with Series A investors",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/iris-36",
-    "name": "Iris",
-    "category": "startup",
-    "industry": "consumer social",
-    "founded_year": 2024,
-    "founders": [
-      "people/mia-park-36"
-    ],
-    "investors": [
-      "people/jack-davis-89"
-    ],
-    "employees": [
-      "people/david-anderson-146"
-    ],
-    "advisors": [
-      "people/david-kim-186"
-    ]
-  }
-}

eval/data/world-v1/companies__jolt-37.json

@@ -1,25 +0,0 @@
-{
-  "slug": "companies/jolt-37",
-  "type": "company",
-  "title": "Jolt - AI Applications Startup",
-  "compiled_truth": "Jolt is an early-stage startup founded in 2025 by [Chris Williams](people/chris-williams-37), operating in the AI applications space. The company emerged during a particularly competitive period for AI ventures, yet managed to secure backing from notable angel investors including [Tina Hernandez](people/tina-hernandez-97) and [Chris Miller](people/chris-miller-101).\n\nThe company focuses on building AI-powered productivity tools aimed at small and medium businesses. Their flagship product, still in development, promises to automate routine administrative tasks using a combination of large language models and custom workflow engines. Chris Williams has described the vision as \"AI that actually fits into how people already work, not the other way around.\"\n\nJolt operates with a lean team, currently around 8 people, mostly engineers with backgrounds in ML infrastructure and frontend development. The company maintains offices in Austin, though most of the team works remotley. Williams has been vocal about keeping the team small until they achieve stronger product-market fit, a philosophy he picked up from his previous startup experience.\n\nFunding details remain somewhat private, but sources suggest the initial round was in the $2-3M range. [Chris Miller](people/chris-miller-101) reportedly led the round after meeting Williams at a conference in late 2024. The investment thesis centered on Williams' track record and the team's technical depth rather than any revolutionary technology moat.\n\nThe startup has been relatively quiet publicly, preferring to focus on building rather than marketing. A private beta launched in Q1 2025 with around 50 companies participating. Early feedback has been mixed but promising—users appreciate the simplicity but want more integrations. The team is currently heads-down on expanding connector support for popular tools like Slack, Notion, and various CRMs.\n\nCompetition in the AI productivity space is fierce, with both well-funded startups and big tech players vying for attention. Jolt's bet is that their focus on SMBs and ease of deployment will carve out a defensible niche. Whether that pans out remains to be seen.",
-  "timeline": "- **2024-11-15** | Chris Williams meets [Chris Miller](people/chris-miller-101) at AI Summit Austin, initial discussions about Jolt concept\n- **2025-01-08** | Jolt officially incorporated in Delaware\n- **2025-01-22** | Seed round closes with participation from [Tina Hernandez](people/tina-hernandez-97) and Chris Miller\n- **2025-02-10** | First two engineers hired, both former colleagues of [Chris Williams](people/chris-williams-37)\n- **2025-03-05** | Internal alpha of core product completed\n- **2025-04-12** | Private beta launches with 50 SMB partners\n- **2025-05-20** | Team expands to 8 people, adds first dedicated product manager\n- **2025-06-18** | Partnership discussions begin with major CRM vendor\n- **2025-07-02** | Beta feedback review leads to pivot toward deeper integrations focus",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/jolt-37",
-    "name": "Jolt",
-    "category": "startup",
-    "industry": "AI applications",
-    "founded_year": 2025,
-    "founders": [
-      "people/chris-williams-37"
-    ],
-    "investors": [
-      "people/tina-hernandez-97",
-      "people/chris-miller-101"
-    ],
-    "employees": [
-      "people/xavier-johnson-147"
-    ]
-  }
-}

eval/data/world-v1/companies__keel-38.json

@@ -1,27 +0,0 @@
-{
-  "slug": "companies/keel-38",
-  "type": "company",
-  "title": "Keel",
-  "compiled_truth": "Keel is a crypto startup founded in early 2025 by [Steve Williams](people/steve-williams-38), a serial entrepreneur with a background in decentralized finance protocols. The company operates in the digital asset infrastructure space, focusing on building institutional-grade custody and settlement solutions for blockchain networks. Despite being a newcomer to an already crowded market, Keel has positioned itself as a lean alternative to legacy crypto custodians, emphasizing speed and regulatory compliance from day one.\n\nThe founding thesis behind Keel centers on the belief that traditional crypto custody providers have become bloated and slow to adapt to emerging Layer 2 ecosystems. Steve Williams has been vocal about this gap, arguing that institutions need nimble partners who understand the nuances of rollups, bridges, and cross-chain liquidity. The company's initial product focuses on Ethereum L2 settlement, with plans to expand into Bitcoin sidechains by late 2025.\n\nKeel raised a pre-seed round in Q1 2025, with [Carol Jackson](people/carol-jackson-81) serving as the lead investor. Jackson, known for her contrarian bets in fintech infrastructure, apparently saw potential in Williams' vision despite the bear market sentiment still lingering from 2024. The round was modest—reportedly under $3 million—but gave the team runway to build out their core platform and hire a small enginering team.\n\nAdvisory support comes from [Linda Taylor](people/linda-taylor-178), who brings regulatory expertise to the table. Taylor's involvement signals that Keel is serious about compliance, a differentiator in an industry still grappling with enforcement actions. Her guidance has reportedly shaped the company's approach to KYC/AML integration and its conversations with potential banking partners.\n\nThe team remains small, operating out of a co-working space in Austin. Williams has kept headcount intentionally low, preferring to ship fast with a tight-knit group rather than scale prematurely. Early users include a handful of crypto-native hedge funds testing the settlement infrastucture in sandbox environments. Keel's public launch is expected sometime in Q3 2025.",
-  "timeline": "- **2024-11-15** | Steve Williams begins exploratory conversations with early backers about a new custody venture\n- **2025-01-08** | Keel officially incorporated in Delaware; [Steve Williams](people/steve-williams-38) named CEO\n- **2025-01-22** | [Carol Jackson](people/carol-jackson-81) commits to leading the pre-seed round\n- **2025-02-10** | Pre-seed funding closes at $2.8M; team begins hiring engineers\n- **2025-02-28** | [Linda Taylor](people/linda-taylor-178) joins as regulatory advisor\n- **2025-03-15** | First internal demo of L2 settlement prototype completed\n- **2025-04-02** | Keel signs NDA with two crypto hedge funds for pilot testing\n- **2025-05-19** | Williams speaks at ETH Denver satellite event on institutional DeFi infrastructure\n- **2025-06-07** | Sandbox testing begins with select institutional partners",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/keel-38",
-    "name": "Keel",
-    "category": "startup",
-    "industry": "crypto",
-    "founded_year": 2025,
-    "founders": [
-      "people/steve-williams-38"
-    ],
-    "investors": [
-      "people/carol-jackson-81"
-    ],
-    "employees": [
-      "people/zoe-nakamura-148"
-    ],
-    "advisors": [
-      "people/linda-taylor-178"
-    ]
-  }
-}

eval/data/world-v1/companies__khosla-ventures-8.json

@@ -1,14 +0,0 @@
-{
-  "slug": "companies/khosla-ventures-8",
-  "type": "company",
-  "title": "Khosla Ventures",
-  "compiled_truth": "Khosla Ventures is a prominent Silicon Valley venture capital firm founded in 2004 by Vinod Khosla, a co-founder of Sun Microsystems. The firm has established itself as one of the most influential investors in technology and cleantech, with a particular focus on companies that can have transformative impact across industries. Headquartered in Menlo Park, California, Khosla operates with a distinctive philosophy that embraces high-risk, high-reward bets on unproven technologies.\n\nThe firm manages multiple funds totaling billions in assets under managment, including seed funds for earlier-stage investments and larger growth funds for follow-on financing. Khosla Ventures has backed some notable successes including Square, DoorDash, and Instacart. More recently, the firm has been aggressively investing in artificial intelligence infrastructure and applications, recognizing the generational shift hapening in enterprise software.\n\nVinod Khosla himself remains deeply involved in investment decisions and is known for his contrarian views and willingness to fund moonshot ideas. The firm's team includes partners with deep technical backgrounds, which allows them to evaluate complex technologies that other VCs might shy away from. They've developed a reputation for being founder-friendly while also providing substantial operational support.\n\nKhosla Ventures has been particularly active in climate tech, betting big on carbon capture, alternative proteins, and next-generation energy storage. This aligns with Vinod's long-standing interest in technologies that address major societal challenges. The firm often co-invests alongside other major venture players like [Andreessen Horowitz](companies/a16z) on larger rounds, though they're equally comfortable leading deals solo.\n\nTheir investment approach tends to be thesis-driven rather than opportunistic. Partners develop deep conviction around specific technology shifts and then actively seek out founders building in those areas. This has led to early positions in categories before they become crowded. The firm maintains close relationships with the Stanford ecosystem and frequently backs technical founders straight out of PhD programs. Recent portfolio companies have explored everything from quantum computing to synthetic biology, reflecting Khosla's continued appetite for frontier tech bets.",
-  "timeline": "- **2021-03-15** | Khosla Ventures closed Fund VII at $1.4 billion, oversubscribed due to strong LP demand\n- **2021-09-22** | Led $50M Series B in carbon removal startup, signaling renewed climate focus\n- **2022-04-08** | Vinod Khosla keynoted Stanford entrepreneurship conference on AI's transformative potential\n- **2022-11-30** | Announced strategic partnership with [Andreessen Horowitz](companies/a16z) for joint investment in AI infrastructure deals\n- **2023-06-14** | Portfolio company Impossible Foods explored IPO options with firm's guidance\n- **2023-12-01** | Khosla published annual predictions letter, forecasting major disruption in healthcare from AI diagnostics\n- **2024-05-19** | Promoted two new general partners from within, expanding investment team to twelve\n- **2024-09-03** | Led $120M growth round for enterprise AI startup at $900M valuation\n- **2025-02-28** | Filed for Fund VIII targeting $2.1 billion across seed and growth vehicles\n- **2025-08-11** | Hosted annual LP summit in Palo Alto featuring portfolio company demos",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/khosla-ventures-8",
-    "name": "Khosla Ventures",
-    "category": "vc",
-    "industry": "venture capital"
-  }
-}

eval/data/world-v1/companies__kindle-20.json

@@ -1,24 +0,0 @@
-{
-  "slug": "companies/kindle-20",
-  "type": "company",
-  "title": "Kindle - Climate Tech Startup",
-  "compiled_truth": "Kindle is a climate tech startup founded in 2023 by [Vera Singh](people/vera-singh-20), focused on developing next-generation carbon capture solutions for industrial emitters. The company emerged from Singh's doctoral research at MIT, where she pioneered novel membrane technologies that significantly reduce the energy costs of direct air capture.\n\nThe startup operates out of Oakland, California, with a small but growing team of around 15 engineers and scientists. Kindle's core product is a modular carbon capture unit designed for mid-sized manufacturing facilities—a market segment that's been largely overlooked by bigger players chasing utility-scale deployments. Their approach prioritizes affordability and ease of installation over raw capture volume, betting that widespread adoption matters more than individual unit performance.\n\nKindle has attracted notable advisors including [Tina Moore](people/tina-moore-191), who brings decades of experience scaling hardware startups. Moore's involvement has been particularly valuable in helping the company navigate supply chain challenges and establish early manufacturing partnerships. The advisory relationship reportedly began after a chance meeting at a climate conference in late 2023.\n\nThe company closed a seed round in early 2024, though exact figures haven't been publicly disclosed. Industry sources suggest somewhere in the $4-6M range, with participation from several climate-focused VCs and a strategic investment from a major cement manufacturer. Vera has been quoted saying the cement partnership represents exactly the kind of industrial collaboration Kindle needs to prove out thier technology at scale.\n\nRecent activity suggests Kindle is preparing for pilot deployments at two manufacturing sites in the midwest, with plans to gather operational data through 2025. The team has been hiring aggressivley for field engineering roles, a sign that real-world testing is imminent. Competition in the carbon capture space remains fierce, but Kindle's focus on the underserved mid-market could give them a meaningful niche if execution goes well.",
-  "timeline": "- **2023-03-15** | Kindle incorporated in Delaware by founder [Vera Singh](people/vera-singh-20)\n- **2023-06-22** | First prototype membrane unit achieves 40% efficiency improvement over baseline\n- **2023-11-08** | [Tina Moore](people/tina-moore-191) joins as lead advisor following Climate Forward conference\n- **2024-01-30** | Seed funding round closed with climate-focused VC syndicate\n- **2024-04-12** | Strategic partnership announced with Midwest cement manufacturer\n- **2024-07-19** | Team expands to 15 employees, opens Oakland R&D facility\n- **2024-10-03** | Vera Singh presents at TechCrunch Disrupt climate track\n- **2025-02-14** | Pilot deployment begins at first manufacturing partner site\n- **2025-05-20** | Second pilot location confirmed in Ohio",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/kindle-20",
-    "name": "Kindle",
-    "category": "startup",
-    "industry": "climate tech",
-    "founded_year": 2023,
-    "founders": [
-      "people/vera-singh-20"
-    ],
-    "employees": [
-      "people/julia-jones-130"
-    ],
-    "advisors": [
-      "people/tina-moore-191"
-    ]
-  }
-}

eval/data/world-v1/companies__kleiner-perkins-14.json

@@ -1,14 +0,0 @@
-{
-  "slug": "companies/kleiner-perkins-14",
-  "type": "company",
-  "title": "Kleiner Perkins",
-  "compiled_truth": "Kleiner Perkins is one of the most storied venture capital firms in Silicon Valley, with a legacy stretching back to 1972. Founded by Eugene Kleiner and Tom Perkins, the firm helped shape the modern tech landscape through early bets on companies like Amazon, Google, and Genentech. Today, KP continues to operate as a top-tier growth and early-stage investor, though its position has evolved considerably from its peak influence in the 1990s and 2000s.\n\nThe firm operates primarily out of Menlo Park, California, maintaining a relatively focused team compared to mega-funds like Andreessen Horowitz or Sequoia. Kleiner Perkins has historically been organized around sector-specific practices, including digital health, fintech, enterprise, and consumer technology. Recent years have seen the firm double down on AI and machine learning opportunities, recognizing the transformative potential of foundation models and applied AI startups.\n\nNotable current partners include Mamoon Hamid, who joined from Social Capital, and Bucky Moore, known for his work in enterprise software. The firm has maintained relationships with iconic founders and frequently co-invests alongside other major players in the ecosystem. Their portfolio includes breakout successes like Figma, Rippling, and several emerging AI-native companies that are reshaping enterprise workflows.\n\nKleiner's approach to venture has shifted somewhat over the past decade. After struggling with its green tech investments in the early 2010s, the firm refocused on software and healthcare, areas where it had demonstrated repeateable success. The cleantech experiment, while producing some winners, largely taught KP hard lessons about capital intensity and market timing. They've since been more disciplined about sector allocation.\n\nThe firm typically writes checks ranging from $1M to $50M depending on stage, though they've participated in larger rounds for high-conviction bets. KP maintains a builder-friendly reputation, often providing operational support through its platform team and network of advisors. They host regular founder dinners and have been known to facilitate introductions across their portfolio companies.\n\nAs of 2024, Kleiner Perkins manages several billion dollars across multiple funds, continuing to attract institutional LPs despite increased competition in the venture landscape. The firm remains a sought-after partner for founders seeking both capital and credibility, though they face stiff competiton from newer entrants with aggressive deployment strategies.",
-  "timeline": "- **2021-03-15** | Kleiner Perkins closed Fund XX at $1.8B, marking a return to larger fund sizes after years of more modest raises.\n- **2021-09-22** | Led Series B for an AI-native workflow automation startup, signaling renewed focus on enterprise machine learning applications.\n- **2022-04-08** | Partner Bucky Moore spoke at a founders summit on the future of vertical SaaS and embedded fintech.\n- **2022-11-30** | KP participated in Figma's final private round before the Adobe acquisition announcement.\n- **2023-06-14** | Announced new partner hire from Stripe, expanding fintech and payments expertise within the firm.\n- **2023-10-02** | Hosted annual CEO Summit in Napa Valley, bringing together portfolio founders for networking and strategy sessions.\n- **2024-02-19** | Led $40M Series A for a foundation model fine-tuning platform focused on healthcare applications.\n- **2024-08-07** | Kleiner Perkins published research report on AI agent adoption trends across enterprise customers.\n- **2025-01-23** | Participated in growth round for Rippling, continuing long-standing relationship with Parker Conrad.\n- **2025-05-11** | Mamoon Hamid joined board of a stealth climate software startup, marking selective return to climate-adjacent investments.",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/kleiner-perkins-14",
-    "name": "Kleiner Perkins",
-    "category": "vc",
-    "industry": "venture capital"
-  }
-}

eval/data/world-v1/companies__lattice-39.json

@@ -1,27 +0,0 @@
-{
-  "slug": "companies/lattice-39",
-  "type": "company",
-  "title": "Lattice - Enterprise SaaS Startup",
-  "compiled_truth": "Lattice is an enterprise SaaS startup founded in 2022 by [Quinn Miller](people/quinn-miller-39), a repeat founder with a background in developer tools and infrastructure software. The company focuses on building next-generation workflow automation platfroms for mid-market and enterprise customers, specifically targeting operations teams who struggle with fragmented tooling across their organizations.\n\nThe company emerged from Quinn's frustration with existing solutions that either served small teams or required massive implementation budgets. Lattice positions itself in the middle ground—powerful enough for complex enterprise needs, but accessible enough that a single ops manager can get started without a consulting engagement. Their core product offers visual workflow builders, deep integrations with popular SaaS tools, and an AI-assisted configuration layer that helps users identify automation opportunities.\n\nEarly backing came from [Vera Gonzalez](people/vera-gonzalez-103), who led a seed round in late 2022. Vera had previously invested in several successful enterprise software companies and saw Lattice as addressing a genuine gap in the market. The company has since grown to approximately 25 employees, with engineering and product teams based primarily in San Francisco.\n\nOn the advisory side, Lattice brought on [Steve Martinez](people/steve-martinez-192) to help navigate enterprise sales cycles and GTM strategy. Steve's experience scaling sales organizations has proven valuable as Lattice transitions from founder-led sales to building out a dedicated revenue team. His connections in the Fortune 500 have also opened doors for pilot conversations that would otherwise take months to secure.\n\nLattice has been relatively quiet publicly, preferring to focus on product development and early customer success over PR. However, industry insiders note that the company has secured several notable design partners in the fintech and healthcare sectors. Their approach emphasizes landing with a single team and expanding organically—a strategy that keeps churn low but requires patience on revenue growth. The company is currently preparing for a Series A raise expected sometime in mid-2025.",
-  "timeline": "- **2022-03-15** | [Quinn Miller](people/quinn-miller-39) incorporates Lattice and begins initial product development\n- **2022-09-22** | Closes $3.2M seed round led by [Vera Gonzalez](people/vera-gonzalez-103)\n- **2022-12-01** | First design partner signed—a mid-sized fintech processing loan applications\n- **2023-04-18** | [Steve Martinez](people/steve-martinez-192) joins as formal advisor to help build sales playbook\n- **2023-08-30** | Launches private beta with 12 companies participating\n- **2024-01-15** | Reaches $500K ARR milestone, transitions to general availability\n- **2024-06-12** | Expands integration library to cover 80+ enterprise tools\n- **2024-11-03** | Hires first dedicated VP of Sales, growing team to 25 employees\n- **2025-02-20** | Begins Series A fundraising conversations with top-tier VCs",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/lattice-39",
-    "name": "Lattice",
-    "category": "startup",
-    "industry": "enterprise SaaS",
-    "founded_year": 2022,
-    "founders": [
-      "people/quinn-miller-39"
-    ],
-    "investors": [
-      "people/vera-gonzalez-103"
-    ],
-    "employees": [
-      "people/owen-patel-149"
-    ],
-    "advisors": [
-      "people/steve-martinez-192"
-    ]
-  }
-}

eval/data/world-v1/companies__lightspeed-6.json

@@ -1,14 +0,0 @@
-{
-  "slug": "companies/lightspeed-6",
-  "type": "company",
-  "title": "Lightspeed Venture Partners",
-  "compiled_truth": "Lightspeed Venture Partners is a global venture capital firm with a storied history dating back to 2000. The firm has established itself as one of the most influential players in early and growth-stage investing, with a particular strength in enterprise software, consumer internet, and fintech. Headquartered in Menlo Park, California, Lightspeed operates across multiple geographies including offices in India, China, Israel, and Europe.\n\nThe firm manages over $25 billion in committed capital across various funds and has backed some of the most consequential technology companies of the past two decades. Notable investments include Snap, Affirm, Mulesoft, and Rubrik. Lightspeed tends to take a hands-on approach with portfolio companies, often providing operational support and leveraging their extensive network to help founders scale.\n\nIn recent years, Lightspeed has been particularly agressive in the AI and machine learning space, deploying significant capital into foundational model companies and AI-native applications. The firm closed a $7.1 billion fund in 2022, one of the largest in its history, signaling continued confidence from LPs despite broader market uncertainty. Partners like Ravi Mhatre and Arif Janmohamed have been instrumental in shaping the firm's enterprise investing thesis.\n\nLightspeed has developed relationships with other major firms in the ecosystem, occasionally co-investing alongside [Andreessen Horowitz](companies/a16z) on competitive deals. The firm is known for moving quickly on conviction and has a reputation for being founder-friendly, though they maintain rigourous diligence processes. Their global footprint allows them to spot trends early—the India team, for instance, was early to companies like Oyo and Byju's before those markets became crowded.\n\nThe firm also runs Lightspeed Faction, a growth-stage vehicle that targets later rounds. This multi-stage capability has become increasingly important as companies stay private longer. They've competed for deals with firms like [Sequoia Capital](companies/sequoia) across multiple stages, sometimes winning on speed and sometimes on terms. Lightspeed remains a top-tier firm that consistently ranks among the most active investors globally.",
-  "timeline": "- **2021-03-15** | Lightspeed leads $150M Series C for enterprise AI startup, marking increased focus on machine learning infrastructure\n- **2021-09-22** | Announced expansion of Israel office with three new partner hires\n- **2022-04-10** | Closed $7.1 billion across early and growth funds, largest raise in firm history\n- **2022-11-08** | Co-invested alongside [Andreessen Horowitz](companies/a16z) in developer tools company seed round\n- **2023-02-14** | Published annual report showing 47 new investments across global portfolio in 2022\n- **2023-07-19** | Partner Mercedes Bent promoted to lead consumer investing practice\n- **2024-01-30** | Lightspeed Faction leads $200M growth round for cybersecurity unicorn\n- **2024-06-12** | Competed with [Sequoia Capital](companies/sequoia) for Series B deal in logistics automation space\n- **2025-02-28** | Opened new office in London to expand European coverage\n- **2025-09-05** | Announced $500M opportunity fund focused exclusively on AI applications",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/lightspeed-6",
-    "name": "Lightspeed",
-    "category": "vc",
-    "industry": "venture capital"
-  }
-}

eval/data/world-v1/companies__lucid-21.json

@@ -1,28 +0,0 @@
-{
-  "slug": "companies/lucid-21",
-  "type": "company",
-  "title": "Lucid",
-  "compiled_truth": "Lucid is a climate tech startup founded in 2020 by [Eric Lee](people/eric-lee-21), focused on developing next-generation carbon capture monitoring systems. The company emerged from Eric's frustration with the lack of real-time verification tools in the voluntary carbon markets—a gap he identified while working on sustainability initiatives at his previous role.\n\nThe core product is a hardware-software platform that provides continous monitoring of carbon sequestration projects, particularly direct air capture facilities and reforestation efforts. Lucid's sensors collect granular data on CO2 flux, which feeds into their analytics dashboard used by project developers, carbon credit buyers, and third-party verifiers. The pitch is simple: if you're buying carbon credits, you should know they're actually removing carbon.\n\nIn 2022, Lucid raised a seed round led by [Fiona Moore](people/fiona-moore-88), with participation from [Ian Anderson](people/ian-anderson-105). The round valued the company at roughly $18M and gave them runway to expand their pilot programs across North America. Fiona joined the board and has been instrumental in connecting Lucid to her network of institutional investors interested in climate infrastructure.\n\nThe company operates lean—around 25 employees as of late 2024, split between hardware engineering in Oakland and a software team that's mostly remote. [Vera Rodriguez](people/vera-rodriguez-171) serves as an advisor, bringing her expertise in carbon markets and regulatory frameworks. Her guidance has been particularly valuable as Lucid navigates the evolving landscape of carbon credit certification standards.\n\nLucid has faced some headwinds. The voluntary carbon market contracted in 2023 amid scrutiny over credit quality, which ironically validated Lucid's core thesis but also slowed sales cycles. Several potential enterprise deals got pushed as companies reassesed their offset strategies. Still, the team sees this as a temporary correction that ultimately benefits players focused on verification and transparency.\n\nRecent moves include a partnership with a major reforestation nonprofit to pilot their monitoring tech across 50,000 hectares in the Pacific Northwest. Eric has been increasingly visible at climate conferences, positioning Lucid as the \"trust layer\" for carbon markets.",
-  "timeline": "- **2020-06-15** | Lucid incorporated by [Eric Lee](people/eric-lee-21) in Delaware, initial focus on carbon monitoring R&D\n- **2021-03-22** | First prototype sensor deployed at a test site in Nevada desert\n- **2021-11-08** | Accepted into climate tech accelerator program, relocated operations to Oakland\n- **2022-04-30** | Closed $4.2M seed round led by [Fiona Moore](people/fiona-moore-88)\n- **2022-09-14** | Hired VP of Engineering from Planet Labs to scale hardware team\n- **2023-02-17** | [Vera Rodriguez](people/vera-rodriguez-171) formally joins as strategic advisor\n- **2023-08-05** | Eric presents at Climate Week NYC on verification standards\n- **2024-01-20** | Announced partnership with ForestWatch nonprofit for Pacific Northwest pilot\n- **2024-07-11** | Reached 15 active deployment sites across US and Canada\n- **2025-03-03** | Began Series A conversations, targeting $15-20M raise",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/lucid-21",
-    "name": "Lucid",
-    "category": "startup",
-    "industry": "climate tech",
-    "founded_year": 2020,
-    "founders": [
-      "people/eric-lee-21"
-    ],
-    "investors": [
-      "people/fiona-moore-88",
-      "people/ian-anderson-105"
-    ],
-    "employees": [
-      "people/ian-nakamura-131"
-    ],
-    "advisors": [
-      "people/vera-rodriguez-171"
-    ]
-  }
-}

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

@@ -1,25 +0,0 @@
-{
-  "slug": "companies/lumen-12",
-  "type": "company",
-  "title": "Lumen - Biotech Startup",
-  "compiled_truth": "Lumen is a biotech startup founded in 2018 by [Henry Johnson](people/henry-johnson-12), focused on developing novel diagnostic tools for early-stage cancer detection. The company operates out of Cambridge, Massachusetts, positioning itself within one of the most concentrated biotech ecosystems in the world. Their core technology leverages proprietary biomarker identification methods combined with machine learning to detect malignancies from standard blood draws—sometimes called liquid biopsy approaches.\n\nThe founding story traces back to Johnson's graduate research at MIT, where he first identified a unique protein signature associated with pancreatic cancer. Rather than pursue a traditional academic path, he spun out the research into what would become Lumen. Early days were scrappy. The company ran lean for nearly two years before securing meaningful outside investment.\n\nLumen's investor base includes [Kate Lopez](people/kate-lopez-99), who led their seed round in late 2020, and [Sarah Wang](people/sarah-wang-104), who joined during the Series A. Both have been activley involved in shaping company strategy, with Lopez taking a board observer seat and Wang providing introductions to pharmaceutical partners. The relationship with these backers has been described as collaborative rather than hands-off—monthly check-ins, strategic planning sessions, the works.\n\nOn the product side, Lumen has made steady progress. Their flagship diagnostic, LumenScreen, completed initial clinical validation in 2023 and is currently pursuing FDA breakthrough device designation. The team has grown to around 45 employees, split between R&D and clinical operations. They've also inked a partnership with a major regional hospital network for pilot testing, though terms weren't disclosed publically.\n\nHenry Johnson remains CEO and is known for a somewhat reserved public presence—he rarely speaks at conferences and prefers to let data do the talking. Internally, employees describe the culture as intense but mission-driven. Turnover has been relatively low for a company at this stage.\n\nLumen faces stiff competition from larger players in the liquid biopsy space, including Grail and Guardant Health. But the company's narrow focus on specific cancer types may prove advantageous for regulatory approval and clinical adoption. The next 18 months will be critical as they push toward commercialization.",
-  "timeline": "- **2018-03-15** | Lumen incorporated in Delaware by [Henry Johnson](people/henry-johnson-12)\n- **2018-09-22** | First lab space secured in Cambridge, initial team of 3 hired\n- **2020-11-08** | Seed round closed with [Kate Lopez](people/kate-lopez-99) leading at $2.4M\n- **2021-06-30** | Biomarker panel v1 validated in preclinical studies\n- **2022-04-12** | Series A announced, $18M raised with participation from [Sarah Wang](people/sarah-wang-104)\n- **2023-01-19** | LumenScreen enters clinical validation trials across 4 sites\n- **2023-08-07** | Partnership announced with Northeast Regional Health System for pilot deployment\n- **2024-02-28** | FDA breakthrough device designation application submitted\n- **2024-11-15** | Team expands to 45 full-time employees\n- **2025-03-22** | Preliminary data from clinical trials presented at AACR annual meeting",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/lumen-12",
-    "name": "Lumen",
-    "category": "startup",
-    "industry": "biotech",
-    "founded_year": 2018,
-    "founders": [
-      "people/henry-johnson-12"
-    ],
-    "investors": [
-      "people/kate-lopez-99",
-      "people/sarah-wang-104"
-    ],
-    "employees": [
-      "people/grace-miller-122"
-    ]
-  }
-}

eval/data/world-v1/companies__mantle-16.json

@@ -1,24 +0,0 @@
-{
-  "slug": "companies/mantle-16",
-  "type": "company",
-  "title": "Mantle",
-  "compiled_truth": "Mantle is a consumer social startup founded in 2024 by [Ulrich Wang](people/ulrich-wang-16), an entrepreneur with a background in community-driven products. The company is building what they describe as a \"social layer for real-world experiences\" — essentially trying to bridge the gap between digital social graphs and physical gatherings. Early product demos have shown features around spontaneous meetups, location-based discovery, and ephemeral group chats tied to specific venues or events.\n\nThe founding team is lean, with Ulrich handling most of the product vision and early engineering. He's been advised by [Julia Wilson](people/julia-wilson-194), who brings experience from previous consumer social ventures and has been instrumental in shaping Mantle's go-to-market thinking. Julia's involvement suggests the company is serious about avoiding the common pitfalls of consumer social — namely, building features nobody asked for and failing to find organic growth loops.\n\nMantle's thesis is that existing social apps have become too performative, too oriented around content creation rather than genuine connection. The team believes there's an underserved segment of users who want lower-friction ways to coordinate IRL hangs without the pressure of posting or maintaining a public persona. It's a crowded space, but Wang argues that most competitors have gotten the incentive structures wrong — focusing on creator monetization when they should be focusing on social utility.\n\nThe company hasn't announced any funding publicly, though sources suggest they've raised a small pre-seed round from angels in the consumer space. Headcount remains under five as of late 2024. Mantle is currently testing with a closed beta group, primarly college students in the Bay Area and a few cities on the East Coast.\n\nWhether Mantle can break through remains to be seen. Consumer social is notoriously difficult — network effects cut both ways, and user attention is finite. But with Ulrich's obsessive focus on user experience and Julia Wilson's strategic guidance, the company has a shot at carving out a niche. Early retention numbers are reportedly encouraging, though the team is tight-lipped about specifics.",
-  "timeline": "- **2024-01-18** | Ulrich Wang incorporates Mantle as a Delaware C-corp, begins solo development on MVP.\n- **2024-03-02** | [Julia Wilson](people/julia-wilson-194) joins as an advisor after intro from a mutual investor.\n- **2024-04-15** | Mantle closes a small pre-seed round; terms undisclosed.\n- **2024-06-10** | First internal alpha launched to ~50 testers across three college campuses.\n- **2024-08-22** | Company hires first full-time engineer, a former classmate of [Ulrich Wang](people/ulrich-wang-16).\n- **2024-09-30** | Closed beta expands to 500 users; early retention data looks promising.\n- **2024-11-12** | Mantle presents at a small consumer social showcase in SF, generates some buzz.\n- **2025-01-08** | Team begins exploring partnerships with event venues for location-based features.\n- **2025-03-20** | Beta user count crosses 2,000; team considering seed raise timing.",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/mantle-16",
-    "name": "Mantle",
-    "category": "startup",
-    "industry": "consumer social",
-    "founded_year": 2024,
-    "founders": [
-      "people/ulrich-wang-16"
-    ],
-    "employees": [
-      "people/noah-lopez-126"
-    ],
-    "advisors": [
-      "people/julia-wilson-194"
-    ]
-  }
-}

eval/data/world-v1/companies__meridian-40.json

@@ -1,29 +0,0 @@
-{
-  "slug": "companies/meridian-40",
-  "type": "company",
-  "title": "Meridian",
-  "compiled_truth": "Meridian is a developer tools startup founded in 2022 by [Chris Nakamura](people/chris-nakamura-40), a former infrastructure engineer who spent years frustrated by the fragmented state of debugging workflows. The company focuses on building unified observability tooling that sits between traditional logging platforms and APM solutions—a niche that's proven surprisingly sticky with mid-sized engineering teams.\n\nThe founding thesis came from Nakamura's experience at larger tech companies where he watched teams cobble together five or six different tools just to trace a single production incident. Meridian's core product aggregates logs, traces, and metrics into what they call a \"narrative view\"—essentially reconstructing the story of what happened in your system without requiring engineers to context-switch between dashboards. Its a deceptively simple idea that turns out to be technically complex to execute well.\n\nFunding came together relatively quickly. [Priya Taylor](people/priya-taylor-85) led the seed round after seeing an early demo, and she brought in [Chris Jackson](people/chris-jackson-91) who had been looking for developer tools plays. [Vera Gonzalez](people/vera-gonzalez-103) joined as a smaller check but has been actively involved in go-to-market strategy. The total seed was $3.2M, closed in late 2022.\n\nOn the advisory side, [Zoe Jackson](people/zoe-jackson-199) has been instrumental in helping Meridian think through enterprise sales motions. Her background in scaling developer-focused products gave the team a playbook they've been iterating on throughout 2023 and into 2024.\n\nMeridian currently has about 14 employees, mostly engineers, operating out of a small office in San Francisco's Dogpatch neighborhood. They've been deliberatley slow on hiring, preferring to keep the team tight while they nail down product-market fit. Revenue numbers aren't public but word is they crossed $500K ARR sometime in early 2024, with a handful of paying customers in the fintech and healthtech spaces.\n\nThe company's biggest challenge right now is differentiation. The observability market is crowded, and larger players like Datadog keep expanding their feature sets. Nakamura has been vocal about staying focused on the \"debugging narrative\" angle rather than trying to become a full platform. Whether that strategy holds as they scale remains to be seen.",
-  "timeline": "- **2022-03-14** | Chris Nakamura incorporates Meridian, begins building initial prototype\n- **2022-08-22** | First demo shown to [Priya Taylor](people/priya-taylor-85), receives positive feedback and term sheet discussions begin\n- **2022-11-03** | Seed round closes at $3.2M with [Chris Jackson](people/chris-jackson-91) and [Vera Gonzalez](people/vera-gonzalez-103) participating\n- **2023-02-17** | Meridian launches private beta, onboards first 12 design partners\n- **2023-06-09** | [Zoe Jackson](people/zoe-jackson-199) joins as formal advisor, begins weekly office hours with team\n- **2023-09-28** | Public launch at a small developer conference in SF, picks up first paying customers\n- **2024-01-15** | Crosses $500K ARR milestone, team celebrates with low-key dinner\n- **2024-05-20** | Hires first dedicated sales rep, begins outbound motion targeting Series B+ startups\n- **2024-11-08** | Ships major \"Narrative 2.0\" update with improved trace visualization\n- **2025-02-14** | Begins early conversations about Series A, [Priya Taylor](people/priya-taylor-85) making introductions to growth-stage funds",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/meridian-40",
-    "name": "Meridian",
-    "category": "startup",
-    "industry": "developer tools",
-    "founded_year": 2022,
-    "founders": [
-      "people/chris-nakamura-40"
-    ],
-    "investors": [
-      "people/priya-taylor-85",
-      "people/chris-jackson-91",
-      "people/vera-gonzalez-103"
-    ],
-    "employees": [
-      "people/kate-kapoor-150"
-    ],
-    "advisors": [
-      "people/zoe-jackson-199"
-    ]
-  }
-}

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

@@ -1,15 +0,0 @@
-{
-  "slug": "companies/meta-2",
-  "type": "company",
-  "title": "Meta (Cybersecurity)",
-  "compiled_truth": "Meta is a cybersecurity firm founded in 1997, not to be confused with the social media giant of the same name. Operating in the enterprise security space for over two decades, the company has built a reputation as a quiet but effective acquirer of smaller security startups and niche technology providers.\n\nThe company specializes in network security infrastructure and threat detection systems, serving primarily Fortune 500 clients and government contractors. Their flagship product line focuses on perimeter defense and intrusion detection, though they've expanded considerably through strategic acquisitions over the years. Meta's approach has always been to identify promising early-stage cybersecurity companies and integrate their technology into the broader Meta ecosystem.\n\nIn recent years, Meta has been particularly active in the acqusition market, snapping up several AI-driven security startups looking to modernize their offerings. The company completed at least three acquisitions in 2024 alone, focusing on machine learning-based threat analysis and zero-trust architecture providers. Their M&A strategy tends to favor companies with strong technical teams rather than those with large customer bases—they're buying talent and IP, not revenue.\n\nLeadership at Meta Cybersecurity has remained relatively stable, with most of the executive team having been with the company for over a decade. This continuity has allowed them to maintain consistent strategic direction even as the cybersecurity landscape shifts dramatically. They've been rumored to be in discussions with [Anduril Industries](companies/anduril-industries) regarding potential partnership opportunities in the defense sector, though neither party has confirmed these reports.\n\nThe firm maintains a low public profile compared to flashier competitors, preferring to let their client relationships speak for themselves. Their government contracting work, in particular, requires discretion. Meta has also been mentioned in connection with [Palantir Technologies](companies/palantir-technologies) as a potential acquisition target, though industry analysts consider this unlikely given Meta's own acquisition-focused strategy and the cultural differences between the two organizations.\n\nHeadquartered in the Washington D.C. metro area, Meta employs approximately 800 people across their main office and satellite locations in Austin and Tel Aviv.",
-  "timeline": "- **2021-03-15** | Meta acquires small endpoint security startup based in Boston for undisclosed sum\n- **2021-09-22** | Company celebrates 24 years in operation with internal summit featuring keynote on future of zero-trust\n- **2022-04-08** | Meta Cybersecurity signs major contract with Department of Defense for network monitoring services\n- **2022-11-30** | Opens new R&D facility in Tel Aviv focused on threat intelligence\n- **2023-06-14** | Partnership discussions reportedly begin with [Anduril Industries](companies/anduril-industries) around defense applications\n- **2024-02-19** | Completes acquisition of AI security startup, third deal in eight months\n- **2024-08-05** | Meta leadership meets with [Palantir Technologies](companies/palantir-technologies) executives at RSA Conference, sparking merger speculation\n- **2025-01-12** | Launches next-generation threat detection platform incorporating acquired ML technology\n- **2025-07-28** | Announces expansion of Austin office, adding 150 new engineering positions\n- **2026-03-03** | Named to Gartner Magic Quadrant for Enterprise Network Security for fifth consecutive year",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/meta-2",
-    "name": "Meta",
-    "category": "acquirer",
-    "industry": "cybersecurity",
-    "founded_year": 1997
-  }
-}

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

@@ -1,15 +0,0 @@
-{
-  "slug": "companies/microsoft-0",
-  "type": "company",
-  "title": "Microsoft",
-  "compiled_truth": "Microsoft is a dominant force in the cybersecurity landscape, having transformed itself from a traditional software giant into one of the most aggressive acquirers in the security space. Founded in 1995, the company has methodically built out its security portfolio through strategic acquisitions and internal development, positioning itself as a one-stop shop for enterprise security needs.\n\nThe company's cybersecurity division generates over $20 billion in annual revenue, making it one of the largest security vendors globally. Microsoft's approach has been to embed security deeply into its cloud infrastructure, particularly Azure and Microsoft 365, creating an integrated ecosystem thats difficult for competitors to match. Their Defender suite, Sentinel SIEM platform, and Entra identity solutions form the backbone of security for thousands of enterprises worldwide.\n\nMicrosoft's acquisition strategy has been notably aggressive. They've snapped up numerous startups and established players alike, often integrating the technology directly into their existing platforms. This has created tension with pure-play security vendors who find themselves competing against a company that bundles security features into products their customers already use. Some critics argue this bundling approach leads to \"good enough\" security rather than best-in-class protection, but the convenience factor has proven compelling for many IT departments.\n\nThe company has also invested heavily in threat intelligence, operating one of the largest security research teams in the industry. Their visibility into global attack patterns—derived from telemetry across Windows, Azure, and Office 365—gives them unique insights that feed back into their products. Recent moves have focused on AI-powered security tools, with Microsoft positioning Copilot for Security as a force multiplier for understaffed security teams.\n\nLeadership under Satya Nadella has prioritized security as a core pillar, especially following several high-profile breaches affecting Microsoft's own infrastructure. The company has faced scrutiny from government agencies and enterprise customers demanding better baseline security, prompting internal reorganizations and the Secure Future Initiative. Despite these challanges, Microsoft remains a category-defining player that shapes how the industry thinks about integrated security platforms.",
-  "timeline": "- **2021-03-15** | Microsoft announces acquisition of RiskIQ for threat intelligence capabilities, expanding its external attack surface management\n- **2021-07-22** | Completed purchase of CloudKnox Security to bolster identity and access management portfolio\n- **2022-04-18** | Launched Microsoft Entra brand, consolidating identity products under unified naming\n- **2022-11-09** | Security revenue surpasses $20 billion annually, making MSFT one of the largest security vendors globally\n- **2023-03-28** | Unveiled Security Copilot at Ignite, bringing generative AI to security operations workflows\n- **2023-08-14** | Faced congressional scrutiny following Chinese threat actor breach of government email accounts via compromised signing keys\n- **2024-01-22** | Announced Secure Future Initiative following internal security review, pledging fundamental changes to development practices\n- **2024-06-11** | Expanded partnership with major defense contractors for classified cloud security workloads\n- **2025-02-19** | Acquired endpoint detection startup to enhance Defender capabilities in OT/IoT environments\n- **2025-09-03** | Microsoft Security leadership presented at RSA Conference on next-generation SIEM architecture",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/microsoft-0",
-    "name": "Microsoft",
-    "category": "acquirer",
-    "industry": "cybersecurity",
-    "founded_year": 1995
-  }
-}

eval/data/world-v1/companies__mosaic-14.json

@@ -1,24 +0,0 @@
-{
-  "slug": "companies/mosaic-14",
-  "type": "company",
-  "title": "Mosaic - Consumer Social Startup",
-  "compiled_truth": "Mosaic is a consumer social startup founded in 2018 by [Vera Chen](people/vera-chen-14), who serves as the company's CEO. The company operates in the consumer social space, building products that aim to reimagine how people connect and share experiences online. Based on the premise that traditional social media has become too performative and shallow, Mosaic set out to create more authentic digital spaces for meaningful interaction.\n\nThe platform's core product allows users to create collaborative visual stories—essentially shared digital scrapbooks that multiple people can contribute to in real-time. Think of it as a blend between Pinterest boards and group chats, but with richer media capabilities. The name \"Mosaic\" reflects this vision: individual pieces coming together to form something beautiful and cohesive.\n\nVera Chen built the initial prototype while working nights and weekends, drawing on her background in interaction design and her frustration with existing social platforms. Early traction came from college students coordinating group trips and long-distance friend groups trying to stay connected. The organic growth caught the attention of several investors in the Bay Area.\n\n[Helen Martinez](people/helen-martinez-87) led an early investment round, providing crucial capital that allowed Mosaic to expand its engineering team and improve infastructure. Martinez saw potential in Chen's vision and the company's strong retention metrics among its early user base. The investment also brought valuable mentorship to the young founder.\n\nThe company has faced significant competition from established players who've tried to replicate similar features. Instagram's \"Collabs\" and Snapchat's shared stories both emerged after Mosaic gained traction. However, the startup has maintained its niche by focusing on depth over breadth—their users create fewer posts but spend more time on each one.\n\nMosiac currently employs around 35 people, mostly engineers and designers. The team operates with a hybrid work model, with offices in San Francisco. Revenue comes primarily from a freemium subscription model, though the company has experimented with brand partnerships for special templates and features.",
-  "timeline": "- **2018-03-15** | Vera Chen incorporates Mosaic and begins building the first prototype\n- **2018-11-02** | Beta launch to 500 users, mostly from Chen's network and local universities\n- **2019-06-20** | [Helen Martinez](people/helen-martinez-87) leads seed round of $2.1M\n- **2020-01-08** | Mosaic hits 100,000 registered users during pandemic surge in social app usage\n- **2021-04-12** | Series A closes at $12M, company expands engineering team to 20\n- **2022-09-30** | Launch of Mosaic Pro subscription tier with premium collaborative features\n- **2023-03-18** | [Vera Chen](people/vera-chen-14) speaks at SXSW on \"Building for Authentic Connection\"\n- **2024-07-22** | Partnership announced with major photo printing service for physical mosaic books\n- **2025-02-14** | Company reaches 2 million monthly active users milestone\n- **2025-11-03** | Mosaic acquires small AR startup to integrate spatial features into platform",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/mosaic-14",
-    "name": "Mosaic",
-    "category": "startup",
-    "industry": "consumer social",
-    "founded_year": 2018,
-    "founders": [
-      "people/vera-chen-14"
-    ],
-    "investors": [
-      "people/helen-martinez-87"
-    ],
-    "employees": [
-      "people/chris-rodriguez-124"
-    ]
-  }
-}

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

@@ -1,14 +0,0 @@
-{
-  "slug": "companies/nea-13",
-  "type": "company",
-  "title": "NEA (New Enterprise Associates)",
-  "compiled_truth": "New Enterprise Associates, commonly known as NEA, stands as one of the largest and most established venture capital firms in the world. Founded in 1977, the firm has grown from its roots in early-stage technology investing to become a multi-stage powerhouse with assets under management exceeding $25 billion. NEA operates across the full spectrum of venture investing, from seed rounds to growth equity, with a particular focus on technology and healthcare sectors.\n\nThe firm maintains offices in Menlo Park, San Francisco, New York, Boston, and internationally, giving it substantial reach across major startup ecosystems. NEA's investment philosophy emphasizes long-term partnerships with founders, and they've backed some of the most consequential companies of the past several decades including Salesforce, Workday, and Uber. Their healthcare practice is particularly notable, having invested in numerous successful biotech and medical device companies.\n\nIn recent years NEA has continued to raise substantial funds, with their latest flagship fund exceeding $3.6 billion. The firm operates with a relatively large partnership compared to some peers, allowing them to cover more ground but sometimes leading to questions about decision-making speed. Partners like Scott Sandell and Peter Barris have shaped the firms direction over multiple decades, though newer partners are increasingly taking lead roles on deals.\n\nNEA has shown interest in emerging areas like AI infrastructure and climate tech, competing with firms like [Andreessen Horowitz](companies/a16z-9) for the hottest deals. Their approach tends to be more traditional than some newer entrants to venture — they're known for thorough due dilligence and sometimes slower processes, which can be both a feature and a bug depending on founder preferences. The firm frequently co-invests alongside other major players including [Sequoia Capital](companies/sequoia-capital-6), particularly on larger growth rounds where syndicate diversity matters to founders.\n\nNEA's brand carries significant weight in boardrooms and with LPs, though they face ongoing pressure to demonstrate continued relevance as the venture landscape evolves rapidly around them.",
-  "timeline": "- **2021-03-15** | NEA closes Fund XIV at $3.6 billion, one of the largest funds in firm history\n- **2021-09-22** | Lead investment in Series B for AI-native cybersecurity startup alongside [Sequoia Capital](companies/sequoia-capital-6)\n- **2022-04-08** | Partner Hannah Kreiswirth promoted to lead healthcare investing practice\n- **2022-11-30** | NEA portfolio company exits via SPAC merger, generating 8x return\n- **2023-06-14** | Announced strategic focus on climate tech, committing $500M to sector\n- **2023-10-02** | Co-led $180M growth round in enterprise AI company with [Andreessen Horowitz](companies/a16z-9)\n- **2024-02-19** | Opened new office in London to expand European presence\n- **2024-08-07** | Scott Sandell announces transition to Chairman role, new managing partners named\n- **2025-01-23** | Led seed round for stealth quantum computing startup at $40M valuation\n- **2025-05-11** | NEA portfolio company IPO on NYSE, largest venture-backed healthcare listing of the year",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/nea-13",
-    "name": "NEA",
-    "category": "vc",
-    "industry": "venture capital"
-  }
-}

eval/data/world-v1/companies__nexus-41.json

@@ -1,21 +0,0 @@
-{
-  "slug": "companies/nexus-41",
-  "type": "company",
-  "title": "Nexus",
-  "compiled_truth": "Nexus is a biotech startup founded in 2023 by [Alice Kim](people/alice-kim-41), a computational biologist who previously spent nearly a decade at Genentech before striking out on her own. The company operates in the synthetic biology space, specifically focused on developing novel protein engineering platforms that leverage machine learning to accelerate drug discovery timelines.\n\nThe founding thesis behind Nexus centers on a simple but powerful idea: traditional protein design is too slow and too expensive. [Alice Kim](people/alice-kim-41) built the initial prototype while still moonlighting at her previous role, using transformer-based models to predict protein folding outcomes with what she claims is 40% better accuracy than existing tools. Bold claim. The early data seems to back it up, though peer review is still pending on their foundational paper.\n\nNexus raised a $4.2M seed round in late 2023, led by a syndicate of biotech-focused angels and one undisclosed strategic investor rumored to be connected to a major pharma company. The funds went primarily toward buildling out their wet lab capabilities in South San Francisco and hiring a small but senior team of six full-time employees. Alice has been deliberate about keeping the team lean—she's said publicly that she'd rather have five exceptional people than fifteen mediocre ones.\n\nThe company's go-to-market strategy involves partnering with mid-size pharmaceutical companies who lack the in-house ML expertise to build these platforms themselves. Nexus positions itself as a \"co-pilot\" rather than a replacement, which has helped ease concerns about IP ownership and control. Two pilot partnerships were announced in early 2024, though neither partner has been named publicly.\n\nCulturally, Nexus operates with an almost academic intensity. Weekly journal clubs, mandatory documentation of experiments, open internal debates about methodology. Alice brought this ethos from her research days and has made it core to how the company functions. Some employees thrive in this environment; others have found it exhausting. Turnover has been minimal so far, but the company is still young.",
-  "timeline": "- **2023-03-15** | [Alice Kim](people/alice-kim-41) incorporates Nexus as a Delaware C-corp while still employed at Genentech\n- **2023-06-22** | Alice leaves Genentech to work on Nexus full-time; secures initial $500K pre-seed from angel investors\n- **2023-09-08** | Nexus closes $4.2M seed round; announces plans to open South San Francisco wet lab\n- **2023-11-30** | First full-time hire: Dr. Marcus Chen joins as Head of Protein Engineering\n- **2024-01-17** | Wet lab facility becomes operational; first internal experiments begin\n- **2024-04-03** | Nexus announces two unnamed pharmaceutical partnership pilots\n- **2024-07-12** | [Alice Kim](people/alice-kim-41) presents preliminary platform results at SynBioBeta conference\n- **2024-10-25** | Team expands to six FTEs; company moves to larger office space\n- **2025-02-14** | Submits foundational paper on ML-driven protein folding to Nature Methods\n- **2025-06-01** | Series A discussions reportedly underway with multiple tier-1 biotech VCs",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/nexus-41",
-    "name": "Nexus",
-    "category": "startup",
-    "industry": "biotech",
-    "founded_year": 2023,
-    "founders": [
-      "people/alice-kim-41"
-    ],
-    "employees": [
-      "people/eric-park-151"
-    ]
-  }
-}

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

@@ -1,24 +0,0 @@
-{
-  "slug": "companies/nimbus-5",
-  "type": "company",
-  "title": "Nimbus",
-  "compiled_truth": "Nimbus is a climate tech startup founded in early 2025 by [Mia Anderson](people/mia-anderson-5), a serial entrepreneur with a background in atmospheric science and distributed systems. The company is building what they describe as a \"climate intelligence layer\" — essentially a real-time data platform that aggregates satellite imagery, sensor networks, and predictive models to help enterprises and governments make better decisions around carbon accounting, extreme weather preparedness, and supply chain resiliance.\n\nThe founding story is pretty straightforward. Mia had been working on climate modeling tools at a larger company, got frustrated with how slow things moved, and decided to spin out her own thing. She bootstrapped for about three months before bringing on [Noah Nakamura](people/noah-nakamura-182) as an advisor. Noah's been instrumental in shaping their go-to-market strategy, particularly around enterprise sales cycles and pricing architecture.\n\nNimbus operates with a small but focused team — currently around 8 people, mostly engineers with a couple of climate scientists. They've been pretty heads-down on product development, though theyve started doing some early pilots with logistics companies in the Pacific Northwest. The initial use case seems to be helping shipping and freight operations anticipate weather disruptions and reroute proactively.\n\nWhat makes Nimbus interesting is their approach to data fusion. Rather than building their own sensor network from scratch, they're aggregating existing data sources — NOAA feeds, commercial satellite providers, IoT sensors already deployed by clients — and layering their own ML models on top. This keeps their infrastructure costs relatively low while still delivering actionable insights.\n\nThe company hasn't announced any formal funding rounds yet, though rumors suggest they're in conversations with a few climate-focused VCs. Mia Anderson has been intentionally keeping things quiet, preferring to let the product speak for itself before raising. Their advisory relationship with Noah Nakamura gives them some credibility in enterprise circles, which should help when they do decide to go out for capital.",
-  "timeline": "- **2024-09-15** | [Mia Anderson](people/mia-anderson-5) leaves previous role to begin exploring climate intelligence concepts\n- **2025-01-08** | Nimbus officially incorporated in Delaware\n- **2025-02-14** | [Noah Nakamura](people/noah-nakamura-182) joins as advisor, begins weekly strategy sessions\n- **2025-03-22** | First engineering hire made — backend systems specialist from Google\n- **2025-04-10** | Internal alpha of climate data platform completed\n- **2025-05-18** | Pilot program launched with two Pacific Northwest logistics companies\n- **2025-07-02** | Team expands to 8 full-time employees\n- **2025-08-29** | Nimbus presents at Climate Tech Connect conference in Portland\n- **2025-10-15** | Early discussions begin with climate-focused VC firms",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/nimbus-5",
-    "name": "Nimbus",
-    "category": "startup",
-    "industry": "climate tech",
-    "founded_year": 2025,
-    "founders": [
-      "people/mia-anderson-5"
-    ],
-    "employees": [
-      "people/quinten-nakamura-115"
-    ],
-    "advisors": [
-      "people/noah-nakamura-182"
-    ]
-  }
-}

eval/data/world-v1/companies__nimbus-labs-55.json

@@ -1,21 +0,0 @@
-{
-  "slug": "companies/nimbus-labs-55",
-  "type": "company",
-  "title": "Nimbus Labs",
-  "compiled_truth": "Nimbus Labs is a developer tools startup founded in 2019 by [Vera Kapoor](people/vera-kapoor-55), who previously spent nearly a decade building infrastructure at larger tech companies before striking out on her own. The company focuses on cloud-native debugging and observability tooling, with their flagship product being a distributed tracing platform that's gained significant traction among mid-sized engineering teams.\n\nThe core thesis behind Nimbus is that debugging microservices shouldn't require a PhD in distributed systems. Their approach combines automatic instrumentation with AI-assisted root cause analysis, letting developers pinpoint issues across complex service meshes without manually correlating logs across dozens of services. It's an opinionated take on observability that's rubbed some infrastructure purists the wrong way, but the product's ease of adoption has won over plenty of converts.\n\nVera has been the public face of the company since day one, frequently speaking at conferences about the future of developer experience. She's known for her direct communication style and has built a small but loyal following on technical blogs. Under her leadership, Nimbus Labs has grown from a three-person team working out of a WeWork to roughly 45 employees spread across San Francisco and a small office in Bangalore.\n\nThe company raised a Series A in late 2021 and has been relatively quiet about fundraising since, though rumors of a Series B have circulated. Nimbus competes in a crowded space against established players like Datadog and newer entrants, but they've carved out a niche by focusing specifically on the debugging workflow rather than trying to be an all-in-one platform. Recent product updates have emphasized integration with popular CI/CD pipelines and expanded support for serverless architectures.\n\n[Vera Kapoor](people/vera-kapoor-55) remains CEO and maintains a hands-on role in product decisions, which some investors see as both a strength and potential bottleneck as the company scales. The next year will likely determine whether Nimbus can break out of its current niche or gets aquired by a larger platform player.",
-  "timeline": "- **2019-03-14** | Nimbus Labs incorporated in Delaware; [Vera Kapoor](people/vera-kapoor-55) listed as sole founder and CEO\n- **2019-11-02** | First public beta launched at a small developer meetup in SF; initial feedback was mixed but enthusiastic from early adopters\n- **2021-06-18** | Closed $8.5M Series A led by Baseline Ventures; announced plans to triple engineering headcount\n- **2022-02-10** | Shipped v2.0 of core tracing platform with AI-assisted analysis features\n- **2022-09-23** | Vera Kapoor delivered keynote at DevOpsCon on \"The Death of Manual Debugging\"\n- **2023-04-05** | Opened Bangalore engineering office; hired first international team members\n- **2023-11-30** | Reached 1,000 paying customers milestone; mostly SMB and mid-market\n- **2024-07-12** | Launched serverless support after months of customer requests\n- **2025-01-20** | Rumored acquisition talks with larger observability vendor fell through\n- **2025-08-03** | Announced partnership with major cloud provider for native integration",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/nimbus-labs-55",
-    "name": "Nimbus Labs",
-    "category": "startup",
-    "industry": "developer tools",
-    "founded_year": 2019,
-    "founders": [
-      "people/vera-kapoor-55"
-    ],
-    "employees": [
-      "people/iris-jones-165"
-    ]
-  }
-}

eval/data/world-v1/companies__orbit-42.json

@@ -1,25 +0,0 @@
-{
-  "slug": "companies/orbit-42",
-  "type": "company",
-  "title": "Orbit - Biotech Startup",
-  "compiled_truth": "Orbit is a biotech startup founded in 2021 by [Jack Patel](people/jack-patel-42), focused on developing novel protein engineering platforms for therapeutic applications. The company emerged from Patel's earlier research work and has positioned itself at the intersection of computational biology and wet lab innovation. Based out of the Boston-Cambridge biotech corridor, Orbit has built a lean but ambitious team.\n\nThe company's core technology revolves around machine learning-driven protein design, enabling faster iteration cycles for drug candidates targeting rare genetic disorders. Their proprietary platform, internally called \"Orbital,\" can predict protein folding outcomes with unusual accuracy, cutting development timelines significantly. Early partnerships with academic institutions have validated their approach, though comercial traction remains nascent.\n\nFunding has come from angel investors including [Julia Davis](people/julia-davis-86) and [Zoe Gonzalez](people/zoe-gonzalez-100), both of whom participated in Orbit's seed round. Davis in particular has been an active advisor, leveraging her network in the life sciences space to open doors for the young company. Gonzalez contributed not just capital but also operational guidance, having scaled biotech ventures before.\n\nJack Patel serves as CEO and remains deeply involved in the scientific direction. He's known for being hands-on in the lab despite growing management responsibilites. The team has grown to roughly 15 people as of late 2024, with key hires in protein chemistry and ML engineering.\n\nOrbit has kept a relatively low profile compared to flashier biotech startups, preferring to let results speak. They've published two peer-reviewed papers and presented at major conferences including the Biotech Showcase in San Francisco. The company is currently running preclinical studies for their lead program, OBT-101, targeting a rare metabolic condition. Industry watchers see Orbit as a company to watch—small but technically rigorous, with a founder who understands both the science and the business.",
-  "timeline": "- **2021-03-15** | Orbit incorporated in Delaware by [Jack Patel](people/jack-patel-42)\n- **2021-08-22** | Closed $1.2M seed round led by [Julia Davis](people/julia-davis-86)\n- **2022-02-10** | First version of Orbital platform completed internally\n- **2022-09-18** | Published initial findings in Nature Biotechnology\n- **2023-01-24** | [Zoe Gonzalez](people/zoe-gonzalez-100) joins as advisor and investor\n- **2023-06-30** | Hired Dr. Maria Chen as Head of Protein Chemistry\n- **2024-01-12** | Presented OBT-101 preclinical data at JP Morgan Healthcare Conference\n- **2024-07-08** | Expanded lab space in Cambridge, MA\n- **2025-03-20** | Initiated IND-enabling studies for lead program\n- **2025-11-05** | Announced collaboration with major pharma partner (undisclosed)",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/orbit-42",
-    "name": "Orbit",
-    "category": "startup",
-    "industry": "biotech",
-    "founded_year": 2021,
-    "founders": [
-      "people/jack-patel-42"
-    ],
-    "investors": [
-      "people/julia-davis-86",
-      "people/zoe-gonzalez-100"
-    ],
-    "employees": [
-      "people/rachel-jones-152"
-    ]
-  }
-}

eval/data/world-v1/companies__prism-43.json

@@ -1,31 +0,0 @@
-{
-  "slug": "companies/prism-43",
-  "type": "company",
-  "title": "Prism",
-  "compiled_truth": "Prism is a cybersecurity startup founded in 2023 by [David Patel](people/david-patel-43), who previously spent nearly a decade building threat detection systems at larger security firms. The company focuses on what it calls 'adaptive perimeter defense'—essentially AI-driven intrusion detection that learns an organization's normal traffic patterns and flags anomolies in real-time. Its early traction has been notable, particularly among mid-market financial services companies who find enterprise solutions too expensive but need more than basic firewall protections.\n\nThe founding story is pretty straightforward. David had grown frustrated with the slow pace of innovation at his previous employer and saw an opening in the market for lightweight, intelligent security tooling that didn't require a dedicated SOC team to operate. He bootstrapped the initial prototype over six months before raising a seed round.\n\nPrism's investor syndicate includes [Carol Jackson](people/carol-jackson-81), [Rosa Jackson](people/rosa-jackson-90), and [Tina Hernandez](people/tina-hernandez-97). Carol led the seed round and reportedly pushed hard for the company to focus on the SMB market rather than chasing enterprise deals too early. This strategic direction has shaped much of Prism's go-to-market approach. Rosa came in through an angel allocation and has been relatively hands-off, while Tina joined the cap table in a follow-on extension round in late 2024.\n\nOn the advisory side, [Alice Davis](people/alice-davis-172) provides guidance on product architecture—she's known for her work on distributed systems and has been instrumental in helping Prism scale its detection engine. [Olivia Miller](people/olivia-miller-176) advises on sales strategy and customer success, drawing on her background in enterprise software GTM.\n\nThe team has grown to around 18 people, mostly engineers, with a small but scrappy sales org. Prism operates out of Austin but has several remote employees scattered across the US. The company culture skews technical and moves fast—David himself still reviews most major PRs. Revenue is growing but the company isn't yet profitable, which is typical for this stage. They're expected to raise a Series A sometime in mid-2025.",
-  "timeline": "- **2023-02-14** | David Patel incorporates Prism and begins building initial prototype\n- **2023-07-22** | Seed round closes with [Carol Jackson](people/carol-jackson-81) leading, $2.1M raised\n- **2023-11-03** | First paying customer signs—a regional credit union in Texas\n- **2024-01-18** | [Alice Davis](people/alice-davis-172) joins as technical advisor\n- **2024-04-09** | Prism launches v1.0 of its adaptive perimeter defense platform\n- **2024-08-15** | Team hits 12 employees, opens small Austin office\n- **2024-10-30** | Extension round adds [Tina Hernandez](people/tina-hernandez-97) to investor group\n- **2025-01-22** | [Olivia Miller](people/olivia-miller-176) begins advising on GTM strategy\n- **2025-03-11** | ARR crosses $800K, Series A conversations begin",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/prism-43",
-    "name": "Prism",
-    "category": "startup",
-    "industry": "cybersecurity",
-    "founded_year": 2023,
-    "founders": [
-      "people/david-patel-43"
-    ],
-    "investors": [
-      "people/carol-jackson-81",
-      "people/rosa-jackson-90",
-      "people/tina-hernandez-97"
-    ],
-    "employees": [
-      "people/mia-singh-153"
-    ],
-    "advisors": [
-      "people/alice-davis-172",
-      "people/olivia-miller-176",
-      "people/zoe-jackson-199"
-    ]
-  }
-}

eval/data/world-v1/companies__pulse-8.json

@@ -1,27 +0,0 @@
-{
-  "slug": "companies/pulse-8",
-  "type": "company",
-  "title": "Pulse - EdTech Startup",
-  "compiled_truth": "Pulse is an edtech startup founded in 2022 by [Yara Johnson](people/yara-johnson-8), a former learning experience designer who spent nearly a decade observing how students actually engage with digital content. The company's core product is a real-time engagement analytics platform designed for K-12 classrooms and higher education institutions. Unlike traditional LMS analytics that track completion rates and grades, Pulse monitors micro-behaviors—pause patterns, scroll velocity, re-reads—to give educators a genuine sense of whether students are struggling before they fail a test.\n\nThe founding thesis came from Johnson's frustration with existing tools that treated engagement as a binary: either a student watched the video or they didn't. Pulse argues that the *how* matters more than the whether. Their proprietary algorithm flags what they call \"confusion signals\" and surfaces them to teachers in a simple dashboard. Early pilots in three school districts showed a 23% reduction in students falling behind, though critics have raised privacy concerns about the level of behavioral tracking involved.\n\nFunding has been modest but strategic. [Eric Martinez](people/eric-martinez-93) led the seed round in late 2022, bringing not just capital but connections to several charter school networks in Texas and California. Martinez has been vocal about his belief that edtech needs more \"unsexy infrastructure\" plays rather than consumer apps, and Pulse fits that thesis perfectly. The company currently employs around 15 people, mostly engineers and former educators.\n\n[David Kim](people/david-kim-186) serves as an advisor, helping Pulse navigate enterprise sales cycles and district procurement processes—notoriously slow and bureacratic. Kim's background in B2B SaaS has been instrumental in shaping Pulse's go-to-market strategy, which prioritizes landing a few large district contracts over chasing individual schools. As of early 2024, Pulse has contracts with 12 districts serving roughly 40,000 students combined. Revenue isn't disclosed but is rumored to be in the low seven figures. Yara Johnson remains CEO and has been clear she's building for the long haul, not a quick exit.",
-  "timeline": "- **2022-03-14** | Yara Johnson incorporates Pulse after leaving her role at a major textbook publisher\n- **2022-09-08** | Closes seed round led by [Eric Martinez](people/eric-martinez-93), raising $1.8M\n- **2022-11-20** | First pilot launches in Austin ISD with 3 middle schools\n- **2023-02-15** | [David Kim](people/david-kim-186) joins as official advisor\n- **2023-06-01** | Pulse ships v2.0 with redesigned teacher dashboard based on pilot feedback\n- **2023-10-12** | Signs first major district contract with Fresno Unified (18,000 students)\n- **2024-01-29** | Presents at SXSWedu panel on ethical student analytics\n- **2024-05-17** | Expands engineering team to 9 people, opens small Denver office\n- **2024-11-03** | Reaches 40,000 students across 12 districts\n- **2025-02-22** | Begins early conversations about Series A with several edtech-focused VCs",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/pulse-8",
-    "name": "Pulse",
-    "category": "startup",
-    "industry": "edtech",
-    "founded_year": 2022,
-    "founders": [
-      "people/yara-johnson-8"
-    ],
-    "investors": [
-      "people/eric-martinez-93"
-    ],
-    "employees": [
-      "people/xavier-nakamura-118"
-    ],
-    "advisors": [
-      "people/david-kim-186"
-    ]
-  }
-}

eval/data/world-v1/companies__pulse-labs-58.json

@@ -1,26 +0,0 @@
-{
-  "slug": "companies/pulse-labs-58",
-  "type": "company",
-  "title": "Pulse Labs",
-  "compiled_truth": "Pulse Labs is a developer tools startup founded in 2019 by [Rachel Lopez](people/rachel-lopez-58), who previously spent nearly a decade building internal tooling at larger tech companies before striking out on her own. The company focuses on API observability and debugging tools, helping engineering teams identify performance bottlenecks and trace issues across distributed systems. Their flagship product, Pulse Trace, has gained traction among mid-sized SaaS companies looking for alternatives to more expensive enterprise solutions.\n\nThe company operates with a relatively lean team of around 35 employees, mostly engineers, spread across San Francisco and a satellite office in Austin. Rachel has been vocal about maintaining a sustainable growth trajectory rather than chasing hypergrowth, which has shaped the company's culture and hiring practices. This philosophy resonated with their investor group, which includes [Carol Jackson](people/carol-jackson-81), [Priya Taylor](people/priya-taylor-85), and [Rosa Jackson](people/rosa-jackson-90).\n\nPulse Labs raised a $4.2M seed round in early 2020, followed by a Series A of $18M in 2022 led by Priya Taylor's fund. The Series A came at a time when developer tooling was seeing significant investor intrest, and Pulse was well-positioned with strong retention metrics among its early customers. Rosa Jackson joined as an angel investor during the seed round and has remained an active advisor, particularly on go-to-market strategy.\n\nRecent moves include expanding their platform to support OpenTelemetry natively, a decision that required significant engineering investment but opened up compatability with a broader ecosystem. The company also launched a free tier in late 2024 aimed at individual developers and small teams, a strategic bet on bottom-up adoption. Rachel Lopez has mentioned in interviews that they're exploring AI-assisted debugging features, though nothing concrete has been announced yet.\n\nPulse Labs competes with established players like Datadog and newer entrants in the observability space, but differentiates through pricing transparency and a focus on developer experience over enterprise feature bloat.",
-  "timeline": "- **2019-03-15** | Pulse Labs incorporated by [Rachel Lopez](people/rachel-lopez-58) in Delaware\n- **2020-01-22** | Closed $4.2M seed round with participation from [Rosa Jackson](people/rosa-jackson-90)\n- **2020-09-08** | Launched Pulse Trace beta to first 50 customers\n- **2021-06-14** | Reached 200 paying customers milestone\n- **2022-04-03** | Announced $18M Series A led by [Priya Taylor](people/priya-taylor-85)\n- **2022-11-17** | Opened Austin office, hired VP of Engineering\n- **2023-05-22** | Rachel Lopez spoke at DevToolsCon on sustainable startup growth\n- **2024-02-09** | Shipped native OpenTelemetry support in Pulse Trace 3.0\n- **2024-10-30** | Launched free tier for individual developers\n- **2025-03-12** | [Carol Jackson](people/carol-jackson-81) joined board as observer seat",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/pulse-labs-58",
-    "name": "Pulse Labs",
-    "category": "startup",
-    "industry": "developer tools",
-    "founded_year": 2019,
-    "founders": [
-      "people/rachel-lopez-58"
-    ],
-    "investors": [
-      "people/carol-jackson-81",
-      "people/priya-taylor-85",
-      "people/rosa-jackson-90"
-    ],
-    "employees": [
-      "people/alice-jones-168"
-    ]
-  }
-}

eval/data/world-v1/companies__quantum-7.json

@@ -1,27 +0,0 @@
-{
-  "slug": "companies/quantum-7",
-  "type": "company",
-  "title": "Quantum",
-  "compiled_truth": "Quantum is a fintech startup founded in 2022 by [Ulrich Johnson](people/ulrich-johnson-7), a serial entrepreneur with a background in quantitative finance and distributed systems. The company emerged from Johnson's frustration with the sluggish settlement times and opaque fee structures that plague traditional payment rails. Based out of Austin, Texas, Quantum has built a real-time payment reconciliation platform targeting mid-market e-commerce businesses and SaaS companies.\n\nThe core product offers instant transaction matching, automated dispute resolution, and predictive cash flow analytics. What sets Quantum apart from competitors is their proprietary matching algorithm, which reportedly achieves 99.7% accuracy on first-pass reconciliation—a significant improvement over industry standards. The platform integrates with major payment processors, banking APIs, and accounting software, positioning itself as the connective tissue in a fragmented fintech ecosystem.\n\nEarly backing came from [Kate Anderson](people/kate-anderson-107), who led a $2.1M seed round in late 2022. Anderson's involvement brought not just capital but credibility, given her track record of identifying breakout fintech plays. The company has since grown to around 25 employees, with plans to double headcount by end of 2025.\n\nOn the advisory side, [Noah Williams](people/noah-williams-198) has been instrumental in shaping Quantum's go-to-market strategy. Williams' connections in the enterprise software space have opened doors to several pilot programs with Fortune 500 companies—a surprising feat for such a young startup. His guidance on pricing and packaging helped the team move away from a pure usage-based model toward a hybrid subscription approach that's proven more predictable for customers and investors alike.\n\nQuantum's roadmap includes international expansion, starting with the UK and EU markets where PSD2 regulations have created fertile ground for innovative payment solutions. There's also talk of an AI-powered fraud detection layer, though details remain sparse. The company operates somewhat stealthily, preferring to let product traction speak rather than chasing press coverage.",
-  "timeline": "- **2022-03-14** | Ulrich Johnson incorporates Quantum in Delaware, begins recruiting founding engineering team\n- **2022-09-22** | Closes $2.1M seed round led by [Kate Anderson](people/kate-anderson-107)\n- **2022-11-08** | Launches private beta with 12 e-commerce customers\n- **2023-02-15** | [Noah Williams](people/noah-williams-198) joins as lead advisor, focuses on GTM stratgy\n- **2023-06-30** | Exits beta, announces general availability of reconciliation platform\n- **2023-10-12** | Surpasses 200 paying customers, hits $1M ARR milestone\n- **2024-04-18** | Opens Austin headquarters, team grows to 25 employees\n- **2024-08-07** | Begins enterprise pilot program with two Fortune 500 retailers\n- **2025-01-20** | Announces plans for UK expansion, begins regulatory groundwork\n- **2025-05-11** | [Ulrich Johnson](people/ulrich-johnson-7) speaks at FinTech Connect conference on real-time reconciliation",
-  "_facts": {
-    "type": "company",
-    "slug": "companies/quantum-7",
-    "name": "Quantum",
-    "category": "startup",
-    "industry": "fintech",
-    "founded_year": 2022,
-    "founders": [
-      "people/ulrich-johnson-7"
-    ],
-    "investors": [
-      "people/kate-anderson-107"
-    ],
-    "employees": [
-      "people/tina-lopez-117"
-    ],
-    "advisors": [
-      "people/noah-williams-198"
-    ]
-  }
-}