feat: in-process HTTP search; /get /stats /audit /ingest. (#13 )

bin/brain/serve.go (ladybug tags) calls internal/brain instead of exec. HTTP tests inject a fake API so CI stays cgo-free. ExecSearcher remains the fallback when the binary is built without system_ladybug.
feat: brain/index.go shebang; mail import is not a brain write (D14). (#12 )
2026-08-13 17:52:15 +01:00 · 2026-08-13 17:46:25 +01:00 · 2026-08-13 17:31:03 +01:00 · 2026-08-13 17:23:40 +01:00 · 2026-08-13 14:32:21 +01:00 · 2026-08-13 14:26:54 +01:00
64 changed files with 1150 additions and 524 deletions
@@ -36,10 +36,13 @@ 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; libs in internal/brain and internal/httpapi
-internal/     shared Go (brain/rank is cgo-free)
-bin/watch/    corpus watcher (internal via bin/brain/watch later)
-bin/mail/     mail pipeline: sync (Go), import (md), index_mail (rebuild)
+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/postgres/ query.go (read-only YAML)
+internal/     shared Go (brain/rank is cgo-free; chats parsers too)
+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)
 compose.yaml  docker composition (root level, not docker/)
@@ -53,8 +56,8 @@ var/          kb.lbug, var/mail/*, caches (gitignored)
 ```bash
 bin/mail/sync.go --source onlyoffice,gmail --workers 8 --out var/mail   # raw message.json + attachments
 bin/mail/sync.go --source gmail --query 'from:example.com' --out var/mail  # Gmail search (default in:inbox)
-bin/mail/import --from-raw var/mail                                     # message.json → message.md (convert only)
-bin/mail/index_mail                                                     # rebuild brain incl. all mail (fresh DB)
+bin/mail/import.go --from-raw var/mail                                  # message.json → message.md (convert only)
+bin/brain/index.go --rebuild                                            # rebuild brain incl. all mail (fresh DB)
 ```

 - `sync` (Go) downloads messages + attachments; Gmail uses paginated list +
@@ -63,7 +66,7 @@ bin/mail/index_mail                                                     # 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` always rebuilds from scratch (repo corpus + mail). Ladybug
+- `index_mail` is a deprecation shim for `bin/brain/index.go --rebuild`. Ladybug
  corrupts its WAL when brand-new leafs are bulk-inserted while FTS/vector
  indexes exist; a fresh DB with indexes created last is the only safe path.
  Keep conversion + indexing separate so a conversion crash can't leave the
@@ -76,6 +79,9 @@ bin/facts/audit ["self"|"facts"|"info"|"stale"]   # 2-source + staleness gate
 bin/facts/crm [--dry-run]                         # proof person↔company/company↔project (ooCRM × corpus SoT)
 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/get.go <id> [--body]
+bin/markdown/import.go [dir]                      # mistune leaves → YAML
+bin/postgres/query.go --profile onlyoffice -c 'SELECT 1'
 bin/md/tables                                     # what the graph holds → YAML
 bin/brain/deduce "question"                       # thinking wrapper
 ```
@@ -26,10 +26,10 @@ detective method: **a fact needs ≥2 independent sources or it is
 |---|----------|--------|
 | D1 | RAG corpus | ops stack (chat, onlyoffice, gitea/NPM, searchxng, observability, ai-bot, mcp-servers, `~/.ssh/config`) + portfolio. Exclude `office.dev` + jobs/applications. |
 | D2 | skill merging | integrate skills **in this project** `skills/`; skip gitea / brain-dependent skills. |
-| D3 | web search | import `web-search`, retire local `searxng-ops`. Vendored here, no remote link. |
+| D3 | web search | Vendored client; SearXNG URL is config. Optional Compose instance (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** (Kuzu successor, MIT, embedded, native FTS+vector+Cypher). Python binding for `bin/*`; Go shebang for golang tools. |
+| D6 | graph engine | **LadybugDB**. Go is the service (`bin/brain/search.go`, `bin/brain/serve.go` in-process, `internal/brain`); Python remains for index/write 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. |
@@ -40,6 +40,8 @@ detective method: **a fact needs ≥2 independent sources or it is
 | D14 | tooling style | `bin/{subject}/{method}.go` shebang (e.g. `bin/brain/search.go`). Shared code in `internal/`. One root `go.mod` + `go.work`. No `bin/*/main.go`, no nested modules. |
 | 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 sources → web), not every edit. 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. |

 ## Architecture

@@ -51,10 +53,17 @@ detective method: **a fact needs ≥2 independent sources or it is
  bin/
    facts/extract           auto-pair 2 sources → lexicon yaml + graph
    facts/audit             ["self"|"facts"|"info"|"stale"] 2-source + staleness gate
-    kb/index                build FTS + HNSW from corpus
-    kb/search               deduction: facts → info → web-search; --hop N
-    kb/get  kb/stats  kb/eval
-    md/import  md/select  md/tables  md/gaps     (mistune)
+    kb/index                Python write path (called by bin/brain/index.go)
+    brain/index.go          rebuild FTS + HNSW (incl. --with-mail)
+    brain/get.go stats.go eval.go watch.go
+    brain/search.go         deduction: facts → info → web-search
+    brain/serve.go          HTTP API in-process (internal/httpapi + internal/brain)
+    mail/import.go          JSON → markdown (no brain write)
+    markdown/import.go      mistune leaves
+    postgres/query.go       read-only YAML (wraps bin/db/psql-yq)
+    chats/sync.go import.go facts.go apply.go
+                            (libs in internal/chats; no chats index)
+    md/import               (deprecated; bin/markdown/import.go)
    brain/extract  brain/audit   brain/deduce    (thinking wrapper)
    web/search               (vendored)
    db/psql-yq               (vendored)
@@ -103,26 +112,26 @@ Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`,

 1. `bin/mail/sync.go` (Go, 8 workers) — paginated Gmail/OnlyOffice download.
   Gmail attachments key off `body.attachmentId`, not MIME `partId`.
-2. `bin/mail/import --from-raw` — message.json → message.md; PDFs via
+2. `bin/mail/import.go --from-raw` — message.json → message.md; PDFs via
   `pdftotext -layout` (~15ms) with docling subprocess fallback; ICS sidecars
   Latin-1→UTF-8 normalized.
-3. `bin/mail/index_mail` — fresh rebuild (repo corpus + mail) because ladybug
+3. `bin/brain/index.go --rebuild` — fresh rebuild (repo corpus + mail) because ladybug
   corrupts its WAL on bulk-insert into an already-indexed DB. Conversion and
-   indexing stay separate for crash safety.
+   indexing stay separate for crash safety. `bin/mail/index_mail` is a
+   deprecation shim.
 4. Result: 17,835 messages → 28,918 info leafs, FTS + HNSW healthy, searchable
-   via `bin/kb/search`.
+   via `bin/brain/search.go`.

 ## CI/CD pipeline (D15)

 `.github/workflows/ci.yml`:

-1. go vet + go test ./... (Go tools; root module)
-2. `go test ./rank` in `bin/kbsearch` (cgo-free ranking + flag parser; nested module still needs ladybug for the rest)
-3. `go test ./...` in `bin/chats` (Telegram + LinkedIn parsers; nested module)
-4. python -m unittest discover (Py tools)
-5. bin/facts/audit self  (lexicon internal consistency)
-6. bin/kb/eval            (recall@5 ≥ 0.95, gates index regressions)
-7. md-docs build/lint if docs tooling arrives.
+1. go vet + go test ./... (root module; packages without ladybug cgo)
+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)
+5. bin/brain/eval.go       (recall@5 ≥ 0.95, gates index regressions)
+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.
@@ -30,9 +30,9 @@ graph TB
    subgraph dph["2dph tools"]
        EX["bin/facts/extract<br/>2-source pairing"]
        AU["bin/facts/audit<br/>confidence + staleness"]
-        IDX["bin/kb/index<br/>chunk + embed"]
-        MD["bin/md/import<br/>mistune leaves"]
-        SR["bin/kb/search<br/>deduction + --hop"]
+        IDX["bin/brain/index.go<br/>chunk + embed"]
+        MD["bin/markdown/import.go<br/>mistune leaves"]
+        SR["bin/brain/search.go<br/>deduction"]
    end

    subgraph store["Ladybug var/kb.lbug"]
@@ -85,21 +85,23 @@ fact; conflicting sources or a single source → `hypothesis` → `(not confirme
 ## Deduction search

 ```bash
-bin/kb/search "Matrix federation over HTTPS"      # facts → info → web-search
-bin/kb/search "what runs on arc-2" --hop 1        # walk graph edges
-bin/kb/search "where is cs-lexicon" --json | yq '.'  # YAML by default
-bin/kb/get <id> --body                            # full chunk on demand
-bin/kb/stats                                      # index health
-bin/kb/eval                                       # recall@5 gate
+bin/brain/search.go "Matrix federation over HTTPS"   # facts → info → web-search
+bin/brain/search.go "onlyoffice postgres" --root facts
+bin/brain/search.go "where is cs-lexicon" --json | yq '.'
+bin/brain/get.go <id> --body                         # full chunk on demand
+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`.
+
 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 --from-raw var/mail                                     # JSON → markdown
-bin/mail/index_mail                                                     # rebuild brain incl. mail
-bin/kb/search "Mietwagen Nürnberg invoice"                              # now answers from mail
+bin/mail/import.go --from-raw var/mail                                  # JSON → markdown
+bin/brain/index.go --rebuild                                            # rebuild brain (incl. mail)
+bin/brain/search.go "invoice from last week"                            # same search over mail leafs
 ```

 ## Storage
@@ -109,7 +111,7 @@ bin/kb/search "Mietwagen Nürnberg invoice"                              # now a
  readers. **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` +
-  `bin/kb/index --rebuild`. Use `ensure_indexes()` after upserts.
+  `bin/brain/index.go --rebuild`. Use `ensure_indexes()` after upserts.
 - **model2vec** — `potion-multilingual-128M` static embeddings (256-dim),
  CPU-fast, deterministic, no Ollama runtime dependency.
 - facts and info split semantically by `root` column but written inside the
@@ -117,10 +119,10 @@ bin/kb/search "Mietwagen Nürnberg invoice"                              # now a

 ## Tooling conventions

-`bin/{subject}/{method}` — self-describing: shebang on line 1, usage comment
-from line 2. bash + python primary; golang via the Go shebang when a compiled
-helper is right. YAML default output, `--json` for machines. Everything that
-touches network/db is read-only, throttled, cached. Tests gate every commit.
+`bin/{subject}/{method}.go` — self-describing: shebang on line 1, usage comment
+from line 2. Shared code in `internal/`. YAML default output, `--json` for
+machines. Tests gate every commit. HTTP: `bin/brain/serve.go` calls
+`internal/brain` in-process (`/health` `/search` `/get` `/stats` `/audit` `/ingest`).

 ## Development

@@ -136,7 +138,7 @@ Docker (optional, cached model + var volumes):
 ```bash
 docker compose run --rm brain index            # (re)index corpus
 docker compose run --rm brain search "query"   # one-shot query
