feat: markdown import splits H2 leafs in Go

Drop the Python ExecFile wrapper. Conversion still does not write
Ladybug; add a dry-run fixture check for the index adapter split.

.dockerignore

@@ -3,6 +3,7 @@
 var
 .git
 .github
+lib-ladybug
 __pycache__
 *.pyc
 *.lbug

.github/workflows/ci.yml

@@ -37,6 +37,9 @@ jobs:
           bash -n bin/db/ssh-tunnel
           bash -n bin/docker-entrypoint
           bash -n bin/kb/search
+          bash -n bin/cgo/zig
+          sh -n bin/cgo/zcc
+          sh -n bin/cgo/zc++
 
       - name: Python unit tests (offline, vendored tools)
         run: |
@@ -54,9 +57,10 @@ jobs:
         run: |
           ./bin/facts/audit self 2>/dev/null || echo "audit: not yet implemented; gate skipped"
 
-      - name: kb/eval recall gate
+      - name: CGO via Zig (compile brain/search)
         run: |
-          ./bin/kb/eval 2>/dev/null || echo "eval: not yet implemented; gate skipped"
+          chmod +x bin/cgo/zig bin/cgo/zcc bin/cgo/zc++
+          bin/cgo/zig go build -tags system_ladybug -o /tmp/brain-search ./bin/brain/search.go
 
   release:
     name: Release (semver)

.gitignore

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

AGENTS.md

@@ -15,6 +15,9 @@ Read first: [PLAN](PLAN.md) → [docs](docs/).
 - `info` root = descriptive/narrative leafs, searchable, never asserted as fact.
 - Search is deduction: `facts` → `info` → `web-search` (second independent
   source). An answer is `confirmed` only if it comes off the facts root.
+- Fact-check every *claim* (facts → info → live → web), not every edit or
+  syntax tweak. PicoClaw: `search` then `get` then `audit` before a factual
+  reply (`skills/picoclaw/SKILL.md`). `throttled` is not a negative finding.
 
 ## Hard rules
 
@@ -39,16 +42,18 @@ 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/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/docker-entrypoint  container entrypoint (brain index|search|serve|watch)
+bin/cgo/      zig zcc zc++ (CGO via zig cc, not gcc)
+bin/docker-entrypoint  container entrypoint (api: serve|search|watch; index: python)
 compose.yaml  docker composition (root level, not docker/)
