feat: search --hop walks FROM_FILE to Person.

Parser no longer errors; hop 1 returns File, hop 3 reaches Person.
Rebuild writes Leaf-[:FROM_FILE]->File so the walk is not empty
on a fresh index (Gitea #17).

.gitignore

@@ -11,3 +11,4 @@ __pycache__/
 .secrets/
 lib-ladybug/
 go.work.local
+models/

AGENTS.md

@@ -3,7 +3,8 @@
 Evidence-first brain over the ops/eSlider stack. Facts need proof or they are
 `(not confirmed)`.
 
-Read first: [PLAN](PLAN.md) → [docs](docs/).
+Read first: [PLAN](PLAN.md) → [docs](docs/) → [roadmap](docs/roadmap.md)
+(epic [#16](https://git.produktor.io/eSlider/2dph/issues/16)).
 
 ## Method (detective, no fork)
 
@@ -39,14 +40,15 @@ PLAN.md       decisions + execution + open questions
 docs/         published docs
 skills/       in-project agent skills (vendored, no external links)
 bin/          self-describing tools bin/{subject}/{method}.go (shebang)
-bin/brain/    search.go serve.go index.go get.go stats.go eval.go watch.go
+bin/brain/    search.go serve.go index.go add.go get.go stats.go eval.go watch.go
 bin/chats/    sync.go import.go facts.go apply.go; libs in internal/chats
 bin/mail/     sync.go import.go (index_mail → brain/index.go)
-bin/markdown/ import.go (mistune leafs)
+bin/markdown/ import.go (H2 leaf split; Python bin/md/import fallback)
 bin/postgres/ query.go (read-only YAML)
 bin/git/      import.go (go-git history; Python shim execs it)
 bin/web/      search.go (SearXNG; Python shim execs it)
-internal/     shared Go (brain/rank is cgo-free; chats parsers; gitlog; websearch)
+bin/reasoner/ bakeoff.go (D18 CPU OpenAI tool-call bake-off)
+internal/     shared Go (brain/rank is cgo-free; chats parsers; gitlog; websearch; reasoner)
 bin/watch/    corpus watcher (used by bin/brain/watch.go)
 bin/tools/    vendored python libs behind bin/* (kblib, yamlout, websearch)
 bin/cgo/      zig zcc zc++ (CGO via zig cc, not gcc)
@@ -72,9 +74,9 @@ bin/brain/index.go --rebuild                                            # rebuil
   `pdftotext -layout` fast path (~15ms); textless/scanned PDFs fall back to
   docling (isolated subprocess — its native onnx can segfault the parent).
   Conversion never touches the brain DB (crash safety).
-- `index_mail` is a deprecation shim for `bin/brain/index.go --rebuild`. Ladybug
+- `index_mail` is a deprecation shim for `bin/brain/index.go --rebuild`. Bulk
-  corrupts its WAL when brand-new leafs are bulk-inserted while FTS/vector
+  rebuild still deletes `var/kb.lbug` and creates FTS/HNSW last. Single-leaf
-  indexes exist; a fresh DB with indexes created last is the only safe path.
+  write is `bin/brain/add.go` (safe while indexes exist; do not DROP INDEX).
   Keep conversion + indexing separate so a conversion crash can't leave the
   DB mid-transaction.
 
@@ -87,13 +89,16 @@ bin/kb/search "query" [--repo X]                  # deprecated wrapper → bin/b
 bin/brain/search.go "query" [--root facts|info]   # deduction search → YAML
 bin/brain/search.go "query" --no-web              # local graph only
 eval "$(bin/cgo/zig env)"                         # Zig cc + liblbug (not gcc)
+bin/brain/add.go --text T --root facts --source "a.md x b.md"  # incremental write
+bin/brain/add.go --json                                      # stdin leaf or {leafs:[...]}
 bin/brain/get.go <id> [--body] [--json]          # Go read; Python bin/kb/get CI fallback
 bin/brain/stats.go [--json]
 bin/brain/eval.go [--json]                       # recall@5; questions in internal/brain/rank
 bin/brain/serve.go                               # HTTP :8630; GET /openapi.json POST /mcp
-bin/markdown/import.go [dir]                      # mistune leaves → YAML
+bin/markdown/import.go [dir]                      # H2 leafs → YAML; Python bin/md/import fallback
 bin/git/import.go [REPO] [--json] [--limit N]     # go-git history → commit leafs
 bin/web/search.go "query" [--json]                # SearXNG; throttled ≠ absence
+bin/reasoner/bakeoff.go [--model ID] [--json]     # D18 CPU tool-call bake-off
 bin/postgres/query.go --profile onlyoffice -c 'SELECT 1'
 bin/md/tables                                     # what the graph holds → YAML
 bin/brain/deduce "question"                       # thinking wrapper

PLAN.md

@@ -4,7 +4,9 @@ A brain that loves facts and deduction. Evidence-first knowledge graph + hybrid
 RAG over the operational Brain/ops/eSlider stack. Built like Sherlock
 Holmes: nothing is asserted unless it has proof.
 
-Status: **in progress** — this file is the plan and the record of decisions.
+Status: **in progress** — read path + MCP work; v1 goal is [epic #16](https://git.produktor.io/eSlider/2dph/issues/16)
+(milestone [v1 detective brain](https://git.produktor.io/eSlider/2dph/milestone/12)).
+Gap: [docs/roadmap.md](docs/roadmap.md).
 
 ## What
 
@@ -29,9 +31,9 @@ detective method: **a fact needs ≥2 independent sources or it is
 | D3 | web search | Go client `bin/web/search.go` (`internal/websearch`). SearXNG URL is config (`BRAIN_SEARCH_URL`). Optional Compose profile `searxng` (sanitized settings). Do not run a second copy on a host that already has one. Empty/`throttled` ≠ “nothing exists”. |
 | D4 | embeddings | **model2vec** `minishlab/potion-multilingual-128M` instead of embeddinggemma. |
 | D5 | parser | **mistune** for MD → leaf extraction (duckdb-md documented as future optional SQL/export layer, not v1). |
-| D6 | graph engine | **LadybugDB**. Go is the service (`bin/brain/search.go`, `bin/brain/serve.go` in-process, `internal/brain`). Read path is Go + Zig CGO (D21). Python `bin/kb/{get,stats,eval}` is the CI fallback when Zig/libs are not fetched. Index/write stays Python (`compose --profile index`) until the Go write path is safe. |
+| D6 | graph engine | **LadybugDB**. Go is the service (`bin/brain/search.go`, `bin/brain/serve.go` in-process, `internal/brain`). Read path is Go + Zig CGO (D21). Python `bin/kb/{get,stats,eval}` is the CI fallback when Zig/libs are not fetched. Incremental write is Python `bin/kb/add` (`bin/brain/add.go`). Bulk rebuild stays `compose --profile index` until the Go write path is safe. |
 | D7 | db access | `db-yaml`/`psql-yq`-style, read-only, YAML out. OnlyOffice Postgres via SSH tunnel (`127.0.0.1:5433`). |
-| D8 | evidence | detective method: ≥2 independent sources or `(not confirmed)`. Auto-pair docker ps × compose × ssh-config × docs. |
+| D8 | evidence | detective method: ≥2 independent sources or `(not confirmed)`. 2-source auto-pair docker ps × compose × ssh-config × docs. |
 | D9 | facts/goal model | Who / What / How / Where / When + evidence + confidence on every edge. |
 | D10 | versioning | everything is a leaf with `sha256 + observed_at + source_rev`; `File-[:HAS_VERSION]->Commit-[:AUTHORED]->Person`. Stale = `source_rev` < git HEAD. |
 | D11 | strong/weak | `root` column: `facts` (strong) vs `info` (weak). Answer is `confirmed` only from facts root. |
@@ -41,9 +43,9 @@ detective method: **a fact needs ≥2 independent sources or it is
 | D15 | repo | Gitea [`eSlider/2dph`](https://git.produktor.io/eSlider/2dph) is origin + [issues](https://git.produktor.io/eSlider/2dph/issues). GitHub `eSlider/2dph` is the public clone (PRs + Actions CI). No direct `main` pushes. TDD → PR → CI green → merge. |
 | D16 | contradictions | ≥2 yes vs ≥2 no → unrelated sources conflict → hypothesis → `(not confirmed)`. Resolution (authority, staleness adjudication) = **v2**, tracked as open question. |
 | D17 | assertion gate | Fact-check every *claim* (facts → info → live → web), not every edit. `bin/brain/search.go` adds a `web` block when there is no facts hit (`throttled`/`skipped`/`refused` ≠ absence). `--root` and `--no-web` stay local. Missing graph ≠ “does not exist”. |
-| D18 | reasoner | Pluggable OpenAI-compatible URL. RAM: Qwen3.5-9B. Quality: Bonsai-27B or Qwen3.6-27B. No official Qwen3.6-9B. |
+| D18 | reasoner | Pluggable OpenAI-compatible URL (`REASONER_BASE_URL`). RAM: `Qwen/Qwen3.5-9B`. Quality: `prism-ml/Bonsai-27B-gguf` or `Qwen/Qwen3.6-27B`. No official Qwen3.6-9B. CPU bake-off: `bin/reasoner/bakeoff.go` + compose profile `reasoner` (`OLLAMA_NUM_GPU=0`, `:11435`). PicoClaw is compose profile `picoclaw`; tools are `search`/`get`/`audit`. Weights are not copied into the 2dph image. Agent lever/loop: [#15](https://git.produktor.io/eSlider/2dph/issues/15). |
 | D19 | git history | [go-git](https://github.com/go-git/go-git) via `bin/git/import.go`. No subprocess of the git binary. Conversion prints commit leafs; brain write is `bin/brain/index.go`. |
-| D20 | agent API | OpenAPI + MCP are generated from the same `internal/httpapi.Ops` table as `bin/brain/serve.go` handlers. `GET /openapi.json`, `POST /mcp` (JSON-RPC tools/list + tools/call). Tool names match OpenAPI paths (`search`/`get`/`stats`/`audit`). |
+| D20 | agent API | OpenAPI + MCP are generated from the same `internal/httpapi.Ops` table as `bin/brain/serve.go` handlers. `GET /openapi.json`, `POST /mcp` (JSON-RPC tools/list + tools/call). Tool names match OpenAPI paths (`search`/`get`/`stats`/`audit`/`ingest`). |
 | D21 | CGO | Ladybug/tokenizers CGO is compiled with **Zig** (`bin/cgo/zcc` → `zig cc -target …-linux-gnu`), not gcc. `bin/cgo/zig` pins Zig 0.14.1 + liblbug 0.19.1 + libtokenizers 1.27.0. Compose `target: api` has no CPython; write/rebuild is profile `index`. |
 
 ## Architecture
@@ -55,18 +57,21 @@ detective method: **a fact needs ≥2 independent sources or it is
   skills/                   in-project skills (web-search, postgres, brain, picoclaw, diataxis-docs)
   bin/
     facts/extract.go audit.go crm.go  # D14 shebang; Python implementation
-    kb/index                Python write path (called by bin/brain/index.go)
+    kb/index                Python bulk write (called by bin/brain/index.go)
+    kb/add                  Python incremental write (called by bin/brain/add.go)
     brain/index.go          rebuild FTS + HNSW (incl. --with-mail)
+    brain/add.go            incremental leaf write (no rebuild)
     brain/get.go stats.go eval.go  # Go read (cgo); Python bin/kb/* CI fallback
     brain/watch.go
     brain/search.go         deduction: facts → info → web-search
     brain/serve.go          HTTP API in-process + OpenAPI/MCP (D20); Zig CGO (D21)
     cgo/zig zcc zc++        CGO toolchain (zig cc, not gcc)
     mail/import.go          JSON → markdown (no brain write)
-    markdown/import.go      mistune leaves
+    markdown/import.go      H2 leaf split (Go); Python bin/md/import fallback
     postgres/query.go       read-only YAML (wraps bin/db/psql-yq)
     git/import.go           go-git history (no git binary; conversion only)
     web/search.go           SearXNG client (throttled ≠ absence)
+    reasoner/bakeoff.go     CPU tool-call bake-off (D18; OpenAI tools)
     chats/sync.go import.go facts.go apply.go
                             (libs in internal/chats; no chats index)
     md/import               (deprecated; bin/markdown/import.go)
@@ -82,7 +87,10 @@ detective method: **a fact needs ≥2 independent sources or it is
 
 Node tables: `Person, Service, Host, Container, Repo, File, Commit, Leaf`.
 `Leaf(embedding FLOAT[N])` — FTS on `text`, HNSW vector index on `embedding`.
-Edges: `RUNS / USES / HAS_VERSION / AUTHORED / ABOUT / ASSOCIATED / SIMILAR_0.85`.
+Edges: `RUNS / USES / FROM_FILE / HAS_VERSION / AUTHORED / ABOUT / ASSOCIATED / SIMILAR_0.85`.
+`FROM_FILE` / `HAS_VERSION` / `AUTHORED`: `bin/brain/search.go --hop N` walks
+them from each hit (1=File, 2=Commit, 3=Person). Rebuild writes
+`Leaf-[:FROM_FILE]->File`; git import writes the rest.
 
 Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`,
 `where`, `when`, `source_rev`.
@@ -107,9 +115,9 @@ Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`,
 ## Open questions (v2)
 
 - OQ1: mutually-contradicting evidence — how to resolve (authority weighting,
-  temporal freshness, audit adjudication).
+  temporal freshness, audit adjudication). **v2**; does not block epic #16.
-- OQ2: OCR pipeline for pdfs/images/docs — mostly solved: poppler pdftotext
+- OQ2: OCR — poppler `pdftotext` fast-path exists; scans still docling.
-  fast-path for born-digital PDFs, docling fallback for the ~5% textless ones.
+  [#6](https://git.produktor.io/eSlider/2dph/issues/6) (v2, does not block #16).
 - OQ3: optional duckdb-md layer for `SELECT … FORMAT MARKDOWN` export/write-back.
 - OQ4: YAML-first storage for leafs — deferred: JSON is ~10x faster to
   serialize and unambiguous; YAML only where humans edit files.
@@ -137,6 +145,7 @@ Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`,
 3. python -m unittest discover -s bin/tools (includes published-docs SoT)
 4. `bin/facts/audit self` (lexicon internal consistency; `bin/facts/audit.go` is the D14 wrapper)
 5. `bin/kb/eval` (recall@5 ≥ 0.95). Local SoT is `bin/brain/eval.go` via Zig CGO.
+   CI SoT switch: [#19](https://git.produktor.io/eSlider/2dph/issues/19).
 6. `bin/cgo/zig go build -tags system_ladybug` (compile search with zig cc; fetches pinned zig+libs).
 
 Feedback loop: every commit → PR → CI → green/gate → merge. Same discipline as
@@ -150,5 +159,23 @@ Feedback loop: every commit → PR → CI → green/gate → merge. Same discipl
 4. .venv: ladybug + model2vec + mistune
 5. schema + tools with TDD (kb + md + facts + brain)
 6. ~/.config/brain config
-7. corpus extraction (facts/info)
+7. corpus extraction (facts/info) — **open**: [#18](https://git.produktor.io/eSlider/2dph/issues/18)
 8. verify: web-search smoke, onlyoffice pg, md-db round-trip, eval, audit
+
+## Gap to v1 (epic #16)
+
+Read path + MCP are in. Incremental `brain/add` and `--hop` are in. Remaining:
+facts+chats corpus on rebuild, and CI eval SoT. Board:
+[epic #16](https://git.produktor.io/eSlider/2dph/issues/16),
+milestone [v1 detective brain](https://git.produktor.io/eSlider/2dph/milestone/12).
+Narrative: [docs/roadmap.md](docs/roadmap.md).
+
+| Order | Issue | Gap |
+|-------|-------|-----|
+| 1 | [#14](https://git.produktor.io/eSlider/2dph/issues/14) | **in** — `bin/brain/add.go` / `POST /ingest` write facts+info without deleting `kb.lbug`. Bulk corpus still `--rebuild`. Leftover Python (mail/facts) is not the living-graph blocker. |
+| 2 | [#17](https://git.produktor.io/eSlider/2dph/issues/17) | **in** — `--hop N` walks `FROM_FILE` → `HAS_VERSION` → `AUTHORED` (max 3). |
+| 3 | [#18](https://git.produktor.io/eSlider/2dph/issues/18) | Rebuild is mostly `info` (repo md + mail). `facts/extract` and chats are not a first-class index input. WhatsApp sync is a stub. |
+| 4 | [#15](https://git.produktor.io/eSlider/2dph/issues/15) | **in** — lever/loop documented (`search` → `get` → `audit`). |
+| 5 | [#19](https://git.produktor.io/eSlider/2dph/issues/19) | GitHub CI recall still runs Python `bin/kb/eval`. |
+
+Does **not** block epic close: [#6](https://git.produktor.io/eSlider/2dph/issues/6) OCR, OQ1, OQ3, OQ4.

README.md

@@ -7,14 +7,16 @@
 [![Latest Release](https://img.shields.io/github/v/tag/eSlider/2dph?sort=semver&label=release)](https://github.com/eSlider/2dph/releases)
 [![GitHub Stars](https://img.shields.io/github/stars/eSlider/2dph?style=social)](https://github.com/eSlider/2dph/stargazers)
 
-An evidence-first brain over the operational eSlider stack. **Facts need two
+An evidence-first brain. **Facts need two independent sources, or they are
-independent sources, or they are `(not confirmed)`.**
+`(not confirmed)`.** Cursor is not the runtime.
 
-`2dph` is a single embedded knowledge graph (LadybugDB = Kuzu successor) with
+`2dph` is a single embedded knowledge graph (LadybugDB) with native **HNSW
-native **HNSW vector** + **BM25 full-text** indexes, built from markdown,
+vector** + **BM25 full-text** indexes. Search is *deduction*: confirmed facts
-compose files, ssh config, docker state, and git history. Search is
+first, supporting info second, `web-search` as the independent second source
-*deduction*: confirmed facts first, supporting info second, `web-search` as
+when the local graph cannot confirm.
-the independent second source when the local graph cannot confirm.
+
+Run it: [docs/runbook.md](docs/runbook.md). Design: [docs/design.md](docs/design.md).
+Docs index: [docs/README.md](docs/README.md).
 
 ## Architecture
 
@@ -31,7 +33,7 @@ graph TB
         EX["bin/facts/extract.go<br/>2-source pairing"]
         AU["bin/facts/audit.go<br/>confidence + staleness"]
         IDX["bin/brain/index.go<br/>chunk + embed"]
-        MD["bin/markdown/import.go<br/>mistune leaves"]
+        MD["bin/markdown/import.go<br/>H2 leaf split"]
         SR["bin/brain/search.go<br/>deduction"]
     end
 
@@ -74,7 +76,7 @@ graph TB
 ## The method
 
 Every assertion is `Who / What / How / Where / When + evidence + confidence`,
-mirroring the detective detective skill: **≥2 independent sources confirm a
+mirroring the detective method: **≥2 independent sources confirm a
 fact; conflicting sources or a single source → `hypothesis` → `(not confirmed)`.**
 
 | root | meaning | used for answers |
@@ -94,7 +96,7 @@ bin/brain/stats.go                                   # index health
 bin/brain/eval.go                                    # recall@5 gate
 ```
 
-`--hop` is not implemented (needs File/FROM_FILE edges); the flag errors instead of walking. `bin/kb/search` is a deprecated wrapper around `bin/brain/search.go`.
+`--hop N` walks File/Commit/Person from each hit (max 3). `bin/kb/search` is a deprecated wrapper around `bin/brain/search.go`.
 
 Git history is read with [go-git](https://github.com/go-git/go-git) (no git binary):
 
@@ -118,23 +120,23 @@ Mail is a first-class corpus (retrievable through the same search):
 ```bash
 bin/mail/sync.go --source onlyoffice,gmail --workers 8 --out var/mail  # raw sync (Go)
 bin/mail/import.go --from-raw var/mail                                  # JSON → markdown
+bin/brain/add.go --text T --root facts --source "a.md x b.md"
 bin/brain/index.go --rebuild                                            # rebuild brain (incl. mail)
 bin/brain/search.go "invoice from last week"                            # same search over mail leafs
 ```
 
 ## Storage
 
-- **LadybugDB** — single `var/kb.lbug`, Cypher property graph, HNSW + BM25
+- **LadybugDB** — single `var/kb.lbug`, Cypher + HNSW + BM25, embedded.
-  in one engine, embedded (no server), ACID, read-only-safe for concurrent
+  Read tools (`get` / `stats` / `eval`) are Go + Zig CGO (`bin/cgo/zcc`).
-  readers. Read tools (`get` / `stats` / `eval`) are Go + Zig CGO (`bin/cgo/zcc`); Python
+  Python fallbacks stay for CI until the runner fetches Zig. Incremental
-  `bin/kb/{get,stats,eval}` is the CI fallback. **Never `DROP INDEX` FTS/VECTOR** on Ladybug 0.19: DROP leaves
+  write is `bin/brain/add.go` (Python `kblib.add_leafs`). Bulk rebuild is
-  ghost catalog tables (`_0_Leaf_vec_UPPER`) so recreate fails while
+  Compose profile `index` (`bin/brain/index.go --rebuild`).
-  `SHOW_INDEXES` omits HNSW. Fresh indexes = delete `var/kb.lbug` +
+- **model2vec** — `potion-multilingual-128M` (256-dim), CPU, no Ollama
-  `bin/brain/index.go --rebuild`. Use `ensure_indexes()` after upserts.
+  runtime dependency.
-- **model2vec** — `potion-multilingual-128M` static embeddings (256-dim),
+- facts and info split by `root` but written in the same transaction.
-  CPU-fast, deterministic, no Ollama runtime dependency.
+
-- facts and info split semantically by `root` column but written inside the
+Ladybug 0.19 DROP INDEX warning: [docs/runbook.md](docs/runbook.md).
-  same transaction.
 
 ## Tooling conventions
 
@@ -145,11 +147,13 @@ machines. Tests gate every commit. HTTP: `bin/brain/serve.go` calls
 
 ## Development
 
+See the portable runbook: [docs/runbook.md](docs/runbook.md).
+
 ```bash
-uv venv .venv                                  # Python 3.12, uv-managed
+uv venv .venv
-uv pip install -r requirements.lock.txt        # pinned toolchain
+uv pip install -r requirements.lock.txt
-bin/facts/audit.go self                        # lexicon consistency gate
+bin/facts/audit.go self
-go test ./... && python -m unittest discover -s bin/tools -t .
+go test ./... && uv run python -m unittest discover -s bin/tools -t .
 ```
 
 Docker (optional, cached model + var volumes):
@@ -158,6 +162,7 @@ Docker (optional, cached model + var volumes):
 docker compose up -d brain                     # API (Zig CGO serve :8630)
 docker compose --profile index run --rm index  # Python Ladybug rebuild
 docker compose --profile picoclaw up brain-mcp # MCP on 127.0.0.1:8630
+docker compose --profile reasoner up -d reasoner  # CPU Ollama 127.0.0.1:11435
 docker compose up brain-watch                  # auto re-index on change
 ```
 
@@ -169,7 +174,9 @@ docker compose up brain-watch                  # auto re-index on change
   skills (`web-search`, `postgres`, …) that 2dph integrates
 - detective method — the two-source method
 
-Work board (issues): [git.produktor.io/eSlider/2dph/issues](https://git.produktor.io/eSlider/2dph/issues).
+Work board (issues): [epic #16](https://git.produktor.io/eSlider/2dph/issues/16)
+on [git.produktor.io/eSlider/2dph/issues](https://git.produktor.io/eSlider/2dph/issues).
 PRs and CI: GitHub [`eSlider/2dph`](https://github.com/eSlider/2dph).
 
-See [PLAN.md](PLAN.md) for decisions, execution status, and v2 open questions.
+See [PLAN.md](PLAN.md) for decisions, [docs/roadmap.md](docs/roadmap.md) for
+the gap to v1, and v2 open questions.

bin/brain/add.go

@@ -0,0 +1,21 @@
+//usr/bin/env go run -tags=brain_add "$0" "$@"; exit
+//go:build brain_add
+//
+// bin/brain/add.go - incremental leaf write (Python kblib, no rebuild).
+//
+//	./bin/brain/add.go --text T --root facts --source "a.md x b.md"
+//	./bin/brain/add.go --json
+//
+// D6: write stays Python. Does not delete var/kb.lbug.
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/internal/cmdbin"
+)
+
+func main() {
+	os.Exit(cmdbin.ExecFile("bin/kb/add", os.Args[1:]))
+}

bin/brain/index.go

@@ -7,8 +7,8 @@
 //	./bin/brain/index.go --rebuild --with-mail
 //	./bin/brain/index.go --dry-run --with-mail
 //
-// v1 write is always a rebuild when mail is included (live FTS/HNSW + bulk
+// v1 write: bin/brain/add.go for one/few leafs (indexes may already exist).
-// insert corrupts Ladybug 0.19 WAL). `add` is v2.
+// Bulk mail/corpus still --rebuild (fresh file, indexes last).
 // NOTE: never run `gofmt -w` on this file — it breaks the shebang.
 package main
 

bin/brain/search.go

@@ -3,7 +3,7 @@
 //
 // bin/brain/search.go - deduction search over the 2dph brain.
 //
-//	./bin/brain/search.go "query" [--root facts|info] [--repo P] [-n N] [--json] [--no-web]
+//	./bin/brain/search.go "query" [--root facts|info] [--repo P] [-n N] [--hop N] [--json] [--no-web]
 //	./bin/brain/search.go serve [port]
 //	./bin/brain/search.go --list-model
 //

bin/kb/add

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""kb/add - incremental leaf write (no rebuild).
+
+  bin/kb/add --text T --root facts|info --source S
+  bin/kb/add --json                 # stdin: one object or {"leafs":[...]}
+  bin/kb/add --db PATH --json
+
+Writes facts+info in one Ladybug transaction. Does not delete kb.lbug.
+Embedding is used when provided; otherwise model2vec encodes the text.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "bin" / "tools"))
+
+from kblib import (  # noqa: E402
+    EMBED_DIM,
+    add_leafs,
+    connect,
+    ensure_indexes,
+    init_schema,
+)
+
+
+def _as_leafs(payload: object) -> list[dict]:
+    if isinstance(payload, list):
+        return [dict(x) for x in payload]
+    if isinstance(payload, dict):
+        if "leafs" in payload:
+            return [dict(x) for x in payload["leafs"]]
+        return [dict(payload)]
+    raise ValueError("json must be an object, a list, or {leafs:[...]}")
+
+
+def _embed_missing(leafs: list[dict]) -> None:
+    missing = [lf for lf in leafs if not lf.get("embedding")]
+    if not missing:
+        return
+    from model2vec import StaticModel
+
+    model = StaticModel.from_pretrained("minishlab/potion-multilingual-128M")
+    for lf in missing:
+        text = str(lf.get("text") or "")
+        vec = model.encode([text])[0].astype(float).tolist()
+        if len(vec) != EMBED_DIM:
+            vec = (vec + [0.0] * EMBED_DIM)[:EMBED_DIM]
+        lf["embedding"] = vec
+
+
+def main(argv: list[str]) -> int:
+    import argparse
+
+    p = argparse.ArgumentParser(description="add leafs without rebuilding the brain")
+    p.add_argument("--db", default="", help="path to kb.lbug (default var/kb.lbug)")
+    p.add_argument("--json", action="store_true", help="read leaf JSON from stdin")
+    p.add_argument("--text", default="", help="leaf text")
+    p.add_argument("--root", default="info", choices=("facts", "info"))
+    p.add_argument("--source", default="")
+    p.add_argument("--confidence", default="confirmed")
+    p.add_argument("--source-rev", default="working-tree")
+    p.add_argument("--how", default="brain/add")
+    p.add_argument("--loc", default="")
+    p.add_argument("--type", default="reference", dest="type_")
+    args = p.parse_args(argv)
+
+    if args.json:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            print("kb/add: empty stdin", file=sys.stderr)
+            return 2
+        leafs = _as_leafs(json.loads(raw))
+    else:
+        if not args.text or not args.source:
+            print("kb/add: --text and --source are required (or --json)", file=sys.stderr)
+            return 2
+        leafs = [{
+            "text": args.text,
+            "root": args.root,
+            "source": args.source,
+            "confidence": args.confidence,
+            "source_rev": args.source_rev,
+            "how": args.how,
+            "loc": args.loc or args.source,
+            "type": args.type_,
+        }]
+
+    for lf in leafs:
+        if not lf.get("text") or not lf.get("source"):
+            print("kb/add: each leaf needs text and source", file=sys.stderr)
+            return 2
+
+    _embed_missing(leafs)
+
+    from kblib import DB_PATH, VAR
+
+    dbpath = Path(args.db) if args.db else DB_PATH
+    dbpath.parent.mkdir(parents=True, exist_ok=True)
+    VAR.mkdir(exist_ok=True)
+    db, conn = connect(dbpath, read_only=False)
+    init_schema(conn)
+    ids = add_leafs(conn, leafs)
+    ensure_indexes(conn)
+    conn.close()
+    db.close()
+    print(json.dumps({"mode": "add", "ids": ids, "db": str(dbpath)}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

bin/kb/index

@@ -22,7 +22,7 @@ ROOT = Path(__file__).resolve().parents[2]
 sys.path.insert(0, str(ROOT / "bin" / "tools"))
 
 from kblib import (  # noqa: E402
-    connect, ensure_indexes, init_schema, upsert_leaf,
+    connect, ensure_indexes, init_schema, upsert_leaf, link_from_file,
     open_readonly, stats,
 )
 from mdleaves import read_markdown, to_all, walk_markdown  # noqa: E402
@@ -81,10 +81,11 @@ def index_leafs(conn, leafs: list[dict], embed_fn, limit: int) -> tuple[int, int
     for lf in leafs[:limit] if limit else leafs:
         query = f"{lf['heading']}\n\n{lf['text']}"
         emb = embed_fn(lf["text"]) if lf["text"] else None
-        upsert_leaf(conn, text=query, root="info", confidence="confirmed",
+        lid = upsert_leaf(conn, text=query, root="info", confidence="confirmed",
                     source=lf["source"], source_rev="working-tree",
                     how="kb/index", loc=lf["source"], type_=lf.get("type", "reference"),
                     embedding=emb)
+        link_from_file(conn, lid, lf["source"], repo=str(lf.get("repo") or ""))
         count += 1
     return count, len(leafs)
 

bin/markdown/import.go

@@ -1,20 +1,100 @@
-//usr/bin/env go run -tags=markdown_import "$0" "$@"; exit
+//usr/bin/env go run "$0" "$@"; exit
-//go:build markdown_import
 //
-// bin/markdown/import.go - split markdown into leafs (mistune).
+// bin/markdown/import.go - split markdown into leafs (H2 boundaries).
 //
 //	./bin/markdown/import.go [dir]
 //	./bin/markdown/import.go --files a.md,b.md --json
 //
+// Conversion only. Brain write is bin/brain/index.go.
+// Python bin/md/import remains as a fallback.
 // NOTE: never run `gofmt -w` on this file — it breaks the shebang.
 package main
 
 import (
+	"fmt"
 	"os"
+	"strings"
 
-	"github.com/eSlider/2dph/internal/cmdbin"
+	"github.com/eSlider/2dph/internal/mdleaves"
 )
 
 func main() {
-	os.Exit(cmdbin.ExecFile("bin/md/import", os.Args[1:]))
+	os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+	jsonOut := false
+	files := ""
+	root := "."
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		switch {
+		case a == "--json":
+			jsonOut = true
+		case a == "--files" && i+1 < len(args):
+			i++
+			files = args[i]
+		case strings.HasPrefix(a, "--files="):
+			files = strings.TrimPrefix(a, "--files=")
+		case a == "-h" || a == "--help":
+			fmt.Fprintln(os.Stderr, "bin/markdown/import.go [dir] [--files a.md,b.md] [--json]")
+			return 0
+		case strings.HasPrefix(a, "-"):
+			fmt.Fprintln(os.Stderr, "unknown arg:", a)
+			return 2
+		default:
+			root = a
+		}
+	}
+
+	var paths []string
+	if files != "" {
+		for _, f := range strings.Split(files, ",") {
+			f = strings.TrimSpace(f)
+			if f != "" {
+				paths = append(paths, f)
+			}
+		}
+	} else {
+		st, err := os.Stat(root)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "md/import: no such path %s\n", root)
+			return 2
+		}
+		if !st.IsDir() {
+			paths = []string{root}
+		} else {
+			var err error
+			paths, err = mdleaves.WalkMarkdown(root)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "md/import: %v\n", err)
+				return 1
+			}
+		}
+	}
+	if len(paths) == 0 {
+		fmt.Fprintln(os.Stderr, "md/import: no markdown files")
+		return 1
+	}
+
+	var all []mdleaves.Leaf
+	for _, p := range paths {
+		raw, err := os.ReadFile(p)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "md/import: %s: %v\n", p, err)
+			continue
+		}
+		all = append(all, mdleaves.ToAll(string(raw), p, "")...)
+	}
+	if jsonOut {
+		s, err := mdleaves.EncodeJSON(all)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return 1
+		}
+		fmt.Print(s)
+		return 0
+	}
+	fmt.Print(mdleaves.EncodeYAML(all))
+	return 0
 }

bin/reasoner/bakeoff.go

@@ -0,0 +1,91 @@
+//usr/bin/env go run -tags=reasoner_bakeoff "$0" "$@"; exit
+//go:build reasoner_bakeoff
+//
+// bin/reasoner/bakeoff.go - CPU tool-call bake-off against an OpenAI-compatible URL (D18).
+//
+//	REASONER_BASE_URL=http://127.0.0.1:11435/v1 REASONER_MODEL=qwen3.5:9b ./bin/reasoner/bakeoff.go
+//	./bin/reasoner/bakeoff.go --model MichelRosselli/bonsai-27b:Q1_0 --json
+//
+// Measures OpenAI tool_calls (search/get/audit) and RSS from Ollama /api/ps, not VRAM.
+// PicoClaw is not in this repo; the tool names match internal/httpapi MCP ops.
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/eSlider/2dph/internal/reasoner"
+)
+
+func main() {
+	os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+	base := os.Getenv("REASONER_BASE_URL")
+	if base == "" {
+		base = "http://127.0.0.1:11435/v1"
+	}
+	model := os.Getenv("REASONER_MODEL")
+	if model == "" {
+		model = reasoner.OllamaRAM
+	}
+	jsonOut := false
+	device := "cpu"
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		switch {
+		case a == "--json":
+			jsonOut = true
+		case a == "--model" && i+1 < len(args):
+			i++
+			model = args[i]
+		case strings.HasPrefix(a, "--model="):
+			model = strings.TrimPrefix(a, "--model=")
+		case a == "--base-url" && i+1 < len(args):
+			i++
+			base = args[i]
+		case a == "--device" && i+1 < len(args):
+			i++
+			device = args[i]
+		case a == "-h" || a == "--help":
+			fmt.Fprintln(os.Stderr, "bin/reasoner/bakeoff.go [--model ID] [--base-url URL] [--device cpu] [--json]")
+			return 0
+		default:
+			fmt.Fprintln(os.Stderr, "unknown arg:", a)
+			return 2
+		}
+	}
+	c := reasoner.Client{BaseURL: base, Model: model, Device: device}
+	rep := reasoner.Run(c)
+	raw, err := json.MarshalIndent(rep, "", "  ")
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return 1
+	}
+	if jsonOut {
+		fmt.Println(string(raw))
+	} else {
+		fmt.Printf("model: %s\n", rep.Model)
+		fmt.Printf("hf_id: %s\n", rep.HF)
+		fmt.Printf("device: %s\n", rep.Device)
+		fmt.Printf("tool_call: %d/%d\n", rep.ToolCallOK, rep.ToolCallN)
+		fmt.Printf("xml_leak: %d\n", rep.XMLLeak)
+		fmt.Printf("rss_mb: %d\n", rep.RSSMB)
+		fmt.Printf("vram_mb: %d\n", rep.VRAMMB)
+		for _, p := range rep.Prompts {
+			status := "fail"
+			if p.OK {
+				status = "ok"
+			}
+			fmt.Printf("  %s: %s wanted=%s got=%s xml=%v %dms %s\n", p.WantedTool, status, p.WantedTool, p.ToolName, p.XMLLeak, p.LatencyMS, p.Err)
+		}
+	}
+	if rep.ToolCallN == 0 {
+		return 1
+	}
+	return 0
+}

bin/reasoner/doc.go

@@ -0,0 +1,2 @@
+// Commands in this directory are shebang mains (bakeoff.go).
+package main

bin/tools/kblib.py

@@ -4,7 +4,7 @@ Single embedded graph `var/kb.lbug`. Two roots: facts (assertions backed by
 >=2 independent sources) and info (narrative leafs). Hybrid retrieval: BM25
 (FTS extension) + HNSW cosine (VECTOR extension) + Cypher graph hops.
 
-All access is read-only unless `--rebuild` is passed to kb/index.
+All access is read-only unless `--rebuild` (kb/index) or `kb/add`.
 """
 from __future__ import annotations
 
@@ -118,6 +118,97 @@ def upsert_leaf(conn: ladybug.Connection, *, text: str, root: str, confidence: s
     return lid
 
 
+def add_leafs(conn: ladybug.Connection, leafs: list[dict]) -> list[str]:
+    """Write facts+info leafs in one transaction. Safe while FTS/HNSW exist.
+
+    Each leaf dict: text, source, optional root/confidence/source_rev/how/loc/type/embedding.
+    Does not delete the database file. Measured on Ladybug 0.19: MERGE of new
+    ids (and updates) stays FTS+HNSW queryable; DROP INDEX is the fatal path.
+    """
+    if not leafs:
+        return []
+    started = False
+    try:
+        conn.execute("BEGIN TRANSACTION")
+        started = True
+    except Exception:
+        started = False
+    ids: list[str] = []
+    try:
+        for lf in leafs:
+            ids.append(
+                upsert_leaf(
+                    conn,
+                    text=str(lf["text"]),
+                    root=str(lf.get("root") or ROOT_INFO),
+                    confidence=str(lf.get("confidence") or CONF_CONFIRMED),
+                    source=str(lf["source"]),
+                    source_rev=str(lf.get("source_rev") or "working-tree"),
+                    how=str(lf.get("how") or "brain/add"),
+                    loc=str(lf.get("loc") or lf.get("source") or ""),
+                    type_=str(lf.get("type") or lf.get("type_") or "reference"),
+                    embedding=lf.get("embedding"),
+                )
+            )
+        if started:
+            conn.execute("COMMIT")
+    except Exception:
+        if started:
+            try:
+                conn.execute("ROLLBACK")
+            except Exception:
+                pass
+        raise
+    return ids
+
+
+def file_id(repo: str, path: str) -> str:
+    """Stable File.id matching gitimport (`repo:path`)."""
+    return f"{repo}:{path}" if repo else path
+
+
+def link_from_file(conn: ladybug.Connection, leaf_id: str, path: str,
+                   repo: str = "", mtime: str = "") -> str:
+    """MERGE File and Leaf-[:FROM_FILE]->File so --hop 1 can walk."""
+    fid = file_id(repo, path)
+    conn.execute(
+        "MERGE (f:File {id:$id}) SET f.path=$path, f.repo=$repo, f.mtime=$mtime",
+        parameters={"id": fid, "path": path, "repo": repo, "mtime": mtime},
+    )
+    conn.execute(
+        "MATCH (l:Leaf {id:$lid}), (f:File {id:$fid}) "
+        "MERGE (l)-[:FROM_FILE]->(f)",
+        parameters={"lid": leaf_id, "fid": fid},
+    )
+    return fid
+
+
+HOP_STMTS = {
+    1: "MATCH (l:Leaf {id:$id})-[:FROM_FILE]->(f:File) RETURN f.id, f.path, 1",
+    2: ("MATCH (l:Leaf {id:$id})-[:FROM_FILE]->(f:File)-[:HAS_VERSION]->(c:Commit) "
+        "RETURN c.id, c.subject, 2"),
+    3: ("MATCH (l:Leaf {id:$id})-[:FROM_FILE]->(f:File)-[:HAS_VERSION]->(c:Commit)"
+        "-[:AUTHORED]->(p:Person) RETURN p.id, p.name, 3"),
+}
+HOP_LABELS = {1: "File", 2: "Commit", 3: "Person"}
+
+
+def hop_walk(conn: ladybug.Connection, leaf_id: str, n: int) -> list[dict]:
+    """Walk Leaf → File → Commit → Person up to n hops (max 3)."""
+    depth = min(max(int(n), 0), 3)
+    out: list[dict] = []
+    for d in range(1, depth + 1):
+        rows = conn.execute(HOP_STMTS[d], parameters={"id": leaf_id}).get_all()
+        for row in rows:
+            out.append({
+                "id": row[0],
+                "label": HOP_LABELS[d],
+                "name": row[1],
+                "depth": int(row[2]),
+            })
+    return out
+
+
 def leaf_index_names(conn: ladybug.Connection) -> set[str]:
     """Return index names on the Leaf table (e.g. {'id', 'Leaf_vec', '_PK'})."""
     rows = conn.execute("CALL SHOW_INDEXES() RETURN *").get_all()

bin/tools/test_bin_layout.py

@@ -75,9 +75,20 @@ class BinLayoutTest(unittest.TestCase):
         )
 
     def test_brain_methods_are_shebangs(self) -> None:
-        for method in ("index.go", "get.go", "stats.go", "eval.go", "watch.go"):
+        for method in ("index.go", "add.go", "get.go", "stats.go", "eval.go", "watch.go"):
             self._assert_shebang(f"bin/brain/{method}")
 
+    def test_brain_add_is_python_write_not_rebuild(self) -> None:
+        self._assert_shebang("bin/brain/add.go")
+        text = (ROOT / "bin" / "brain" / "add.go").read_text()
+        self.assertIn("cmdbin.ExecFile", text)
+        self.assertIn("bin/kb/add", text)
+        self.assertNotIn("--rebuild", text)
+        py = (ROOT / "bin" / "kb" / "add").read_text()
+        self.assertIn("add_leafs", py)
+        self.assertIn("--json", py)
+        self.assertNotIn("unlink", py.lower())
+
     def test_brain_get_stats_eval_are_not_python_exec(self) -> None:
         for method in ("get.go", "stats.go", "eval.go"):
             text = (ROOT / "bin" / "brain" / method).read_text()
@@ -125,8 +136,28 @@ class BinLayoutTest(unittest.TestCase):
             "index_mail must point at bin/brain/index.go",
         )
 
-    def test_markdown_import_is_shebang(self) -> None:
+    def test_markdown_import_is_go_not_python_exec(self) -> None:
         self._assert_shebang("bin/markdown/import.go")
+        text = (ROOT / "bin" / "markdown" / "import.go").read_text()
+        self.assertNotIn("ExecFile", text)
+        self.assertNotIn("cmdbin", text)
+        self.assertIn("internal/mdleaves", text)
+        self.assertNotIn("kb.lbug", text)
+
+    def test_import_adapters_do_not_write_ladybug(self) -> None:
+        for rel in (
+            "bin/mail/import.go",
+            "bin/mail/import",
+            "bin/markdown/import.go",
+            "bin/chats/import.go",
+            "bin/git/import.go",
+        ):
+            text = (ROOT / rel).read_text()
+            self.assertNotIn("upsert_leaf", text, rel)
+            self.assertNotIn("kb.lbug", text, rel)
+            self.assertNotIn("var/brain.lbug", text, rel)
+        index = (ROOT / "bin" / "brain" / "index.go").read_text()
+        self.assertIn("bin/kb/index", index)
 
     def test_postgres_query_is_shebang(self) -> None:
         self._assert_shebang("bin/postgres/query.go")

bin/tools/test_index_adapters.py

@@ -0,0 +1,41 @@
+"""Import adapters write files only. Index rebuild is brain/index (D14 / Gitea #7)."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class IndexAdapterTest(unittest.TestCase):
+    def test_dry_run_fixture_corpus_does_not_write_lbug(self) -> None:
+        tmp = Path(tempfile.mkdtemp())
+        (tmp / "note.md").write_text("# Fixture\n\n## Leaf\n\nhello corpus\n", encoding="utf-8")
+        lbug = tmp / "kb.lbug"
+        try:
+            import ladybug  # noqa: F401
+        except ImportError:
+            venv_py = ROOT / ".venv" / "bin" / "python"
+            if not venv_py.is_file():
+                self.skipTest("ladybug missing")
+            py = str(venv_py)
+        else:
+            py = sys.executable
+        proc = subprocess.run(
+            [py, str(ROOT / "bin" / "kb" / "index"), "--dry-run", "--json", "--corpus", str(tmp)],
+            cwd=ROOT,
+            capture_output=True,
+            text=True,
+            env=os.environ.copy(),
+            check=False,
+        )
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        msg = json.loads(proc.stdout)
+        self.assertTrue(msg.get("dry_run"))
+        self.assertGreaterEqual(msg.get("corpus_total", 0), 1)
+        self.assertFalse(lbug.exists(), "dry-run must not create a Ladybug file")

bin/tools/test_kb_add.py

@@ -0,0 +1,69 @@
+"""Incremental add writes leafs without deleting kb.lbug."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class KbAddCLITest(unittest.TestCase):
+    def test_json_add_does_not_delete_db(self) -> None:
+        tmp = Path(tempfile.mkdtemp())
+        dbpath = tmp / "kb.lbug"
+        py = sys.executable
+        venv_py = ROOT / ".venv" / "bin" / "python"
+        if venv_py.is_file():
+            py = str(venv_py)
+        payload = {
+            "text": "cli zebra leaf",
+            "root": "info",
+            "source": "cli-test",
+            "confidence": "confirmed",
+            "how": "test",
+            "loc": str(tmp),
+            "type": "reference",
+            "embedding": [0.0] * 256,
+        }
+        payload["embedding"][0] = 0.3
+        proc = subprocess.run(
+            [py, str(ROOT / "bin" / "kb" / "add"), "--db", str(dbpath), "--json"],
+            cwd=ROOT,
+            input=json.dumps(payload),
+            capture_output=True,
+            text=True,
+            env=os.environ.copy(),
+            check=False,
+        )
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertTrue(dbpath.exists(), "add must create the db, not skip write")
+        out = json.loads(proc.stdout)
+        self.assertEqual(out.get("mode"), "add")
+        self.assertEqual(len(out.get("ids") or []), 1)
+        again = subprocess.run(
+            [py, str(ROOT / "bin" / "kb" / "add"), "--db", str(dbpath), "--json"],
+            cwd=ROOT,
+            input=json.dumps({
+                **payload,
+                "text": "second moose leaf",
+                "source": "cli-test-2",
+            }),
+            capture_output=True,
+            text=True,
+            env=os.environ.copy(),
+            check=False,
+        )
+        self.assertEqual(again.returncode, 0, again.stderr)
+        self.assertTrue(dbpath.exists())
+        second = json.loads(again.stdout)
+        self.assertEqual(len(second.get("ids") or []), 1)
+        self.assertNotEqual(out["ids"][0], second["ids"][0])
+
+
+if __name__ == "__main__":
+    unittest.main()

bin/tools/test_kblib.py

@@ -71,6 +71,69 @@ class KblibTest(unittest.TestCase):
         self.assertTrue(hits)
         self.assertIn("Leaf_vec", kblib.leaf_index_names(self.conn))
 
+    def test_add_after_indexes_keeps_fts_queryable(self):
+        """Incremental add after FTS+HNSW must find the new leaf on both indexes."""
+        kblib.upsert_leaf(self.conn, text="seed fox leaf", root="info",
+                          confidence="confirmed", source="s", source_rev="r1",
+                          how="test", loc="/tmp", type_="reference",
+                          embedding=make_emb(0.1))
+        kblib.ensure_indexes(self.conn)
+        ids = kblib.add_leafs(self.conn, [{
+            "text": "added zebra after index",
+            "root": "facts",
+            "confidence": "confirmed",
+            "source": "a.md x b.md",
+            "source_rev": "r1",
+            "how": "test",
+            "loc": "/tmp",
+            "type": "fact",
+            "embedding": make_emb(0.9),
+        }])
+        self.assertEqual(len(ids), 1)
+        fts = kblib.query_fts(self.conn, "zebra", 5)
+        self.assertTrue(fts)
+        self.assertIn("zebra", fts[0]["text"])
+        self.assertEqual(fts[0]["root"], "facts")
+        vec = kblib.query_vector(self.conn, make_emb(0.9), 5)
+        self.assertTrue(any("zebra" in h["text"] for h in vec))
+        fox = kblib.query_fts(self.conn, "fox", 5)
+        self.assertTrue(fox)
+        self.assertIn("fox", fox[0]["text"])
+
+    def test_add_facts_and_info_one_transaction(self):
+        """D12: facts and info land in the same transaction."""
+        kblib.ensure_indexes(self.conn)
+        ids = kblib.add_leafs(self.conn, [
+            {
+                "text": "tx fact leaf two-source",
+                "root": "facts",
+                "confidence": "confirmed",
+                "source": "compose.yml x docker ps",
+                "source_rev": "r1",
+                "how": "test",
+                "loc": "/tmp",
+                "type": "fact",
+                "embedding": make_emb(0.4),
+            },
+            {
+                "text": "tx info narrative",
+                "root": "info",
+                "confidence": "confirmed",
+                "source": "note.md",
+                "source_rev": "r1",
+                "how": "test",
+                "loc": "/tmp",
+                "type": "reference",
+                "embedding": make_emb(0.5),
+            },
+        ])
+        self.assertEqual(len(ids), 2)
+        stats = kblib.stats(self.conn)
+        self.assertEqual(stats["by_root"].get("facts"), 1)
+        self.assertEqual(stats["by_root"].get("info"), 1)
+        self.assertTrue(kblib.query_fts(self.conn, "two-source", 5))
+        self.assertTrue(kblib.query_fts(self.conn, "narrative", 5))
+
     def test_drop_vector_then_create_raises_clear_error(self):
         """DROP INDEX leaves ghost catalog; create_fts_and_vector must raise."""
         kblib.upsert_leaf(self.conn, text="seed", root="info",
@@ -98,6 +161,39 @@ class KblibTest(unittest.TestCase):
         self.assertEqual(stats["total"], 2)
         self.assertEqual(stats["by_root"], {"facts": 1, "info": 1})
 
+    def test_hop_1_returns_file_hop_3_reaches_person(self):
+        """--hop walks FROM_FILE / HAS_VERSION / AUTHORED (Gitea #17)."""
+        import gitimport
+
+        lid = kblib.upsert_leaf(
+            self.conn, text="readme hop fixture", root="info",
+            confidence="confirmed", source="README.md", source_rev="r1",
+            how="test", loc="README.md", type_="reference",
+            embedding=make_emb(0.3),
+        )
+        kblib.link_from_file(self.conn, lid, "README.md", repo="sample-repo")
+        gitimport.index_commits(self.conn, [gitimport.Commit(
+            sha="a1b2c3d",
+            author="Ada Lovelace",
+            email="ada@example.com",
+            date="2026-08-10T12:00:00Z",
+            subject="feat: first commit",
+            files=["README.md"],
+        )], "sample-repo")
+        hop1 = kblib.hop_walk(self.conn, lid, 1)
+        self.assertEqual(len(hop1), 1)
+        self.assertEqual(hop1[0]["label"], "File")
+        self.assertEqual(hop1[0]["name"], "README.md")
+        self.assertEqual(hop1[0]["depth"], 1)
+        hop3 = kblib.hop_walk(self.conn, lid, 3)
+        labels = {n["label"] for n in hop3}
+        self.assertIn("File", labels)
+        self.assertIn("Commit", labels)
+        self.assertIn("Person", labels)
+        person = [n for n in hop3 if n["label"] == "Person"][0]
+        self.assertEqual(person["name"], "Ada Lovelace")
+        self.assertEqual(person["depth"], 3)
+
 
 if __name__ == "__main__":
     unittest.main()

bin/tools/test_published_docs.py

@@ -1,7 +1,6 @@
-"""Published docs must match live commands (Gitea SoT, brain/search, no fake --hop)."""
+"""Published docs must match live commands (Gitea SoT, brain/search)."""
 from __future__ import annotations
 
-import re
 import unittest
 from pathlib import Path
 
@@ -103,6 +102,35 @@ class PublishedDocsTest(unittest.TestCase):
         self.assertIn('profiles: ["index"]', compose)
         self.assertIn("target: api", compose)
 
+    def test_reasoner_docs_name_real_hf_ids_cpu_sidecar(self) -> None:
+        docs = (ROOT / "docs" / "reasoner.md").read_text()
+        for hf in (
+            "Qwen/Qwen3.5-9B",
+            "Qwen/Qwen3.6-27B",
+            "prism-ml/Bonsai-27B-gguf",
+        ):
+            self.assertIn(hf, docs)
+        self.assertIn("no official qwen3.6-9b", docs.lower())
+        self.assertIn("OLLAMA_NUM_GPU", docs)
+        self.assertIn("rss_mb", docs)
+        self.assertIn("vram_mb", docs)
+        self.assertIn("3/3", docs)
+        self.assertIn("Do not claim 9B is better at tools", docs)
+        self.assertNotIn("Qwen/Qwen3.6-9B", docs)
+        plan = (ROOT / "PLAN.md").read_text()
+        self.assertIn("D18", plan)
+        self.assertIn("Qwen/Qwen3.5-9B", plan)
+        compose = (ROOT / "compose.yaml").read_text()
+        self.assertIn('profiles: ["reasoner"]', compose)
+        self.assertIn("OLLAMA_NUM_GPU", compose)
+        self.assertIn("127.0.0.1:11435", compose)
+        dockerfile = (ROOT / "Dockerfile").read_text()
+        self.assertNotIn(".gguf", dockerfile.lower())
+        self.assertNotIn(".safetensors", dockerfile.lower())
+        api = dockerfile[dockerfile.index("FROM debian:bookworm-slim AS api") :]
+        self.assertNotIn("COPY models", api)
+        self.assertNotIn("qwen", api.lower())
+
     def test_readme_search_escalates_web(self) -> None:
         text = (ROOT / "README.md").read_text()
         self.assertIn("--no-web", text)
@@ -110,19 +138,51 @@ class PublishedDocsTest(unittest.TestCase):
         skill = (ROOT / "skills" / "brain" / "SKILL.md").read_text()
         self.assertIn("`web` block", skill)
 
-    def test_docs_do_not_claim_hop_walks(self) -> None:
+    def test_docs_say_hop_walks_from_file(self) -> None:
         paths = [
             ROOT / "README.md",
             ROOT / "docs" / "design.md",
             ROOT / "skills" / "brain" / "SKILL.md",
-            ROOT / "skills" / "diataxis-docs" / "SKILL.md",
+            ROOT / "docs" / "runbook.md",
+            ROOT / "docs" / "README.md",
         ]
-        # Command-style `--hop 1` / `--hop N` plus follow/walk = the old lie.
-        # Honest "not implemented" notes must not match.
-        lie = re.compile(r"--hop (?:N|1).*(?:follow|walk)", re.I | re.S)
         for path in paths:
             text = path.read_text()
-            self.assertIsNone(
+            self.assertIn("--hop", text, f"{path.relative_to(ROOT)} must document --hop")
-                lie.search(text),
+            self.assertNotIn(
-                f"{path.relative_to(ROOT)} still claims --hop walks the graph",
+                "not implemented",
+                text.lower(),
+                f"{path.relative_to(ROOT)} still says hop is not implemented",
             )
+
+    def test_docs_are_portable_diataxis(self) -> None:
+        index = (ROOT / "docs" / "README.md").read_text()
+        self.assertIn("type: reference", index)
+        for d in ("D3", "D6", "D14", "D15", "D17", "D18"):
+            self.assertIn(d, index)
+        runbook = (ROOT / "docs" / "runbook.md").read_text()
+        self.assertIn("type: howto", runbook)
+        self.assertIn("bin/brain/search.go", runbook)
+        self.assertIn("bin/brain/index.go", runbook)
+        self.assertNotIn("search.ops.io", runbook)
+        self.assertNotIn("/mnt/", runbook)
+        self.assertNotIn("/home/", runbook)
+        readme = (ROOT / "README.md").read_text()
+        self.assertIn("docs/runbook.md", readme)
+        self.assertNotIn("search.ops.io", readme)
+
+    def test_v1_epic_is_named_in_docs(self) -> None:
+        plan = (ROOT / "PLAN.md").read_text()
+        self.assertIn("Gap to v1", plan)
+        self.assertIn("eSlider/2dph/issues/16", plan)
+        self.assertIn("eSlider/2dph/issues/17", plan)
+        self.assertIn("eSlider/2dph/milestone/12", plan)
+        road = (ROOT / "docs" / "roadmap.md").read_text()
+        self.assertIn("type: explanation", road)
+        self.assertIn("issues/16", road)
+        self.assertIn("issues/14", road)
+        index = (ROOT / "docs" / "README.md").read_text()
+        self.assertIn("roadmap.md", index)
+        self.assertIn("epic #16", index)
+        agents = (ROOT / "AGENTS.md").read_text()
+        self.assertIn("roadmap.md", agents)

compose.yaml

@@ -3,6 +3,7 @@
 #   docker compose up -d brain                  # API (Zig CGO serve)
 #   docker compose --profile index run --rm index   # Python rebuild
 #   docker compose --profile picoclaw up brain-mcp
+#   docker compose --profile reasoner up -d reasoner   # CPU Ollama :11435
 #   docker compose --profile searxng up -d
 #
 # Secrets never baked in: search.env + db-profiles.yml from ~/.config/brain.
@@ -114,6 +115,23 @@ services:
       - /tmp
     restart: unless-stopped
 
+  # CPU OpenAI-compatible sidecar (D18). Weights are pulled at runtime, not
+  # baked into the 2dph image. Does not touch host Ollama on :11434.
+  #   docker compose --profile reasoner up -d reasoner
+  #   docker compose --profile reasoner exec reasoner ollama pull qwen3.5:9b
+  reasoner:
+    profiles: ["reasoner"]
+    image: docker.io/ollama/ollama:latest
+    environment:
+      OLLAMA_NUM_GPU: "0"
+      OLLAMA_HOST: "0.0.0.0:11434"
+    ports:
+      - "127.0.0.1:11435:11434"
+    volumes:
+      - reasoner-ollama:/root/.ollama
+    restart: unless-stopped
+
 volumes:
   kb-model:
   kb-var:
+  reasoner-ollama:

docs/README.md

@@ -1,15 +1,38 @@
-# 2dph (deductionphile)
+---
+type: reference
+status: current
+related:
+  - docs/runbook.md
+  - docs/design.md
+  - PLAN.md
+  - docs/roadmap.md
+---
 
-Evidence-first knowledge graph + hybrid RAG over the operational
+# 2dph docs (Diataxis)
-Brain/ops/eSlider stack. Facts need proof or they are
+
+Evidence-first knowledge graph. Facts need proof or they are
 `(not confirmed)`.
 
-- [PLAN.md](../PLAN.md) — decisions, execution order, open questions (v2)
+| Type | Doc |
-- [design](design.md) — schema, deduction model, sources
+|------|-----|
-- [Gitea issues](https://git.produktor.io/eSlider/2dph/issues) — work board (origin)
+| tutorial / howto | [runbook](runbook.md) — run anywhere (uv, Go, Docker) |
+| explanation | [design](design.md) — two roots, deduction, D17/D20/D18 |
+| explanation | [roadmap](roadmap.md) — gap to v1 (epic #16) |
+| howto | [picoclaw](picoclaw.md) — MCP agent profile |
+| howto | [reasoner](reasoner.md) — CPU bake-off (D18) |
+| reference | [PLAN.md](../PLAN.md) — decisions D1–D21 |
+
+Decisions the public face must name: **D3** SearXNG compose, **D6** Go service /
+Python write sidecar, **D14** `bin/{subject}/{method}.go`, **D15** Gitea origin,
+**D17** assertion gate (facts → info → web), **D18** pluggable reasoner.
 
 Search: `bin/brain/search.go "query"` (HTTP: `bin/brain/serve.go` —
-`/health` `/search` `/get` `/stats` `/audit` `/ingest`). `--hop` is
+`/health` `/search` `/get` `/stats` `/audit` `/ingest`). `--hop N` walks
-not a walk; the flag errors until File/FROM_FILE edges exist.
+`FROM_FILE` → Commit → Person from each hit (max 3). Rebuild writes
+File edges ([#17](https://git.produktor.io/eSlider/2dph/issues/17)).
 
-Published docs live here and mirror the project state.
+Work board: [Gitea issues](https://git.produktor.io/eSlider/2dph/issues)
+([epic #16](https://git.produktor.io/eSlider/2dph/issues/16)).
+PRs and CI: GitHub [`eSlider/2dph`](https://github.com/eSlider/2dph).
+
+Published docs live here and match live commands.

docs/design.md

@@ -1,3 +1,12 @@
+---
+type: explanation
+status: current
+related:
+  - docs/README.md
+  - docs/runbook.md
+  - docs/roadmap.md
+---
+
 # Design — facts, info, deduction
 
 ## Two roots, one transaction
@@ -25,8 +34,9 @@ bin/brain/search.go "question"
      is not evidence of absence; `--no-web` / `--root` skip it)
 ```
 
-`--hop` is not implemented yet (needs File/FROM_FILE edges). The flag is an
+`--hop N` walks `Leaf-[:FROM_FILE]->File-[:HAS_VERSION]->Commit-[:AUTHORED]->Person`
-error; it is not a graph walk.
+from each hit (1=File, 2=Commit, 3=Person). Rebuild writes FROM_FILE;
+git import writes HAS_VERSION/AUTHORED ([#17](https://git.produktor.io/eSlider/2dph/issues/17)).
 
 ## Who / What / How / Where / When + evidence
 
@@ -70,12 +80,25 @@ Conflicting pairings (≥2 yes vs ≥2 no) = hypothesis (OQ1 → v2 resolution).
 They do not exec Python. Control questions for recall@5 live in
 `internal/brain/rank` so CI can test the table without libladybug.
 Python `bin/kb/{get,stats,eval}` remain for GitHub Actions until the runner
-fetches Zig + libs (`bin/cgo/zig`). Index/write is still `bin/kb/index`
+fetches Zig + libs (`bin/cgo/zig`). Incremental write is `bin/kb/add`
+(`bin/brain/add.go`). Bulk index/write is still `bin/kb/index`
 (`docker compose --profile index`).
 
 ## Agent API (D20)
 
 `bin/brain/serve.go` exposes the same `internal/httpapi.Ops` table as OpenAPI
 (`GET /openapi.json`) and MCP (`POST /mcp` JSON-RPC `tools/list` +
-`tools/call`). Tool names match paths: `search`, `get`, `stats`, `audit`.
+`tools/call`). Tool names match paths: `search`, `get`, `stats`, `audit`,
+`ingest` (add a leaf; omit body for the CLI hint).
 Agents should use these endpoints instead of shebang CLIs.
+
+## Reasoner (D18)
+
+Pluggable OpenAI-compatible URL. RAM: `Qwen/Qwen3.5-9B`. Quality:
+`prism-ml/Bonsai-27B-gguf` or `Qwen/Qwen3.6-27B`. No official Qwen3.6-9B.
+CPU sidecar: compose profile `reasoner` (`OLLAMA_NUM_GPU=0`,
+`127.0.0.1:11435`). Bake-off: `bin/reasoner/bakeoff.go`. Weights stay out
+of the 2dph image. See [docs/reasoner.md](reasoner.md).
+
+Gap to v1 (hops, corpus, CI eval): [roadmap](roadmap.md),
+[epic #16](https://git.produktor.io/eSlider/2dph/issues/16).

docs/reasoner.md

@@ -0,0 +1,69 @@
+# Reasoner bake-off (D18)
+
+Pluggable OpenAI-compatible URL. 2dph does not ship weights. PicoClaw is
+not in this repo; the bake-off hits the same tool names PicoClaw would
+(`search` → `get` → `audit` from `internal/httpapi.Ops`).
+
+```bash
+docker compose --profile reasoner up -d reasoner
+docker compose --profile reasoner exec reasoner ollama pull qwen3.5:9b
+REASONER_BASE_URL=http://127.0.0.1:11435/v1 REASONER_MODEL=qwen3.5:9b \
+  ./bin/reasoner/bakeoff.go --json
+```
+
+Host Ollama on `:11434` is left alone. This sidecar binds `127.0.0.1:11435`
+with `OLLAMA_NUM_GPU=0` (CPU). Measure RSS (`/api/ps` `size`), not VRAM.
+
+If Compose cannot allocate a project network (Docker IPAM pool exhausted),
+the same sidecar is:
+
+```bash
+docker run -d --name 2dph-reasoner \
+  -e OLLAMA_NUM_GPU=0 \
+  -p 127.0.0.1:11435:11434 \
+  -v 2dph-reasoner-ollama:/root/.ollama \
+  ollama/ollama:latest
+```
+
+## Real Hugging Face ids
+
+| Role | HF id | Ollama tag (this bake-off) |
+|------|-------|----------------------------|
+| RAM / 9B | `Qwen/Qwen3.5-9B` | `qwen3.5:9b` |
+| Quality 27B (CPU) | `prism-ml/Bonsai-27B-gguf` (derived from Qwen3.6-27B) | `MichelRosselli/bonsai-27b:Q1_0` |
+| Quality 27B (full) | `Qwen/Qwen3.6-27B` | not pulled on this CPU box |
+
+There is **no official Qwen3.6-9B**. Do not invent that id.
+
+Qwen3.5-9B has documented upstream tool-call XML bugs. A 9B win on tools
+is only claimed if this bake-off records OpenAI `tool_calls` (not
+`<tool_call>` XML in `content`).
+
+The 2dph API image does not `COPY` GGUF/safetensors. Pull at runtime into
+the `reasoner-ollama` volume.
+
+## Live CPU run
+
+Host sidecar: Ollama **0.32.9**, `OLLAMA_NUM_GPU=0`, `127.0.0.1:11435`,
+`device: cpu`, `vram_mb: 0`. Date: 2026-08-13. Same three prompts
+(`search` / `get` / `audit`). PicoClaw binary was not used; the OpenAI
+tools payload is the surface it would send.
+
+| Model | HF id | tool_call | xml_leak | rss_mb | latency_ms (search/get/audit) |
+|-------|-------|-----------|----------|--------|-------------------------------|
+| `qwen3.5:9b` | `Qwen/Qwen3.5-9B` | 3/3 | 0 | 5790 | 50059 / 51678 / 31980 |
+| `MichelRosselli/bonsai-27b:Q1_0` | `prism-ml/Bonsai-27B-gguf` | 3/3 | 0 | 21951 | 327702 / 166830 / 119808 |
+| `Qwen/Qwen3.6-27B` | `Qwen/Qwen3.6-27B` | not loaded | — | — | too heavy for this CPU box |
+
+Both loaded models emitted OpenAI `tool_calls` (not `<tool_call>` XML) on
+this runtime. **Do not claim 9B is better at tools** — the score is tied
+at 3/3. 9B is smaller and faster. Bonsai RSS includes weights + KV
+(`size` from `/api/ps`); first Bonsai prompt includes cold load.
+
+Re-run:
+
+```bash
+REASONER_BASE_URL=http://127.0.0.1:11435/v1 REASONER_MODEL=qwen3.5:9b \
+  ./bin/reasoner/bakeoff.go --json
+REASONER_MODEL=MichelRosselli/bonsai-27b:Q1_0 ./bin/reasoner/bakeoff.go --json
+```

docs/roadmap.md

@@ -0,0 +1,60 @@
+---
+type: explanation
+status: current
+related:
+  - PLAN.md
+  - docs/design.md
+  - docs/runbook.md
+---
+
+# Gap to v1 — detective brain
+
+Goal: a brain that does not assert without proof. Search is deduction
+(`facts` ≥2 sources → `info` → `web`). `confirmed` only from the facts root.
+
+**v1 is a living graph the agent can write and walk**, not “more RAG”.
+
+Epic: [Gitea #16](https://git.produktor.io/eSlider/2dph/issues/16).
+Milestone: [v1 detective brain](https://git.produktor.io/eSlider/2dph/milestone/12).
+Decisions: [PLAN.md](../PLAN.md).
+
+## In (do not reopen)
+
+Read path Go + Zig CGO (D21). HTTP + OpenAPI + MCP (D20). PicoClaw compose
+profile + CPU reasoner (D18). Mail sync → import → rebuild. D14 shebangs.
+Compose `api` (no CPython) / `index` (Python write). Issues #1–#5, #7–#13.
+[#15](https://git.produktor.io/eSlider/2dph/issues/15) lever/loop.
+[#14](https://git.produktor.io/eSlider/2dph/issues/14) `bin/brain/add.go` /
+`POST /ingest` (Python `kblib.add_leafs`; no Go upsert port).
+[#17](https://git.produktor.io/eSlider/2dph/issues/17) `--hop N` walks
+FROM_FILE / HAS_VERSION / AUTHORED.
+
+## Blockers
+
+```
+question
+    │
+    ├─ FTS + HNSW          ← in
+    ├─ facts / info roots  ← in
+    ├─ web (D17)           ← in
+    ├─ brain/add ACID      ← in
+    ├─ Cypher hop          ← in
+    └─ facts+chats corpus  ← #18
+```
+
+1. **[#18](https://git.produktor.io/eSlider/2dph/issues/18) corpus** —
+   rebuild loads repo markdown + mail as `info`. `facts/extract` pairing
+   and `bin/chats` are not indexed. WhatsApp is a stub. PII stays in `var/`.
+2. **[#19](https://git.produktor.io/eSlider/2dph/issues/19) CI eval** —
+   recall SoT should be `bin/brain/eval.go` via Zig, not Python `bin/kb/eval`.
+
+## Not v1
+
+[#6](https://git.produktor.io/eSlider/2dph/issues/6) OCR (OQ2), OQ1
+contradiction resolution, OQ3 duckdb-md export, OQ4 YAML-first leafs.
+
+## Close epic #16 when
+
+- ops pairing + chat import land as leafs on rebuild
+- MCP tool order is documented and still gated by tests
+- CI recall SoT is `bin/brain/eval.go` via Zig

docs/runbook.md

@@ -0,0 +1,84 @@
+---
+type: howto
+status: current
+related:
+  - docs/README.md
+  - PLAN.md
+---
+
+# Run 2dph (portable)
+
+No laptop-absolute paths. Config lives in env files under `$HOME/.config/brain/`
+(mode 0600), not in git.
+
+## Toolchain
+
+- Go (see `go.mod`)
+- Python 3.12 + [uv](https://docs.astral.sh/uv)
+- Optional: Docker, Zig CGO via `bin/cgo/zig` (not gcc)
+
+```bash
+uv venv .venv
+uv pip install -r requirements.lock.txt
+eval "$(bin/cgo/zig env)"   # when compiling Ladybug read tools
+go test ./...
+uv run python -m unittest discover -s bin/tools -t .
+```
+
+## Config
+
+| File / env | Purpose |
+|------------|---------|
+| `$BRAIN_SEARCH_ENV` (default `$HOME/.config/brain/search.env`) | `BRAIN_SEARCH_URL` (SearXNG). Optional Basic Auth. |
+| `$HOME/.config/brain/db-profiles.yml` | read-only Postgres profiles (OnlyOffice via tunnel) |
+
+If the host already runs SearXNG, point `BRAIN_SEARCH_URL` at it. Do not start
+a second copy (D3). Optional Compose instance:
+
+```bash
+SEARXNG_SECRET=$(openssl rand -hex 32) docker compose --profile searxng up -d
+```
+
+That binds `127.0.0.1:8888`. JSON format must stay enabled.
+
+## Index then search
+
+Write path is `bin/brain/add.go` for a leaf (or `POST /ingest`). Bulk
+corpus rebuild remains `bin/brain/index.go --rebuild` (Compose profile
+`index`). Do not DROP INDEX on Ladybug 0.19.
+
+```bash
+bin/brain/add.go --text "arc-1 runs Matrix" --root facts --source "compose.yml x docker ps"
+bin/brain/index.go --rebuild
+bin/brain/search.go "LadybugDB vector index"     # facts → info → web (D17)
+bin/brain/search.go "upstream flag" --no-web
+bin/brain/get.go <id> --body
+bin/brain/stats.go
+```
+
+`--hop N` walks File → Commit → Person from each hit. Empty web results are `throttled`, not absence.
+Gap to v1: [roadmap](roadmap.md) / [epic #16](https://git.produktor.io/eSlider/2dph/issues/16).
+
+Ladybug 0.19: never `DROP INDEX` FTS/VECTOR (ghost catalog). Fresh indexes =
+delete `var/kb.lbug` then `--rebuild`.
+
+## HTTP / MCP
+
+```bash
+docker compose up -d brain                       # :8630 Zig CGO serve
+docker compose --profile index run --rm index    # rebuild
+docker compose --profile picoclaw up brain-mcp   # MCP 127.0.0.1:8630
+```
+
+`GET /openapi.json`, `POST /mcp`. Agent tool order: `search` → `get` → `audit`.
+
+## Reasoner (optional, D18)
+
+CPU sidecar on `127.0.0.1:11435`. Weights are not in the 2dph image.
+
+```bash
+docker compose --profile reasoner up -d reasoner
+REASONER_BASE_URL=http://127.0.0.1:11435/v1 ./bin/reasoner/bakeoff.go --json
+```
+
+See [reasoner.md](reasoner.md).

internal/brain/http.go

@@ -7,6 +7,8 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os/exec"
+	"path/filepath"
 
 	"github.com/eSlider/2dph/internal/brain/rank"
 )
@@ -137,12 +139,22 @@ func (HTTP) Audit(context.Context) ([]byte, error) {
 	return json.Marshal(map[string]any{"status": "ok", "by_confidence": rows})
 }
 
-func (HTTP) Ingest(context.Context) ([]byte, error) {
+func (HTTP) Ingest(ctx context.Context, body []byte) ([]byte, error) {
+	if len(bytes.TrimSpace(body)) == 0 {
 		return json.Marshal(map[string]any{
-		"mode":    "rebuild",
+			"mode":    "add",
-		"command": "bin/brain/index.go --rebuild",
+			"command": "bin/brain/add.go",
-		"add":     "v2",
+			"rebuild": "bin/brain/index.go --rebuild",
 		})
+	}
+	cmd := exec.CommandContext(ctx, filepath.Join(repoRoot(), "bin", "kb", "add"), "--json")
+	cmd.Stdin = bytes.NewReader(body)
+	cmd.Dir = repoRoot()
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("add: %w", err)
+	}
+	return out, nil
 }
 
 func asInt(v any) int64 {

internal/brain/rank/args.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 )
 
-const Usage = `usage: bin/brain/search.go "query" [--root facts|info] [--repo REPO] [-n N] [--json] [--no-web]
+const Usage = `usage: bin/brain/search.go "query" [--root facts|info] [--repo REPO] [-n N] [--hop N] [--json] [--no-web]
        bin/brain/search.go serve [port]
        bin/brain/search.go --list-model`
 
@@ -15,6 +15,7 @@ type Options struct {
 	Root      string
 	Repo      string
 	Limit     int
+	Hop       int
 	JSONOut   bool
 	ListModel bool
 	NoWeb     bool
@@ -22,8 +23,6 @@ type Options struct {
 
 // ParseArgs reads flags. Unknown flags are an error: silently dropping them
 // meant `--hop 1` vanished and its argument `1` was appended to the query.
-// --hop is recognised so it cannot be swallowed; it is not implemented until
-// File/FROM_FILE edges exist.
 func ParseArgs(args []string) (Options, error) {
 	opt := Options{Limit: 20}
 	var queryArgs []string
@@ -52,7 +51,15 @@ func ParseArgs(args []string) (Options, error) {
 			}
 			opt.Limit = n
 		case "--hop":
-			return opt, fmt.Errorf("--hop is not implemented yet (needs File/FROM_FILE edges)")
+			i++
+			n, err := strconv.Atoi(args[i])
+			if err != nil || n < 1 {
+				return opt, fmt.Errorf("--hop must be a positive integer, got %q", args[i])
+			}
+			if n > 3 {
+				return opt, fmt.Errorf("--hop max is 3 (File → Commit → Person)")
+			}
+			opt.Hop = n
 		case "--json":
 			opt.JSONOut = true
 		case "--no-web":

internal/brain/rank/query.go

@@ -7,3 +7,30 @@ const FTSStmt = "CALL QUERY_FTS_INDEX('Leaf', 'id', $q) " +
 
 const VecStmt = "CALL QUERY_VECTOR_INDEX('Leaf', 'Leaf_vec', $q, $n) " +
 	"RETURN node.id, node.text, node.root, node.source, distance ORDER BY distance LIMIT $n"
+
+// HopStmt is the Cypher walk from a search hit. Depth 1 = File, 2 = Commit, 3 = Person.
+func HopStmt(depth int) string {
+	switch depth {
+	case 1:
+		return "MATCH (l:Leaf {id:$id})-[:FROM_FILE]->(f:File) RETURN f.id, f.path, 1"
+	case 2:
+		return "MATCH (l:Leaf {id:$id})-[:FROM_FILE]->(f:File)-[:HAS_VERSION]->(c:Commit) RETURN c.id, c.subject, 2"
+	case 3:
+		return "MATCH (l:Leaf {id:$id})-[:FROM_FILE]->(f:File)-[:HAS_VERSION]->(c:Commit)-[:AUTHORED]->(p:Person) RETURN p.id, p.name, 3"
+	default:
+		return ""
+	}
+}
+
+func HopLabel(depth int) string {
+	switch depth {
+	case 1:
+		return "File"
+	case 2:
+		return "Commit"
+	case 3:
+		return "Person"
+	default:
+		return ""
+	}
+}

internal/brain/rank/rank.go

@@ -7,6 +7,13 @@ import (
 	"strings"
 )
 
+type HopNode struct {
+	ID    string `json:"id"`
+	Label string `json:"label"`
+	Name  string `json:"name"`
+	Depth int    `json:"depth"`
+}
+
 // Hit is one search result, mirroring the python script's dict shape.
 type Hit struct {
 	ID      string    `json:"id"`
@@ -15,6 +22,7 @@ type Hit struct {
 	Source  string    `json:"-"`
 	Score   float64   `json:"score"`
 	Snippet string    `json:"snippet,omitempty"`
+	Hops    []HopNode `json:"hops,omitempty"`
 }
 
 // rrfK dampens the contribution of low ranks; same constant as kblib.py.

internal/brain/rank/rank_test.go

@@ -91,15 +91,41 @@ func TestHybridKeepsVectorScoreForSharedHit(t *testing.T) {
 }
 
 // The old parser dropped unknown flags and appended their arguments to the
-// query, so `search "q" --hop 1` searched for "q 1". --hop is not implemented
+// query, so `search "q" --hop 1` searched for "q 1". --hop must stay a flag.
-// here (needs File edges); it must still fail closed instead of changing q.
 func TestParseHopIsNotSwallowedIntoTheQuery(t *testing.T) {
-	_, err := ParseArgs([]string{"what runs on arc-2", "--hop", "1"})
+	opt, err := ParseArgs([]string{"what runs on arc-2", "--hop", "1"})
-	if err == nil {
+	if err != nil {
-		t.Fatal("expected --hop to error (not implemented), not be swallowed")
+		t.Fatalf("unexpected error: %v", err)
 	}
-	if !strings.Contains(err.Error(), "--hop") {
+	if opt.Query != "what runs on arc-2" {
-		t.Fatalf("error should name --hop, got %v", err)
+		t.Fatalf("query swallowed hop arg: %q", opt.Query)
+	}
+	if opt.Hop != 1 {
+		t.Fatalf("hop = %d, want 1", opt.Hop)
+	}
+}
+
+func TestParseHopMaxIsThree(t *testing.T) {
+	if _, err := ParseArgs([]string{"q", "--hop", "4"}); err == nil {
+		t.Fatal("expected --hop 4 to error")
+	}
+	opt, err := ParseArgs([]string{"q", "--hop", "3"})
+	if err != nil || opt.Hop != 3 {
+		t.Fatalf("hop 3: %+v err=%v", opt, err)
+	}
+}
+
+func TestHopStmtWalksFromFile(t *testing.T) {
+	s := HopStmt(1)
+	if !strings.Contains(s, "FROM_FILE") || !strings.Contains(s, "File") {
+		t.Fatalf("hop 1 must walk FROM_FILE, got %q", s)
+	}
+	s3 := HopStmt(3)
+	if !strings.Contains(s3, "HAS_VERSION") || !strings.Contains(s3, "AUTHORED") || !strings.Contains(s3, "Person") {
+		t.Fatalf("hop 3 must reach Person, got %q", s3)
+	}
+	if HopLabel(1) != "File" || HopLabel(3) != "Person" {
+		t.Fatal("hop labels")
 	}
 }
 

internal/brain/search.go

@@ -56,6 +56,12 @@ func runSearch(args []string) int {
 		fmt.Fprintf(os.Stderr, "search: %v\n", err)
 		return 1
 	}
+	if opt.Hop > 0 {
+		if err := attachHops(hits, opt.Hop); err != nil {
+			fmt.Fprintf(os.Stderr, "hop: %v\n", err)
+			return 1
+		}
+	}
 
 	results := hits
 	for i := range results {
@@ -108,6 +114,44 @@ func searchHits(query, root, repo string, limit int) ([]Hit, error) {
 	return rank.RankAndFilter(fts, vec, root, repo, limit), nil
 }
 
+func attachHops(hits []Hit, n int) error {
+	if conn == nil {
+		return fmt.Errorf("brain not open")
+	}
+	for i := range hits {
+		var hops []rank.HopNode
+		for d := 1; d <= n; d++ {
+			stmt, err := conn.Prepare(rank.HopStmt(d))
+			if err != nil {
+				return err
+			}
+			res, err := conn.Execute(stmt, map[string]any{"id": hits[i].ID})
+			stmt.Close()
+			if err != nil {
+				return err
+			}
+			for res.HasNext() {
+				row, err := res.Next()
+				if err != nil {
+					return err
+				}
+				vals, err := row.GetAsSlice()
+				if err != nil || len(vals) < 3 {
+					continue
+				}
+				hops = append(hops, rank.HopNode{
+					ID:    fmt.Sprint(vals[0]),
+					Label: rank.HopLabel(d),
+					Name:  fmt.Sprint(vals[1]),
+					Depth: int(asInt(vals[2])),
+				})
+			}
+		}
+		hits[i].Hops = hops
+	}
+	return nil
+}
+
 func b2i(err error) int {
 	if err != nil {
 		return 1
@@ -188,6 +232,7 @@ type jsonHit struct {
 	Root    string         `json:"root"`
 	Score   float64        `json:"score"`
 	Snippet string         `json:"snippet,omitempty"`
+	Hops    []rank.HopNode `json:"hops,omitempty"`
 }
 
 func toJSONOut(hits []Hit, query, rootFilter string, web *rank.SecondSource) *jsonOut {
@@ -199,6 +244,7 @@ func toJSONOut(hits []Hit, query, rootFilter string, web *rank.SecondSource) *js
 			Root:    h.Root,
 			Score:   h.Score,
 			Snippet: h.Snippet,
+			Hops:    h.Hops,
 		}
 	}
 	return &jsonOut{
@@ -222,6 +268,18 @@ func resultsToDicts(hits []Hit) []any {
 		if h.Snippet != "" {
 			d = append(d, KV{"snippet", h.Snippet})
 		}
+		if len(h.Hops) > 0 {
+			nodes := make([]any, len(h.Hops))
+			for j, n := range h.Hops {
+				nodes[j] = Dict{
+					{"id", n.ID},
+					{"label", n.Label},
+					{"name", n.Name},
+					{"depth", n.Depth},
+				}
+			}
+			d = append(d, KV{"hops", nodes})
+		}
 		out[i] = d
 	}
 	return out

internal/httpapi/mcp.go

@@ -144,7 +144,15 @@ func (s *Server) mcpCall(r *http.Request, params json.RawMessage) (any, error) {
 			return nil, fmt.Errorf("cancelled")
 		}
 		defer s.release()
-		body, err = s.api.Ingest(r.Context())
+		var payload []byte
+		text := strings.TrimSpace(fmt.Sprint(p.Arguments["text"]))
+		if text != "" && text != "<nil>" {
+			payload, err = json.Marshal(p.Arguments)
+			if err != nil {
+				return nil, err
+			}
+		}
+		body, err = s.api.Ingest(r.Context(), payload)
 	default:
 		return nil, fmt.Errorf("unknown tool %s", p.Name)
 	}

internal/httpapi/server.go

@@ -11,6 +11,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"io"
 	"log"
 	"net/http"
 	"os"
@@ -27,7 +28,7 @@ type API interface {
 	Get(ctx context.Context, id string, body bool) ([]byte, error)
 	Stats(ctx context.Context) ([]byte, error)
 	Audit(ctx context.Context) ([]byte, error)
-	Ingest(ctx context.Context) ([]byte, error)
+	Ingest(ctx context.Context, body []byte) ([]byte, error)
 }
 
 type Server struct {
@@ -59,7 +60,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	case PathAudit:
 		s.handleJSON(w, r, s.api.Audit)
 	case PathIngest:
-		s.handleJSON(w, r, s.api.Ingest)
+		s.handleIngest(w, r)
 	case PathOpenAPI:
 		s.handleOpenAPI(w, r)
 	case PathMCP:
@@ -116,6 +117,24 @@ func (s *Server) handleJSON(w http.ResponseWriter, r *http.Request, fn func(cont
 	writeAPI(w, body, err)
 }
 
+func (s *Server) handleIngest(w http.ResponseWriter, r *http.Request) {
+	var raw []byte
+	if r.Method == http.MethodPost {
+		b, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
+		if err != nil {
+			writeJSON(w, http.StatusBadRequest, map[string]any{"error": "read body"})
+			return
+		}
+		raw = b
+	}
+	if !s.acquire(w, r) {
+		return
+	}
+	defer s.release()
+	body, err := s.api.Ingest(r.Context(), raw)
+	writeAPI(w, body, err)
+}
+
 func (s *Server) tryAcquire(r *http.Request) bool {
 	return s.acquire(nopWriter{}, r)
 }
@@ -191,11 +210,30 @@ func (ExecSearcher) Get(context.Context, string, bool) ([]byte, error) {
 }
 func (ExecSearcher) Stats(context.Context) ([]byte, error) { return nil, errUnimplemented }
 func (ExecSearcher) Audit(context.Context) ([]byte, error) { return nil, errUnimplemented }
-func (ExecSearcher) Ingest(context.Context) ([]byte, error) {
+func (b ExecSearcher) Ingest(ctx context.Context, body []byte) ([]byte, error) {
+	if len(strings.TrimSpace(string(body))) == 0 {
 		return json.Marshal(map[string]any{
-		"mode":    "rebuild",
+			"mode":    "add",
-		"command": "bin/brain/index.go --rebuild",
+			"command": "bin/brain/add.go",
+			"rebuild": "bin/brain/index.go --rebuild",
 		})
+	}
+	root := os.Getenv("KB_ROOT")
+	if root == "" {
+		root = "."
+	}
+	cmd := exec.CommandContext(ctx, filepath.Join(root, "bin/kb/add"), "--json")
+	cmd.Stdin = strings.NewReader(string(body))
+	cmd.Dir = root
+	out, err := cmd.Output()
+	if err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			return nil, errors.New("add failed: " + strings.TrimSpace(string(exitErr.Stderr)))
+		}
+		return nil, err
+	}
+	return out, nil
 }
 
 func defaultSearchCmd(root string) string {

internal/httpapi/server_test.go

@@ -1,6 +1,7 @@
 package httpapi
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"net/http"
@@ -64,8 +65,11 @@ func (f *fakeSearcher) Audit(context.Context) ([]byte, error) {
 	return []byte(`{"status":"ok"}`), nil
 }
 
-func (f *fakeSearcher) Ingest(context.Context) ([]byte, error) {
+func (f *fakeSearcher) Ingest(_ context.Context, body []byte) ([]byte, error) {
-	return []byte(`{"mode":"rebuild","command":"bin/brain/index.go --rebuild"}`), nil
+	if len(bytes.TrimSpace(body)) == 0 {
+		return []byte(`{"mode":"add","command":"bin/brain/add.go"}`), nil
+	}
+	return []byte(`{"mode":"add","ids":["fake-leaf"]}`), nil
 }
 
 func (f *fakeSearcher) count() int {
@@ -193,6 +197,27 @@ func TestStatsAuditIngest(t *testing.T) {
 	}
 }
 
+func TestIngestIsAddNotRebuildHint(t *testing.T) {
+	h := NewServer(&fakeSearcher{}, 1)
+	code, body := get(t, h, "/ingest")
+	if code != http.StatusOK {
+		t.Fatalf("GET /ingest code = %d body=%s", code, body)
+	}
+	if strings.Contains(string(body), `"add":"v2"`) || strings.Contains(string(body), "write is v2") {
+		t.Fatalf("GET /ingest still a v2 hint: %s", body)
+	}
+	if !strings.Contains(string(body), "bin/brain/add.go") {
+		t.Fatalf("GET /ingest should name add.go: %s", body)
+	}
+	code, body = postJSON(t, h, "/ingest", `{"text":"hello","root":"info","source":"t"}`)
+	if code != http.StatusOK {
+		t.Fatalf("POST /ingest code = %d body=%s", code, body)
+	}
+	if !strings.Contains(string(body), "fake-leaf") {
+		t.Fatalf("POST /ingest should add: %s", body)
+	}
+}
+
 func TestHTTPPackageDoesNotExecPython(t *testing.T) {
 	raw, err := os.ReadFile("server.go")
 	if err != nil {

internal/httpapi/spec.go

@@ -47,7 +47,15 @@ var Ops = []Op{
 	},
 	{Path: PathStats, Method: "get", ID: "stats", Summary: "index health", MCP: true},
 	{Path: PathAudit, Method: "get", ID: "audit", Summary: "facts confidence histogram", MCP: true},
-	{Path: PathIngest, Method: "get", ID: "ingest", Summary: "rebuild hint (write is v2)", MCP: true},
+	{
+		Path: PathIngest, Method: "post", ID: "ingest", Summary: "add a leaf without rebuild",
+		MCP: true,
+		Params: []Param{
+			{Name: "text", In: "query", Type: "string", Description: "leaf text (omit for CLI hint)"},
+			{Name: "root", In: "query", Type: "string", Description: "facts or info (default info)"},
+			{Name: "source", In: "query", Type: "string", Description: "evidence pointer; facts need two sources"},
+		},
+	},
 	{Path: PathOpenAPI, Method: "get", ID: "openapi", Summary: "OpenAPI 3 document for this server"},
 }
 

internal/httpapi/spec_test.go

@@ -38,11 +38,24 @@ func TestMCPToolsMatchOpenAPIPaths(t *testing.T) {
 			t.Fatalf("MCP tool %s has no OpenAPI path %s", tool.Name, path)
 		}
 	}
-	for _, need := range []string{"search", "get", "stats", "audit"} {
+	for _, need := range []string{"search", "get", "stats", "audit", "ingest"} {
 		if !names[need] {
 			t.Fatalf("MCP tools missing %s: %v", need, names)
 		}
 	}
+	var ingest MCPTool
+	for _, tool := range tools {
+		if tool.Name == "ingest" {
+			ingest = tool
+			break
+		}
+	}
+	if strings.Contains(ingest.Description, "v2") {
+		t.Fatalf("ingest still a v2 hint: %s", ingest.Description)
+	}
+	if !strings.Contains(ingest.Description, "add") {
+		t.Fatalf("ingest should describe add: %s", ingest.Description)
+	}
 }
 
 func TestOpenAPIHTTP(t *testing.T) {

internal/mdleaves/leaf.go

@@ -0,0 +1,146 @@
+package mdleaves
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+type Leaf struct {
+	Source  string `json:"source"`
+	Repo    string `json:"repo"`
+	Heading string `json:"heading"`
+	Text    string `json:"text"`
+	Type    string `json:"type"`
+	Status  string `json:"status"`
+	Related string `json:"related"`
+}
+
+type chunk struct {
+	Heading string
+	Text    string
+}
+
+var (
+	h1 = regexp.MustCompile(`^# \S`)
+	h2 = regexp.MustCompile(`^## \S`)
+)
+
+func ExtractFrontmatter(text string) (map[string]string, string) {
+	if !strings.HasPrefix(text, "---") {
+		return map[string]string{}, text
+	}
+	end := strings.Index(text[3:], "\n---")
+	if end == -1 {
+		return map[string]string{}, text
+	}
+	fm := strings.TrimSpace(text[3 : 3+end])
+	body := text[3+end+4:]
+	meta := map[string]string{}
+	for _, line := range strings.Split(fm, "\n") {
+		key, value, ok := strings.Cut(line, ":")
+		if !ok {
+			continue
+		}
+		meta[strings.TrimSpace(key)] = strings.Trim(strings.TrimSpace(value), `"'`)
+	}
+	return meta, body
+}
+
+func SplitLeafs(meta map[string]string, body string) []chunk {
+	lines := strings.Split(body, "\n")
+	title := ""
+	type hdr struct {
+		heading string
+		start   int
+	}
+	var headers []hdr
+	for i, line := range lines {
+		switch {
+		case h1.MatchString(line):
+			title = strings.TrimSpace(strings.TrimLeft(line, "#"))
+		case h2.MatchString(line):
+			headers = append(headers, hdr{strings.TrimSpace(strings.TrimLeft(line, "#")), i})
+		}
+	}
+	if len(headers) == 0 {
+		var kept []string
+		for _, l := range lines {
+			if strings.TrimSpace(l) != "" {
+				kept = append(kept, l)
+			}
+		}
+		return []chunk{{Heading: title, Text: strings.TrimSpace(strings.Join(kept, "\n"))}}
+	}
+	out := make([]chunk, 0, len(headers))
+	for idx, h := range headers {
+		end := len(lines)
+		if idx+1 < len(headers) {
+			end = headers[idx+1].start
+		}
+		var kept []string
+		for _, l := range lines[h.start:end] {
+			if strings.TrimSpace(l) != "" {
+				kept = append(kept, l)
+			}
+		}
+		text := strings.Join(kept, "\n")
+		if idx == 0 && title != "" {
+			text = title + "\n\n" + text
+		}
+		out = append(out, chunk{Heading: h.heading, Text: strings.TrimSpace(text)})
+	}
+	return out
+}
+
+func ToAll(text, path, repo string) []Leaf {
+	meta, body := ExtractFrontmatter(text)
+	if meta["type"] == "" {
+		meta["type"] = "reference"
+	}
+	if meta["status"] == "" {
+		meta["status"] = "current"
+	}
+	chunks := SplitLeafs(meta, body)
+	out := make([]Leaf, 0, len(chunks))
+	for _, c := range chunks {
+		out = append(out, Leaf{
+			Source:  path,
+			Repo:    repo,
+			Heading: c.Heading,
+			Text:    c.Text,
+			Type:    meta["type"],
+			Status:  meta["status"],
+			Related: meta["related"],
+		})
+	}
+	return out
+}
+
+func WalkMarkdown(root string) ([]string, error) {
+	var out []string
+	err := filepath.Walk(root, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if info.IsDir() {
+			return nil
+		}
+		ext := strings.ToLower(filepath.Ext(p))
+		if ext == ".md" || ext == ".markdown" {
+			out = append(out, p)
+		}
+		return nil
+	})
+	return out, err
+}
+
+func EncodeJSON(leafs []Leaf) (string, error) {
+	raw, err := json.MarshalIndent(leafs, "", "  ")
+	if err != nil {
+		return "", err
+	}
+	return string(raw) + "\n", nil
+}

internal/mdleaves/leaf_test.go

@@ -0,0 +1,73 @@
+package mdleaves
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSplitLeafsOnH2(t *testing.T) {
+	body := "# Title\n\n## One\n\nalpha\n\n## Two\n\nbeta\n"
+	leafs := SplitLeafs(map[string]string{}, body)
+	if len(leafs) != 2 {
+		t.Fatalf("n=%d", len(leafs))
+	}
+	if leafs[0].Heading != "One" || !strings.Contains(leafs[0].Text, "Title") {
+		t.Fatalf("first=%+v", leafs[0])
+	}
+	if leafs[1].Heading != "Two" || strings.Contains(leafs[1].Text, "Title") {
+		t.Fatalf("second=%+v", leafs[1])
+	}
+}
+
+func TestSplitLeafsNoH2IsWholeDoc(t *testing.T) {
+	body := "# Title\n\njust a paragraph\n"
+	leafs := SplitLeafs(nil, body)
+	if len(leafs) != 1 {
+		t.Fatalf("n=%d", len(leafs))
+	}
+	if leafs[0].Heading != "Title" {
+		t.Fatalf("heading=%q", leafs[0].Heading)
+	}
+	if !strings.Contains(leafs[0].Text, "just a paragraph") {
+		t.Fatalf("text=%q", leafs[0].Text)
+	}
+}
+
+func TestFrontmatterAndToAll(t *testing.T) {
+	raw := "---\ntype: howto\nstatus: current\nrelated: docs/design.md\n---\n# Doc\n\n## Step\n\ndo it\n"
+	got := ToAll(raw, "docs/x.md", "eSlider/2dph")
+	if len(got) != 1 {
+		t.Fatalf("n=%d", len(got))
+	}
+	if got[0].Type != "howto" || got[0].Status != "current" {
+		t.Fatalf("%+v", got[0])
+	}
+	if got[0].Source != "docs/x.md" || got[0].Repo != "eSlider/2dph" {
+		t.Fatalf("%+v", got[0])
+	}
+	if got[0].Related != "docs/design.md" {
+		t.Fatalf("related=%q", got[0].Related)
+	}
+}
+
+func TestEncodeJSONAndYAML(t *testing.T) {
+	leafs := ToAll("# Hi\n\nbody\n", "a.md", "")
+	js, err := EncodeJSON(leafs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(js, `"heading": "Hi"`) {
+		t.Fatalf("json=%s", js)
+	}
+	y := EncodeYAML(leafs)
+	if !strings.Contains(y, "heading: Hi") {
+		t.Fatalf("yaml=%s", y)
+	}
+}
+
+func TestDefaultsTypeAndStatus(t *testing.T) {
+	got := ToAll("# Hi\n\nbody\n", "a.md", "")
+	if got[0].Type != "reference" || got[0].Status != "current" {
+		t.Fatalf("%+v", got[0])
+	}
+}

internal/mdleaves/yaml.go

@@ -0,0 +1,36 @@
+package mdleaves
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func EncodeYAML(leafs []Leaf) string {
+	if len(leafs) == 0 {
+		return "[]\n"
+	}
+	var b strings.Builder
+	for _, lf := range leafs {
+		b.WriteString("-\n")
+		writeKV(&b, "source", lf.Source)
+		writeKV(&b, "repo", lf.Repo)
+		writeKV(&b, "heading", lf.Heading)
+		writeKV(&b, "text", lf.Text)
+		writeKV(&b, "type", lf.Type)
+		writeKV(&b, "status", lf.Status)
+		writeKV(&b, "related", lf.Related)
+	}
+	return b.String()
+}
+
+func writeKV(b *strings.Builder, k, v string) {
+	fmt.Fprintf(b, "  %s: %s\n", k, yamlScalar(v))
+}
+
+func yamlScalar(s string) string {
+	if strings.Contains(s, "\n") || s == "" || strings.ContainsAny(s, ":#'\"[]{}&*!|>%@`") || s != strings.TrimSpace(s) {
+		return strconv.Quote(s)
+	}
+	return s
+}

internal/reasoner/client.go

@@ -0,0 +1,325 @@
+package reasoner
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// HF IDs named in docs. No Qwen3.6-9B exists.
+const (
+	HFQwen35_9B   = "Qwen/Qwen3.5-9B"
+	HFQwen36_27B  = "Qwen/Qwen3.6-27B"
+	HFBonsai27B   = "prism-ml/Bonsai-27B-gguf"
+	OllamaRAM     = "qwen3.5:9b"
+	OllamaQuality = "MichelRosselli/bonsai-27b:Q1_0"
+)
+
+type ToolCall struct {
+	Name      string
+	Arguments string
+}
+
+type Result struct {
+	Model      string `json:"model"`
+	OK         bool   `json:"ok"`
+	ToolName   string `json:"tool_name,omitempty"`
+	XMLLeak    bool   `json:"xml_leak"`
+	Err        string `json:"error,omitempty"`
+	LatencyMS  int64  `json:"latency_ms"`
+	RSSMB      int    `json:"rss_mb,omitempty"`
+	Device     string `json:"device"`
+	WantedTool string `json:"wanted_tool"`
+}
+
+type Prompt struct {
+	Name string
+	Want string
+	User string
+}
+
+var BakePrompts = []Prompt{
+	{
+		Name: "search-before-claim",
+		Want: "search",
+		User: "Use tools. Search the 2dph brain for LadybugDB before you answer. Call search.",
+	},
+	{
+		Name: "get-leaf",
+		Want: "get",
+		User: "Use tools. Fetch leaf id leaf-demo with get. Do not invent the body.",
+	},
+	{
+		Name: "audit-index",
+		Want: "audit",
+		User: "Use tools. Call audit on the brain index health.",
+	},
+}
+
+func MCPTools() []map[string]any {
+	return []map[string]any{
+		openaiTool("search", "deduction search (facts → info → web)", map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"q": map[string]any{"type": "string", "description": "search query"},
+				"n": map[string]any{"type": "integer"},
+			},
+			"required": []string{"q"},
+		}),
+		openaiTool("get", "read one leaf by id", map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"id":   map[string]any{"type": "string"},
+				"body": map[string]any{"type": "boolean"},
+			},
+			"required": []string{"id"},
+		}),
+		openaiTool("audit", "facts confidence histogram", map[string]any{
+			"type":       "object",
+			"properties": map[string]any{},
+		}),
+	}
+}
+
+func openaiTool(name, desc string, schema map[string]any) map[string]any {
+	return map[string]any{
+		"type": "function",
+		"function": map[string]any{
+			"name":        name,
+			"description": desc,
+			"parameters":  schema,
+		},
+	}
+}
+
+type Client struct {
+	BaseURL    string
+	Model      string
+	HTTP       *http.Client
+	Device     string
+	ToolChoice string
+}
+
+type Report struct {
+	Model      string   `json:"model"`
+	HF         string   `json:"hf_id"`
+	Device     string   `json:"device"`
+	ToolCallOK int      `json:"tool_call_ok"`
+	ToolCallN  int      `json:"tool_call_n"`
+	XMLLeak    int      `json:"xml_leak"`
+	RSSMB      int      `json:"rss_mb"`
+	VRAMMB     int      `json:"vram_mb"`
+	Prompts    []Result `json:"prompts"`
+}
+
+func HFFor(model string) string {
+	switch model {
+	case OllamaRAM:
+		return HFQwen35_9B
+	case OllamaQuality:
+		return HFBonsai27B
+	default:
+		if strings.Contains(model, "qwen3.6") || strings.Contains(model, "Qwen3.6") {
+			return HFQwen36_27B
+		}
+		return ""
+	}
+}
+
+func (c *Client) httpc() *http.Client {
+	if c.HTTP == nil {
+		c.HTTP = &http.Client{Timeout: 10 * time.Minute}
+	}
+	return c.HTTP
+}
+
+func Origin(base string) string {
+	s := strings.TrimRight(base, "/")
+	return strings.TrimSuffix(s, "/v1")
+}
+
+func (c Client) ChatTools(user string) (ToolCall, string, error) {
+	choice := c.ToolChoice
+	if choice == "" {
+		choice = "required"
+	}
+	body, _ := json.Marshal(map[string]any{
+		"model": c.Model,
+		"messages": []map[string]string{
+			{"role": "system", "content": "You are PicoClaw talking to 2dph MCP. Always call a tool before a factual claim. search then get then audit."},
+			{"role": "user", "content": user},
+		},
+		"tools":       MCPTools(),
+		"tool_choice": choice,
+	})
+	base := strings.TrimRight(c.BaseURL, "/")
+	if !strings.HasSuffix(base, "/v1") {
+		base += "/v1"
+	}
+	url := base + "/chat/completions"
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return ToolCall{}, "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	res, err := c.httpc().Do(req)
+	if err != nil {
+		return ToolCall{}, "", err
+	}
+	defer res.Body.Close()
+	raw, _ := io.ReadAll(res.Body)
+	if res.StatusCode >= 300 {
+		return ToolCall{}, string(raw), fmt.Errorf("http %d", res.StatusCode)
+	}
+	return ParseToolResponse(raw)
+}
+
+func ParseToolResponse(raw []byte) (ToolCall, string, error) {
+	var wrap struct {
+		Choices []struct {
+			Message struct {
+				Content   string `json:"content"`
+				ToolCalls []struct {
+					Function struct {
+						Name      string          `json:"name"`
+						Arguments json.RawMessage `json:"arguments"`
+					} `json:"function"`
+				} `json:"tool_calls"`
+			} `json:"message"`
+		} `json:"choices"`
+	}
+	if err := json.Unmarshal(raw, &wrap); err != nil {
+		return ToolCall{}, "", err
+	}
+	content := ""
+	if len(wrap.Choices) > 0 {
+		content = wrap.Choices[0].Message.Content
+		if n := len(wrap.Choices[0].Message.ToolCalls); n > 0 {
+			fn := wrap.Choices[0].Message.ToolCalls[0].Function
+			return ToolCall{Name: fn.Name, Arguments: rawArgs(fn.Arguments)}, content, nil
+		}
+	}
+	return ToolCall{}, content, fmt.Errorf("no tool_calls")
+}
+
+func rawArgs(raw json.RawMessage) string {
+	if len(raw) == 0 {
+		return ""
+	}
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		return s
+	}
+	return string(raw)
+}
+
+func XMLLeak(content string) bool {
+	s := strings.ToLower(content)
+	return strings.Contains(s, "<tool_call>") ||
+		strings.Contains(s, "<function=") ||
+		strings.Contains(s, "<parameter")
+}
+
+func RunPrompt(c Client, p Prompt) Result {
+	start := time.Now()
+	tc, content, err := c.ChatTools(p.User)
+	out := Result{
+		Model:      c.Model,
+		WantedTool: p.Want,
+		LatencyMS:  time.Since(start).Milliseconds(),
+		Device:     c.Device,
+		XMLLeak:    XMLLeak(content),
+	}
+	if err != nil {
+		out.Err = err.Error()
+		if content != "" && out.XMLLeak {
+			out.Err = "xml tool call instead of openai tool_calls"
+		}
+		return out
+	}
+	out.ToolName = tc.Name
+	out.OK = tc.Name == p.Want
+	if !out.OK {
+		out.Err = "wanted " + p.Want + " got " + tc.Name
+	}
+	return out
+}
+
+type ProcMem struct {
+	Name   string
+	SizeMB int
+	VRAMMB int
+}
+
+func ParsePS(raw []byte) []ProcMem {
+	var wrap struct {
+		Models []struct {
+			Name     string `json:"name"`
+			Size     int64  `json:"size"`
+			SizeVRAM int64  `json:"size_vram"`
+		} `json:"models"`
+	}
+	if err := json.Unmarshal(raw, &wrap); err != nil {
+		return nil
+	}
+	out := make([]ProcMem, 0, len(wrap.Models))
+	for _, m := range wrap.Models {
+		out = append(out, ProcMem{
+			Name:   m.Name,
+			SizeMB: int(m.Size / (1024 * 1024)),
+			VRAMMB: int(m.SizeVRAM / (1024 * 1024)),
+		})
+	}
+	return out
+}
+
+func (c Client) FetchPS() []ProcMem {
+	url := Origin(c.BaseURL) + "/api/ps"
+	res, err := c.httpc().Get(url)
+	if err != nil {
+		return nil
+	}
+	defer res.Body.Close()
+	raw, _ := io.ReadAll(res.Body)
+	if res.StatusCode >= 300 {
+		return nil
+	}
+	return ParsePS(raw)
+}
+
+func Run(c Client) Report {
+	if c.Device == "" {
+		c.Device = "cpu"
+	}
+	rep := Report{
+		Model:  c.Model,
+		HF:     HFFor(c.Model),
+		Device: c.Device,
+	}
+	for _, p := range BakePrompts {
+		r := RunPrompt(c, p)
+		rep.Prompts = append(rep.Prompts, r)
+		rep.ToolCallN++
+		if r.OK {
+			rep.ToolCallOK++
+		}
+		if r.XMLLeak {
+			rep.XMLLeak++
+		}
+	}
+	if mems := c.FetchPS(); len(mems) > 0 {
+		rep.RSSMB = mems[0].SizeMB
+		rep.VRAMMB = mems[0].VRAMMB
+		if c.Device == "cpu" && mems[0].VRAMMB > 0 {
+			rep.Device = "gpu"
+		}
+		for i := range rep.Prompts {
+			rep.Prompts[i].RSSMB = rep.RSSMB
+		}
+	}
+	return rep
+}

internal/reasoner/client_test.go

@@ -0,0 +1,166 @@
+package reasoner
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/eSlider/2dph/internal/httpapi"
+)
+
+func TestHFIdsAreRealAndNoQwen36Nine(t *testing.T) {
+	if HFQwen35_9B != "Qwen/Qwen3.5-9B" {
+		t.Fatalf("9B id = %s", HFQwen35_9B)
+	}
+	if HFQwen36_27B != "Qwen/Qwen3.6-27B" {
+		t.Fatalf("27B id = %s", HFQwen36_27B)
+	}
+	if HFBonsai27B != "prism-ml/Bonsai-27B-gguf" {
+		t.Fatalf("bonsai id = %s", HFBonsai27B)
+	}
+}
+
+func TestParseToolResponseOpenAI(t *testing.T) {
+	raw := []byte(`{"choices":[{"message":{"tool_calls":[{"function":{"name":"search","arguments":"{\"q\":\"LadybugDB\"}"}}]}}]}`)
+	tc, _, err := ParseToolResponse(raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tc.Name != "search" {
+		t.Fatalf("name=%s", tc.Name)
+	}
+}
+
+func TestParseToolResponseXMLIsFailure(t *testing.T) {
+	raw := []byte(`{"choices":[{"message":{"content":"<tool_call>search</tool_call>"}}]}`)
+	_, content, err := ParseToolResponse(raw)
+	if err == nil {
+		t.Fatal("expected no tool_calls")
+	}
+	if !XMLLeak(content) {
+		t.Fatal("xml leak not detected")
+	}
+}
+
+func TestBakePromptsWantMCPTools(t *testing.T) {
+	if len(BakePrompts) != 3 {
+		t.Fatalf("prompts=%d", len(BakePrompts))
+	}
+	names := map[string]bool{}
+	for _, p := range BakePrompts {
+		names[p.Want] = true
+	}
+	for _, n := range []string{"search", "get", "audit"} {
+		if !names[n] {
+			t.Fatalf("missing want %s", n)
+		}
+	}
+}
+
+func TestParseToolResponseObjectArgs(t *testing.T) {
+	raw := []byte(`{"choices":[{"message":{"tool_calls":[{"function":{"name":"get","arguments":{"id":"leaf-demo"}}}]}}]}`)
+	tc, _, err := ParseToolResponse(raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if tc.Name != "get" {
+		t.Fatalf("name=%s", tc.Name)
+	}
+	if !strings.Contains(tc.Arguments, "leaf-demo") {
+		t.Fatalf("args=%s", tc.Arguments)
+	}
+}
+
+func TestParsePSCPUNotVRAM(t *testing.T) {
+	raw := []byte(`{"models":[{"name":"qwen3.5:9b","size":6900000000,"size_vram":0}]}`)
+	got := ParsePS(raw)
+	if len(got) != 1 {
+		t.Fatalf("n=%d", len(got))
+	}
+	if got[0].VRAMMB != 0 {
+		t.Fatalf("vram=%d", got[0].VRAMMB)
+	}
+	if got[0].SizeMB < 6000 {
+		t.Fatalf("rss=%d", got[0].SizeMB)
+	}
+}
+
+func TestMCPToolsArePicoClawSubset(t *testing.T) {
+	mcp := map[string]bool{}
+	for _, op := range httpapi.Ops {
+		if op.MCP {
+			mcp[op.ID] = true
+		}
+	}
+	seen := map[string]bool{}
+	for _, tool := range MCPTools() {
+		fn, _ := tool["function"].(map[string]any)
+		name, _ := fn["name"].(string)
+		if !mcp[name] {
+			t.Fatalf("%s is not an MCP op", name)
+		}
+		seen[name] = true
+	}
+	for _, n := range []string{"search", "get", "audit"} {
+		if !seen[n] {
+			t.Fatalf("bake-off missing %s", n)
+		}
+	}
+}
+
+func TestChatToolsHitsOpenAIPath(t *testing.T) {
+	var gotTools bool
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/chat/completions" {
+			t.Errorf("path=%s", r.URL.Path)
+		}
+		body, _ := io.ReadAll(r.Body)
+		var payload map[string]any
+		_ = json.Unmarshal(body, &payload)
+		if _, ok := payload["tools"]; ok {
+			gotTools = true
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"choices":[{"message":{"tool_calls":[{"function":{"name":"search","arguments":"{\"q\":\"LadybugDB\"}"}}]}}]}`))
+	}))
+	defer srv.Close()
+	c := Client{BaseURL: srv.URL + "/v1", Model: "stub", HTTP: srv.Client(), Device: "cpu"}
+	r := RunPrompt(c, BakePrompts[0])
+	if !gotTools {
+		t.Fatal("tools not sent")
+	}
+	if !r.OK {
+		t.Fatalf("result=%+v", r)
+	}
+}
+
+func TestRunSamplesPSAfterPrompts(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		if r.URL.Path == "/api/ps" {
+			_, _ = w.Write([]byte(`{"models":[{"name":"stub","size":6500000000,"size_vram":0}]}`))
+			return
+		}
+		_, _ = w.Write([]byte(`{"choices":[{"message":{"tool_calls":[{"function":{"name":"search","arguments":"{}"}}]}}]}`))
+	}))
+	defer srv.Close()
+	c := Client{BaseURL: srv.URL + "/v1", Model: "stub", HTTP: srv.Client(), Device: "cpu"}
+	if mems := c.FetchPS(); len(mems) != 1 || mems[0].VRAMMB != 0 {
+		t.Fatalf("%+v", mems)
+	}
+	if mems := c.FetchPS(); mems[0].SizeMB < 6000 {
+		t.Fatalf("rss=%d", mems[0].SizeMB)
+	}
+}
+
+func TestHFForKnownOllamaTags(t *testing.T) {
+	if HFFor(OllamaRAM) != HFQwen35_9B {
+		t.Fatal(HFFor(OllamaRAM))
+	}
+	if HFFor(OllamaQuality) != HFBonsai27B {
+		t.Fatal(HFFor(OllamaQuality))
+	}
+}

skills/brain/SKILL.md

@@ -26,13 +26,14 @@ second independent source when local roots cannot confirm. An answer is
 bin/brain/search.go "Matrix federation"                # pointers + snippets, YAML
 bin/brain/search.go "onlyoffice postgres" --root facts # restrict to confirmed
 bin/brain/search.go "where is cs-lexicon" --json | yq '.[].ref'
+bin/brain/add.go --text T --root facts --source "a.md x b.md"
 bin/brain/get.go <id> --body                           # full chunk only when needed
 bin/brain/stats.go                                     # index health
 bin/brain/eval.go                                      # recall@5 >= 0.95 gate (Go; Python bin/kb/eval is CI fallback)
 ```
 
-`bin/kb/search` is a deprecated wrapper. `--hop` errors (File/FROM_FILE edges
+`bin/kb/search` is a deprecated wrapper. `--hop N` walks
-are not wired yet); do not treat it as a graph walk.
+`FROM_FILE` / `HAS_VERSION` / `AUTHORED` from each hit (1=File, 3=Person).
 
 ## Rules
 

skills/brain/tools.md

@@ -8,4 +8,4 @@ Serve: `bin/brain/serve.go` (`GET /openapi.json`, `POST /mcp`).
 - `get` — read one leaf by id
 - `stats` — index health
 - `audit` — facts confidence histogram
-- `ingest` — rebuild hint (write is v2)
+- `ingest` — add a leaf without rebuild