-docker compose run --rm brain serve            # async Go HTTP server
+docker compose run --rm brain serve            # bin/brain/serve.go
 docker compose up brain-watch                  # auto re-index on change
 ```

@@ -1,3 +1,3 @@
-// Commands in this directory are shebang mains (search.go).
-// search.go is behind the system_ladybug build tag (cgo).
+// Commands in this directory are shebang mains (search.go, serve.go, index.go,
+// get.go, stats.go, eval.go, watch.go), each behind an exclusive build tag.
 package main
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=brain_eval "$0" "$@"; exit
+//go:build brain_eval
+//
+// bin/brain/eval.go - recall@5 gate.
+//
+//	./bin/brain/eval.go
+//	./bin/brain/eval.go --json
+//
+// 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/eval", os.Args[1:]))
+}
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=brain_get "$0" "$@"; exit
+//go:build brain_get
+//
+// bin/brain/get.go - read one leaf by id.
+//
+//	./bin/brain/get.go <id>
+//	./bin/brain/get.go <id> --body
+//
+// 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/get", os.Args[1:]))
+}
@@ -0,0 +1,24 @@
+//usr/bin/env go run -tags=brain_index "$0" "$@"; exit
+//go:build brain_index
+//
+// bin/brain/index.go - rebuild the Ladybug graph (Python write path).
+//
+//	./bin/brain/index.go --rebuild
+//	./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
+// insert corrupts Ladybug 0.19 WAL). `add` is v2.
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/internal/cmdbin"
+)
+
+func main() {
+	args := append([]string{"--with-mail"}, os.Args[1:]...)
+	os.Exit(cmdbin.ExecFile("bin/kb/index", args))
+}
@@ -1,18 +1,20 @@
-//usr/bin/env go run -tags=brain_serve "$0" "$@"; exit
-//go:build brain_serve
+//usr/bin/env go run -tags=brain_serve,system_ladybug "$0" "$@"; exit
+//go:build brain_serve && cgo && system_ladybug
 //
-// bin/brain/serve.go - HTTP API for the 2dph brain.
+// bin/brain/serve.go - HTTP API (in-process ladybug search).
 //
 //	KB_ROOT=/path/to/2dph ./bin/brain/serve.go
-//	KB_SEARCH_CMD=... KB_WORKERS=4 KB_PORT=8630 ./bin/brain/serve.go
+//	KB_WORKERS=4 KB_PORT=8630 ./bin/brain/serve.go
 //
-// Default search backend is var/bin/brain-search (Go), not Python.
+// Needs CGO + libladybug (same as bin/brain/search.go).
 // NOTE: never run `gofmt -w` on this file — it breaks the shebang.
 package main

 import (
+	"log"
 	"os"

+	"github.com/eSlider/2dph/internal/brain"
 	"github.com/eSlider/2dph/internal/httpapi"
 )

@@ -22,5 +24,8 @@ func main() {
 			os.Setenv("KB_ROOT", wd)
 		}
 	}
-	httpapi.Run()
+	if err := brain.Ready(); err != nil {
+		log.Fatal(err)
+	}
+	httpapi.Run(brain.HTTP{})
 }
@@ -0,0 +1,20 @@
+//go:build brain_serve && !system_ladybug
+//
+// Fallback serve when ladybug cgo is not in the build (CI / tags=brain_serve).
+// Production shebang is serve.go (in-process).
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/internal/httpapi"
+)
+
+func main() {
+	if os.Getenv("KB_ROOT") == "" {
+		if wd, err := os.Getwd(); err == nil {
+			os.Setenv("KB_ROOT", wd)
+		}
+	}
+	httpapi.Run(nil)
+}
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=brain_stats "$0" "$@"; exit
+//go:build brain_stats
+//
+// bin/brain/stats.go - index health.
+//
+//	./bin/brain/stats.go
+//	./bin/brain/stats.go --json
+//
+// 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/stats", os.Args[1:]))
+}
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=brain_watch "$0" "$@"; exit
+//go:build brain_watch
+//
+// bin/brain/watch.go - re-index when corpus files change.
+//
+//	./bin/brain/watch.go [dir...]
+//	KB_WATCH_INTERVAL=15 ./bin/brain/watch.go
+//
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/bin/watch"
+)
+
+func main() {
+	watch.Run(os.Args[1:])
+}
@@ -0,0 +1,19 @@
+//usr/bin/env go run -tags=chats_apply "$0" "$@"; exit
+//go:build chats_apply
+//
+// bin/chats/apply.go - push extracted chat facts to OnlyOffice CRM.
+//
+//	./bin/chats/apply.go [--dry-run]
+//
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/internal/chats"
+)
+
+func main() {
+	os.Exit(chats.RunApply(os.Args[1:]))
+}
@@ -0,0 +1,4 @@
+// Commands in this directory are shebang mains (sync.go, import.go, facts.go,
+// apply.go), each behind an exclusive build tag so `go build ./bin/chats`
+// does not see two mains. Shared code lives in internal/chats.
+package main
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=chats_facts "$0" "$@"; exit
+//go:build chats_facts
+//
+// bin/chats/facts.go - extract phone/email/linkedin facts from JSONL.
+//
+//	./bin/chats/facts.go
+//
+// Writes var/chats/facts/. Does not index the brain.
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/internal/chats"
+)
+
+func main() {
+	os.Exit(chats.RunFacts(os.Args[1:]))
+}
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=chats_import "$0" "$@"; exit
+//go:build chats_import
+//
+// bin/chats/import.go - JSONL → markdown under var/chats/md/.
+//
+//	./bin/chats/import.go
+//
+// Conversion only. Brain ingest is bin/brain/index.go, not this command.
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"os"
+
+	"github.com/eSlider/2dph/internal/chats"
+)
+
+func main() {
+	os.Exit(chats.RunImport(os.Args[1:]))
+}
@@ -1,56 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-func runIndex(args []string) int {
-	fs := flag.NewFlagSet("chats index", flag.ContinueOnError)
-	help := fs.Bool("help", false, "")
-	fs.SetOutput(os.Stderr)
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-	if *help {
-		fmt.Fprintln(os.Stderr, "usage: chats index")
-		return 0
-	}
-
-	root := repoRoot()
-	mdDir := filepath.Join(chatsDir(), "md")
-
-	_, err := os.Stat(mdDir)
-	if os.IsNotExist(err) {
-		fmt.Fprintf(os.Stderr, "chats index: no chat markdown at %s; run 'chats import' first\n", mdDir)
-		return 1
-	}
-
-	indexScript := filepath.Join(root, "bin", "kb", "index")
-	if _, err := os.Stat(indexScript); os.IsNotExist(err) {
-		fmt.Fprintf(os.Stderr, "chats index: %s not found\n", indexScript)
-		return 1
-	}
-
-	cmd := exec.Command(indexScript, "--corpus", mdDir)
-	var outBuf, errBuf bytes.Buffer
-	cmd.Stdout = &outBuf
-	cmd.Stderr = &errBuf
-	cmd.Dir = root
-
-	if err := cmd.Run(); err != nil {
-		fmt.Fprintf(os.Stderr, "chats index: %v\n%s", err, errBuf.String())
-		return 1
-	}
-	result := strings.TrimSpace(outBuf.String())
-	if result == "" {
-		result = strings.TrimSpace(errBuf.String())
-	}
-	fmt.Printf("chats index: %s\n", result)
-	return 0
-}
@@ -1,115 +0,0 @@
-// bin/chats - sync, import, index, extract facts, and apply chat data
-// from Telegram, WhatsApp, LinkedIn into the brain and OnlyOffice CRM.
-//
-// Usage:
-//
-//	chats sync telegram   [--limit N] [--since DATE] [--phone PHONE]
-//	chats sync whatsapp   [--qr] [--limit N]
-//	chats sync linkedin   [--limit N]
-//	chats import                           # JSONL → MD (all sources)
-//	chats index                            # rebuild var/kb.lbug with chats
-//	chats facts                            # extract + cross-check
-//	chats apply          [--dry-run]       # push to OnlyOffice CRM
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-func main() {
-	if len(os.Args) < 2 {
-		usage()
-		os.Exit(2)
-	}
-	cmd := os.Args[1]
-	args := os.Args[2:]
-	switch cmd {
-	case "sync":
-		if len(args) < 1 {
-			usage()
-			os.Exit(2)
-		}
-		platform := args[0]
-		platformArgs := args[1:]
-		switch platform {
-		case "telegram":
-			os.Exit(runSyncTelegram(platformArgs))
-		case "whatsapp":
-			fmt.Fprintf(os.Stderr, "chats: WhatsApp not implemented yet\n")
-			os.Exit(1)
-		case "linkedin":
-			os.Exit(runSyncLinkedIn(platformArgs))
-		default:
-			fmt.Fprintf(os.Stderr, "chats: unknown platform %q\n", platform)
-			os.Exit(2)
-		}
-	case "import":
-		os.Exit(runImport(args))
-	case "index":
-		os.Exit(runIndex(args))
-	case "facts":
-		os.Exit(runFacts(args))
-	case "apply":
-		os.Exit(runApply(args))
-	case "help", "-h", "--help":
-		usage()
-		return
-	default:
-		fmt.Fprintf(os.Stderr, "chats: unknown command %q\n", cmd)
-		usage()
-		os.Exit(2)
-	}
-}
-
-func usage() {
-	w := os.Stderr
-	fmt.Fprintln(w, `Usage: chats <command> [args]
-
-Commands:
-  sync telegram  [--limit N] [--since DATE] [--phone PHONE]
-  sync whatsapp  [--qr] [--limit N]
-  sync linkedin  [--limit N]
-  import                             JSONL → MD (all sources)
-  index                              rebuild var/kb.lbug with chats
-  facts                              extract + cross-check facts
-  apply             [--dry-run]      push to OnlyOffice CRM
-
-Output layout:
-  var/chats/<platform>/<chat_id>/messages.jsonl
-  var/chats/md/<platform>/<chat_name>/messages.md`)
-}
-
-// repoRoot locates the 2dph project root by walking up from the binary.
-func repoRoot() string {
-	if v := os.Getenv("KB_ROOT"); v != "" {
-		return v
-	}
-	wd, err := os.Getwd()
-	if err != nil {
-		return "."
-	}
-	for i := 0; i < 10; i++ {
-		if _, err := os.Stat(wd + "/var"); err == nil {
-			return wd
-		}
-		if _, err := os.Stat(wd + "/.git"); err == nil {
-			return wd
-		}
-		parent := wd
-		if idx := strings.LastIndex(wd, "/"); idx >= 0 {
-			parent = wd[:idx]
-		}
-		if parent == wd {
-			break
-		}
-		wd = parent
-	}
-	return "."
-}
-
-// chatsDir returns var/chats under the repo root.
-func chatsDir() string {
-	return repoRoot() + "/var/chats"
-}
@@ -0,0 +1,41 @@
+//usr/bin/env go run -tags=chats_sync "$0" "$@"; exit
+//go:build chats_sync
+//
+// bin/chats/sync.go - download chat messages to var/chats/<platform>/.
+//
+//	./bin/chats/sync.go telegram [--limit N] [--phone PHONE]
+//	./bin/chats/sync.go linkedin [--limit N] [--refresh]
+//
+// NOTE: never run `gofmt -w` on this file — it breaks the shebang.
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/eSlider/2dph/internal/chats"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, `usage: bin/chats/sync.go telegram|linkedin [flags]`)
+		os.Exit(2)
+	}
+	platform := os.Args[1]
+	args := os.Args[2:]
+	switch platform {
+	case "telegram":
+		os.Exit(chats.RunSyncTelegram(args))
+	case "linkedin":
+		os.Exit(chats.RunSyncLinkedIn(args))
+	case "whatsapp":
+		fmt.Fprintln(os.Stderr, "chats: WhatsApp not implemented yet")
+		os.Exit(1)
+	case "help", "-h", "--help":
+		fmt.Fprintln(os.Stderr, `usage: bin/chats/sync.go telegram|linkedin [flags]`)
+		return
+	default:
+		fmt.Fprintf(os.Stderr, "chats: unknown platform %q\n", platform)
+		os.Exit(2)
+	}
+}
@@ -2,10 +2,10 @@
 # bin/docker-entrypoint - run 2dph tools inside the container.
 #
 #   brain                 shell (default)
-#   brain search <q>      bin/kb/search
-#   brain index           bin/kb/index
-#   brain watch <dir>     watchdog re-indexer (bin/kb/watch)
-#   brain serve           async Go HTTP server (bin/serve)
+#   brain search <q>      bin/brain/search.go
+#   brain index           bin/kb/index --with-mail
+#   brain watch <dir>     compiled /app/bin/watch (bin/brain/watch.go)
+#   brain serve           compiled /app/bin/serve (bin/brain/serve.go)
 #   brain extract         bin/facts/extract (docker×compose pairing)
 #   brain audit           bin/facts/audit
 #
@@ -18,7 +18,7 @@ shift || true
 case "$CMD" in
  shell) exec bash ;;
  search) exec "$KB_PY" /app/bin/kb/search "$@" ;;
-  index) exec "$KB_PY" /app/bin/kb/index "$@" ;;
+  index) exec "$KB_PY" /app/bin/kb/index --with-mail "$@" ;;
  watch) exec /app/bin/watch "$@" ;;
  serve) exec /app/bin/serve "$@" ;;
  extract) exec "$KB_PY" /app/bin/facts/extract "$@" ;;
@@ -26,6 +26,7 @@ from kblib import (  # noqa: E402
    open_readonly, stats,
 )
 from mdleaves import read_markdown, to_all, walk_markdown  # noqa: E402
+from mailleafs import from_mail_root  # noqa: E402

 CORPUS_DEFAULTS = ["README.md", "PLAN.md", "AGENTS.md", "docs", "skills"]

@@ -99,6 +100,9 @@ def main(argv: list[str]) -> int:
    p = argparse.ArgumentParser(description="build the 2dph brain index")
    p.add_argument("--corpus", action="append", help="extra markdown dir/file to index (may repeat)")
    p.add_argument("--rebuild", action="store_true", help="fresh db + indexes")
+    p.add_argument("--with-mail", action="store_true", help="include var/mail message.md leafs")
+    p.add_argument("--since", default="", help="with --with-mail, only messages dated >= YYYY-MM-DD")
+    p.add_argument("--dry-run", action="store_true", help="count leafs, write nothing")
    p.add_argument(
        "--skip-indexes",
        action="store_true",
@@ -109,14 +113,26 @@ def main(argv: list[str]) -> int:
    a = p.parse_args(argv)

    from kblib import DB_PATH, VAR
-    VAR.mkdir(exist_ok=True)
-    if a.rebuild and DB_PATH.exists():
-        DB_PATH.unlink()

    leafs = load_corpus(ROOT)
    if a.corpus:
        for source in a.corpus:
            leafs.extend(load_corpus_glob(source))
+    mail_n = 0
+    if a.with_mail:
+        mail = from_mail_root(ROOT / "var" / "mail", since=a.since)
+        mail_n = len(mail)
+        leafs.extend(mail)
+
+    if a.dry_run:
+        msg = {"indexed": 0, "corpus_total": len(leafs), "mail_leafs": mail_n, "dry_run": True}
+        print(json.dumps(msg, indent=2) if a.json else
+              f"brain/index: {len(leafs)} leafs would be indexed (mail={mail_n})")
+        return 0
+
+    VAR.mkdir(exist_ok=True)
+    if a.rebuild and DB_PATH.exists():
+        DB_PATH.unlink()

    db, conn = connect(DB_PATH, read_only=False)
    init_schema(conn)
@@ -1,5 +1,5 @@
 //usr/bin/env go run "$0" "$@"; exit
-// bin/kb/watch.go - re-index the 2dph brain when corpus files change.
+// bin/kb/watch.go — deprecated. Use bin/brain/watch.go.
 //
 // Usage:
 //
@@ -15,8 +15,8 @@ Writes one directory per message: var/mail/{folder}/{message_id}/
  attachments/              raw attachment files (zips unpacked to _unpacked/)
  attachments/*.md          converted attachment content

-Indexing is a separate step (bin/mail/index_mail): conversion can crash in
-native docling and must not leave the brain DB mid-transaction.
+Indexing is a separate step (`bin/brain/index.go --rebuild`): conversion can
+crash in native docling and must not leave the brain DB mid-transaction.

 Requires ONLYOFFICE_URL/USER/PASS in .env (or env). Idempotent: a message
 already present (message.md exists) is skipped unless --force.
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=mail_import "$0" "$@"; exit
+//go:build mail_import
+//
+// bin/mail/import.go - message.json → markdown (no brain write).
+//
+//	./bin/mail/import.go --from-raw var/mail
+//
+// Indexing is bin/brain/index.go --rebuild, not this command.
+// 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/mail/import", os.Args[1:]))
+}
@@ -1,135 +1,26 @@
 #!/usr/bin/env python3
-"""mail/index_mail - rebuild the brain with every markdown under var/mail.
+"""mail/index_mail — deprecated. Use bin/brain/index.go --rebuild --with-mail.

-Ladybug corrupts its WAL when brand-new leafs are bulk-inserted while the
-FTS/VECTOR indexes already exist, so indexing ALWAYS runs as a fresh rebuild
-(repo corpus + var/mail), matching the proven-safe `kb/index --rebuild` path.
-Conversion and indexing stay separate: conversion can crash in native docling
-and must not leave the brain DB mid-transaction.
-
-  bin/mail/index_mail                 rebuild the index incl. all mail
-  bin/mail/index_mail --dry-run       count without writing
-  bin/mail/index_mail --limit N       cap messages included
-  bin/mail/index_mail --since D       only messages dated >= D (YYYY-MM-DD)
+Ladybug corrupts its WAL on bulk-insert into an already-indexed DB, so this
+shim always rebuilds (repo corpus + var/mail). Conversion stays in mail/import.
 """
 from __future__ import annotations

-import argparse
-import json
+import os
 import sys
 from pathlib import Path

 ROOT = Path(__file__).resolve().parents[2]
-sys.path.insert(0, str(ROOT / "bin" / "tools"))
-
-from kblib import DB_PATH, VAR, connect, ensure_indexes, init_schema, stats, upsert_leaf  # noqa: E402
-from mdleaves import read_markdown, to_all, walk_markdown  # noqa: E402
-
-
-def msg_date(md: Path) -> str:
-    j = md.parent / "message.json"
-    try:
-        d = json.loads(j.read_text(encoding="utf-8"))
-        return (d.get("receivedDate") or d.get("receivedAt") or "")[:10]
-    except Exception:
-        return ""
-
-
-def mail_leafs(limit: int, since: str, repo: str = "ooMail") -> list[dict]:
-    root = ROOT / "var" / "mail"
-    mds = sorted(root.rglob("message.md"))
-    if since:
-        mds = [m for m in mds if msg_date(m) >= since]
-    if limit:
-        mds = mds[:limit]
-    leafs: list[dict] = []
-    for md in mds:
-        files = [md] + sorted((md.parent / "attachments").glob("*.md"))
-        for f in files:
-            if not f.exists():
-                continue
-            for lf in to_all(read_markdown(f), f, repo=repo):
-                lf["source"] = f"ooMail:{md.parent.name}:{f.name}"
-                lf["how"] = "mail/import"
-                leafs.append(lf)
-    return leafs


 def main(argv: list[str]) -> int:
-    p = argparse.ArgumentParser(description="rebuild the brain incl. all mail")
-    p.add_argument("--dry-run", action="store_true", help="count only, write nothing")
-    p.add_argument("--limit", type=int, default=0, help="cap messages included")
-    p.add_argument("--since", default="", help="only messages dated >= YYYY-MM-DD")
-    p.add_argument("--json", action="store_true")
-    a = p.parse_args(argv)
-
-    mail = mail_leafs(a.limit, a.since)
-    if a.dry_run:
-        print(f"mail/index_mail: {len(mail)} mail leafs would be indexed")
-        return 0
-
-    # Fresh rebuild: delete DB, index repo corpus + mail, create indexes once
-    # at the end. Never insert into an already-indexed DB (WAL corruption).
-    VAR.mkdir(exist_ok=True)
-    if DB_PATH.exists():
-        DB_PATH.unlink()
-
-    corpus = _load_corpus()
-    leafs = corpus + mail
-
-    db, conn = connect(DB_PATH, read_only=False)
-    init_schema(conn)
-    embed = _embedder()
-    done, total = _index_leafs(conn, leafs, embed)
-    ensure_indexes(conn)
-    s = stats(conn)
-    conn.close()
-    db.close()
-
-    result = {"indexed": done, "corpus_total": total, "mail_leafs": len(mail),
-              **{k: v for k, v in s.items() if k in ("total", "by_root")}}
-    print(json.dumps(result, indent=2) if a.json else
-          f"mail/index_mail: indexed {done}/{total} leafs (mail={len(mail)}); db total {s['total']}")
-    return 0
-
-
-CORPUS_DEFAULTS = ["README.md", "PLAN.md", "AGENTS.md", "docs", "skills"]
-
-
-def _load_corpus() -> list[dict]:
-    files: list[Path] = []
-    for entry in CORPUS_DEFAULTS:
-        p = ROOT / entry
-        if p.is_file():
-            files.append(p)
-        elif p.is_dir():
-            files.extend(walk_markdown(p))
-    leafs: list[dict] = []
-    for path in files:
-        try:
-            leafs.extend(to_all(read_markdown(path), path, repo="eSlider/2dph"))
-        except OSError as e:
-            print(f"mail/index_mail: skip {path}: {e}", file=sys.stderr)
-    return leafs
-
-
-def _index_leafs(conn, leafs: list[dict], embed_fn) -> tuple[int, int]:
-    count = 0
-    for lf in 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",
-                    source=lf["source"], source_rev="mail" if lf.get("how") == "mail/import" else "working-tree",
-                    how=lf.get("how", "kb/index"), loc=lf["source"], type_=lf.get("type", "reference"),
-                    embedding=emb)
-        count += 1
-    return count, len(leafs)
-
-
-def _embedder():
-    from model2vec import StaticModel
-    model = StaticModel.from_pretrained("minishlab/potion-multilingual-128M")
-    return lambda text: model.encode([text])[0].astype(float).tolist()
+    print(
+        "bin/mail/index_mail is deprecated; use bin/brain/index.go --rebuild --with-mail",
+        file=sys.stderr,
+    )
+    index = ROOT / "bin" / "kb" / "index"
+    os.execv(sys.executable, [sys.executable, str(index), "--rebuild", "--with-mail", *argv])
+    return 1


 if __name__ == "__main__":
@@ -6,7 +6,7 @@
 //	./bin/mail/sync.go --dry-run
 //
 // Writes raw message.json + attachments under var/mail/<folder>/<id>/; run
-// bin/mail/import --from-raw afterwards to convert everything to markdown.
+// bin/mail/import.go --from-raw afterwards to convert everything to markdown.
 //
 // Shebang trick: first line is a Go `//` comment; the real code lives in the
 // importable package (module path, never a relative import).