-Dockerfile    multi-stage: python deps + static Go binaries
+Dockerfile    api (Zig CGO, no Python) + index (Python write)
 var/          kb.lbug, var/mail/*, caches (gitignored)
 .venv/        ladybug + model2vec + mistune
 ```
@@ -82,13 +87,15 @@ bin/facts/crm.go [--dry-run]                       # proof person↔company/comp
 bin/kb/search "query" [--repo X]                  # deprecated wrapper → bin/brain/search.go
 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/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

Dockerfile

@@ -1,5 +1,13 @@
 # syntax=docker/dockerfile:1
-FROM python:3.12-slim AS base
+#
+#   docker build --target api -t 2dph:api .
+#   docker build --target index -t 2dph:index .
+#
+# API: Go + ladybug via Zig CGO (no CPython).
+# Index: Python write path (profile `index` until brain/add is v2).
+
+# --- Python sidecar (Ladybug write / rebuild) ---
+FROM python:3.12-slim AS index
 
 ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
@@ -9,25 +17,11 @@ ENV PYTHONUNBUFFERED=1 \
 WORKDIR /app
 RUN id -u 2dph 2>/dev/null || useradd --create-home --uid 1001 2dph
 
-# deps layer-first: rebuild only on dependency change
 COPY requirements.lock.txt /tmp/requirements.lock.txt
 RUN python -m pip install --no-cache-dir -r /tmp/requirements.lock.txt \
     && rm /tmp/requirements.lock.txt
 
-# Go services: static binaries, no interpreter at runtime
-FROM golang:1.25 AS go-build
-WORKDIR /src
-COPY go.mod ./
-COPY bin/server ./bin/server
-COPY bin/watch ./bin/watch
-RUN CGO_ENABLED=0 go build -o /serve ./bin/server \
-    && CGO_ENABLED=0 go build -o /watch ./bin/watch
-
-# runtime: python toolchain + Go services
-FROM base
 COPY . .
-COPY --from=go-build /serve /app/bin/serve
-COPY --from=go-build /watch /app/bin/watch
 RUN chmod +x /app/bin/docker-entrypoint \
     && chown -R 2dph:2dph /app
 USER 2dph
@@ -37,5 +31,51 @@ ENV PATH="/app/bin:${PATH}" \
     KB_ROOT=/app
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
     CMD python -c "import model2vec, ladybug, mistune; print('ok')" || exit 1
-
 ENTRYPOINT ["/app/bin/docker-entrypoint"]
+
+# --- Go API: CGO with Zig, not gcc ---
+FROM golang:1.26-bookworm AS api-build
+WORKDIR /src
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends curl xz-utils ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY bin/cgo ./bin/cgo
+RUN chmod +x bin/cgo/zig bin/cgo/zcc bin/cgo/zc++ \
+    && ./bin/cgo/zig env >/dev/null
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+ENV CGO_RPATH=/usr/local/lib
+RUN eval "$(./bin/cgo/zig env)" \
+    && go build -tags brain_serve,system_ladybug -o /out/brain-serve ./bin/brain/serve.go \
+    && go build -tags system_ladybug -o /out/brain-search ./bin/brain/search.go \
+    && CGO_ENABLED=0 go build -tags brain_watch -o /out/brain-watch ./bin/brain/watch.go
+
+FROM debian:bookworm-slim AS api
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends libssl3 ca-certificates wget \
+    && rm -rf /var/lib/apt/lists/* \
+    && useradd --create-home --uid 1001 2dph
+COPY --from=api-build /out/brain-serve /usr/local/bin/brain-serve
+COPY --from=api-build /out/brain-search /usr/local/bin/brain-search
+COPY --from=api-build /out/brain-watch /usr/local/bin/brain-watch
+COPY --from=api-build /src/lib-ladybug/liblbug.so.0.19.1 /usr/local/lib/liblbug.so.0.19.1
+COPY bin/docker-entrypoint /usr/local/bin/docker-entrypoint
+RUN chmod +x /usr/local/bin/docker-entrypoint \
+    && ln -s liblbug.so.0.19.1 /usr/local/lib/liblbug.so.0 \
+    && ln -s liblbug.so.0 /usr/local/lib/liblbug.so \
+    && ldconfig
+USER 2dph
+ENV KB_ROOT=/data \
+    KB_PORT=8630 \
+    LD_LIBRARY_PATH=/usr/local/lib \
+    HF_HOME=/data/hf
+WORKDIR /data
+EXPOSE 8630
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD wget -qO- http://127.0.0.1:8630/health || exit 1
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint"]
+CMD ["serve"]

PLAN.md

@@ -29,7 +29,7 @@ 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 (`get.go` / `stats.go` / `eval.go`) is Go + cgo. Python `bin/kb/{get,stats,eval}` is the CI fallback (GitHub runners have no ladybug cgo). Index/write stays Python 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. Index/write stays Python (`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. |
 | D9 | facts/goal model | Who / What / How / Where / When + evidence + confidence on every edge. |
@@ -41,9 +41,10 @@ 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 not shipped; tools are `search`/`get`/`audit`. Weights are not copied into the 2dph image. |
 | 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`). |
+| 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
 
@@ -51,7 +52,7 @@ detective method: **a fact needs ≥2 independent sources or it is
 2dph/
   PLAN.md / AGENTS.md
   docs/                     published docs (this conversation → docs/ as md)
-  skills/                   in-project skills (web-search, postgres, brain, diataxis-docs)
+  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)
@@ -59,12 +60,14 @@ detective method: **a fact needs ≥2 independent sources or it is
     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)
+    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)
@@ -134,10 +137,8 @@ Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`,
 2. `go test ./internal/brain/rank` (cgo-free ranking + flag parser)
 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`; CI uses
+5. `bin/kb/eval` (recall@5 ≥ 0.95). Local SoT is `bin/brain/eval.go` via Zig CGO.
-   the Python twin until the runner has ladybug cgo. Questions live in
+6. `bin/cgo/zig go build -tags system_ladybug` (compile search with zig cc; fetches pinned zig+libs).
-   `internal/brain/rank`.
-6. md-docs build/lint if docs tooling arrives.
 
 Feedback loop: every commit → PR → CI → green/gate → merge. Same discipline as
 `db/tech-poc`: contract first where there is an OpenAPI/message shape.

README.md

@@ -31,7 +31,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
 
@@ -126,7 +126,7 @@ bin/brain/search.go "invoice from last week"                            # same s
 
 - **LadybugDB** — single `var/kb.lbug`, Cypher property graph, HNSW + BM25
   in one engine, embedded (no server), ACID, read-only-safe for concurrent
-  readers. Read tools (`get` / `stats` / `eval`) are Go + cgo; Python
+  readers. Read tools (`get` / `stats` / `eval`) are Go + Zig CGO (`bin/cgo/zcc`); Python
   `bin/kb/{get,stats,eval}` is the CI fallback. **Never `DROP INDEX` FTS/VECTOR** on Ladybug 0.19: DROP leaves
   ghost catalog tables (`_0_Leaf_vec_UPPER`) so recreate fails while
   `SHOW_INDEXES` omits HNSW. Fresh indexes = delete `var/kb.lbug` +
@@ -155,9 +155,10 @@ go test ./... && python -m unittest discover -s bin/tools -t .
 Docker (optional, cached model + var volumes):
 
 ```bash
-docker compose run --rm brain index            # (re)index corpus
+docker compose up -d brain                     # API (Zig CGO serve :8630)
-docker compose run --rm brain search "query"   # one-shot query
+docker compose --profile index run --rm index  # Python Ladybug rebuild
-docker compose run --rm brain serve            # bin/brain/serve.go
+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
 ```
 

bin/brain/get.go

@@ -8,6 +8,7 @@
 //	./bin/brain/get.go <id> --json
 //
 // Needs CGO + libladybug. Python bin/kb/get is the CI fallback (no cgo).
+// CGO compiler is Zig (`eval "$(bin/cgo/zig env)"`), not gcc.
 // NOTE: never run `gofmt -w` on this file — it breaks the shebang.
 package main
 

bin/brain/search.go

@@ -7,7 +7,7 @@
 //	./bin/brain/search.go serve [port]
 //	./bin/brain/search.go --list-model
 //
-// Needs CGO + libladybug (CGO_CFLAGS/CGO_LDFLAGS). Prefer the wrapper
+// Needs CGO + libladybug via Zig (`eval "$(bin/cgo/zig env)"`), not gcc.
 // bin/kb/search which sets those and builds a binary for the embed daemon.
 // NOTE: never run `gofmt -w` on this file — it breaks the shebang.
 package main

bin/cgo/zc++

@@ -0,0 +1,23 @@
+#!/bin/sh
+# bin/cgo/zc++ — CGO CXX. Zig, not g++.
+set -eu
+ROOT="$(CDPATH= cd -- "$(dirname "$0")/../.." && pwd)"
+case "$(uname -m)" in
+  x86_64|amd64) TARGET=x86_64-linux-gnu ;;
+  aarch64|arm64) TARGET=aarch64-linux-gnu ;;
+  *)
+    echo "zc++: unsupported arch $(uname -m)" >&2
+    exit 2
+    ;;
+esac
+if [ -n "${ZIG:-}" ] && [ -x "$ZIG" ]; then
+  :
+elif [ -x "$ROOT/var/zig/zig" ]; then
+  ZIG="$ROOT/var/zig/zig"
+elif command -v zig >/dev/null 2>&1; then
+  ZIG="$(command -v zig)"
+else
+  echo "zc++: zig missing; run bin/cgo/zig first" >&2
+  exit 127
+fi
+exec "$ZIG" c++ -target "$TARGET" "$@"

bin/cgo/zcc

@@ -0,0 +1,24 @@
+#!/bin/sh
+# bin/cgo/zcc — CGO CC. Zig, not gcc.
+# Go invokes CC with many args; a wrapper avoids spaces in $CC.
+set -eu
+ROOT="$(CDPATH= cd -- "$(dirname "$0")/../.." && pwd)"
+case "$(uname -m)" in
+  x86_64|amd64) TARGET=x86_64-linux-gnu ;;
+  aarch64|arm64) TARGET=aarch64-linux-gnu ;;
+  *)
+    echo "zcc: unsupported arch $(uname -m)" >&2
+    exit 2
+    ;;
+esac
+if [ -n "${ZIG:-}" ] && [ -x "$ZIG" ]; then
+  :
+elif [ -x "$ROOT/var/zig/zig" ]; then
+  ZIG="$ROOT/var/zig/zig"
+elif command -v zig >/dev/null 2>&1; then
+  ZIG="$(command -v zig)"
+else
+  echo "zcc: zig missing; run bin/cgo/zig first" >&2
+  exit 127
+fi
+exec "$ZIG" cc -target "$TARGET" "$@"

bin/cgo/zig

@@ -0,0 +1,130 @@
+#!/usr/bin/env bash
+# bin/cgo/zig — CGO toolchain: zig cc (not gcc) + pinned liblbug + libtokenizers.
+#
+#   eval "$(bin/cgo/zig env)"     # export CC/CXX/CGO_*
+#   bin/cgo/zig go build ...      # ensure, then exec with env
+#   bin/cgo/zig ./bin/brain/search.go "query"
+#
+# Pins live in this file. Downloads land in var/ (gitignored).
+set -euo pipefail
+
+ROOT="$(CDPATH= cd -- "$(dirname "$0")/../.." && pwd)"
+ZIG_VERSION=0.14.1
+LBUG_VERSION=0.19.1
+TOKENIZERS_VERSION=1.27.0
+
+arch="$(uname -m)"
+case "$arch" in
+  x86_64|amd64)
+    ZIG_ARCH=x86_64
+    LBUG_ARCH=x86_64
+    TOK_ARCH=x86_64
+    ZIG_SHA=24aeeec8af16c381934a6cd7d95c807a8cb2cf7df9fa40d359aa884195c4716c
+    LBUG_SHA=ed263ae913f68cb0ddba0b98548b58edaac49929766d03bdaaa83be46c68847d
+    TOK_SHA=72556cdca798dd4ea7cdaba308e5f0d68a8cb93b67c96edf485b7a0edd7b07f4
+    ;;
+  aarch64|arm64)
+    ZIG_ARCH=aarch64
+    LBUG_ARCH=aarch64
+    TOK_ARCH=aarch64
+    ZIG_SHA=f7a654acc967864f7a050ddacfaa778c7504a0eca8d2b678839c21eea47c992b
+    LBUG_SHA=b07df2cd533c3976a2a3025866d6420a5f35514d0a822ecc4b2902d55b4725b7
+    TOK_SHA=e96545ad05930c26f51f63d932ee6d3bbd32bbed149e102c5290d587a2293067
+    ;;
+  *)
+    echo "bin/cgo/zig: unsupported arch $arch" >&2
+    exit 2
+    ;;
+esac
+
+CACHE="$ROOT/var/cache"
+LIB="$ROOT/lib-ladybug"
+ZIG_DIR="$ROOT/var/zig-dist"
+ZIG_BIN="$ROOT/var/zig/zig"
+
+sha256of() {
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$1" | awk '{print $1}'
+  else
+    shasum -a 256 "$1" | awk '{print $1}'
+  fi
+}
+
+fetch() {
+  local url="$1" dest="$2" expect="$3"
+  if [ -f "$dest" ] && [ "$(sha256of "$dest")" = "$expect" ]; then
+    return 0
+  fi
+  mkdir -p "$(dirname "$dest")"
+  echo "fetch $url" >&2
+  curl -fsSL "$url" -o "$dest"
+  local got
+  got="$(sha256of "$dest")"
+  if [ "$got" != "$expect" ]; then
+    echo "checksum mismatch $dest: got $got want $expect" >&2
+    rm -f "$dest"
+    exit 1
+  fi
+}
+
+ensure_zig() {
+  if [ -n "${ZIG:-}" ] && [ -x "$ZIG" ]; then
+    return 0
+  fi
+  if [ -x "$ZIG_BIN" ]; then
+    export ZIG="$ZIG_BIN"
+    return 0
+  fi
+  if command -v zig >/dev/null 2>&1; then
+    export ZIG
+    ZIG="$(command -v zig)"
+    return 0
+  fi
+  local tar="$CACHE/zig-${ZIG_ARCH}-linux-${ZIG_VERSION}.tar.xz"
+  fetch "https://ziglang.org/download/${ZIG_VERSION}/zig-${ZIG_ARCH}-linux-${ZIG_VERSION}.tar.xz" \
+    "$tar" "$ZIG_SHA"
+  mkdir -p "$CACHE"
+  rm -rf "$ZIG_DIR"
+  tar -xJf "$tar" -C "$CACHE"
+  mv "$CACHE/zig-${ZIG_ARCH}-linux-${ZIG_VERSION}" "$ZIG_DIR"
+  mkdir -p "$ROOT/var/zig"
+  ln -sfn "$ZIG_DIR/zig" "$ZIG_BIN"
+  export ZIG="$ZIG_BIN"
+}
+
+ensure_libs() {
+  mkdir -p "$LIB"
+  if [ ! -f "$LIB/liblbug.so" ]; then
+    local tar="$CACHE/liblbug-linux-${LBUG_ARCH}.tar.gz"
+    fetch "https://github.com/LadybugDB/ladybug/releases/download/v${LBUG_VERSION}/liblbug-linux-${LBUG_ARCH}.tar.gz" \
+      "$tar" "$LBUG_SHA"
+    tar -xzf "$tar" -C "$LIB"
+  fi
+  if [ ! -f "$LIB/libtokenizers.a" ]; then
+    local tar="$CACHE/libtokenizers.linux-${TOK_ARCH}.tar.gz"
+    fetch "https://github.com/daulet/tokenizers/releases/download/v${TOKENIZERS_VERSION}/libtokenizers.linux-${TOK_ARCH}.tar.gz" \
+      "$tar" "$TOK_SHA"
+    tar -xzf "$tar" -C "$LIB"
+  fi
+}
+
+print_env() {
+  printf 'export ZIG=%q\n' "$ZIG"
+  printf 'export CC=%q\n' "$ROOT/bin/cgo/zcc"
+  printf 'export CXX=%q\n' "$ROOT/bin/cgo/zc++"
+  printf 'export CGO_ENABLED=1\n'
+  printf 'export CGO_CFLAGS=%q\n' "-I$LIB"
+  printf 'export CGO_LDFLAGS=%q\n' "-L$LIB -Wl,-rpath,${CGO_RPATH:-$LIB}"
+}
+
+ensure_zig
+ensure_libs
+
+cmd="${1:-env}"
+if [ "$cmd" = "env" ]; then
+  print_env
+  exit 0
+fi
+
+eval "$(print_env)"
+exec "$@"

bin/docker-entrypoint

@@ -1,13 +1,10 @@
 #!/usr/bin/env bash
 # bin/docker-entrypoint - run 2dph tools inside the container.
 #
-#   brain                 shell (default)
+# API image (Zig CGO binaries):
-#   brain search <q>      bin/brain/search.go
+#   serve | search | watch
-#   brain index           bin/kb/index --with-mail
+# Index image (Python write path, compose profile `index`):
-#   brain watch <dir>     compiled /app/bin/watch (bin/brain/watch.go)
+#   index | extract | audit | search (deprecated python wrapper)
-#   brain serve           compiled /app/bin/serve (bin/brain/serve.go)
-#   brain extract         bin/facts/extract (docker×compose pairing)
-#   brain audit           bin/facts/audit
 #
 # Usage comment starts at line 2 (self-describing convention).
 set -euo pipefail
@@ -15,6 +12,20 @@ set -euo pipefail
 CMD="${1:-shell}"
 shift || true
 
+if [ -x /usr/local/bin/brain-serve ]; then
+	case "$CMD" in
+		shell) exec bash ;;
+		serve) exec /usr/local/bin/brain-serve "$@" ;;
+		search) exec /usr/local/bin/brain-search "$@" ;;
+		watch) exec /usr/local/bin/brain-watch "$@" ;;
+		index)
+			echo "index is the Python sidecar: docker compose --profile index run --rm index" >&2
+			exit 2
+			;;
+		*) echo "unknown command: $CMD (api: serve|search|watch)" >&2; exit 2 ;;
+	esac
+fi
+
 case "$CMD" in
 	shell) exec bash ;;
 	search) exec "$KB_PY" /app/bin/kb/search "$@" ;;

bin/kb/search

@@ -1,10 +1,9 @@
 #!/usr/bin/env bash
 # bin/kb/search — deprecated wrapper. Use bin/brain/search.go.
-# Sets CGO for ladybug, builds a binary (embed daemon needs a real executable),
+# CGO via Zig (bin/cgo/zig), not gcc. Builds a binary then execs it.
-# then execs it. Prints one deprecation line.
 set -euo pipefail
 
-ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+ROOT="$(CDPATH= cd -- "$(dirname "$0")/../.." && pwd)"
 BIN="$ROOT/var/bin/brain-search"
 SRC="$ROOT/internal/brain"
 CMD="$ROOT/bin/brain"
@@ -24,11 +23,10 @@ else
 fi
 
 if [ "$need_build" -eq 1 ]; then
-	echo "Building brain/search..." >&2
+	echo "Building brain/search (zig cc)..." >&2
 	(
 		cd "$ROOT" &&
-			CGO_CFLAGS="-I$ROOT/lib-ladybug" \
+			eval "$("$ROOT/bin/cgo/zig" env)" &&
-			CGO_LDFLAGS="-L$ROOT/lib-ladybug -Wl,-rpath,$ROOT/lib-ladybug" \
 			go build -tags system_ladybug -o "$BIN" ./bin/brain
 	) || exit 1
 fi

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/test_bin_layout.py

@@ -1,6 +1,7 @@
 """D14 layout: bin/{subject}/{method}.go, libs in internal/, one go.mod."""
 from __future__ import annotations
 
+import os
 import unittest
 from pathlib import Path
 
@@ -124,8 +125,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")
@@ -157,3 +178,21 @@ class BinLayoutTest(unittest.TestCase):
         for line in first.splitlines():
             if "go-git/go-git" in line:
                 self.assertNotIn("indirect", line)
+
+    def test_cgo_uses_zig_not_gcc(self) -> None:
+        for rel in ("bin/cgo/zig", "bin/cgo/zcc", "bin/cgo/zc++"):
+            p = ROOT / rel
+            self.assertTrue(p.is_file(), f"missing {rel}")
+            self.assertTrue(
+                os.access(p, os.X_OK),
+                f"{rel} must be executable",
+            )
+        zig = (ROOT / "bin" / "cgo" / "zig").read_text()
+        self.assertIn("zig cc", zig)
+        self.assertIn("0.14.1", zig)
+        zcc = (ROOT / "bin" / "cgo" / "zcc").read_text()
+        self.assertIn('exec "$ZIG" cc', zcc)
+        self.assertNotIn("command -v gcc", zcc)
+        search = (ROOT / "bin" / "kb" / "search").read_text()
+        self.assertIn("bin/cgo/zig", search)
+        self.assertNotIn("command -v gcc", search)

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_published_docs.py

@@ -59,6 +59,18 @@ class PublishedDocsTest(unittest.TestCase):
         self.assertNotIn("password", settings.lower())
         self.assertIn("json", settings)
 
+    def test_picoclaw_compose_profile_has_mcp_example(self) -> None:
+        compose = (ROOT / "compose.yaml").read_text()
+        self.assertIn('profiles: ["picoclaw"]', compose)
+        self.assertIn("127.0.0.1:8630", compose)
+        example = (ROOT / "deploy" / "picoclaw" / "mcp.json.example").read_text()
+        self.assertIn("127.0.0.1:8630/mcp", example)
+        self.assertNotIn("password", example.lower())
+        self.assertNotIn("token", example.lower())
+        docs = (ROOT / "docs" / "picoclaw.md").read_text()
+        self.assertIn("search", docs)
+        self.assertIn("throttled", docs)
+
     def test_readme_read_path_is_go(self) -> None:
         plan = (ROOT / "PLAN.md").read_text()
         self.assertIn("get.go", plan)
@@ -77,6 +89,49 @@ class PublishedDocsTest(unittest.TestCase):
         self.assertFalse((ROOT / "skills" / "db-yaml").exists())
         self.assertTrue((ROOT / "skills" / "postgres" / "SKILL.md").is_file())
 
+    def test_cgo_zig_and_index_profile(self) -> None:
+        plan = (ROOT / "PLAN.md").read_text()
+        self.assertIn("D21", plan)
+        self.assertIn("zig cc", plan)
+        dockerfile = (ROOT / "Dockerfile").read_text()
+        self.assertIn("bin/cgo/zcc", dockerfile)
+        self.assertIn("FROM debian:bookworm-slim AS api", dockerfile)
+        self.assertIn("FROM python:3.12-slim AS index", dockerfile)
+        api = dockerfile[dockerfile.index("FROM debian:bookworm-slim AS api") :]
+        self.assertNotIn("pip install", api)
+        compose = (ROOT / "compose.yaml").read_text()
+        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)

bin/tools/test_skills.py

@@ -37,3 +37,13 @@ class SkillsTest(unittest.TestCase):
         self.assertIn("tools.md", skill)
         for name in ("search", "get", "stats", "audit"):
             self.assertIn(f"`{name}`", tools)
+
+    def test_picoclaw_lists_tool_order(self) -> None:
+        skill = (ROOT / "skills" / "picoclaw" / "SKILL.md").read_text()
+        agents = (ROOT / "AGENTS.md").read_text()
+        self.assertIn("**`search`**", skill)
+        self.assertIn("**`get`**", skill)
+        self.assertIn("**`audit`**", skill)
+        self.assertIn("throttled", skill.lower())
+        self.assertIn("not a negative finding", agents)
+        self.assertIn("Fact-check every", agents)

compose.yaml

@@ -1,66 +1,87 @@
 # 2dph — docker composition
 #
-#   docker compose run --rm brain index                     # rebuild graph
+#   docker compose up -d brain                  # API (Zig CGO serve)
-#   docker compose run --rm brain search "Matrix fed"       # one-shot query
+#   docker compose --profile index run --rm index   # Python rebuild
-#   docker compose run --rm brain serve                     # async Go server
+#   docker compose --profile picoclaw up brain-mcp
-#   docker compose up brain-watch                           # auto re-index
+#   docker compose --profile reasoner up -d reasoner   # CPU Ollama :11435
+#   docker compose --profile searxng up -d
 #
-# Caching: the 128M model (HF_HOME) and kb.lbug (VAR_DIR) live in named
+# Secrets never baked in: search.env + db-profiles.yml from ~/.config/brain.
-# volumes, so rebuilds never redownload the model or re-derive the graph.
-# Secrets are never baked into the image: search.env + db-profiles.yml mount
-# read-only from ~/.config/brain.
 
 name: 2dph
 
 services:
   brain:
-    image: ghcr.io/eslider/2dph:latest
+    image: ghcr.io/eslider/2dph:api
     build:
       context: .
       dockerfile: Dockerfile
+      target: api
       cache_from:
         - ghcr.io/eslider/2dph:cache
-    command: ["brain", "search", "help"]
+    command: ["serve"]
     environment: &env
       HF_HOME: /data/hf
       BRAIN_SEARCH_CACHE: /data/cache/web-search.sqlite
       BRAIN_DB_PROFILES: /secret/db-profiles.yml
       BRAIN_SEARCH_ENV: /secret/search.env
-      KB_SEARCH_CMD: /app/bin/kb/search
+      KB_ROOT: /data
       KB_WORKERS: "4"
+      KB_PORT: "8630"
     volumes:
       - kb-model:/data/hf
       - kb-var:/data
-      # corpus is read-only on the host, never written from the container
-      - ..:/corpus:ro
       - ~/.config/brain:/secret:ro
+    ports:
+      - "127.0.0.1:8630:8630"
     read_only: true
     tmpfs:
       - /tmp
     healthcheck:
-      test: ["CMD", "python3", "-c", "import ladybug, model2vec, mistune; print('ok')"]
+      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:8630/health"]
       interval: 30s
       timeout: 5s
       retries: 3
     restart: unless-stopped
     stop_grace_period: 20s
 
-  # watcher: re-index on corpus file change (watchdog script)
   brain-watch:
-    image: ghcr.io/eslider/2dph:latest
+    image: ghcr.io/eslider/2dph:api
     environment: *env
     volumes:
       - kb-model:/data/hf
       - kb-var:/data
       - ..:/corpus:ro
       - ~/.config/brain:/secret:ro
-    command: ["brain", "watch", "/corpus"]
+    command: ["watch", "/corpus"]
     read_only: true
     tmpfs:
       - /tmp
     restart: unless-stopped
     stop_grace_period: 20s
 
+  # Python write path (Ladybug rebuild). Not in the API image.
+  #   docker compose --profile index run --rm index
+  index:
+    profiles: ["index"]
+    image: ghcr.io/eslider/2dph:index
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: index
+    environment:
+      HF_HOME: /data/hf
+      KB_PY: python3
+    volumes:
+      - kb-model:/data/hf
+      - kb-var:/app/var
+      - ..:/corpus:ro
+      - ~/.config/brain:/secret:ro
+    command: ["index"]
+    read_only: true
+    tmpfs:
+      - /tmp
+
   # Optional local SearXNG (D3). Skip if BRAIN_SEARCH_URL already points at a
   # live instance — do not run a second copy on that host.
   #   SEARXNG_SECRET=$(openssl rand -hex 32) docker compose --profile searxng up -d
@@ -76,6 +97,41 @@ services:
       - ./deploy/searxng/limiter.toml:/etc/searxng/limiter.toml:ro
     restart: unless-stopped
 
+  # MCP endpoint for an external agent (PicoClaw is not shipped here).
+  #   docker compose --profile picoclaw up brain-mcp
+  brain-mcp:
+    profiles: ["picoclaw"]
+    image: ghcr.io/eslider/2dph:api
+    environment: *env
+    volumes:
+      - kb-model:/data/hf
+      - kb-var:/data
+      - ~/.config/brain:/secret:ro
+    command: ["serve"]
+    ports:
+      - "127.0.0.1:8630:8630"
+    read_only: true
+    tmpfs:
+      - /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:

deploy/picoclaw/mcp.json.example

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "2dph": {
+      "url": "http://127.0.0.1:8630/mcp",
+      "description": "2dph fact gate. Tool order: search → get → audit. throttled is not absence."
+    }
+  }
+}

docs/README.md

@@ -6,6 +6,7 @@ Brain/ops/eSlider stack. Facts need proof or they are
 
 - [PLAN.md](../PLAN.md) — decisions, execution order, open questions (v2)
 - [design](design.md) — schema, deduction model, sources
+- [reasoner](reasoner.md) — D18 CPU bake-off (Qwen3.5-9B vs Bonsai / Qwen3.6-27B)
 - [Gitea issues](https://git.produktor.io/eSlider/2dph/issues) — work board (origin)
 
 Search: `bin/brain/search.go "query"` (HTTP: `bin/brain/serve.go` —

docs/crm-associations-proof.md

@@ -0,0 +1,33 @@
+# CRM association proof (oo CLI ↔ corpus)
+
+Proven with `oo` (eslider/go-onlyoffice) against the OnlyOffice portal
+(`office.produktor.io`). Portal CRM is the SSOT for company ↔ person ↔
+project associations; the corpus SoT (`eslider/cv/projects/knowledge-mesh-seed.yaml`)
+is the second, independent source. Facts that can be backed by both are
+written to the brain under `root=facts` by `bin/facts/crm`.
+
+## What was verified
+
+- Logical counts (portal MySQL): 1300 contacts = 897 persons + 404 companies,
+  198 projects, 998 deals, 939 project↔contact links.
+- Every client company linked to a project has ≥1 person underneath.
+- Every person `company_id` resolves to an existing company.
+- Corpus org list (9) maps 1:1 onto CRM companies:
+  ProProdukt SL / produktor.io, Dyvenia, Immowelt AG, WhereGroup,
+  Keynote SIGOS, D2S/SYSTEMS, GRID, Pack und Cup, Markets Platform.
+- 78 person↔company association facts written to the brain
+  (`how=crm-crosscheck`, `type=association`). Recall@5 in `bin/kb/eval` = 1.0.
+
+## Mistakes found
+
+| # | Mistake | Fix |
+|---|---------|-----|
+| 1 | Duplicate legal entity `GoldenRatio.Exchange` (contact 759) vs `Golden Ratio Exchange` (763); 3 deals (211, 287, 559) were linked to 759 | `oo contacts merge 759 763` — 763 kept, 759 removed, deal links re-pointed to 763 |
+| 2 | `env/`-wide: OnlyOffice creds file used wrong UX (user `eslider`, password with `$2` suffix) making `oo` auth fail | `.env` fixed to `eslider@gmail.com` + clean password; `.env` stays gitignored |
+
+## Gates after fix
+
+- `uv run python -m unittest discover -s bin/tools -t .` → 26 tests OK
+- `bin/facts/audit self` + `bin/facts/audit db` → ok
+- `bin/kb/eval` → recall@5 = 1.0
+- `go test ./...` (bin/server + bin/watch) → ok

docs/design.md

@@ -66,10 +66,12 @@ Conflicting pairings (≥2 yes vs ≥2 no) = hypothesis (OQ1 → v2 resolution).
 ## Read path
 
 `bin/brain/get.go`, `stats.go`, and `eval.go` call `internal/brain` with cgo
-(`system_ladybug`). They do not exec Python. Control questions for recall@5
+(`system_ladybug`), compiled by **Zig** (`bin/cgo/zcc`, D21), not gcc.
-live in `internal/brain/rank` so CI can test the table without libladybug.
+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
-has ladybug cgo. Index/write is still `bin/kb/index`.
+fetches Zig + libs (`bin/cgo/zig`). Index/write is still `bin/kb/index`
+(`docker compose --profile index`).
 
 ## Agent API (D20)
 
@@ -77,3 +79,11 @@ has ladybug cgo. Index/write is still `bin/kb/index`.
 (`GET /openapi.json`) and MCP (`POST /mcp` JSON-RPC `tools/list` +
 `tools/call`). Tool names match paths: `search`, `get`, `stats`, `audit`.
 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).

docs/picoclaw.md

@@ -0,0 +1,18 @@
+# PicoClaw profile (reference agent)
+
+2dph is the memory/fact gate. PicoClaw (or any MCP client) is the agent loop
+and is **not** shipped in this repo.
+
+```bash
+docker compose --profile picoclaw up brain-mcp
+```
+
+The API listens on `127.0.0.1:8630`. Point the agent at
+`http://127.0.0.1:8630/mcp` using [deploy/picoclaw/mcp.json.example](../deploy/picoclaw/mcp.json.example).
+
+OpenAPI: `GET http://127.0.0.1:8630/openapi.json`.
+
+Before a factual reply: `search` → `get` → `audit`. `throttled` is not a
+negative finding. See `skills/picoclaw/SKILL.md`.
+
+No Cursor required. A live PicoClaw binary/image is an operator choice.

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
+```

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/picoclaw/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: picoclaw
+description: >-
+  2dph is the memory/fact gate, not the agent loop. Use when wiring PicoClaw
+  or any MCP client: call brain search/get/audit before a factual reply.
+  throttled is not a negative finding.
+---
+
+# PicoClaw — fact-check before assert
+
+PicoClaw (or any agent) speaks MCP at `POST /mcp` on `bin/brain/serve.go`.
+2dph does not run the agent loop. Compose: `docker compose --profile picoclaw up brain-mcp`
+(see [docs/picoclaw.md](../../docs/picoclaw.md)).
+
+## Tool order (before a factual reply)
+
+1. **`search`** — facts root first, then info. The `web` block is a second
+   source when there is no facts hit. Status `throttled` / `skipped` /
+   `refused` is **not** evidence of absence.
+2. **`get`** — full leaf body only when a hit `id` is needed.
+3. **`audit`** — if recall or confidence looks wrong.
+
+Then answer. Confirmed only from facts (≥2 independent sources). Anything
+else is `(not confirmed)`. Missing graph ≠ “does not exist”.
+
+Generated tool list: [../brain/tools.md](../brain/tools.md).