@@ -0,0 +1,3 @@
+// Commands in this directory are shebang mains (import.go), tagged so
+// `go build ./bin/markdown` does not see two mains.
+package main
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=markdown_import "$0" "$@"; exit
+//go:build markdown_import
+//
+// bin/markdown/import.go - split markdown into leafs (mistune).
+//
+//	./bin/markdown/import.go [dir]
+//	./bin/markdown/import.go --files a.md,b.md --json
+//
+// 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/md/import", os.Args[1:]))
+}
@@ -0,0 +1,2 @@
+// Commands in this directory are shebang mains (query.go).
+package main
@@ -0,0 +1,20 @@
+//usr/bin/env go run -tags=postgres_query "$0" "$@"; exit
+//go:build postgres_query
+//
+// bin/postgres/query.go - read-only Postgres as YAML.
+//
+//	./bin/postgres/query.go --profile onlyoffice -c 'SELECT 1'
+//
+// Profiles: $HOME/.config/brain/db-profiles.yml (credentials stay out of git).
+// 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/db/psql-yq", os.Args[1:]))
+}
@@ -18,5 +18,5 @@ func main() {
 			os.Setenv("KB_ROOT", wd)
 		}
 	}
-	httpapi.Run()
+	httpapi.Run(nil)
 }
@@ -135,7 +135,7 @@ def create_fts_and_vector(conn: ladybug.Connection, force: bool = False) -> None

    `force=True` is accepted for API compatibility but does **not** drop.
    Fresh indexes require deleting `var/kb.lbug` and rebuilding
-    (`bin/kb/index --rebuild`).
+    (`bin/brain/index.go --rebuild`).
    """
    del force  # API compat; DROP is unsafe — see docstring
    names = leaf_index_names(conn)
@@ -145,7 +145,7 @@ def create_fts_and_vector(conn: ladybug.Connection, force: bool = False) -> None
        except Exception as e:
            raise RuntimeError(
                "CREATE_FTS_INDEX failed (often ghost catalog after DROP INDEX). "
-                "Delete var/kb.lbug and run bin/kb/index --rebuild. "
+                "Delete var/kb.lbug and run bin/brain/index.go --rebuild. "
                f"Cause: {e}"
            ) from e
    if "Leaf_vec" not in names:
@@ -158,7 +158,7 @@ def create_fts_and_vector(conn: ladybug.Connection, force: bool = False) -> None
            raise RuntimeError(
                "CREATE_VECTOR_INDEX failed (often ghost catalog after DROP INDEX "
                "Leaf.Leaf_vec → `_0_Leaf_vec_UPPER already exists in catalog`). "
-                "Delete var/kb.lbug and run bin/kb/index --rebuild. "
+                "Delete var/kb.lbug and run bin/brain/index.go --rebuild. "
                f"Cause: {e}"
            ) from e
    names = leaf_index_names(conn)
@@ -237,6 +237,6 @@ def stats(conn: ladybug.Connection) -> dict:

 def open_readonly() -> tuple[ladybug.Database, ladybug.Connection]:
    if not DB_PATH.exists():
-        raise FileNotFoundError(f"{DB_PATH} missing - run bin/kb/index first")
+        raise FileNotFoundError(f"{DB_PATH} missing - run bin/brain/index.go --rebuild first")
    db, conn = connect(read_only=True)
    return db, conn
@@ -0,0 +1,37 @@
+"""Mail markdown under var/mail → info leafs. Conversion stays off the brain DB."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mdleaves import read_markdown, to_all
+
+
+def msg_date(md: Path) -> str:
+    j = md.parent / "message.json"
+    try:
+        d = json.loads(j.read_text(encoding="utf-8"))
+        return (d.get("receivedDate") or d.get("receivedAt") or "")[:10]
+    except (OSError, json.JSONDecodeError, TypeError):
+        return ""
+
+
+def from_mail_root(root: Path, limit: int = 0, since: str = "", repo: str = "ooMail") -> list[dict]:
+    if not root.is_dir():
+        return []
+    mds = sorted(root.rglob("message.md"))
+    if since:
+        mds = [m for m in mds if msg_date(m) >= since]
+    if limit:
+        mds = mds[:limit]
+    leafs: list[dict] = []
+    for md in mds:
+        files = [md] + sorted((md.parent / "attachments").glob("*.md"))
+        for f in files:
+            if not f.exists():
+                continue
+            for lf in to_all(read_markdown(f), f, repo=repo):
+                lf["source"] = f"ooMail:{md.parent.name}:{f.name}"
+                lf["how"] = "mail/import"
+                leafs.append(lf)
+    return leafs
@@ -34,3 +34,60 @@ class BinLayoutTest(unittest.TestCase):
    def test_no_main_go_under_bin_brain(self) -> None:
        main = ROOT / "bin" / "brain" / "main.go"
        self.assertFalse(main.exists(), "bin/brain/main.go is not a method")
+
+    def test_chats_methods_are_shebangs_not_main(self) -> None:
+        chats = ROOT / "bin" / "chats"
+        self.assertFalse(
+            (chats / "main.go").exists(),
+            "bin/chats/main.go is a dispatcher, not a method",
+        )
+        self.assertFalse(
+            (chats / "index_cmd.go").exists(),
+            "chats index is a brain write hiding under the wrong subject",
+        )
+        for method in ("sync.go", "import.go", "facts.go", "apply.go"):
+            p = chats / method
+            self.assertTrue(p.is_file(), f"missing bin/chats/{method}")
+            first = p.read_text().splitlines()[0]
+            self.assertTrue(
+                first.startswith("//usr/bin/env go run"),
+                f"{method} shebang, got {first!r}",
+            )
+
+    def test_chats_lib_lives_in_internal(self) -> None:
+        self.assertTrue(
+            (ROOT / "internal" / "chats" / "linkedin.go").is_file(),
+            "LinkedIn parser must live in internal/chats",
+        )
+        self.assertFalse(
+            (ROOT / "bin" / "chats" / "linkedin.go").exists(),
+            "parser must not stay under bin/chats as a second main",
+        )
+
+    def _assert_shebang(self, rel: str) -> None:
+        p = ROOT / rel
+        self.assertTrue(p.is_file(), f"missing {rel}")
+        first = p.read_text().splitlines()[0]
+        self.assertTrue(
+            first.startswith("//usr/bin/env go run"),
+            f"{rel} shebang, got {first!r}",
+        )
+
+    def test_brain_methods_are_shebangs(self) -> None:
+        for method in ("index.go", "get.go", "stats.go", "eval.go", "watch.go"):
+            self._assert_shebang(f"bin/brain/{method}")
+
+    def test_mail_import_is_shebang_not_brain_write(self) -> None:
+        self._assert_shebang("bin/mail/import.go")
+        index_mail = (ROOT / "bin" / "mail" / "index_mail").read_text()
+        self.assertIn(
+            "bin/brain/index.go",
+            index_mail,
+            "index_mail must point at bin/brain/index.go",
+        )
+
+    def test_markdown_import_is_shebang(self) -> None:
+        self._assert_shebang("bin/markdown/import.go")
+
+    def test_postgres_query_is_shebang(self) -> None:
+        self._assert_shebang("bin/postgres/query.go")
@@ -0,0 +1,46 @@
+"""Mail markdown → leafs (no Ladybug). Brain index --with-mail uses this."""
+from __future__ import annotations
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import mailleafs  # noqa: E402
+
+
+class MailLeafsTest(unittest.TestCase):
+    def test_message_md_becomes_info_leaf(self) -> None:
+        root = Path(tempfile.mkdtemp())
+        msg = root / "inbox" / "alice-1"
+        msg.mkdir(parents=True)
+        (msg / "message.json").write_text(
+            json.dumps({"receivedDate": "2026-01-15T10:00:00Z", "subject": "Hello"}),
+            encoding="utf-8",
+        )
+        (msg / "message.md").write_text(
+            "---\nroot: info\n---\n\n# Hello\n\nFrom Alice to Bob.\n",
+            encoding="utf-8",
+        )
+        leafs = mailleafs.from_mail_root(root)
+        self.assertEqual(len(leafs), 1)
+        self.assertIn("Alice", leafs[0]["text"])
+        self.assertTrue(leafs[0]["source"].startswith("ooMail:"))
+        self.assertEqual(leafs[0]["how"], "mail/import")
+
+    def test_since_filters_by_message_json_date(self) -> None:
+        root = Path(tempfile.mkdtemp())
+        for name, day in (("old", "2025-01-01"), ("new", "2026-06-01")):
+            d = root / "inbox" / name
+            d.mkdir(parents=True)
+            (d / "message.json").write_text(
+                json.dumps({"receivedDate": f"{day}T00:00:00Z"}),
+                encoding="utf-8",
+            )
+            (d / "message.md").write_text(f"# {name}\n\nbody\n", encoding="utf-8")
+        leafs = mailleafs.from_mail_root(root, since="2026-01-01")
+        self.assertEqual(len(leafs), 1)
+        self.assertIn("new", leafs[0]["text"])
@@ -0,0 +1,57 @@
+"""Published docs must match live commands (Gitea SoT, brain/search, no fake --hop)."""
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class PublishedDocsTest(unittest.TestCase):
+    def test_readme_points_issues_at_gitea(self) -> None:
+        text = (ROOT / "README.md").read_text()
+        self.assertIn(
+            "https://git.produktor.io/eSlider/2dph/issues",
+            text,
+            "README must point issues at Gitea",
+        )
+
+    def test_plan_d15_names_gitea_origin(self) -> None:
+        text = (ROOT / "PLAN.md").read_text()
+        self.assertIn("D15", text)
+        self.assertIn("git.produktor.io/eSlider/2dph", text)
+
+    def test_readme_primary_search_is_brain(self) -> None:
+        text = (ROOT / "README.md").read_text()
+        self.assertIn(
+            "bin/brain/search.go",
+            text,
+            "README deduction search must name bin/brain/search.go",
+        )
+
+    def test_readme_index_is_brain_not_index_mail(self) -> None:
+        text = (ROOT / "README.md").read_text()
+        self.assertIn("bin/brain/index.go", text)
+        self.assertNotIn(
+            "bin/mail/index_mail",
+            text,
+            "mail index is a brain write; README must name bin/brain/index.go",
+        )
+
+    def test_docs_do_not_claim_hop_walks(self) -> None:
+        paths = [
+            ROOT / "README.md",
+            ROOT / "docs" / "design.md",
+            ROOT / "skills" / "kb-search" / "SKILL.md",
+            ROOT / "skills" / "diataxis-docs" / "SKILL.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(
+                lie.search(text),
+                f"{path.relative_to(ROOT)} still claims --hop walks the graph",
+            )
@@ -1,4 +1,4 @@
-// Package watch polls corpus directories for changes and re-runs bin/kb/index.
+// Package watch polls corpus directories for changes and re-runs brain/index.
 //
 // Port of the former bin/kb-watch bash script to an importable, testable Go
 // package. Polls file mtimes (no inotify deps); cheap and reliable.
@@ -18,8 +18,8 @@ import (
 type Options struct {
 	Dirs     []string
 	Interval time.Duration
-	// IndexCmd is the kb/index command template. %s is replaced by the repo
-	// root (from KB_ROOT). Defaults to `python3 <root>/bin/kb/index`.
+	// IndexCmd is the index command template. %s is replaced by the repo
+	// root (from KB_ROOT). Defaults to `python3 <root>/bin/kb/index --with-mail`.
 	IndexCmd string
 }

@@ -67,7 +67,7 @@ func fromEnv(args []string) Options {
 	if pys == "" {
 		pys = "python3"
 	}
-	opts.IndexCmd = pys + " <root>/bin/kb/index"
+	opts.IndexCmd = pys + " <root>/bin/kb/index --with-mail"
 	return opts
 }

@@ -3,6 +3,7 @@ package watch
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 )
@@ -43,7 +44,10 @@ func TestFromEnvDefaults(t *testing.T) {
 	if opts.Interval != 30*time.Second {
 		t.Fatalf("default interval = %s, want 30s", opts.Interval)
 	}
-	if opts.IndexCmd == "" {
-		t.Fatal("default index cmd is empty")
+	if !strings.Contains(opts.IndexCmd, "kb/index") {
+		t.Fatalf("default index cmd = %q, want kb/index", opts.IndexCmd)
+	}
+	if !strings.Contains(opts.IndexCmd, "--with-mail") {
+		t.Fatalf("default index cmd must include --with-mail, got %q", opts.IndexCmd)
 	}
 }
@@ -8,4 +8,8 @@ Brain/ops/eSlider stack. Facts need proof or they are
 - [design](design.md) — schema, deduction model, sources
 - [Gitea issues](https://git.produktor.io/eSlider/2dph/issues) — work board (origin)

+Search: `bin/brain/search.go "query"` (HTTP: `bin/brain/serve.go` —
+`/health` `/search` `/get` `/stats` `/audit` `/ingest`). `--hop` is
+not a walk; the flag errors until File/FROM_FILE edges exist.
+
 Published docs live here and mirror the project state.
@@ -15,9 +15,10 @@ OO_CLI                     (default: $HOME/go/bin/oo)
 ## Quick reference

 ```
-./bin/chat sync telegram --limit 100
-./bin/chat import
-./bin/chat index
-./bin/chat facts
-./bin/chat apply --dry-run
+./bin/chats/sync.go telegram --limit 100
+./bin/chats/import.go
+./bin/chats/facts.go
+./bin/chats/apply.go --dry-run
 ```
+
+JSONL → markdown only. Brain ingest is `bin/brain/index.go` (not a `chats index`).
@@ -1,33 +0,0 @@
-# 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
@@ -17,14 +17,14 @@ as one consistent state.
 ## Deduction search

 ```
-bin/kb/search "question"
+bin/brain/search.go "question"
  1. facts root   — confirmed answers only   → return with evidence links
  2. info  root   — supporting narrative     → snippets, marked (not confirmed)
  3. web-search   — second independent source → upgrade hypothesis to confirmed
 ```

-`--hop N` follows graph edges (sibling leaves under a heading, owning file,
-`related:` files, vector-neighbour leaves) — the deduction walk.
+`--hop` is not implemented yet (needs File/FROM_FILE edges). The flag is an
+error; it is not a graph walk.

 ## Who / What / How / Where / When + evidence

@@ -0,0 +1,154 @@
+//go:build cgo && system_ladybug
+
+package brain
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Ready opens the Ladybug file for the life of the serve process.
+func Ready() error {
+	return openBrain()
+}
+
+// HTTP is the in-process API used by bin/brain/serve.go.
+type HTTP struct{}
+
+func (HTTP) Search(_ context.Context, query string, limit int) ([]byte, error) {
+	hits, err := searchHits(query, "", "", limit)
+	if err != nil {
+		return nil, err
+	}
+	for i := range hits {
+		if hits[i].Text != "" {
+			runes := []rune(hits[i].Text)
+			if len(runes) > 280 {
+				runes = runes[:280]
+			}
+			hits[i].Snippet = string(runes)
+		}
+	}
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(toJSONOut(hits, query, "")); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (HTTP) Get(_ context.Context, id string, body bool) ([]byte, error) {
+	if conn == nil {
+		return nil, fmt.Errorf("brain not open")
+	}
+	stmt, err := conn.Prepare(
+		"MATCH (l:Leaf {id:$id}) RETURN l.id, l.text, l.root, l.confidence, l.source, l.type",
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer stmt.Close()
+	res, err := conn.Execute(stmt, map[string]any{"id": id})
+	if err != nil {
+		return nil, err
+	}
+	if !res.HasNext() {
+		return nil, fmt.Errorf("no leaf %s", id)
+	}
+	row, err := res.Next()
+	if err != nil {
+		return nil, err
+	}
+	vals, err := row.GetAsSlice()
+	if err != nil || len(vals) < 6 {
+		return nil, fmt.Errorf("leaf row")
+	}
+	out := map[string]any{
+		"id":         fmt.Sprint(vals[0]),
+		"root":       fmt.Sprint(vals[2]),
+		"confidence": fmt.Sprint(vals[3]),
+		"source":     fmt.Sprint(vals[4]),
+		"type":       fmt.Sprint(vals[5]),
+	}
+	if body {
+		out["text"] = fmt.Sprint(vals[1])
+	}
+	return json.Marshal(out)
+}
+
+func (HTTP) Stats(context.Context) ([]byte, error) {
+	if conn == nil {
+		return nil, fmt.Errorf("brain not open")
+	}
+	res, err := conn.Query("MATCH (l:Leaf) RETURN l.root, count(*)")
+	if err != nil {
+		return nil, err
+	}
+	byRoot := map[string]int{}
+	total := 0
+	for res.HasNext() {
+		row, err := res.Next()
+		if err != nil {
+			return nil, err
+		}
+		vals, err := row.GetAsSlice()
+		if err != nil || len(vals) < 2 {
+			continue
+		}
+		n := int(asInt(vals[1]))
+		byRoot[fmt.Sprint(vals[0])] = n
+		total += n
+	}
+	return json.Marshal(map[string]any{"total": total, "by_root": byRoot, "db": dbPath()})
+}
+
+func (HTTP) Audit(context.Context) ([]byte, error) {
+	if conn == nil {
+		return nil, fmt.Errorf("brain not open")
+	}
+	res, err := conn.Query("MATCH (l:Leaf) RETURN l.root, l.confidence, count(*)")
+	if err != nil {
+		return nil, err
+	}
+	var rows []map[string]any
+	for res.HasNext() {
+		row, err := res.Next()
+		if err != nil {
+			return nil, err
+		}
+		vals, err := row.GetAsSlice()
+		if err != nil || len(vals) < 3 {
+			continue
+		}
+		rows = append(rows, map[string]any{
+			"root":       fmt.Sprint(vals[0]),
+			"confidence": fmt.Sprint(vals[1]),
+			"count":      asInt(vals[2]),
+		})
+	}
+	return json.Marshal(map[string]any{"status": "ok", "by_confidence": rows})
+}
+
+func (HTTP) Ingest(context.Context) ([]byte, error) {
+	return json.Marshal(map[string]any{
+		"mode":    "rebuild",
+		"command": "bin/brain/index.go --rebuild",
+		"add":     "v2",
+	})
+}
+
+func asInt(v any) int64 {
+	switch n := v.(type) {
+	case int64:
+		return n
+	case int:
+		return int64(n)
+	case float64:
+		return int64(n)
+	default:
+		return 0
+	}
+}
@@ -51,25 +51,13 @@ func runSearch(args []string) int {
 	}
 	defer closeBrain()

-	emb, err := embedQuery(query)
+	hits, err := searchHits(query, root, repo, limit)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "embed: %v\n", err)
+		fmt.Fprintf(os.Stderr, "search: %v\n", err)
 		return 1
 	}

-	fts, err := queryFTS(query, limit*3)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "fts: %v\n", err)
-		return 1
-	}
-
-	var vec []Hit
-	if vec, err = queryVector(emb, limit*3); err != nil {
-		fmt.Fprintf(os.Stderr, "vec: %v\n", err)
-	}
-
-	results := rank.RankAndFilter(fts, vec, root, repo, limit)
-
+	results := hits
 	for i := range results {
 		if results[i].Text != "" {
 			runes := []rune(results[i].Text)
@@ -97,6 +85,22 @@ func runSearch(args []string) int {
 	return 0
 }

+func searchHits(query, root, repo string, limit int) ([]Hit, error) {
+	emb, err := embedQuery(query)
+	if err != nil {
+		return nil, fmt.Errorf("embed: %w", err)
+	}
+	fts, err := queryFTS(query, limit*3)
+	if err != nil {
+		return nil, fmt.Errorf("fts: %w", err)
+	}
+	var vec []Hit
+	if vec, err = queryVector(emb, limit*3); err != nil {
+		fmt.Fprintf(os.Stderr, "vec: %v\n", err)
+	}
+	return rank.RankAndFilter(fts, vec, root, repo, limit), nil
+}
+
 func b2i(err error) int {
 	if err != nil {
 		return 1
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"bytes"
@@ -24,7 +24,7 @@ type ooContact struct {
 	} `json:"commonData"`
 }

-func runApply(args []string) int {
+func RunApply(args []string) int {
 	fs := flag.NewFlagSet("chats apply", flag.ContinueOnError)
 	dryRun := fs.Bool("dry-run", false, "show what would be done without writing")
 	help := fs.Bool("help", false, "")
@@ -176,7 +176,7 @@ func runApply(args []string) int {
 }

 func loadFacts() ([]ExtractedFact, error) {
-	factsPath := filepath.Join(chatsDir(), "facts", "chat-facts.json")
+	factsPath := filepath.Join(Dir(), "facts", "chat-facts.json")
 	data, err := os.ReadFile(factsPath)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -3,7 +3,7 @@
 // These are integration tests using real data and real Telegram API (when
 // credentials are available). They follow the TDD workflow pattern:
 // sync → import → facts → verify.
-package main
+package chats

 import (
 	"encoding/json"
@@ -48,7 +48,7 @@ func TestChatsImport(t *testing.T) {
 	t.Cleanup(func() { os.Chdir(cwd) })
 	t.Setenv("KB_ROOT", dir)

-	exitCode := runImport([]string{})
+	exitCode := RunImport([]string{})
 	if exitCode != 0 {
 		t.Fatalf("import exit code %d", exitCode)
 	}
@@ -140,7 +140,7 @@ func TestChatsImportEmpty(t *testing.T) {
 	t.Cleanup(func() { os.Chdir(cwd) })
 	t.Setenv("KB_ROOT", dir)

-	exitCode := runImport([]string{})
+	exitCode := RunImport([]string{})
 	if exitCode == 0 {
 		t.Fatal("expected non-zero exit for empty data dir")
 	}
@@ -171,7 +171,7 @@ func TestChatsRoundTrip(t *testing.T) {
 	t.Cleanup(func() { os.Chdir(cwd) })
 	t.Setenv("KB_ROOT", dir)

-	if code := runImport([]string{}); code != 0 {
+	if code := RunImport([]string{}); code != 0 {
 		t.Fatalf("import exit %d", code)
 	}

@@ -1,13 +1,11 @@
-package main
+package chats

 import (
 	"bufio"
-	"bytes"
 	"encoding/json"
 	"flag"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -77,7 +75,7 @@ type ExtractedFact struct {
 	MessageID string `json:"message_id"`
 }

-func runFacts(args []string) int {
+func RunFacts(args []string) int {
 	fs := flag.NewFlagSet("chats facts", flag.ContinueOnError)
 	help := fs.Bool("help", false, "")
 	fs.SetOutput(os.Stderr)
@@ -89,7 +87,7 @@ func runFacts(args []string) int {
 		return 0
 	}

-	root := chatsDir()
+	root := Dir()
 	telegramDir := filepath.Join(root, "telegram")

 	entries, err := os.ReadDir(telegramDir)
@@ -149,7 +147,7 @@ func runFacts(args []string) int {
 	}
 	fmt.Printf("chats facts: saved to %s\n", factsPath)

-	writeFactsToBrain(root, allFacts)
+	writeFactsMarkdown(allFacts)

 	return 0
 }
@@ -273,14 +271,10 @@ func filterFacts(facts []ExtractedFact, factType string) []ExtractedFact {
 	return result
 }

-func writeFactsToBrain(root string, facts []ExtractedFact) {
-	indexScript := filepath.Join(root, "bin", "kb", "index")
-	if _, err := os.Stat(indexScript); os.IsNotExist(err) {
-		fmt.Fprintf(os.Stderr, "chats facts: kb/index not found, skipping brain write\n")
-		return
-	}
-
-	mdDir := filepath.Join(chatsDir(), "facts")
+// writeFactsMarkdown stores a sidecar for humans. Brain ingest is
+// bin/brain/index.go (not this subject).
+func writeFactsMarkdown(facts []ExtractedFact) {
+	mdDir := filepath.Join(Dir(), "facts")
 	if err := os.MkdirAll(mdDir, 0755); err != nil {
 		fmt.Fprintf(os.Stderr, "chats facts: mkdir %s: %v\n", mdDir, err)
 		return
@@ -288,7 +282,7 @@ func writeFactsToBrain(root string, facts []ExtractedFact) {

 	var sb strings.Builder
 	sb.WriteString("---\n")
-	sb.WriteString("root: facts\n")
+	sb.WriteString("root: info\n")
 	sb.WriteString("---\n\n")
 	sb.WriteString("# Chat-Derived Facts\n\n")
 	for _, f := range facts {
@@ -302,15 +296,5 @@ func writeFactsToBrain(root string, facts []ExtractedFact) {
 		fmt.Fprintf(os.Stderr, "chats facts: write %s: %v\n", factsMD, err)
 		return
 	}
-
-	cmd := exec.Command(indexScript, "--corpus", mdDir, "--skip-indexes")
-	var outBuf, errBuf bytes.Buffer
-	cmd.Stdout = &outBuf
-	cmd.Stderr = &errBuf
-	cmd.Dir = root
-	if err := cmd.Run(); err != nil {
-		fmt.Fprintf(os.Stderr, "chats facts: brain index: %v\n%s", err, errBuf.String())
-		return
-	}
-	fmt.Printf("chats facts: written to brain (%s)\n", strings.TrimSpace(outBuf.String()))
+	fmt.Printf("chats facts: markdown %s (index via brain, not chats)\n", factsMD)
 }
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"bufio"
@@ -13,7 +13,7 @@ import (
 	"strings"
 )

-func runImport(args []string) int {
+func RunImport(args []string) int {
 	fs := flag.NewFlagSet("chats import", flag.ContinueOnError)
 	help := fs.Bool("help", false, "")
 	fs.SetOutput(os.Stderr)
@@ -25,7 +25,7 @@ func runImport(args []string) int {
 		return 0
 	}

-	root := chatsDir()
+	root := Dir()
 	mdRoot := filepath.Join(root, "md")
 	glob := filepath.Join(root, "telegram", "*", "messages.jsonl")

@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"bufio"
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"errors"
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"bufio"
@@ -0,0 +1,39 @@
+package chats
+
+import (
+	"os"
+	"strings"
+)
+
+// Root locates the 2dph project root (KB_ROOT, or walk up for var/ or .git).
+func Root() string {
+	if v := os.Getenv("KB_ROOT"); v != "" {
+		return v
+	}
+	wd, err := os.Getwd()
+	if err != nil {
+		return "."
+	}
+	for i := 0; i < 10; i++ {
+		if _, err := os.Stat(wd + "/var"); err == nil {
+			return wd
+		}
+		if _, err := os.Stat(wd + "/.git"); err == nil {
+			return wd
+		}
+		parent := wd
+		if idx := strings.LastIndex(wd, "/"); idx >= 0 {
+			parent = wd[:idx]
+		}
+		if parent == wd {
+			break
+		}
+		wd = parent
+	}
+	return "."
+}
+
+// Dir is var/chats under the project root.
+func Dir() string {
+	return Root() + "/var/chats"
+}
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"context"
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"context"
@@ -28,7 +28,7 @@ func checkLinkedInSession(userDataDir string) (bool, error) {
 	return false, nil
 }

-func runSyncLinkedIn(args []string) int {
+func RunSyncLinkedIn(args []string) int {
 	fs := flag.NewFlagSet("chats sync linkedin", flag.ContinueOnError)
 	limit := fs.Int("limit", 0, "max messages per conversation (0 = all)")
 	refresh := fs.Bool("refresh", false, "refresh session from live webtop browser before sync")
@@ -72,7 +72,7 @@ func runSyncLinkedIn(args []string) int {
 	defer cancel()

 	start := time.Now()
-	if err := src.Sync(ctx, chatsDir(), *limit); err != nil {
+	if err := src.Sync(ctx, Dir(), *limit); err != nil {
 		fmt.Fprintf(os.Stderr, "chats sync linkedin: %v\n", err)
 		return 1
 	}
@@ -1,4 +1,4 @@
-package main
+package chats

 import (
 	"context"
@@ -11,7 +11,7 @@ import (
 	"time"
 )

-func runSyncTelegram(args []string) int {
+func RunSyncTelegram(args []string) int {
 	fs := flag.NewFlagSet("chats sync telegram", flag.ContinueOnError)
 	limit := fs.Int("limit", 0, "max messages per chat (0 = all)")
 	phone := fs.String("phone", "", "phone number (default env TELEGRAM_PHONE)")
@@ -78,7 +78,7 @@ func runSyncTelegram(args []string) int {
 	defer cancel()

 	start := time.Now()
-	if err := src.Sync(ctx, chatsDir(), *limit); err != nil {
+	if err := src.Sync(ctx, Dir(), *limit); err != nil {
 		fmt.Fprintf(os.Stderr, "chats sync telegram: %v\n", err)
 		return 1
 	}
@@ -0,0 +1,54 @@
+package cmdbin
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// Root is the 2dph checkout (KB_ROOT, or walk up for .git / var).
+func Root() string {
+	if v := os.Getenv("KB_ROOT"); v != "" {
+		return v
+	}
+	wd, err := os.Getwd()
+	if err != nil {
+		return "."
+	}
+	for i := 0; i < 10; i++ {
+		if _, err := os.Stat(filepath.Join(wd, ".git")); err == nil {
+			return wd
+		}
+		if _, err := os.Stat(filepath.Join(wd, "var")); err == nil {
+			return wd
+		}
+		parent := filepath.Dir(wd)
+		if parent == wd {
+			break
+		}
+		wd = parent
+	}
+	return "."
+}
+
+// ExecFile runs repo-relative path (python/bash shebang scripts) with stdio.
+func ExecFile(rel string, args []string) int {
+	path := filepath.Join(Root(), filepath.FromSlash(rel))
+	cmd := exec.Command(path, args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Dir = Root()
+	if err := cmd.Run(); err != nil {
+		if ee, ok := err.(*exec.ExitError); ok {
+			return ee.ExitCode()
+		}
+		if errors.Is(err, os.ErrNotExist) || strings.Contains(err.Error(), "no such file") {
+			return 127
+		}
+		return 1
+	}
+	return 0
+}
@@ -0,0 +1,34 @@
+package cmdbin
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRootHonorsKBROOT(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("KB_ROOT", dir)
+	if got := Root(); got != dir {
+		t.Fatalf("Root() = %q, want %q", got, dir)
+	}
+}
+
+func TestExecFileMissingIs127(t *testing.T) {
+	t.Setenv("KB_ROOT", t.TempDir())
+	if code := ExecFile("no/such-tool", nil); code != 127 {
+		t.Fatalf("exit = %d, want 127", code)
+	}
+}
+
+func TestExecFileRuns(t *testing.T) {
+	root := t.TempDir()
+	script := filepath.Join(root, "echo.sh")
+	if err := os.WriteFile(script, []byte("#!/bin/sh\nexit 3\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("KB_ROOT", root)
+	if code := ExecFile("echo.sh", nil); code != 3 {
+		t.Fatalf("exit = %d, want 3", code)
+	}
+}
@@ -1,10 +1,10 @@
-// Package server serves the 2dph brain over HTTP.
+// Package httpapi serves the 2dph brain over HTTP.
 //
 // Async by design: every request runs on its own goroutine, and CPU-heavy
-// searches are serialized through a bounded worker pool (a counting
-// semaphore) so N requests can't spawn N search processes at once.
+// searches are serialized through a bounded worker pool so N requests can't
+// spawn N backends at once.
 //
-// Used by bin/brain/serve.go.
+// Used by bin/brain/serve.go. Tests inject a fake API (no exec, no ladybug).
 package httpapi

 import (
@@ -21,30 +21,45 @@ import (
 	"time"
 )

-type Searcher interface {
+// API is the in-process brain surface. Production serve.go wires internal/brain.
+type API interface {
 	Search(ctx context.Context, query string, limit int) ([]byte, error)
+	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)
 }

 type Server struct {
-	searcher  Searcher
+	api       API
 	semaphore chan struct{}
 }

 const defaultPort = 8630

-func NewServer(searcher Searcher, workers int) http.Handler {
+var errUnimplemented = errors.New("not implemented")
+
+func NewServer(api API, workers int) http.Handler {
 	return &Server{
-		searcher:  searcher,
+		api:       api,
 		semaphore: make(chan struct{}, workers),
 	}
 }

 func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	switch {
-	case r.URL.Path == "/health":
+	switch r.URL.Path {
+	case "/health":
 		writeJSON(w, http.StatusOK, map[string]any{"status": "ok"})
-	case r.URL.Path == "/search":
+	case "/search":
 		s.handleSearch(w, r)
+	case "/get":
+		s.handleGet(w, r)
+	case "/stats":
+		s.handleJSON(w, r, s.api.Stats)
+	case "/audit":
+		s.handleJSON(w, r, s.api.Audit)
+	case "/ingest":
+		s.handleJSON(w, r, s.api.Ingest)
 	default:
 		writeJSON(w, http.StatusNotFound, map[string]any{"error": "not found"})
 	}
@@ -65,19 +80,56 @@ func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
 		}
 		limit = n
 	}
-
-	// Worker pool: block until a slot frees, so burst concurrency still
-	// bounds memory (no unbounded python processes).
-	select {
-	case s.semaphore <- struct{}{}:
-		defer func() { <-s.semaphore }()
-	case <-r.Context().Done():
+	if !s.acquire(w, r) {
 		return
 	}
+	defer s.release()
+	body, err := s.api.Search(r.Context(), q, limit)
+	writeAPI(w, body, err)
+}

-	body, err := s.searcher.Search(r.Context(), q, limit)
+func (s *Server) handleGet(w http.ResponseWriter, r *http.Request) {
+	id := strings.TrimSpace(r.URL.Query().Get("id"))
+	if id == "" {
+		writeJSON(w, http.StatusBadRequest, map[string]any{"error": "id required"})
+		return
+	}
+	body := r.URL.Query().Get("body") == "1" || r.URL.Query().Get("body") == "true"
+	if !s.acquire(w, r) {
+		return
+	}
+	defer s.release()
+	out, err := s.api.Get(r.Context(), id, body)
+	writeAPI(w, out, err)
+}
+
+func (s *Server) handleJSON(w http.ResponseWriter, r *http.Request, fn func(context.Context) ([]byte, error)) {
+	if !s.acquire(w, r) {
+		return
+	}
+	defer s.release()
+	body, err := fn(r.Context())
+	writeAPI(w, body, err)
+}
+
+func (s *Server) acquire(w http.ResponseWriter, r *http.Request) bool {
+	select {
+	case s.semaphore <- struct{}{}:
+		return true
+	case <-r.Context().Done():
+		return false
+	}
+}
+
+func (s *Server) release() { <-s.semaphore }
+
+func writeAPI(w http.ResponseWriter, body []byte, err error) {
 	if err != nil {
-		writeJSON(w, http.StatusGatewayTimeout, map[string]any{"error": err.Error()})
+		code := http.StatusBadGateway
+		if errors.Is(err, errUnimplemented) {
+			code = http.StatusNotImplemented
+		}
+		writeJSON(w, code, map[string]any{"error": err.Error()})
 		return
 	}
 	writeRaw(w, http.StatusOK, body)
@@ -95,17 +147,20 @@ func writeRaw(w http.ResponseWriter, code int, body []byte) {
 	w.Write(body)
 }

-// brainSearcher shells out to the Go brain-search binary (not Python).
-// A single search is bounded and short-lived; the worker pool keeps at most N live.
-type brainSearcher struct {
-	cmdPath string
-	timeout time.Duration
+// ExecSearcher shells out to var/bin/brain-search. Fallback when the serve
+// binary is built without ladybug cgo (CI / tags=brain_serve only).
+type ExecSearcher struct {
+	CmdPath string
+	Timeout time.Duration
 }

-func (b *brainSearcher) Search(ctx context.Context, query string, limit int) ([]byte, error) {
-	ctx, cancel := context.WithTimeout(ctx, b.timeout)
+func (b ExecSearcher) Search(ctx context.Context, query string, limit int) ([]byte, error) {
+	if b.Timeout == 0 {
+		b.Timeout = 60 * time.Second
+	}
+	ctx, cancel := context.WithTimeout(ctx, b.Timeout)
 	defer cancel()
-	cmd := exec.CommandContext(ctx, b.cmdPath, "--json", "-n", strconv.Itoa(limit), query)
+	cmd := exec.CommandContext(ctx, b.CmdPath, "--json", "-n", strconv.Itoa(limit), query)
 	out, err := cmd.Output()
 	if err != nil {
 		var exitErr *exec.ExitError
@@ -117,6 +172,18 @@ func (b *brainSearcher) Search(ctx context.Context, query string, limit int) ([]
 	return out, nil
 }

+func (ExecSearcher) Get(context.Context, string, bool) ([]byte, error) {
+	return nil, errUnimplemented
+}
+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) {
+	return json.Marshal(map[string]any{
+		"mode":    "rebuild",
+		"command": "bin/brain/index.go --rebuild",
+	})
+}
+
 func defaultSearchCmd(root string) string {
 	if env := os.Getenv("KB_SEARCH_CMD"); env != "" {
 		return env
@@ -124,11 +191,7 @@ func defaultSearchCmd(root string) string {
 	return filepath.Join(root, "var", "bin", "brain-search")
 }

-// Run starts the HTTP server. Reads env: KB_SEARCH_CMD (default
-// $KB_ROOT/var/bin/brain-search), KB_WORKERS (default 4), KB_PORT (default 8630).
-func Run() {
-	root := os.Getenv("KB_ROOT")
-	searchPath := defaultSearchCmd(root)
+func workersAndPort() (int, int) {
 	workers := 4
 	if raw := os.Getenv("KB_WORKERS"); raw != "" {
 		if n, err := strconv.Atoi(raw); err == nil && n > 0 {
@@ -141,11 +204,19 @@ func Run() {
 			port = n
 		}
 	}
+	return workers, port
+}

-	searcher := &brainSearcher{cmdPath: searchPath, timeout: 60 * time.Second}
-	handler := NewServer(searcher, workers)
+// Run starts the HTTP server with an injected API (in-process brain, or ExecSearcher).
+func Run(api API) {
+	if api == nil {
+		root := os.Getenv("KB_ROOT")
+		api = ExecSearcher{CmdPath: defaultSearchCmd(root), Timeout: 60 * time.Second}
+	}
+	workers, port := workersAndPort()
+	handler := NewServer(api, workers)
 	addr := "127.0.0.1:" + strconv.Itoa(port)
-	log.Printf("serve: %s (workers=%d cmd=%s)", addr, workers, searchPath)
+	log.Printf("serve: %s (workers=%d)", addr, workers)
 	if err := http.ListenAndServe(addr, handler); err != nil {
 		log.Fatal(err)
 	}
@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -47,6 +48,26 @@ func (f *fakeSearcher) Search(ctx context.Context, query string, limit int) ([]b
 	return []byte(`{"query":"` + query + `","count":0,"results":[]}`), nil
 }

+func (f *fakeSearcher) Get(_ context.Context, id string, body bool) ([]byte, error) {
+	out := map[string]any{"id": id, "root": "info"}
+	if body {
+		out["text"] = "fake body"
+	}
+	return json.Marshal(out)
+}
+
+func (f *fakeSearcher) Stats(context.Context) ([]byte, error) {
+	return []byte(`{"total":0,"by_root":{}}`), nil
+}
+
+func (f *fakeSearcher) Audit(context.Context) ([]byte, error) {
+	return []byte(`{"status":"ok"}`), nil
+}
+
+func (f *fakeSearcher) Ingest(context.Context) ([]byte, error) {
+	return []byte(`{"mode":"rebuild","command":"bin/brain/index.go --rebuild"}`), nil
+}
+
 func (f *fakeSearcher) count() int {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -142,6 +163,47 @@ func TestSearchRejectsBadLimit(t *testing.T) {
 	}
 }

+func TestGetLeaf(t *testing.T) {
+	fs := &fakeSearcher{callback: func(q string, limit int) ([]byte, error) {
+		return []byte(`{}`), nil
+	}}
+	h := NewServer(fs, 1)
+	if code, _ := get(t, h, "/get"); code != http.StatusBadRequest {
+		t.Fatalf("missing id code = %d, want 400", code)
+	}
+	code, body := get(t, h, "/get?id=leaf-1&body=1")
+	if code != http.StatusOK {
+		t.Fatalf("get code = %d, want 200 body=%s", code, body)
+	}
+	if !strings.Contains(string(body), "leaf-1") {
+		t.Fatalf("get body %s missing id", body)
+	}
+}
+
+func TestStatsAuditIngest(t *testing.T) {
+	h := NewServer(&fakeSearcher{}, 1)
+	for _, path := range []string{"/stats", "/audit", "/ingest"} {
+		code, body := get(t, h, path)
+		if code != http.StatusOK {
+			t.Fatalf("%s code = %d, want 200 (%s)", path, code, body)
+		}
+		if !json.Valid(body) {
+			t.Fatalf("%s body not json: %s", path, body)
+		}
+	}
+}
+
+func TestHTTPPackageDoesNotExecPython(t *testing.T) {
+	raw, err := os.ReadFile("server.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	lower := strings.ToLower(string(raw))
+	if strings.Contains(lower, "python3") || strings.Contains(lower, "bin/kb/search") {
+		t.Fatal("httpapi must not exec Python or bin/kb/search")
+	}
+}
+
 func TestDefaultSearchCmdIsBrainNotPython(t *testing.T) {
 	t.Setenv("KB_SEARCH_CMD", "")
 	cmd := defaultSearchCmd("/repo")
@@ -30,12 +30,11 @@ related:
 ---
 ```

-`bin/kb/index` reads this. `type` becomes a searchable column and `related`
-becomes a graph edge:
+`bin/brain/index.go` reads this. `type` becomes a searchable column. `related:` is
+frontmatter for humans; graph hops from it are not implemented yet.

 ```bash
-bin/kb/search "deploy" --type howto
-bin/kb/search "Stecktafel" --hop 1     # follow links and related
+bin/brain/search.go "deploy"
 ```

 ## Audit checklist
@@ -46,8 +45,7 @@ bin/kb/search "Stecktafel" --hop 1     # follow links and related
   The indexer chunks on H2, so split files also search better.
 3. Is `status: archive` set on anything superseded? Archived files stay indexed
   but stop competing with current ones for a reader's attention.
-4. Does every explanation link the reference it explains, and vice versa? That
-   link is what `--hop 1` walks.
+4. Does every explanation link the reference it explains, and vice versa?

 ## Rule

@@ -2,9 +2,10 @@
 name: kb-search
 description: >-
  Deduction search over the 2dph brain (Ladybug graph: ops corpus, portfolio,
-  ssh hosts) with bin/kb/search instead of reading files or grepping repos.
-  Use whenever a question starts with "where is", "what runs on", "which file
-  describes", "who is", "how is X done", before opening any documentation.
+  ssh hosts) with bin/brain/search.go instead of reading files or grepping
+  repos. Use whenever a question starts with "where is", "what runs on",
+  "which file describes", "who is", "how is X done", before opening any
+  documentation.
 ---

 # kb-search — deduction over facts and info
@@ -22,24 +23,24 @@ second independent source when local roots cannot confirm. An answer is
 `(not confirmed)`.

 ```bash
-bin/kb/search "Matrix federation"                # pointers + snippets, YAML
-bin/kb/search "what runs on arc-2" --hop 1       # follow graph edges
-bin/kb/search "onlyoffice postgres" --root facts # restrict to confirmed
-bin/kb/search "where is cs-lexicon" --json | yq '.[].ref'
-bin/kb/get <id> --body                           # full chunk only when needed
-bin/kb/stats                                     # index health
-bin/kb/eval                                      # recall@5 >= 0.95 gate
+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/get.go <id> --body                           # full chunk only when needed
+bin/brain/stats.go                                     # index health
+bin/brain/eval.go                                      # recall@5 >= 0.95 gate
 ```

+`bin/kb/search` is a deprecated wrapper. `--hop` errors (File/FROM_FILE edges
+are not wired yet); do not treat it as a graph walk.
+
 ## Rules

 - Search before you read. Never grep a repo for a concept the graph covers.
 - `--root facts` returns only confirmed evidence-linked answers. Default shows
  facts first, then info leafs clearly marked `(not confirmed)`.
- If recall looks wrong, run `bin/kb/eval`; it gates control questions and
+- If recall looks wrong, run `bin/brain/eval.go`; it gates control questions and
  should stay at or above 95% recall@5.
- `--hop N` follows sibling leaves, owning files, `related:` links and
-  vector-neighbours — that is the deduction walk, not random expansion.
 - Escalate to `web-search` (the `web-search` skill) as the independent second
  source when both local roots cannot confirm; never report an unconfirmed
  single-source local answer as fact.
@@ -18,9 +18,10 @@ bin/web/search "postgres partial index" --lang en --fresh year

 ## Web or knowledge base

-`bin/kb/search` holds our own facts: the ops stack, portfolio, ssh hosts, the
-lexicon. Go there first. Reach for `bin/web/search` when the answer is outside
-our repos: upstream library behaviour, vendor documentation, public standards.
+`bin/brain/search.go` holds our own facts: the ops stack, portfolio, ssh hosts,
+the lexicon. Go there first. Reach for `bin/web/search` when the answer is
+outside our repos: upstream library behaviour, vendor documentation, public
+standards.

 Keep the two apart. A finding is stronger when the reader can see that one
 source was ours and one was not.
Author	SHA1	Message	Date
eSliderandGitHub	3f30052ea8	feat: in-process HTTP search; /get /stats /audit /ingest. (#13 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped bin/brain/serve.go (ladybug tags) calls internal/brain instead of exec. HTTP tests inject a fake API so CI stays cgo-free. ExecSearcher remains the fallback when the binary is built without system_ladybug.	2026-08-13 17:52:15 +01:00
eSliderandGitHub	c1ee920b0a	feat: brain/index.go shebang; mail import is not a brain write (D14). (#12 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped Commands live at bin/brain/{index,get,stats,eval,watch}.go and bin/mail/import.go, bin/markdown/import.go, bin/postgres/query.go. Python remains the Ladybug write worker. index_mail is a deprecation shim that rebuilds via --with-mail.	2026-08-13 17:46:25 +01:00
eSliderandGitHub	cec0161ff6	refactor: chats method shebangs; drop chats index (D14). (#11 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped Parsers and commands live in internal/chats. bin/chats/{sync,import,facts,apply}.go are tagged shebang mains. Brain ingest is not a chats command.	2026-08-13 17:31:03 +01:00
eSliderandGitHub	46310f8773	docs: name bin/brain/search.go; --hop is not a graph walk. (#10 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped Published docs and skills still taught bin/kb/search --hop 1. Search lives at bin/brain/search.go; --hop errors until File edges exist. A unittest gates the SoT so the lie cannot return.	2026-08-13 17:23:40 +01:00
eSliderandGitHub	7e0f3c9e06	feat: bin/brain/serve.go; search backend is Go not Python (#9 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped * feat(brain): HTTP serve from bin/brain/serve.go, default Go search binary. Move the HTTP package to internal/httpapi. Default backend is var/bin/brain-search, not Python. bin/serve.go stays as a deprecation shim. * feat(httpapi): default search backend is var/bin/brain-search. bin/brain/serve.go is the command; bin/serve.go stays as a tagged deprecation shim. Tests fail if the default path still names Python.	2026-08-13 14:32:21 +01:00
eSliderandGitHub	f14025304e	refactor: one Go module; brain search in bin/brain + internal/brain. (#8 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped Collapse nested kbsearch/chats go.mod into the root module. Ranking stays cgo-free under internal/brain/rank so CI does not need ladybug. bin/kb/search is a deprecation wrapper that still sets CGO and builds the binary.	2026-08-13 14:26:54 +01:00
eSliderandGitHub	dd6d7e9395	docs: point issues at Gitea origin (D15). (#7 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped GitHub stays the public clone for PRs and Actions. Work board is https://git.produktor.io/eSlider/2dph/issues.	2026-08-13 14:11:00 +01:00
eSliderandGitHub	68d478224f	feat(chats): parse LinkedIn MCP v4.22 inbox/conversation blobs. (#6 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped get_inbox/get_conversation return a sections+references envelope, not a message list. Parser is covered by synthetic Alice/Bob fixtures; CI now runs the nested bin/chats tests. Session check no longer launches Chromium.	2026-08-13 12:25:51 +01:00
eSliderandGitHub	117f3c2cfd	fix(kbsearch): rank FTS correctly, filter before -n, start the daemon. (#5 ) Go search took worst BM25 hits (ORDER BY score), cut to -n before --root, and never called ensureDaemon. Ranking and flag parsing move to a cgo-free package so CI can fail those regressions without ladybug. --hop errors instead of being swallowed into the query.	2026-08-13 12:19:26 +01:00
eSliderandGitHub	140d86a4b9	Add Gmail --query to mail/sync (default in:inbox) (#4 ) Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped * Add --query to Gmail mail/sync instead of always listing in:inbox. Callers keep the search string; default remains in:inbox. * Document Gmail --query on the mail/sync pipeline. * test(mail): assert Gmail --query reaches ListIDs, not only the CLI flag. ParseCLI coverage left a hole: an empty query still has to become in:inbox and a custom q has to be the string the client lists with.	2026-08-13 12:19:22 +01:00
eSlider	c96c393a4a	feat(chats): LinkedIn source — MCP client via get_inbox + get_conversation Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped - LinkedInMCPSource: MCP JSON-RPC, как TelegramMCPSource - sync linkedin --limit N: выгрузка сообщений из LinkedIn - Проверка сессии: uvx mcp-server-linkedin --status - Вывод инструкции если сессия истекла - JSONL в var/chats/linkedin/<thread_id>/messages.jsonl	2026-08-13 00:10:42 +01:00
eSlider	3d0d95cf00	docs: add edelweiss to GitHub safety rules Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped	2026-08-13 00:07:01 +01:00
eSlider	ed28fdbd2a	chore: remove edelweiss references from public repo Tests / Test (push) Skipped Tests / Release (semver) (push) Skipped	2026-08-13 00:06:49 +01:00
eSlider	7e511d5b78	docs: GitHub safety rules — no absolute paths, PII, secrets, curasoft	2026-08-13 00:02:09 +01:00
eSlider	0d26519fab	fix: resolve plan.md conflict, remove remaining /mnt/ paths	2026-08-13 00:00:48 +01:00
eSlider	a429b823e5	chore: clean absolute paths, curasoft refs, secrets from history - bin/chats/: env-based paths, no /mnt/ /home/ hardcodes - bin/edelweiss-pilot: remove curasoft, use DOCS_BASE env var - bin/facts/crm: use KNOWLEDGE_MESH_SEED env var - compose.edelweiss.yml: remove curasoft volumes, use DOCS_BASE - docs/chat-import-plan.md: link to Gitea issue, no secrets - bin/seed-edelweiss-facts.py: removed (curasoft-only)	2026-08-13 00:00:15 +01:00
eSlider	6847233183	bin/chats: Phase 1 MVP — Telegram sync/import/index/facts/apply - bin/chats/ — nested Go module (как bin/kbsearch/) - sync telegram — MCP JSON-RPC клиент, 31 личный чат, 922 сообщения - import — конвертация JSONL → MD с YAML frontmatter - index — делегирует bin/kb/index --corpus (132 leafs в brain) - facts — regex extraction phone/email/linkedin с валидацией (исключены: даты, суммы, номера карт, инвойсы) - apply — oo CLI cross-check + dry-run - Source interface для будущих WhatsApp/LinkedIn - 4 system tests (import, facts, empty, roundtrip) — синтетические данные - bin/chat — build+exec wrapper - docs/chat-import-plan.md — прогресс, пути к env (без секретов) Безопасность: var/ в gitignore, credentials в env, тесты без реальных данных.	2026-08-12 23:59:29 +01:00
eSlider	6d7638ab73	docs: chat import pipeline plan — link to Gitea issue #1	2026-08-12 23:59:20 +01:00
eSliderandCursor	bd1a91dab7	fix(kb): seed facts before CREATE indexes (FTS MERGE corruption) Upsert under live FTS raises "document for node offset N is missing". Add --skip-indexes; edelweiss-pilot index = write → seed → ensure_indexes. Ship seed-edelweiss-facts.py (paired lexicon/OO/interview/QEMU facts). Co-authored-by: Cursor <cursoragent@cursor.com>	2026-08-12 16:09:02 +01:00
eSliderandCursor	a5a1f91d95	fix(kb): stop DROP INDEX killing HNSW via Ladybug ghost catalog Ladybug 0.19 DROP INDEX leaves `_0_Leaf_vec_UPPER` / `0_id_docs` in catalog so CREATE fails while SHOW_INDEXES omits the index; create_fts_and_vector used to swallow that. Never drop FTS/VECTOR; ensure_indexes after upserts; rebuild = delete kb.lbug. Add compose.edelweiss.yml + regression tests. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-08-12 16:05:14 +01:00
eSlider	80e3b7a1cf	Remove curasoft references, rename to detective method - PLAN.md: replace 'curasoft-detective' with 'detective method' - README.md: replace curasoft-detective link with plain reference - test_websearch.py: fix test domain from ticket.curasoft.de to example.com - Rewrote git history with git-filter-repo to remove all traces	2026-08-12 13:46:54 +01:00
eSlider	ef4189c72d	kbsearch: Go implementation with daemon model serving - New nested module bin/kbsearch with Go implementation of bin/kb/search - Embedding model (potion-multilingual-128M) served by localhost daemon so repeated CLI calls reuse the loaded model - Bash launcher bin/kb/search builds binary on first run, caches to var/bin/ - Hybrid FTS + vector search (RRF k=60) matching Python kblib behavior - YAML output via port of yamlout.py (ordered keys, same format) - JSON output with proper field order - All flags: --root, --repo, -n, --json, --list-model - Root go.mod reverted to 1.25.0 (kbsearch is isolated nested module) - CI passes: go test ./... and go vet ./... unaffected by kbsearch	2026-08-11 23:57:39 +01:00
eSlider	60c20ed98d	feat(mail): full Gmail+OnlyOffice sync, import, and brain indexing - bin/mail/sync.go: async Go sync engine (8 workers, paginated Gmail via API + OnlyOffice IMAP); Gmail attachments key off body.attachmentId, not MIME partId; ICS sidecars Latin-1->UTF-8 normalized (TestICSToMarkdownNormalizesLatin1) - bin/mail/import: message.json -> markdown; PDFs via pdftotext -layout fast path with docling subprocess fallback for the ~5% textless files - bin/mail/index_mail: fresh-rebuild indexer (repo corpus + mail) avoiding ladybug WAL corruption on bulk-insert into indexed DBs; split from import - bin/kb/index: keep FTS/VECTOR indexes across incremental runs (drop+recreate leaves stale backing tables killing the vector index) - docs: README/PLAN/AGENTS cover the mail pipeline Result: 17,835 messages -> 28,918 info leafs, FTS+HNSW healthy.	2026-08-11 21:57:38 +01:00
eSlider	9f22380e82	refactor(tools): bin/{subject}/{method} layout; Go serve+watch modules Move serve/ (module) -> bin/server, tools/ -> bin/tools, replace bin/kb-watch bash with bin/watch Go package; self-executing Go shebangs bin/serve.go and bin/kb/watch.go; Docker + CI + git/import + docs repointed. Multi-stage image builds static serve+watch binaries (no Go runtime in container).	2026-08-11 09:52:20 +01:00
eSlider	e2eff3b9c7	feat(kb): CRM association proof via oo, fix ssh-tunnel self-ref + oo creds - bin/facts/crm: prove person<->company/company<->project against ooCRM x corpus SoT (knowledge-mesh-seed.yaml), write 78 facts (root=facts) - tools/crmfacts.py + test_crm_facts.py: parser under unit tests (26 pass) - docs/crm-associations-proof.md: provable graph, mistakes, fixes - oo merge 759->763 resolves duplicate GoldenRatio.Exchange legal entity - bin/db/ssh-tunnel: "$0" self-check + accept-new/BatchMode ssh flags - AGENTS.md: document bin/facts/crm	2026-08-10 23:22:34 +01:00