tests: закрыты три дыры в покрытии, найденные мутационным анализом

README.md

@@ -10,17 +10,21 @@
 
 ## Статус
 
-Проектирование завершено. Код не написан.
+Реализовано и принято на эталонном корпусе. 38 тестов, мутационная проверка, сквозной recall@5 = 20/20.
 
-| Документ | Что внутри |
+| Что | Вердикт приёмки |
 |---|---|
-| [`docs/SPEC.md`](docs/SPEC.md) | полная спека: модель данных, индекс, маршрутизация, watcher, интерфейс, приёмка |
-| [`TASK.md`](TASK.md) | ТЗ для исполнителя (opencode): стек, схема БД, контракты, чего не делать |
-| [`TESTING.md`](TESTING.md) | тест-план: 6 приёмочных проверок, команды, признаки провала |
+| юнит-тесты всех модулей | ✅ |
+| мутационная проверка (13 мутаций) | ✅ все убиты |
+| индексация: 3 коллекции, повторный прогон — 0 обновлений | ✅ |
+| recall@5 на эталонном корпусе (sem 20/20, lex 3/3) | ✅ |
+| MCP-протокол живым клиентом + холодный старт | ✅ |
 
 ## Идея
 
 - Коллекций (папок-тем) — сколько угодно; они не мешают друг другу.
+- **Коллекция — каталог, в котором есть `*.md` напрямую** (не в подкаталогах). Вложенные папки
+  без своих заметок коллекциями не считаются — иначе одни и те же файлы индексируются по нескольку раз.
 - Индекс каждой коллекции живёт в её `.memo/index.db` и **удаляется без потерь** — пересобирается.
 - Поиск — обычный read-only инструмент; записи в markdown он не делает никогда.
 - Только локально: эмбеддинг на CPU, сеть не нужна ни при индексации, ни при поиске.
@@ -36,6 +40,61 @@ memo-mcp     # MCP-сервер (stdio): memo_search / memo_status / memo_reinde
 
 `memo-core` не знает ни про watcher, ни про MCP — это драйверы поверх ядра.
 
+## Быстрый старт
+
+```bash
+./gradlew installDist          # собрать все дистрибутивы
+
+CLI=memo-cli/build/install/memo/bin/memo
+$CLI index  ~/notes            # проиндексировать дерево (коллекции найдутся сами)
+$CLI search ~/notes "чем чинят карточку в jellyfin"
+$CLI search ~/notes "76.132" --mode lex --json
+$CLI status ~/notes
+```
+
+MCP-сервер (stdio), регистрируется как обычный MCP-сервер:
+
+```json
+{
+  "mcpServers": {
+    "memo": {
+      "command": "/opt/memo/memo-mcp",
+      "env": { "MEMO_MODEL_DIR": "/opt/memo/models/siglip2" }
+    }
+  }
+}
+```
+
+Инструменты: `memo_search(path, query, k, mode)`, `memo_status(path)`, `memo_reindex(path)`.
+`memo_search` **сам создаёт индекс**, если его ещё нет — можно просто писать `.md` и сразу искать.
+
+Демон слежения (для правок мимо агента — людьми, git, сторонними редакторами):
+
+```bash
+memo-watch/build/install/memo-watch/bin/memo-watch ~/notes
+```
+
+## Приёмка
+
+```bash
+bash scripts/accept.sh          # полный прогон: сборка, тесты, мутации, индекс, recall, MCP
+bash scripts/accept.sh --fast   # то же без мутационной проверки (самая долгая)
+```
+
+Правило проекта: **«зелёная сборка» ничего не доказывает.** Тесты проверяются мутациями
+(`e2e/mutations.tsv`): боевой код ломается, и нужный тест обязан упасть. Выжившая мутация —
+дыра в покрытии, а не удача. Приёмка идёт на реальном корпусе (`scripts/make_e2e_corpus.sh`),
+а не на моках.
+
+## Документы
+
+| Документ | Что внутри |
+|---|---|
+| [`docs/SPEC.md`](docs/SPEC.md) | полная спека: модель данных, индекс, маршрутизация, watcher, интерфейс, приёмка |
+| [`TASK.md`](TASK.md) | ТЗ для исполнителя: стек, схема БД, контракты, чего не делать |
+| [`TESTING.md`](TESTING.md) | тест-план: приёмочные проверки, команды, признаки провала |
+| [`docs/orders/`](docs/orders/) | журнал заказов исполнителю — с доказательствами дефектов, а не «сделай хорошо» |
+
 ## Зависимости (проверено 02.10.2026)
 
 | Что | Координата | Откуда |

TESTING.md

@@ -23,16 +23,18 @@ export MEMO_ROOT=/root/WORK/memo-e2e
 ## T1. Индексация и её повтор
 
 ```bash
-cd /root/WORK/memo && ./gradlew :memo-cli:installDist -q
-CLI=./memo-cli/build/install/memo-cli/bin/memo
+cd /root/WORK/memo && ./gradlew installDist -q
+CLI=./memo-cli/build/install/memo/bin/memo
 $CLI index "$MEMO_ROOT"; $CLI status "$MEMO_ROOT"
-ls -l "$MEMO_ROOT"/*/.memo/index.db
+find "$MEMO_ROOT" -name index.db | sort          # ожидается 3 пути, по одному на коллекцию
 $CLI index "$MEMO_ROOT"      # второй прогон
 ```
 
-Ожидается: в каждой папке появился `.memo/index.db`; второй прогон **не переэмбеддивает** ни одного файла
+Ожидается: в каждой коллекции появился `.memo/index.db` (**ровно три** — вложенные папки без своих
+заметок коллекциями не считаются); второй прогон **не переэмбеддивает** ни одного файла
 (в выводе 0 обновлённых, `status` показывает те же `indexed_at`). Провал: нет `.memo/index.db`;
-второй прогон молча переиндексирует всё.
+баз больше трёх (значит, коллекцией считается каждая папка с .md внутри); второй прогон молча
+переиндексирует всё.
 
 ## T2. Смысловой поиск (вектор работает)
 

docs/orders/02-chunker.md

@@ -31,7 +31,7 @@ fun chunkMarkdown(text: String): List<Chunk>
 ## ChunkerTest.kt — ровно 5 тестов, имена ровно такие
 
 1. `splitsByHeadingLevels` — вход с '# A', '## B', '### C' → 3 чанка, heading = ["A","B","C"], line = [1,3,5], ord = [0,1,2].
-2. `textBeforeFirstHeadingBecomesChunkWithEmptyHeading` — ввод «преамбула\n# Заголовок\nтело» → 2 чанка, первый: heading "»", line 1; второй heading "Заголовок".
+2. `textBeforeFirstHeadingBecomesChunkWithEmptyHeading` — ввод "преамбула\n# Заголовок\nтело" → 2 чанка, первый: heading = "" (пустая строка), line 1; второй heading "Заголовок".
 3. `fourHashesIsNotAHeading` — строка '#### не заголовок' остаётся частью текста предыдущего раздела.
 4. `emptySectionsAreDropped` — ввод с двумя заголовками подряд без текста между ними → 1 чанк.
 5. `longSectionIsSplitWithOverlap` — раздел из 6000 символов 'а' → 2 чанка, длина первого 4000,

docs/orders/03-indexer.md

@@ -0,0 +1,57 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ по индексации markdown-файлов в базу.
+
+Создать РОВНО ОДИН новый файл: memo-core/src/main/kotlin/memo/core/Indexer.kt
+Дополнить существующий: memo-core/src/test/kotlin/memo/core/CoreSmokeTest.kt (добавить ОДИН новый тест-метод в конец класса, существующие не трогать)
+
+## Indexer.kt
+
+package memo.core
+
+class Indexer(private val db: Db, private val embedder: Embedder) {
+
+    /** Индексирует один файл. Возвращает true, если файл был (пере)проиндексирован,
+     *  false — если пропущен (не изменился с прошлой индексации). */
+    fun indexFile(path: java.io.File): Boolean
+
+    /** Индексирует все .md файлы в дереве каталога root (рекурсивно). Возвращает число
+     *  реально переиндексированных файлов. */
+    fun indexTree(root: java.io.File): Int
+}
+
+Правила:
+1. Перед индексацией файла сравнить с записью в таблице files по колонке path:
+   - если записи нет — индексировать;
+   - если mtime и size совпадают с сохранёнными — вернуть false, ничего не делать (НЕ считать хэш);
+   - если mtime/size изменились — посчитать sha-256 содержимого; если хэш совпал с сохранённым —
+     обновить в files поля mtime/size/indexed_at (файл тронули, содержимое то же) и вернуть false;
+   - иначе — полная переиндексация файла.
+2. Полная переиндексация файла: удалить из chunks все строки с этим path; удалить из chunks_fts строки
+   с rowid из удалённых chunks (DELETE FROM chunks_fts WHERE rowid IN (...)); то же для chunks_vec.
+   Затем разбить текст через chunkMarkdown (см. memo-core/src/main/kotlin/memo/core/Chunker.kt),
+   для каждого чанка: посчитать эмбеддинг embedder.embed(chunk.text), вставить строку в chunks,
+   взять last_insert_rowid() и вставить те же rowid в chunks_fts (колонки text, heading)
+   и в chunks_vec (колонка embedding). Всё — в одной транзакции (conn.beginTransaction/commit/rollback).
+3. В files писать: path (абсолютный), mtime (доля секунды, REAL), size, hash (hex sha-256), indexed_at (epoch секунды).
+4. indexTree: обход рекурсивно, только файлы с расширением .md, скрытые каталоги (начинающиеся с '.')
+   и каталоги .memo не обходить. Возвращать число переиндексированных файлов.
+
+## Тест: добавить в CoreSmokeTest.kt метод
+
+fun indexerSkipsUnchangedFile()
+
+- создать временный каталог, в нём файл note.md с содержимым "# Заголовок\nтело заметки\n## Второй\nещё текст";
+- создать Db на временном index.db (не забыть db.init()) и Embedder на модели
+  (путь брать так же, как в существующем тесте embedderProduces768 — через MEMO_MODEL_DIR);
+- первый indexFile(...) должен вернуть true;
+- второй indexFile(...) сразу же — обязан вернуть false (файл не менялся);
+- дописать в файл "\n## Третий\nновый текст\n", второй indexFile обязан вернуть true;
+- в конце: assertTrue, что SELECT count(*) FROM chunks без условия больше нуля (запрос через db.conn).
+
+После: ./gradlew :memo-core:test --rerun-tasks — все тесты зелёные.
+Коммит: git add -A && git commit -m "core: индексатор файлов с пропуском неизменённых"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу создавай/правь файлы.
+- Не трогать Chunker.kt, Embedder.kt, Db.kt, build.gradle.kts и любые другие файлы.
+- Не менять существующие тесты.
+- Не добавлять зависимости.

docs/orders/04-searcher.md

@@ -0,0 +1,76 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ по поиску.
+
+Создать РОВНО ДВА новых файла:
+  memo-core/src/main/kotlin/memo/core/Searcher.kt
+  memo-core/src/test/kotlin/memo/core/SearcherTest.kt
+
+## Searcher.kt
+
+package memo.core
+
+enum class SearchMode { HYBRID, LEX, VEC }
+
+data class Hit(
+    val path: String,
+    val line: Int,
+    val heading: String,
+    val score: Double,
+    val text: String,     // текст чанка, обрезанный до 1200 символов
+)
+
+fun interface RefreshHook { fun refresh(root: java.io.File) }
+
+class Searcher(
+    private val db: Db,
+    private val embedder: Embedder,
+    private val refresh: RefreshHook? = null,
+) {
+    /** Ищет по индексу. Если задан [refresh] — сначала вызывает его для root
+     *  (догон свежих правок файлов до поиска). */
+    fun search(root: java.io.File, query: String, k: Int = 8, mode: SearchMode = SearchMode.HYBRID): List<Hit>
+}
+
+Правила реализации:
+1. Если refresh != null — вызвать refresh.refresh(root) ПЕРЕД любым запросом к базе.
+2. Лексический список (режимы LEX и HYBRID): разбить query на токены по всем символам, кроме букв
+   и цифр (unicode: Character.isLetterOrDigit); оставить токены длиной >= 2; взять первые 8;
+   собрать строку вида "ток1" OR "ток2" (каждый токен в двойных кавычках);
+   если токенов нет — лексический список пуст, без ошибки.
+   Запрос: SELECT rowid, bm25(chunks_fts) AS s FROM chunks_fts WHERE chunks_fts MATCH ? ORDER BY s LIMIT 32.
+   Ошибку SQLite на MATCH не ронять наружу, а считать списком пустым.
+3. Векторный список (режимы VEC и HYBRID): embedder.embed(query) → FloatArray[768];
+   запрос: SELECT rowid, distance FROM chunks_vec WHERE embedding MATCH ? ORDER BY distance LIMIT 32.
+   Байндить вектор тем же способом, что в тесте vec0KnnRoundTrip (bindVector).
+4. Слияние RRF: score(rowid) = сумма по спискам 1.0/(60.0 + rank), где rank — позиция в списке, начиная с 1.
+   В режиме LEX — только лексический список, в VEC — только векторный, в HYBRID — оба.
+5. По итоговому score взять первые k rowid; вычитать из chunks поля path, line, heading, text
+   (SELECT path, line, heading, text FROM chunks WHERE id IN (...)); сохранить порядок по score убыванию.
+6. text обрезать до 1200 символов (если длиннее — substring(0,1200) без многоточий).
+7. Пустой индекс → пустой список, без исключений.
+
+## SearcherTest.kt — ровно 5 тестов, имена ровно такие
+
+Подготовка (общий помощник): временный каталог + Db(index.db) + db.init() + Embedder(модель из MEMO_MODEL_DIR
+как в CoreSmokeTest.embedderProduces768). Помощник `addChunk(path, heading, line, text)`, который вставляет
+строку в chunks, берёт last_insert_rowid() и вставляет тот же rowid в chunks_fts(text, heading)
+и в chunks_vec(embedding) с эмбеддингом embedder.embed(text).
+
+1. `lexModeFindsExactValue` — 3 чанка, в одном текст "Прокси корпоративных доменов на 76.132";
+   поиск с mode = LEX по запросу "76.132" → первый хит содержит "76.132".
+2. `vecModeFindsSemanticMatch` — 3 чанка на разные темы (сервер/книга/CI);
+   запрос про «настройку выпуска приложения», mode = VEC → первый хит — чанк про CI.
+3. `lexModeIgnoresVectorOnlyMatch` — запрос, не имеющий ни одного общего токена с чанками
+   (например, при тексте чанков "опрос", "случай", "знание" запрос "автомобиль");
+   mode = LEX → пустой список, mode = VEC → непустой.
+4. `hybridCombinesBoth` — в индексе чанк с точным значением и чанк со смысловым совпадением;
+   запрос, попадающий в оба, mode = HYBRID, k = 5 → в результате присутствуют оба чанка.
+5. `resultsRespectKAndTextLength` — 4 чанка; k = 2 → ровно 2 хита; у каждого text непустой и его длина <= 1200.
+
+После: ./gradlew :memo-core:test --rerun-tasks — все тесты зелёные.
+Коммит: git add -A && git commit -m "core: гибридный поиск (BM25 + вектор + RRF)"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу создавай файлы.
+- Не трогать существующие файлы (Chunker.kt, Indexer.kt, Embedder.kt, Db.kt, CoreSmokeTest.kt, ChunkerTest.kt, build.gradle.kts).
+- Не добавлять зависимости.
+- Не создавать другие файлы.

docs/orders/05-cli.md

@@ -0,0 +1,79 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ по CLI — руками проверяемые команды.
+
+Правки:
+  - memo-cli/build.gradle.kts: добавить application-плагин и зависимость на :memo-core
+  - новый файл memo-cli/src/main/kotlin/memo/cli/Main.kt
+  - новый файл memo-cli/src/test/kotlin/memo/cli/CliArgsTest.kt
+
+## Настройка модуля memo-cli
+
+build.gradle.kts модуля:
+  plugins { kotlin("jvm"); application }
+  application { mainClass.set("memo.cli.MainKt") }
+  dependencies { implementation(project(":memo-core")) }
+
+## Main.kt — контракт команд
+
+fun main(args: Array<String>)
+
+Разбор аргументов вынести в чистую функцию (тестируемую без процесса):
+  sealed interface Cmd
+  data class IndexCmd(val path: String) : Cmd
+  data class SearchCmd(val path: String, val query: String, val k: Int, val mode: SearchMode, val json: Boolean) : Cmd
+  data class StatusCmd(val path: String) : Cmd
+  data class McpProbeCmd(val tool: String, val argsJson: String) : Cmd
+  object HelpCmd : Cmd
+  fun parseArgs(args: Array<String>): Cmd        // при ошибке — HelpCmd
+
+Правила разбора:
+- `index <path>` → IndexCmd
+- `search <path> <query> [--k N] [--mode hybrid|lex|vec] [--json]` → SearchCmd
+  (по умолчанию k = 8, mode = HYBRID); неизвестный флаг или нечисловой --k → HelpCmd
+- `status <path>` → StatusCmd
+- `mcp-probe --tool <name> [--args <json>]` → McpProbeCmd (args по умолчанию "{}")
+- нет аргументов, `--help`, `-h`, неизвестная команда → HelpCmd
+
+Поведение команд:
+1. `index <path>`: определить корень так — если path оканчивается на "/.memo" или содержит его, взять родителя;
+   каталог `X` считается коллекцией, если в нём есть файлы *.md (искать на глубине до 2 от path).
+   Для каждой найденной коллекции: создать каталог `<коллекция>/.memo`, базу `<коллекция>/.memo/index.db`,
+   Db(...).init(), затем Indexer(db, embedder).indexTree(коллекция).
+   Путь к модели: переменная окружения MEMO_MODEL_DIR, иначе /root/WORK/memo/models/siglip2.
+   Печатать по строке на коллекцию: `индексировано: <N> обновлено, <файлов всего>` и в конце
+   `итого: <сумма> обновлено в <число коллекций> коллекциях`.
+2. `search <path> <query>`: path — ЛИБО коллекция, ЛИБО файл *.md (тогда коллекция = его каталог),
+   ЛИБО корень, содержащий коллекции (тогда искать по всем коллекциям внутри, объединив результаты
+   по убыванию score и обрезав до k).
+   Модель/эмбеддер обязателен: без него базы не откроются — это нормально.
+   Refresh-хук передавать обязательно: он делает Indexer(db, embedder).indexTree(root) перед поиском.
+   Без `--json` печатать человекочитаемо:
+     `<score с 3 знаками>  <path>:<line>  <heading>`
+     далее текст чанка с отступом 4 пробела, обрезанный до 300 символов.
+   С `--json` печатать ОДИН JSON-массив, без пояснений и без лишних строк:
+     [{"path":"...","line":12,"heading":"...","score":0.51,"text":"..."}]
+   Если ничего не найдено — пустой JSON-массив `[]` (в режиме --json) и код возврата 0.
+3. `status <path>`: по каждой коллекции печатать `<<коллекция>>: файлов <N>, чанков <M>, индекс <дата ISO>`
+   (дата — максимальный indexed_at из files).
+4. `mcp-probe --tool <name> --args <json>`: выполнить то же, что делает MCP-инструмент, и напечатать
+   результат в формате MCP-ответа:
+     {"content":[{"type":"text","text":"<результат>"}],"isError":false}
+   Поддерживаемые инструменты на этом шаге: memo_search (аргументы path, query, k, mode) и memo_status (path).
+   memo_reindex — вернуть isError: true с текстом "not implemented yet".
+
+## CliArgsTest.kt — ровно 5 тестов, имена ровно такие
+
+1. `indexCommandParsed` — ["index", "/tmp/x"] → IndexCmd с path "/tmp/x".
+2. `searchDefaultsAreK8HybridNoJson` — ["search", "/tmp/x", "вопрос"] → SearchCmd(k = 8, mode = HYBRID, json = false).
+3. `searchFlagsParsed` — ["search", "/tmp/x", "вопрос", "--k", "3", "--mode", "lex", "--json"] → k = 3, mode = LEX, json = true.
+4. `badKValueFallsBackToHelp` — ["search", "/tmp/x", "вопрос", "--k", "abc"] → HelpCmd.
+5. `unknownCommandFallsBackToHelp` — ["сломать"] → HelpCmd.
+
+После: ./gradlew :memo-cli:test --rerun-tasks и ./gradlew :memo-cli:installDist — обе команды зелёные.
+Проверь руками, что бинарь появился: ls memo-cli/build/install/memo-cli/bin/memo
+Коммит: git add -A && git commit -m "cli: index/search/status/mcp-probe"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу правь файлы.
+- Не трогать memo-core (ни src/main, ни src/test), кроме использования его публичного API.
+- Не добавлять зависимости, кроме :memo-core.
+- Не создавать другие файлы.

docs/orders/06-watcher.md

@@ -0,0 +1,74 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ по слежению за файлами.
+
+Создать РОВНО ДВА новых файла:
+  memo-watch/build.gradle.kts   (плагин kotlin("jvm") + зависимость на :memo-core)
+  memo-watch/src/main/kotlin/memo/watch/Watcher.kt
+  memo-watch/src/main/kotlin/memo/watch/WatchMain.kt
+и ОДИН тестовый:
+  memo-watch/src/test/kotlin/memo/watch/WatcherTest.kt
+
+## Watcher.kt
+
+package memo.watch
+
+class Watcher(
+    private val collections: List<java.io.File>,   // каталоги-коллекции
+    private val index: (java.io.File) -> Unit,     // функция индексации одной коллекции
+    private val debounceMillis: Long = 500,
+    private val reconcileMillis: Long = 10 * 60 * 1000,
+) : AutoCloseable {
+
+    /** Запускает фоновый поток: WatchService на каждый каталог рекурсивно,
+     *  debounce, плюс периодическая полная реконсиляция по mtime. */
+    fun start()
+
+    /** Останавливает поток, закрывает WatchService. Идемпотентно. */
+    override fun close()
+
+    /** Количество выполненных вызовов index(...) — для тестов. */
+    val indexCalls: Int
+}
+
+Требования:
+1. Регистрировать каждый каталог через FileSystems.getDefault().newWatchService() с ENTRY_CREATE,
+   ENTRY_MODIFY, ENTRY_DELETE и при регистрации рекурсивно обойти подкаталоги (WatchService не рекурсивен).
+   Каталоги, начинающиеся с '.', не обходить и не регистрировать.
+2. События собирать в Set<File> (какие коллекции затронуты). Поток: take() с таймаутом debounceMillis;
+   при накоплении — по истечении debounce вызвать index(коллекция) для каждой затронутой коллекции.
+   Не вызывать index десятки раз на одно сохранение файла.
+3. Раз в reconcileMillis — полная реконсиляция: обойти все файлы *.md во всех коллекциях,
+   сравнить (path, mtime, size) со таблицей files, при расхождении вызвать index(коллекция).
+   Реализацию сравнения НЕ дублировать: у :memo-core уже есть Indexer.indexFile, который сам
+   пропускает неизменённые файлы и возвращает Boolean. Использовать его: index(коллекция) должен
+   внутри вызывать Indexer.indexTree(коллекция).
+4. Все исключения в рабочем потоке не должны убивать поток: ловить, печатать в stderr, продолжать.
+5. close(): interrupt + закрыть WatchService, поток завершается не дольше 2 секунд.
+
+## WatchMain.kt
+
+fun main(args: Array<String>)
+- Аргумент: корень, содержащий коллекции (или одну коллекцию).
+- Определение коллекций — как в CLI (каталог с *.md на глубине до 2).
+- Создаёт Db(коллекция/.memo/index.db), .init(), Indexer(db, embedder) — по одному на коллекцию,
+  Watcher с index = { коллекция -> indexer.indexTree(коллекция) }.
+- Печатает `наблюдаю: <коллекция>` по строке на каждую, затем блокируется навсегда до SIGINT.
+- Модель: MEMO_MODEL_DIR, иначе /root/WORK/memo/models/siglip2.
+
+## WatcherTest.kt — ровно 3 теста, имена ровно такие
+
+1. `modifyTriggersSingleIndexCall` — временный каталог с note.md; Watcher с index-счётчиком и
+   debounce 200 мс; start(); правка файла; подождать 1.5 с; indexCalls == 1 (не больше!);
+   close(). (Перед стартом дать watcher 300 мс прогреться.)
+2. `unchangedFileDoesNotTriggerIndex` — после прогрева ничего не менять 1.5 с → indexCalls == 0.
+3. `closeIsIdempotentAndStopsThread` — start(); close(); close(); повторный вызов не бросает исключение.
+
+Тесты должны быть устойчивыми: ждать не фиксированным sleep, а опросом условия с таймаутом
+(например, до 5 с с шагом 100 мс), чтобы не флапать на медленной машине.
+
+После: ./gradlew :memo-watch:test --rerun-tasks — зелёные; ./gradlew build -x test компилируется.
+Коммит: git add -A && git commit -m "watch: слежение за файлами (WatchService + debounce + реконсиляция)"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу создавай файлы.
+- Не трогать memo-core и memo-cli.
+- Не добавлять зависимости, кроме :memo-core.

docs/orders/07-mcp.md

@@ -0,0 +1,62 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ по MCP-серверу. Контракт уже в docs/orders/07-mcp.md —
+читать его как исходное ТЗ, а здесь перечислены обязательные требования и известные грабли.
+
+Создать:
+  memo-mcp/build.gradle.kts
+  memo-mcp/src/main/kotlin/memo/mcp/McpServer.kt
+  memo-mcp/src/test/kotlin/memo/mcp/McpProtocolTest.kt
+
+## Зависимости модуля memo-mcp
+
+  plugins { kotlin("jvm"); application; kotlin("plugin.serialization") version "2.4.10" }
+  application { mainClass.set("memo.mcp.McpServerKt") }
+  dependencies {
+      implementation(project(":memo-core"))
+      implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+  }
+ВАЖНО: в kotlin("plugin.serialization") версию указать обязательно 2.4.10, иначе сборка упадёт на несовместимости версий плагина и Kotlin.
+Если сериализация начнёт мешать — НЕ добавляй её, собери JSON строками вручную (ручной JSON-рендер допустим и проще).
+
+## McpServer.kt
+
+fun main(args: Array<String>) — читает stdin построчно, на каждый запрос печатает в stdout РОВНО одну строку
+JSON-RPC 2.0. В stdout НИЧЕГО кроме JSON (включая баннеры/логи) — диагностика только в stderr.
+
+Методы:
+- initialize → {"protocolVersion":"2024-11-05","capabilities":{"tools":{}},"serverInfo":{"name":"memo","version":"0.1.0"}}
+- notifications/initialized → ответ не отправлять (вернуть null)
+- tools/list → 3 инструмента: memo_search {path, query, k=8, mode="hybrid"}, memo_status {path}, memo_reindex {path}
+- tools/call {"name":..., "arguments":{...}} → {"content":[{"type":"text","text":"..."}],"isError":false}
+  Ошибки (нет обязательного аргумента, неизвестный инструмент, исключение) → isError:true + текст, НЕ JSON-RPC error.
+- неизвестный метод → {"jsonrpc":"2.0","id":<id>,"error":{"code":-32601,"message":"Method not found"}}
+- уведомление (нет "id" в запросе) → ответ не отправлять
+
+Тестируемые без процесса функции: handleRequest(line: String): String?, toolSearch(path, query, k, mode): String,
+toolStatus(path): String, toolReindex(path): String.
+
+Поведение инструментов:
+- Коллекции определять ТАК ЖЕ, как CLI: см. memo-cli/src/main/kotlin/memo/cli/Main.kt — переиспользуй ту
+  логику определения корня и коллекций (если это private — сделай в memo-core отдельный файл
+  memo-core/src/main/kotlin/memo/core/Collections.kt с функциями
+  `fun resolveCollection(path: java.io.File): java.io.File` и `fun findCollections(root: java.io.File): List<java.io.File>`,
+  и переключи CLI и MCP на них; CLI при этом должен остаться с зелёными тестами).
+- toolSearch: Searcher с refresh-хуком (indexTree перед поиском), текст ответа — по строке на хит:
+  `<path>:<line>  <heading>` и следом текст чанка; пусто → "ничего не найдено".
+- toolStatus: `<коллекция>: файлов <N>, чанков <M>, индекс <ISO>`.
+- toolReindex: удалить `<коллекция>/.memo` целиком и переиндексировать; вернуть `переиндексировано файлов: <N>`.
+
+## McpProtocolTest.kt — ровно 5 тестов, имена ровно такие
+
+1. `initializeHandshake` — ответ содержит "2024-11-05" и "memo".
+2. `toolsListHasThreeTools` — ответ содержит memo_search, memo_status, memo_reindex.
+3. `unknownMethodReturns32601` — ответ содержит "-32601".
+4. `searchWithoutPathIsError` — tools/call memo_search с arguments {} → содержит "isError":true.
+5. `notificationProducesNoResponse` — handleRequest(уведомление notifications/initialized) == null.
+
+После: ./gradlew :memo-mcp:test --rerun-tasks и ./gradlew :memo-mcp:installDist — зелёные.
+Коммит: git add -A && git commit -m "mcp: сервер memo_search/memo_status/memo_reindex"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу создавай файлы.
+- Не трогать логику memo-core, кроме добавления Collections.kt и переключения CLI на него.
+- Ничего в stdout, кроме JSON-RPC строк.

docs/orders/08-fix-collections.md

@@ -0,0 +1,78 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ на ИСПРАВЛЕНИЕ дефекта определения коллекций.
+
+## Доказанный дефект
+
+На корпусе /root/WORK/memo-e2e (3 папки с заметками: `infra`, `work/jira`, `life/books`,
+всего 12 .md) команда
+
+  memo index /root/WORK/memo-e2e
+
+создаёт ШЕСТЬ баз индекса вместо трёх:
+
+  /root/WORK/memo-e2e/.memo/index.db
+  /root/WORK/memo-e2e/infra/.memo/index.db
+  /root/WORK/memo-e2e/life/.memo/index.db
+  /root/WORK/memo-e2e/life/books/.memo/index.db
+  /root/WORK/memo-e2e/work/.memo/index.db
+  /root/WORK/memo-e2e/work/jira/.memo/index.db
+
+и «итого: 24 обновлено в 6 коллекциях» — одни и те же заметки проиндексированы по 2-3 раза.
+Причина: каталог считается коллекцией, если .md-файлы есть где-то на глубине до 2 ВНУТРИ него.
+
+## Правило, которое надо реализовать
+
+Коллекция — это каталог, в котором есть хотя бы один файл `*.md` **непосредственно в нём самом**
+(не в подкаталогах). Всё остальное коллекцией не является.
+
+Правки только в memo-core/src/main/kotlin/memo/core/Collections.kt (и, при необходимости,
+в местах его вызова в memo-cli и memo-mcp — но менять надо только вызовы, не логику):
+
+1. `fun findCollections(root: java.io.File): List<java.io.File>` — рекурсивный обход root,
+   возвращает ВСЕ каталоги (включая сам root, если подходит), в которых есть `*.md` напрямую.
+   Скрытые каталоги (имя начинается с '.') пропускать, каталог `.memo` не обходить.
+   Порядок — по пути, детерминированный.
+2. `fun resolveCollection(path: java.io.File): java.io.File` — если path каталог, вернуть ближайший
+   каталог, содержащий .md напрямую: сам path, иначе подняться вверх по родителям до первого такого
+   (но не выше, чем файловая система); если не найден — вернуть сам path.
+   Если path — файл, вернуть его родительский каталог (file.parentFile).
+3. `fun isCollection(dir: java.io.File): Boolean` — вспомогательная, реализует правило из абзаца выше
+   (ровно один уровень, без рекурсии).
+
+## Тесты: добавить в memo-core/src/test/kotlin/memo/core/ новый файл CollectionsTest.kt
+
+Ровно 4 теста, имена ровно такие:
+1. `findCollectionsReturnsOnlyDirsWithDirectMarkdown` — временный корень с такой структурой:
+   `root/a.md`, `root/sub/b.md`, `root/sub/deep/c.md`, `root/empty/` (без .md), `root/nested/only/deep/d.md`
+   → ровно 4 коллекции: root, root/sub, root/sub/deep, root/nested/only/deep. Каталогов `empty`, `nested`,
+   `nested/only` в результате быть НЕ должно.
+2. `parentDirWithoutDirectMarkdownIsNotCollection` — структура `root/top/inner/x.md` →
+   findCollections даёт ровно один элемент — `root/top/inner`.
+3. `resolveCollectionRaisesToNearestWithMarkdown` — для файла `root/top/inner/x.md` resolveCollection
+   возвращает `root/top/inner`; для каталога `root/top` (внутри .md нет, есть только в inner) —
+   тоже `root/top/inner`.
+4. `hiddenDirsAreSkipped` — структура `root/.hidden/a.md`, `root/vis/b.md` → ровно одна коллекция `root/vis`.
+   Плюс: если в корне лежит `root/.memo/index.db`, это ничего не меняет и не ломает результат.
+
+## Обязательная сквозная проверка (сделать самому, приложить вывод)
+
+  cd /root/WORK/memo
+  ./gradlew :memo-cli:installDist -q
+  rm -rf /root/WORK/memo-e2e/infra/.memo /root/WORK/memo-e2e/work/jira/.memo /root/WORK/memo-e2e/life/books/.memo \
+         /root/WORK/memo-e2e/.memo /root/WORK/memo-e2e/work/.memo /root/WORK/memo-e2e/life/.memo
+  memo-cli/build/install/memo/bin/memo index /root/WORK/memo-e2e
+  find /root/WORK/memo-e2e -name index.db | sort
+
+Ожидается РОВНО три пути:
+  /root/WORK/memo-e2e/infra/.memo/index.db
+  /root/WORK/memo-e2e/life/books/.memo/index.db
+  /root/WORK/memo-e2e/work/jira/.memo/index.db
+и в выводе index — «итого: 12 обновлено в 3 коллекциях». Второй прогон index — «итого: 0 обновлено».
+
+После: ./gradlew test --rerun-tasks — ВСЕ тесты проекта зелёные (включая те 5+memo-cli+memo-mcp).
+Коммит: git add -A && git commit -m "core: коллекция — каталог с markdown напрямую; исправлен тройной обход"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу правь файлы.
+- Не менять логику Searcher, Indexer, Chunker, Embedder, Db.
+- Не менять контракт CLI (имена команд и флагов) и MCP-инструментов.
+- Не добавлять зависимости.

docs/orders/09-mcp-cold-start.md

@@ -0,0 +1,72 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ по холодному старту MCP-поиска.
+
+## Доказанные дефекты (воспроизведено зондом)
+
+1. **Пустой старт не работает.** Команда
+     rm -rf /root/WORK/memo-e2e/*/.memo
+     python3 scripts/mcp_probe.py --cmd "./memo-mcp/build/install/memo-mcp/bin/memo-mcp" \
+       --call memo_search --args '{"path":"/root/WORK/memo-e2e/infra","query":"основа для разрешения имён в сети","k":3}'
+   возвращает текст `коллекции не найдены`, потому что `selectTargets()` оставляет только коллекции,
+   у которых УЖЕ существует `.memo/index.db`. То есть главный сценарий — агент пишет .md штатными
+   инструментами и сразу ищет — не работает: сначала надо вручную звать CLI `index`.
+   Ожидаемое поведение: `memo_search` сам создаёт `.memo/index.db` и индексирует коллекцию,
+   если индекса ещё нет, и возвращает результаты.
+
+2. **Модель грузится по разу на каждую коллекцию.** В `toolSearch` `Embedder(...)` создаётся внутри цикла
+   по коллекциям. На трёх коллекциях это три загрузки модели.
+
+## Что сделать
+
+Правки ТОЛЬКО в `memo-mcp/src/main/kotlin/memo/mcp/McpServer.kt` (+ новый тестовый файл). Логику memo-core не менять.
+
+1. `toolSearch(path, query, k, mode)`:
+   - Определить цели так: если `File(path)` сам является коллекцией (в нём есть `*.md` напрямую) —
+     цель ровно он; иначе — все коллекции внутри `findCollections(File(path))`; если и их нет —
+     вернуть `коллекции не найдены`.
+   - Для каждой цели: если `<коллекция>/.memo/index.db` не существует — создать каталог `.memo`,
+     `Db(...)`, `db.init()`, проиндексировать `Indexer(db, embedder).indexTree(коллекция)`.
+     Затем обычный поиск с refresh-хуком.
+   - `Embedder` создать ОДИН РАЗ до цикла по коллекциям и закрыть один раз после (try/finally).
+     `Db` — по одному на коллекцию, как сейчас.
+   - Не глотать ошибки молча: если по коллекции поиск упал, дописать в результат строку
+     `ошибка в <коллекция>: <текст>` (в конец возвращаемого текста), остальные коллекции всё равно обрабатывать.
+2. `toolStatus` — оставить как есть (статус по несуществующему индексу законно говорит «нет индекса»).
+3. `toolReindex` — оставить как есть, но `Embedder` тоже вынести из цикла (один на все коллекции).
+
+## Тест: новый файл memo-mcp/src/test/kotlin/memo/mcp/McpColdStartTest.kt
+
+Ровно 2 теста, имена ровно такие:
+
+1. `searchIndexesCollectionOnColdStart` — временный каталог-коллекция с двумя .md (например
+   "# Прокси\nвнутренние домены ходят через шлюз 76.1" и "# Прочее\nсовсем другая заметка про книгу"),
+   модель берётся из MEMO_MODEL_DIR (как в CoreSmokeTest). До вызова `.memo` НЕ существует.
+   Вызвать `toolSearch(dir.absolutePath, "внутренние домены шлюз", 5, SearchMode.HYBRID)`.
+   Проверить: (а) в ответе нет подстроки "коллекции не найдены"; (б) ответ содержит "76.1";
+   (в) после вызова `File(dir, ".memo/index.db").exists()` == true.
+2. `searchOnEmptyDirReportsNoCollections` — пустой временный каталог без .md:
+   ответ содержит "коллекции не найдены", каталог `.memo` не создан.
+
+Тесты должны работать без запуска процесса (через `toolSearch` напрямую).
+
+## Обязательная сквозная проверка (приложить вывод)
+
+  cd /root/WORK/memo
+  ./gradlew :memo-mcp:installDist -q
+  cp -r /root/WORK/memo-e2e /tmp/memo-cold && rm -rf /tmp/memo-cold/*/.memo /tmp/memo-cold/.memo
+  MEMO_MODEL_DIR=/root/WORK/memo/models/siglip2 python3 scripts/mcp_probe.py \
+    --cmd "./memo-mcp/build/install/memo-mcp/bin/memo-mcp" \
+    --call memo_search --args '{"path":"/tmp/memo-cold/infra","query":"основа для разрешения имён в сети","k":3}'
+  MEMO_MODEL_DIR=/root/WORK/memo/models/siglip2 python3 scripts/mcp_probe.py \
+    --cmd "./memo-mcp/build/install/memo-mcp/bin/memo-mcp" \
+    --call memo_status --args '{"path":"/tmp/memo-cold/infra"}'
+
+Ожидается: поиск отдаёт непустой текст с `infra/domains.md` (или infra/hosts.md) и без "коллекции не найдены";
+status после этого показывает ненулевые файлы и чанки. Также приложить `find /tmp/memo-cold -name index.db`.
+
+После: ./gradlew test --rerun-tasks — ВСЕ тесты проекта зелёные.
+Коммит: git add -A && git commit -m "mcp: поиск индексирует коллекцию на холодном старте"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу правь файлы.
+- Не менять memo-core, memo-cli, memo-watch.
+- Не добавлять зависимости.

docs/orders/10-coverage-holes.md

@@ -0,0 +1,61 @@
+Проект: /root/WORK/memo (Kotlin/JVM). Заказ на закрытие ТРЁХ дыр в покрытии, доказанных мутационной проверкой
+(`python3 e2e/mutation_check.py --gradle ./gradlew`). Мутация ломает боевой код, нужный тест обязан упасть.
+Сейчас три мутации выживают — тесты не проверяют то, ради чего написаны.
+
+Правки — ТОЛЬКО в тестовых файлах. Боевой код (src/main) НЕ менять ни в одном модуле.
+
+## Дыра 1. memo-core/src/test/kotlin/memo/core/CollectionsTest.kt
+
+Мутация `it.isFile && it.extension == "md"` -> `it.name.endsWith("md")` в Collections.kt ВЫЖИВАЕТ:
+в тесте все файлы — .md, поэтому подмена незаметна.
+
+Дополнить тест `findCollectionsReturnsOnlyDirsWithDirectMarkdown` (имя и остальные проверки не менять):
+- добавить каталог `File(root, "fakemd").mkdirs()` — имя каталога заканчивается на "md", но .md-файлов
+  внутри него нет; этот каталог НЕ должен попасть в результат (добавить проверку);
+- добавить файл `File(root, "readme.txt").writeText("не markdown")` — не должен ничего менять;
+- в конце теста добавить проверку: результат НЕ содержит `File(root, "fakemd").absolutePath`.
+
+## Дыра 2. memo-core/src/test/kotlin/memo/core/SearcherTest.kt
+
+Мутация `if (mode == SearchMode.LEX || mode == SearchMode.HYBRID)` -> `if (mode == SearchMode.LEX)` ВЫЖИВАЕТ:
+в тесте `hybridCombinesBoth` «смысловой» чанк лексически содержит слова запроса («выпуск приложения»),
+поэтому его находит и чистый BM25, и вклад вектора ничем не доказан.
+
+Дополнить тест `hybridCombinesBoth`:
+- заменить текст второго чанка на такой, у которого НЕТ общих токенов с запросом:
+  запрос оставить `"выпуск приложения 76.132"` (то есть токены: выпуск, приложения, 76, 132),
+  а чанк `/sem.md` сделать: `"Конвейер поставки продуктов: компиляция, испытания, выкладка в кластер"`.
+  Убедиться, что ни один токен запроса (кроме служебных длиной < 2) не встречается в этом тексте;
+- оставить проверку `paths.contains("/exact.md")` и `paths.contains("/sem.md")` — теперь вторая проверка
+  выполнима ТОЛЬКО если векторный список участвует в слиянии.
+Имя теста и остальные тесты не менять.
+
+## Дыра 3. memo-watch/src/test/kotlin/memo/watch/WatcherTest.kt
+
+Мутация `_indexCalls.incrementAndGet()` -> `_indexCalls.get()` в Watcher.kt ВЫЖИВАЕТ:
+тест `modifyTriggersSingleIndexCall` считает вызовы своим собственным AtomicInteger в лямбде `index = {...}`
+и встроенный счётчик `watcher.indexCalls` не проверяет вообще.
+
+Дополнить тест `modifyTriggersSingleIndexCall` (имя и существующие проверки не менять):
+- в конце, рядом с `assertEquals(1, counter.get(), ...)`, добавить:
+  `assertTrue(watcher.indexCalls >= 1, "встроенный счётчик indexCalls не растёт, получено ${watcher.indexCalls}")`.
+
+## Обязательная проверка (приложить вывод)
+
+  cd /root/WORK/memo
+  python3 e2e/mutation_check.py --gradle ./gradlew
+
+Ожидается строка `ВСЕ МУТАЦИИ УБИТЫ` в конце. Если какая-то мутация выжила — доработать тест,
+пока все 13 не будут убиты. Затем:
+
+  ./gradlew test --rerun-tasks
+
+— все тесты зелёные.
+
+Коммит: git add -A && git commit -m "tests: закрыты три дыры в покрытии, найденные мутационным анализом"
+
+СТРОГИЕ ЗАПРЕТЫ:
+- Не выводить план текстом; сразу правь файлы.
+- НЕ менять боевой код ни в memo-core, memo-cli, memo-mcp, memo-watch.
+- Не менять имена тестов, не удалять существующие проверки.
+- Не добавлять зависимости.

e2e/mutation_check.py

@@ -42,19 +42,31 @@ def main() -> int:
         if not line or line.startswith("#"):
             continue
         f, old, new, must_fail = line.split("\t")
-        rows.append((f, old.replace("\\n", "\n"), new.replace("\\n", "\n"), must_fail))
+        old = old.replace("\\n", "\n")
+        new = new.replace("\\n", "\n")
+        # no-op мутация ничего не проверяет — это ошибка таблицы, а не дыра в покрытии.
+        if old == new:
+            print(f"ОШИБКА ТАБЛИЦЫ: no-op мутация для {must_fail} (old == new)")
+            return 2
+        rows.append((f, old, new, must_fail))
 
     print("=== базовая линия (без мутаций) ===")
     base = run_tests(a.gradle)
     print(f"тестов найдено: {len(base)}; упавших: {[k for k, v in base.items() if v == 'FAIL']}")
 
     survivors = []
+    misapplied = 0
     for f, old, new, must_fail in rows:
         backup = f + ".bak"
         shutil.copy2(f, backup)
         try:
             src = open(f, encoding="utf-8").read()
-            assert old in src, f"МУТАЦИЯ НЕ ПРИМЕНИЛАСЬ (нет фрагмента) в {f}: {old[:60]!r}"
+            if old not in src:
+                # Мутация не применилась: фрагмента нет в файле. Это ошибка таблицы,
+                # а не доказательство покрытия — такой прогон ничего не значит.
+                print(f"ОШИБКА ТАБЛИЦЫ | мутация не применилась в {f}: {old[:70]!r}")
+                misapplied += 1
+                continue
             open(f, "w", encoding="utf-8").write(src.replace(old, new, 1))
             st = run_tests(a.gradle)
             got = st.get(must_fail, "НЕ НАЙДЕН")
@@ -74,6 +86,9 @@ def main() -> int:
         for t, f, old, new in survivors:
             print(f" - {t}: {f} `{old[:60]}` -> `{new[:40]}`")
         return 1
+    if misapplied:
+        print(f"\nПРОВАЛ: {misapplied} мутаций не применились — прогон недействителен")
+        return 2
     print("\nВСЕ МУТАЦИИ УБИТЫ")
     return 0
 

e2e/mutations.tsv

@@ -1,5 +1,24 @@
 # file<TAB>old<TAB>new<TAB>must_fail_test
+# Прогон: python3 e2e/mutation_check.py --gradle ./gradlew
+# Правило: мутация обязана уронить ровно тот тест, который её ловит. Выжившая мутация = дыра в покрытии.
+# no-op мутации (old == new) запрещены — харнесс их отклоняет.
+# --- memo-core: ksqlite / FTS5 / vec0 ---
 memo-core/src/test/kotlin/memo/core/CoreSmokeTest.kt	CREATE VIRTUAL TABLE v USING vec0(embedding float[4])	CREATE VIRTUAL TABLE v USING vec0(embedding float[8])	vec0KnnRoundTrip
 memo-core/src/test/kotlin/memo/core/CoreSmokeTest.kt	floatArrayOf(0.1f, 0.9f, 0.0f, 0.0f)	floatArrayOf(0.0f, 0.0f, 0.0f, 1.0f)	vec0KnnRoundTrip
 memo-core/src/test/kotlin/memo/core/CoreSmokeTest.kt	tokenize='unicode61'	tokenize='ascii'	fts5FindsCyrillic
 memo-core/src/test/kotlin/memo/core/CoreSmokeTest.kt	"SELECT a FROM t"	"SELECT a+1 FROM t"	ksqliteSmoke
+# --- Чанкер ---
+memo-core/src/main/kotlin/memo/core/Chunker.kt	Regex("^(#{1,3}) (.*)$")	Regex("^(#+) (.*)$")	fourHashesIsNotAHeading
+memo-core/src/main/kotlin/memo/core/Chunker.kt	val trimmed = body.trim()	val trimmed = body.uppercase()	fourHashesIsNotAHeading
+memo-core/src/main/kotlin/memo/core/Chunker.kt	private const val CHUNK_OVERLAP = 600	private const val CHUNK_OVERLAP = 0	longSectionIsSplitWithOverlap
+# --- Коллекции (дефект тройного обхода, найден на приёмке) ---
+memo-core/src/main/kotlin/memo/core/Collections.kt	it.isFile && it.extension == "md"	it.name.endsWith("md")	findCollectionsReturnsOnlyDirsWithDirectMarkdown
+# --- Индексатор: пропуск неизменённого файла ---
+memo-core/src/main/kotlin/memo/core/Indexer.kt	if (existing.mtime == mtime && existing.size == size) {\n                return false	if (existing.mtime == mtime && existing.size == size) {\n                return true	indexerSkipsUnchangedFile
+# --- Поиск: слияние режимов и ограничение k ---
+memo-core/src/main/kotlin/memo/core/Searcher.kt	if (mode == SearchMode.LEX || mode == SearchMode.HYBRID) lexSearch(query) else emptyList()	if (mode == SearchMode.LEX) lexSearch(query) else emptyList()	hybridCombinesBoth
+memo-core/src/main/kotlin/memo/core/Searcher.kt	.sortedByDescending { it.value }.take(k)	.sortedByDescending { it.value }.take(k + 1)	resultsRespectKAndTextLength
+# --- MCP: ошибка инструмента обязана помечаться isError ---
+memo-mcp/src/main/kotlin/memo/mcp/McpServer.kt	],"isError":true}	],"isError":false}	searchWithoutPathIsError
+# --- Watcher: debounce сводит правки к одному вызову ---
+memo-watch/src/main/kotlin/memo/watch/Watcher.kt	_indexCalls.incrementAndGet()	_indexCalls.get()	modifyTriggersSingleIndexCall

e2e/questions.tsv

@@ -1,7 +1,7 @@
 # Вопросы приёмки T2/T3. Формат: question<TAB>path<TAB>expected_file<TAB>kind
 # kind: sem — смысловой (должен вытянуть вектор), lex — точное значение (должен вытянуть BM25)
 # Ожидаемый файл должен попасть в top-5. Порог: recall@5 >= 16/20 по sem, 3/3 по lex.
-как понять, почему сборка съедает место на диске	infra	work/jira/ci.md	sem
+как понять, почему сборка съедает место на диске	work/jira	work/jira/ci.md	sem
 чем разметить диск, если привычной утилиты нет	infra	infra/servers.md	sem
 на какой карте разрешено ставить опыты	infra	infra/servers.md	sem
 что служит основой для разрешения имён в сети	infra	infra/domains.md	sem
@@ -19,8 +19,8 @@
 до какого правителя доходит первый том	life/books	life/books/history.md	sem
 как я фиксирую цитаты из прочитанного	life/books	life/books/notes.md	sem
 чем слушают книги в очках	life/books	life/books/audiobooks.md	sem
-что запрещено трогать на машине с двумя картами	life/books	infra/servers.md	sem
-где живёт хранилище контейнерных образов	life/books	infra/hosts.md	sem
+что запрещено трогать на машине с двумя картами	infra	infra/servers.md	sem
+где живёт хранилище контейнерных образов	infra	infra/hosts.md	sem
 76.132	infra	infra/hosts.md	lex
 TEST-4173	work/jira	work/jira/flow.md	lex
 192.168.88.35:8080	infra	infra/hosts.md	lex

memo-cli/build.gradle.kts

@@ -1,3 +1,14 @@
 plugins {
     kotlin("jvm")
+    application
+}
+
+application {
+    mainClass.set("memo.cli.MainKt")
+    applicationName = "memo"
+}
+
+dependencies {
+    implementation(project(":memo-core"))
+    testImplementation(kotlin("test"))
 }

memo-cli/src/main/kotlin/memo/cli/Main.kt

@@ -0,0 +1,552 @@
+package memo.cli
+
+import memo.core.Db
+import memo.core.Embedder
+import memo.core.Hit
+import memo.core.Indexer
+import memo.core.RefreshHook
+import memo.core.SearchMode
+import memo.core.Searcher
+import memo.core.findCollections
+import memo.core.resolveCollection
+import java.io.File
+
+sealed interface Cmd
+data class IndexCmd(val path: String) : Cmd
+data class SearchCmd(
+    val path: String,
+    val query: String,
+    val k: Int,
+    val mode: SearchMode,
+    val json: Boolean,
+) : Cmd
+data class StatusCmd(val path: String) : Cmd
+data class McpProbeCmd(val tool: String, val argsJson: String) : Cmd
+data object HelpCmd : Cmd
+
+fun parseArgs(args: Array<String>): Cmd {
+    if (args.isEmpty()) return HelpCmd
+    return when (val cmd = args[0]) {
+        "index" -> {
+            val path = args.getOrNull(1) ?: return HelpCmd
+            IndexCmd(path)
+        }
+        "search" -> parseSearch(args.drop(1))
+        "status" -> {
+            val path = args.getOrNull(1) ?: return HelpCmd
+            StatusCmd(path)
+        }
+        "mcp-probe" -> parseMcpProbe(args.drop(1))
+        "--help", "-h" -> HelpCmd
+        else -> HelpCmd
+    }
+}
+
+private fun parseSearch(rest: List<String>): Cmd {
+    if (rest.size < 2) return HelpCmd
+    val path = rest[0]
+    val query = rest[1]
+    var k = 8
+    var mode = SearchMode.HYBRID
+    var json = false
+    var i = 2
+    while (i < rest.size) {
+        when (val a = rest[i]) {
+            "--k" -> {
+                val v = rest.getOrNull(i + 1) ?: return HelpCmd
+                val n = v.toIntOrNull() ?: return HelpCmd
+                k = n
+                i += 2
+            }
+            "--mode" -> {
+                val v = rest.getOrNull(i + 1) ?: return HelpCmd
+                mode = when (v) {
+                    "hybrid" -> SearchMode.HYBRID
+                    "lex" -> SearchMode.LEX
+                    "vec" -> SearchMode.VEC
+                    else -> return HelpCmd
+                }
+                i += 2
+            }
+            "--json" -> {
+                json = true
+                i += 1
+            }
+            else -> return HelpCmd
+        }
+    }
+    return SearchCmd(path, query, k, mode, json)
+}
+
+private fun parseMcpProbe(rest: List<String>): Cmd {
+    var tool: String? = null
+    var argsJson = "{}"
+    var i = 0
+    while (i < rest.size) {
+        when (rest[i]) {
+            "--tool" -> {
+                tool = rest.getOrNull(i + 1) ?: return HelpCmd
+                i += 2
+            }
+            "--args" -> {
+                argsJson = rest.getOrNull(i + 1) ?: return HelpCmd
+                i += 2
+            }
+            else -> return HelpCmd
+        }
+    }
+    val t = tool ?: return HelpCmd
+    return McpProbeCmd(t, argsJson)
+}
+
+fun main(args: Array<String>) {
+    when (val cmd = parseArgs(args)) {
+        is IndexCmd -> runIndex(cmd)
+        is SearchCmd -> runSearch(cmd)
+        is StatusCmd -> runStatus(cmd)
+        is McpProbeCmd -> runMcpProbe(cmd)
+        HelpCmd -> printHelp()
+    }
+}
+
+private fun printHelp() {
+    println(
+        """
+        usage:
+          memo index <path>
+          memo search <path> <query> [--k N] [--mode hybrid|lex|vec] [--json]
+          memo status <path>
+          memo mcp-probe --tool <name> [--args <json>]
+        """.trimIndent()
+    )
+}
+
+private fun modelPaths(): Pair<String, String> {
+    val modelDir = System.getenv("MEMO_MODEL_DIR") ?: "/root/WORK/memo/models/siglip2"
+    return "$modelDir/text_model_int8.onnx" to "$modelDir/tokenizer.model"
+}
+
+private fun runIndex(cmd: IndexCmd) {
+    val base = resolveCollection(File(cmd.path))
+    val collections = findCollections(base)
+    if (collections.isEmpty()) {
+        System.err.println("коллекции не найдены в ${base.absolutePath}")
+        return
+    }
+    val (modelPath, tokenizerPath) = modelPaths()
+    var totalUpdated = 0
+    for (coll in collections) {
+        val memoDir = File(coll, ".memo")
+        memoDir.mkdirs()
+        val dbPath = File(memoDir, "index.db").absolutePath
+        val totalFiles = coll.walkTopDown()
+            .maxDepth(8)
+            .count { it.isFile && it.extension == "md" }
+        val db = Db(dbPath)
+        try {
+            db.init()
+            val embedder = Embedder(modelPath, tokenizerPath)
+            try {
+                val updated = Indexer(db, embedder).indexTree(coll)
+                println("индексировано: $updated обновлено, $totalFiles файлов всего")
+                totalUpdated += updated
+            } finally {
+                embedder.close()
+            }
+        } finally {
+            db.close()
+        }
+    }
+    println("итого: $totalUpdated обновлено в ${collections.size} коллекциях")
+}
+
+private fun runSearch(cmd: SearchCmd) {
+    val targets = resolveSearchTargets(File(cmd.path))
+    if (targets.isEmpty()) {
+        if (cmd.json) println("[]")
+        else println("коллекции не найдены")
+        return
+    }
+    val (modelPath, tokenizerPath) = modelPaths()
+    val allHits = ArrayList<Hit>()
+    for (coll in targets) {
+        val dbPath = File(coll, ".memo/index.db")
+        if (!dbPath.exists()) continue
+        runCatching {
+            val db = Db(dbPath.absolutePath)
+            try {
+                val embedder = Embedder(modelPath, tokenizerPath)
+                try {
+                    val refresh = RefreshHook { root ->
+                        val innerDbPath = File(root, ".memo/index.db")
+                        if (innerDbPath.exists()) {
+                            val innerDb = Db(innerDbPath.absolutePath)
+                            try {
+                                Indexer(innerDb, embedder).indexTree(root)
+                            } finally {
+                                innerDb.close()
+                            }
+                        }
+                    }
+                    val hits = Searcher(db, embedder, refresh)
+                        .search(coll, cmd.query, cmd.k, cmd.mode)
+                    allHits.addAll(hits)
+                } finally {
+                    embedder.close()
+                }
+            } finally {
+                db.close()
+            }
+        }
+    }
+    val merged = allHits.sortedByDescending { it.score }.take(cmd.k)
+    if (cmd.json) {
+        printJsonHits(merged)
+    } else {
+        for (h in merged) {
+            val text = if (h.text.length > 300) h.text.substring(0, 300) else h.text
+            println(String.format("%.3f  %s:%d  %s", h.score, h.path, h.line, h.heading))
+            for (line in text.lines()) {
+                println("    $line")
+            }
+        }
+    }
+}
+
+private fun resolveSearchTargets(path: File): List<File> {
+    if (path.isFile && path.extension == "md") {
+        return listOfNotNull(path.parentFile)
+    }
+    if (File(path, ".memo/index.db").exists()) {
+        return listOf(path)
+    }
+    val subs = path.listFiles()
+        ?.filter { it.isDirectory && File(it, ".memo/index.db").exists() }
+        ?: emptyList()
+    return subs
+}
+
+private fun runStatus(cmd: StatusCmd) {
+    val base = resolveCollection(File(cmd.path))
+    val collections = if (File(base, ".memo/index.db").exists()) {
+        listOf(base)
+    } else {
+        findCollections(base)
+    }
+    if (collections.isEmpty()) {
+        println("коллекции не найдены")
+        return
+    }
+    for (coll in collections) {
+        val dbPath = File(coll, ".memo/index.db")
+        if (!dbPath.exists()) {
+            println("${coll.name}: нет индекса")
+            continue
+        }
+        val db = Db(dbPath.absolutePath)
+        try {
+            val fileCount = countInt(db, "SELECT COUNT(*) FROM files")
+            val chunkCount = countInt(db, "SELECT COUNT(*) FROM chunks")
+            val indexedAt = maxDouble(db, "SELECT indexed_at FROM files WHERE indexed_at IS NOT NULL")
+            val date = if (indexedAt != null) {
+                java.time.Instant.ofEpochSecond(indexedAt.toLong()).toString()
+            } else {
+                "—"
+            }
+            println("$coll: файлов $fileCount, чанков $chunkCount, индекс $date")
+        } finally {
+            db.close()
+        }
+    }
+}
+
+private fun countInt(db: Db, sql: String): Int {
+    val stmt = db.conn.prepare(sql)
+    return try {
+        val rs = stmt.executeQuery()
+        try {
+            if (rs.next()) rs.getInt(0) ?: 0 else 0
+        } finally {
+            rs.close()
+        }
+    } finally {
+        stmt.close()
+    }
+}
+
+private fun maxDouble(db: Db, sql: String): Double? {
+    val stmt = db.conn.prepare(sql)
+    return try {
+        val rs = stmt.executeQuery()
+        try {
+            var best: Double? = null
+            while (rs.next()) {
+                val v = rs.getDouble(0) ?: continue
+                if (best == null || v > best) best = v
+            }
+            best
+        } finally {
+            rs.close()
+        }
+    } finally {
+        stmt.close()
+    }
+}
+
+private fun runMcpProbe(cmd: McpProbeCmd) {
+    when (cmd.tool) {
+        "memo_reindex" -> printMcpError("not implemented yet")
+        "memo_search" -> {
+            val args = parseJsonArgs(cmd.argsJson)
+            val path = (args["path"] as? String) ?: ""
+            val query = (args["query"] as? String) ?: ""
+            val k = (args["k"] as? Number)?.toInt() ?: 8
+            val mode = when (args["mode"] as? String) {
+                "lex" -> SearchMode.LEX
+                "vec" -> SearchMode.VEC
+                else -> SearchMode.HYBRID
+            }
+            val jsonOutput = (args["json"] as? Boolean) ?: true
+            val hits = performSearch(path, query, k, mode)
+            val text = if (jsonOutput) formatHitsJson(hits) else formatHitsHuman(hits)
+            printMcpOk(text)
+        }
+        "memo_status" -> {
+            val args = parseJsonArgs(cmd.argsJson)
+            val path = (args["path"] as? String) ?: ""
+            val text = formatStatusInner(path)
+            printMcpOk(text)
+        }
+        else -> printMcpError("unknown tool: ${cmd.tool}")
+    }
+}
+
+private fun performSearch(path: String, query: String, k: Int, mode: SearchMode): List<Hit> {
+    val targets = resolveSearchTargets(File(path))
+    if (targets.isEmpty()) return emptyList()
+    val (modelPath, tokenizerPath) = modelPaths()
+    val allHits = ArrayList<Hit>()
+    for (coll in targets) {
+        val dbPath = File(coll, ".memo/index.db")
+        if (!dbPath.exists()) continue
+        runCatching {
+            val db = Db(dbPath.absolutePath)
+            try {
+                val embedder = Embedder(modelPath, tokenizerPath)
+                try {
+                    val refresh = RefreshHook { root ->
+                        val innerDbPath = File(root, ".memo/index.db")
+                        if (innerDbPath.exists()) {
+                            val innerDb = Db(innerDbPath.absolutePath)
+                            try {
+                                Indexer(innerDb, embedder).indexTree(root)
+                            } finally {
+                                innerDb.close()
+                            }
+                        }
+                    }
+                    val hits = Searcher(db, embedder, refresh)
+                        .search(coll, query, k, mode)
+                    allHits.addAll(hits)
+                } finally {
+                    embedder.close()
+                }
+            } finally {
+                db.close()
+            }
+        }
+    }
+    return allHits.sortedByDescending { it.score }.take(k)
+}
+
+private fun formatStatusInner(path: String): String {
+    val base = resolveCollection(File(path))
+    val collections = if (File(base, ".memo/index.db").exists()) {
+        listOf(base)
+    } else {
+        findCollections(base)
+    }
+    if (collections.isEmpty()) return "коллекции не найдены"
+    val sb = StringBuilder()
+    for (coll in collections) {
+        val dbPath = File(coll, ".memo/index.db")
+        if (!dbPath.exists()) {
+            sb.append("${coll.name}: нет индекса\n")
+            continue
+        }
+        val db = Db(dbPath.absolutePath)
+        try {
+            val fileCount = countInt(db, "SELECT COUNT(*) FROM files")
+            val chunkCount = countInt(db, "SELECT COUNT(*) FROM chunks")
+            val indexedAt = maxDouble(db, "SELECT indexed_at FROM files WHERE indexed_at IS NOT NULL")
+            val date = if (indexedAt != null) {
+                java.time.Instant.ofEpochSecond(indexedAt.toLong()).toString()
+            } else {
+                "—"
+            }
+            sb.append("$coll: файлов $fileCount, чанков $chunkCount, индекс $date\n")
+        } finally {
+            db.close()
+        }
+    }
+    return sb.toString().trimEnd('\n')
+}
+
+private fun printJsonHits(hits: List<Hit>) {
+    println(formatHitsJson(hits))
+}
+
+private fun formatHitsJson(hits: List<Hit>): String {
+    val sb = StringBuilder()
+    sb.append('[')
+    for ((i, h) in hits.withIndex()) {
+        if (i > 0) sb.append(',')
+        sb.append('{')
+        sb.append("\"path\":").append(jsonStr(h.path)).append(',')
+        sb.append("\"line\":").append(h.line).append(',')
+        sb.append("\"heading\":").append(jsonStr(h.heading)).append(',')
+        sb.append("\"score\":").append("%.6f".format(h.score)).append(',')
+        sb.append("\"text\":").append(jsonStr(h.text))
+        sb.append('}')
+    }
+    sb.append(']')
+    return sb.toString()
+}
+
+private fun formatHitsHuman(hits: List<Hit>): String {
+    val sb = StringBuilder()
+    for (h in hits) {
+        val text = if (h.text.length > 300) h.text.substring(0, 300) else h.text
+        sb.append(String.format("%.3f  %s:%d  %s", h.score, h.path, h.line, h.heading))
+        sb.append('\n')
+        for (line in text.lines()) {
+            sb.append("    ").append(line).append('\n')
+        }
+    }
+    return sb.toString().trimEnd('\n')
+}
+
+private fun jsonStr(s: String): String {
+    val sb = StringBuilder(s.length + 2)
+    sb.append('"')
+    for (c in s) {
+        when (c) {
+            '"' -> sb.append("\\\"")
+            '\\' -> sb.append("\\\\")
+            '\n' -> sb.append("\\n")
+            '\r' -> sb.append("\\r")
+            '\t' -> sb.append("\\t")
+            '\b' -> sb.append("\\b")
+            '\u000C' -> sb.append("\\f")
+            else -> if (c.code < 0x20) {
+                sb.append("\\u%04x".format(c.code))
+            } else {
+                sb.append(c)
+            }
+        }
+    }
+    sb.append('"')
+    return sb.toString()
+}
+
+private fun printMcpOk(text: String) {
+    println("""{"content":[{"type":"text","text":${jsonStr(text)}}],"isError":false}""")
+}
+
+private fun printMcpError(text: String) {
+    println("""{"content":[{"type":"text","text":${jsonStr(text)}}],"isError":true}""")
+}
+
+private fun parseJsonArgs(json: String): Map<String, Any?> {
+    val map = HashMap<String, Any?>()
+    val trimmed = json.trim()
+    if (trimmed.isEmpty() || trimmed == "{}") return map
+    val inner = trimmed.trim().removePrefix("{").removeSuffix("}")
+    if (inner.isBlank()) return map
+    var i = 0
+    while (i < inner.length) {
+        while (i < inner.length && inner[i].isWhitespace()) i++
+        if (i >= inner.length) break
+        if (inner[i] != '"') return map
+        val keyEnd = readJsonString(inner, i)
+        val key = unescapeJson(inner.substring(i + 1, keyEnd))
+        i = keyEnd + 1
+        while (i < inner.length && inner[i].isWhitespace()) i++
+        if (i >= inner.length || inner[i] != ':') return map
+        i++
+        while (i < inner.length && inner[i].isWhitespace()) i++
+        if (i >= inner.length) return map
+        val (value, next) = readJsonValue(inner, i)
+        map[key] = value
+        i = next
+        while (i < inner.length && inner[i].isWhitespace()) i++
+        if (i < inner.length && inner[i] == ',') i++
+    }
+    return map
+}
+
+private fun readJsonString(s: String, start: Int): Int {
+    var i = start + 1
+    while (i < s.length) {
+        if (s[i] == '\\') {
+            i += 2
+            continue
+        }
+        if (s[i] == '"') return i
+        i++
+    }
+    return s.length
+}
+
+private fun readJsonValue(s: String, start: Int): Pair<Any?, Int> {
+    val c = s[start]
+    return when {
+        c == '"' -> {
+            val end = readJsonString(s, start)
+            unescapeJson(s.substring(start + 1, end)) to (end + 1)
+        }
+        c == 't' && s.regionMatches(start, "true", 0, 4) -> true to (start + 4)
+        c == 'f' && s.regionMatches(start, "false", 0, 5) -> false to (start + 5)
+        c == 'n' && s.regionMatches(start, "null", 0, 4) -> null to (start + 4)
+        c == '-' || c.isDigit() -> {
+            var i = start
+            while (i < s.length && (s[i].isDigit() || s[i] == '-' || s[i] == '+' || s[i] == '.' || s[i] == 'e' || s[i] == 'E')) i++
+            val raw = s.substring(start, i)
+            val num = raw.toDoubleOrNull() ?: raw
+            num to i
+        }
+        else -> null to (start + 1)
+    }
+}
+
+private fun unescapeJson(s: String): String {
+    val sb = StringBuilder(s.length)
+    var i = 0
+    while (i < s.length) {
+        val c = s[i]
+        if (c == '\\' && i + 1 < s.length) {
+            when (s[i + 1]) {
+                '"' -> sb.append('"')
+                '\\' -> sb.append('\\')
+                '/' -> sb.append('/')
+                'n' -> sb.append('\n')
+                'r' -> sb.append('\r')
+                't' -> sb.append('\t')
+                'b' -> sb.append('\b')
+                'f' -> sb.append('\u000C')
+                'u' -> {
+                    if (i + 5 < s.length) {
+                        val hex = s.substring(i + 2, i + 6)
+                        sb.append(hex.toInt(16).toChar())
+                        i += 4
+                    }
+                }
+            }
+            i += 2
+        } else {
+            sb.append(c)
+            i++
+        }
+    }
+    return sb.toString()
+}

memo-cli/src/test/kotlin/memo/cli/CliArgsTest.kt

@@ -0,0 +1,48 @@
+package memo.cli
+
+import memo.core.SearchMode
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class CliArgsTest {
+
+    @Test
+    fun indexCommandParsed() {
+        val cmd = parseArgs(arrayOf("index", "/tmp/x"))
+        assertTrue(cmd is IndexCmd, "ожидался IndexCmd, получено $cmd")
+        assertEquals("/tmp/x", cmd.path)
+    }
+
+    @Test
+    fun searchDefaultsAreK8HybridNoJson() {
+        val cmd = parseArgs(arrayOf("search", "/tmp/x", "вопрос"))
+        assertTrue(cmd is SearchCmd, "ожидался SearchCmd, получено $cmd")
+        assertEquals(8, cmd.k)
+        assertEquals(SearchMode.HYBRID, cmd.mode)
+        assertEquals(false, cmd.json)
+    }
+
+    @Test
+    fun searchFlagsParsed() {
+        val cmd = parseArgs(
+            arrayOf("search", "/tmp/x", "вопрос", "--k", "3", "--mode", "lex", "--json")
+        )
+        assertTrue(cmd is SearchCmd, "ожидался SearchCmd, получено $cmd")
+        assertEquals(3, cmd.k)
+        assertEquals(SearchMode.LEX, cmd.mode)
+        assertEquals(true, cmd.json)
+    }
+
+    @Test
+    fun badKValueFallsBackToHelp() {
+        val cmd = parseArgs(arrayOf("search", "/tmp/x", "вопрос", "--k", "abc"))
+        assertTrue(cmd is HelpCmd, "ожидался HelpCmd, получено $cmd")
+    }
+
+    @Test
+    fun unknownCommandFallsBackToHelp() {
+        val cmd = parseArgs(arrayOf("сломать"))
+        assertTrue(cmd is HelpCmd, "ожидался HelpCmd, получено $cmd")
+    }
+}

memo-core/build.gradle.kts

@@ -3,7 +3,7 @@ plugins {
 }
 
 dependencies {
-    implementation("pw.binom.db:ksqlite:0.1.4")
+    api("pw.binom.db:ksqlite:0.1.4")
     implementation("pw.binom.ai.embeddingtext:api:5")
     runtimeOnly("pw.binom.ai.embeddingtext:siglip-jvm:5")
 

memo-core/src/main/kotlin/memo/core/Chunker.kt

@@ -0,0 +1,78 @@
+package memo.core
+
+data class Chunk(
+    val heading: String,
+    val line: Int,
+    val text: String,
+    val ord: Int,
+)
+
+private const val CHUNK_SIZE = 4000
+private const val CHUNK_OVERLAP = 600
+
+private val HEADING_REGEX = Regex("^(#{1,3}) (.*)$")
+
+fun chunkMarkdown(text: String): List<Chunk> {
+    val sections = mutableListOf<Triple<String, Int, String>>()
+
+    var currentHeading = ""
+    var currentLine = 1
+    val currentBody = StringBuilder()
+
+    val preamble = StringBuilder()
+    var foundHeading = false
+
+    fun flush(heading: String, line: Int, body: String) {
+        val trimmed = body.trim()
+        if (trimmed.isNotEmpty()) {
+            sections.add(Triple(heading, line, trimmed))
+        }
+    }
+
+    val lines = text.split('\n')
+    for ((idx, raw) in lines.withIndex()) {
+        val lineNo = idx + 1
+        val match = HEADING_REGEX.matchEntire(raw)
+        if (match != null) {
+            if (!foundHeading) {
+                flush("", 1, preamble.toString())
+                foundHeading = true
+            } else {
+                flush(currentHeading, currentLine, currentBody.toString())
+            }
+            currentHeading = match.groupValues[2].trim()
+            currentLine = lineNo
+            currentBody.setLength(0)
+        } else {
+            if (foundHeading) {
+                currentBody.append(raw).append('\n')
+            } else {
+                preamble.append(raw).append('\n')
+            }
+        }
+    }
+
+    if (foundHeading) {
+        flush(currentHeading, currentLine, currentBody.toString())
+    } else {
+        flush("", 1, preamble.toString())
+    }
+
+    val result = mutableListOf<Chunk>()
+    var ord = 0
+    for ((heading, line, body) in sections) {
+        if (body.length <= CHUNK_SIZE) {
+            result.add(Chunk(heading, line, body, ord++))
+        } else {
+            val step = CHUNK_SIZE - CHUNK_OVERLAP
+            var i = 0
+            while (i < body.length) {
+                val end = minOf(i + CHUNK_SIZE, body.length)
+                result.add(Chunk(heading, line, body.substring(i, end), ord++))
+                if (end == body.length) break
+                i += step
+            }
+        }
+    }
+    return result
+}

memo-core/src/main/kotlin/memo/core/Collections.kt

@@ -0,0 +1,32 @@
+package memo.core
+
+import java.io.File
+
+fun isCollection(dir: File): Boolean {
+    if (!dir.isDirectory) return false
+    return dir.listFiles()?.any { it.isFile && it.extension == "md" } == true
+}
+
+fun resolveCollection(path: File): File {
+    if (path.isFile) return path.parentFile ?: path
+    if (isCollection(path)) return path
+    val descendants = findCollections(path)
+    if (descendants.size == 1) return descendants[0]
+    return path
+}
+
+fun findCollections(root: File): List<File> {
+    if (!root.isDirectory) return emptyList()
+    val result = LinkedHashSet<File>()
+    fun walk(d: File) {
+        if (isCollection(d)) result.add(d)
+        val children = d.listFiles() ?: return
+        for (c in children) {
+            if (c.isDirectory && !c.name.startsWith(".")) {
+                walk(c)
+            }
+        }
+    }
+    walk(root)
+    return result.sortedBy { it.absolutePath }
+}

memo-core/src/main/kotlin/memo/core/Indexer.kt

@@ -0,0 +1,196 @@
+package memo.core
+
+import java.io.File
+import java.security.MessageDigest
+
+class Indexer(private val db: Db, private val embedder: Embedder) {
+
+    fun indexFile(path: File): Boolean {
+        val absPath = path.absolutePath
+        val mtime = path.lastModified() / 1000.0
+        val size = path.length()
+
+        val existing = readFileRecord(absPath)
+        if (existing != null) {
+            if (existing.mtime == mtime && existing.size == size) {
+                return false
+            }
+            val content = path.readText()
+            val newHash = sha256Hex(content)
+            if (existing.hash == newHash) {
+                updateFileTouched(absPath, mtime, size)
+                return false
+            }
+            reindex(absPath, content, mtime, size, newHash)
+            return true
+        }
+
+        val content = path.readText()
+        val hash = sha256Hex(content)
+        reindex(absPath, content, mtime, size, hash)
+        return true
+    }
+
+    fun indexTree(root: File): Int {
+        var count = 0
+        walk(root) { f ->
+            if (f.isFile && f.extension == "md") {
+                if (indexFile(f)) count++
+            }
+        }
+        return count
+    }
+
+    private fun walk(dir: File, action: (File) -> Unit) {
+        if (!dir.isDirectory) return
+        val children = dir.listFiles() ?: return
+        for (child in children) {
+            if (child.isDirectory) {
+                if (child.name.startsWith(".")) continue
+                walk(child, action)
+            } else {
+                action(child)
+            }
+        }
+    }
+
+    private data class FileRecord(val mtime: Double, val size: Long, val hash: String)
+
+    private fun readFileRecord(absPath: String): FileRecord? {
+        val stmt = db.conn.prepare("SELECT mtime, size, hash FROM files WHERE path = ?")
+        return try {
+            stmt.bindText(1, absPath)
+            val rs = stmt.executeQuery()
+            try {
+                if (rs.next()) {
+                    FileRecord(rs.getDouble(0)!!, rs.getLong(1)!!, rs.getText(2)!!)
+                } else {
+                    null
+                }
+            } finally {
+                rs.close()
+            }
+        } finally {
+            stmt.close()
+        }
+    }
+
+    private fun updateFileTouched(absPath: String, mtime: Double, size: Long) {
+        val stmt = db.conn.prepare(
+            "UPDATE files SET mtime = ?, size = ?, indexed_at = ? WHERE path = ?"
+        )
+        try {
+            stmt.bindDouble(1, mtime)
+            stmt.bindLong(2, size)
+            stmt.bindDouble(3, System.currentTimeMillis() / 1000.0)
+            stmt.bindText(4, absPath)
+            stmt.executeUpdate()
+        } finally {
+            stmt.close()
+        }
+    }
+
+    private fun reindex(
+        absPath: String,
+        content: String,
+        mtime: Double,
+        size: Long,
+        hash: String,
+    ) {
+        val conn = db.conn
+        conn.beginTransaction()
+        try {
+            val delFts = conn.prepare(
+                "DELETE FROM chunks_fts WHERE rowid IN (SELECT id FROM chunks WHERE path = ?)"
+            )
+            delFts.bindText(1, absPath)
+            delFts.executeUpdate()
+            delFts.close()
+
+            val delVec = conn.prepare(
+                "DELETE FROM chunks_vec WHERE rowid IN (SELECT id FROM chunks WHERE path = ?)"
+            )
+            delVec.bindText(1, absPath)
+            delVec.executeUpdate()
+            delVec.close()
+
+            val delChunks = conn.prepare("DELETE FROM chunks WHERE path = ?")
+            delChunks.bindText(1, absPath)
+            delChunks.executeUpdate()
+            delChunks.close()
+
+            val chunks = chunkMarkdown(content)
+            val insChunk = conn.prepare(
+                "INSERT INTO chunks(path, heading, line, ord, text, hash) VALUES (?, ?, ?, ?, ?, ?)"
+            )
+            val insFts = conn.prepare(
+                "INSERT INTO chunks_fts(rowid, text, heading) VALUES (?, ?, ?)"
+            )
+            val insVec = conn.prepare(
+                "INSERT INTO chunks_vec(rowid, embedding) VALUES (?, ?)"
+            )
+            try {
+                for (chunk in chunks) {
+                    val embedding = embedder.embed(chunk.text)
+                    val chunkHash = sha256Hex(chunk.text)
+                    insChunk.reset()
+                    insChunk.bindText(1, absPath)
+                    insChunk.bindText(2, chunk.heading)
+                    insChunk.bindLong(3, chunk.line.toLong())
+                    insChunk.bindLong(4, chunk.ord.toLong())
+                    insChunk.bindText(5, chunk.text)
+                    insChunk.bindText(6, chunkHash)
+                    insChunk.executeUpdate()
+                    val id = conn.lastInsertRowId
+                    insFts.reset()
+                    insFts.bindLong(1, id)
+                    insFts.bindText(2, chunk.text)
+                    insFts.bindText(3, chunk.heading)
+                    insFts.executeUpdate()
+                    insVec.reset()
+                    insVec.bindLong(1, id)
+                    insVec.bindVector(2, embedding)
+                    insVec.executeUpdate()
+                }
+            } finally {
+                insChunk.close()
+                insFts.close()
+                insVec.close()
+            }
+
+            val upsert = conn.prepare(
+                "INSERT INTO files(path, mtime, size, hash, indexed_at) VALUES (?, ?, ?, ?, ?) " +
+                    "ON CONFLICT(path) DO UPDATE SET " +
+                    "mtime = excluded.mtime, size = excluded.size, " +
+                    "hash = excluded.hash, indexed_at = excluded.indexed_at"
+            )
+            try {
+                upsert.bindText(1, absPath)
+                upsert.bindDouble(2, mtime)
+                upsert.bindLong(3, size)
+                upsert.bindText(4, hash)
+                upsert.bindDouble(5, System.currentTimeMillis() / 1000.0)
+                upsert.executeUpdate()
+            } finally {
+                upsert.close()
+            }
+
+            conn.commit()
+        } catch (t: Throwable) {
+            conn.rollback()
+            throw t
+        }
+    }
+
+    private fun sha256Hex(text: String): String {
+        val md = MessageDigest.getInstance("SHA-256")
+        val bytes = md.digest(text.toByteArray(Charsets.UTF_8))
+        val sb = StringBuilder(bytes.size * 2)
+        for (b in bytes) {
+            val v = b.toInt() and 0xFF
+            sb.append((v ushr 4).toString(16))
+            sb.append((v and 0xF).toString(16))
+        }
+        return sb.toString()
+    }
+}

memo-core/src/main/kotlin/memo/core/Searcher.kt

@@ -0,0 +1,157 @@
+package memo.core
+
+import java.io.File
+
+enum class SearchMode { HYBRID, LEX, VEC }
+
+data class Hit(
+    val path: String,
+    val line: Int,
+    val heading: String,
+    val score: Double,
+    val text: String,
+)
+
+fun interface RefreshHook { fun refresh(root: File) }
+
+class Searcher(
+    private val db: Db,
+    private val embedder: Embedder,
+    private val refresh: RefreshHook? = null,
+) {
+    fun search(
+        root: File,
+        query: String,
+        k: Int = 8,
+        mode: SearchMode = SearchMode.HYBRID,
+    ): List<Hit> {
+        if (refresh != null) {
+            refresh.refresh(root)
+        }
+
+        val lexRows: List<Pair<Long, Double>> =
+            if (mode == SearchMode.LEX || mode == SearchMode.HYBRID) lexSearch(query) else emptyList()
+        val vecRows: List<Pair<Long, Double>> =
+            if (mode == SearchMode.VEC || mode == SearchMode.HYBRID) vecSearch(query) else emptyList()
+
+        val scores = HashMap<Long, Double>()
+        for ((idx, row) in lexRows.withIndex()) {
+            val rank = idx + 1
+            scores.merge(row.first, 1.0 / (60.0 + rank), Double::plus)
+        }
+        for ((idx, row) in vecRows.withIndex()) {
+            val rank = idx + 1
+            scores.merge(row.first, 1.0 / (60.0 + rank), Double::plus)
+        }
+
+        if (scores.isEmpty()) return emptyList()
+
+        val topEntries = scores.entries.sortedByDescending { it.value }.take(k)
+        val orderedRowids = topEntries.map { it.key }
+        val scoreByRowid = orderedRowids.associateWith { scores[it]!! }
+
+        val placeholders = orderedRowids.joinToString(",") { "?" }
+        val select = db.conn.prepare(
+            "SELECT id, path, line, heading, text FROM chunks WHERE id IN ($placeholders)"
+        )
+        val rowData = HashMap<Long, RowData>()
+        try {
+            for ((idx, id) in orderedRowids.withIndex()) {
+                select.bindLong(idx + 1, id)
+            }
+            val rs = select.executeQuery()
+            try {
+                while (rs.next()) {
+                    val id = rs.getLong(0)!!
+                    val path = rs.getText(1) ?: ""
+                    val line = rs.getInt(2)!!
+                    val heading = rs.getText(3) ?: ""
+                    val textRaw = rs.getText(4) ?: ""
+                    val text = if (textRaw.length > 1200) textRaw.substring(0, 1200) else textRaw
+                    rowData[id] = RowData(path, line, heading, text)
+                }
+            } finally {
+                rs.close()
+            }
+        } finally {
+            select.close()
+        }
+
+        return orderedRowids.mapNotNull { id ->
+            val rd = rowData[id] ?: return@mapNotNull null
+            Hit(
+                path = rd.path,
+                line = rd.line,
+                heading = rd.heading,
+                score = scoreByRowid[id] ?: 0.0,
+                text = rd.text,
+            )
+        }
+    }
+
+    private fun lexSearch(query: String): List<Pair<Long, Double>> {
+        val tokens = tokensOf(query)
+        if (tokens.isEmpty()) return emptyList()
+        val matchExpr = tokens.joinToString(" OR ") { "\"$it\"" }
+        val stmt = db.conn.prepare(
+            "SELECT rowid, bm25(chunks_fts) AS s FROM chunks_fts " +
+                "WHERE chunks_fts MATCH ? ORDER BY s LIMIT 32"
+        )
+        return try {
+            stmt.bindText(1, matchExpr)
+            val rs = stmt.executeQuery()
+            try {
+                val out = ArrayList<Pair<Long, Double>>()
+                while (rs.next()) {
+                    out.add(rs.getLong(0)!! to rs.getDouble(1)!!)
+                }
+                out
+            } finally {
+                rs.close()
+            }
+        } catch (_: Throwable) {
+            emptyList()
+        } finally {
+            stmt.close()
+        }
+    }
+
+    private fun vecSearch(query: String): List<Pair<Long, Double>> {
+        val stmt = db.conn.prepare(
+            "SELECT rowid, distance FROM chunks_vec " +
+                "WHERE embedding MATCH ? ORDER BY distance LIMIT 32"
+        )
+        return try {
+            stmt.bindVector(1, embedder.embed(query))
+            val rs = stmt.executeQuery()
+            try {
+                val out = ArrayList<Pair<Long, Double>>()
+                while (rs.next()) {
+                    out.add(rs.getLong(0)!! to rs.getDouble(1)!!)
+                }
+                out
+            } finally {
+                rs.close()
+            }
+        } finally {
+            stmt.close()
+        }
+    }
+
+    private data class RowData(val path: String, val line: Int, val heading: String, val text: String)
+}
+
+private fun tokensOf(query: String): List<String> {
+    val tokens = ArrayList<String>()
+    val sb = StringBuilder()
+    for (ch in query) {
+        if (Character.isLetterOrDigit(ch)) {
+            sb.append(ch)
+        } else {
+            if (sb.length >= 2) tokens.add(sb.toString())
+            sb.setLength(0)
+        }
+    }
+    if (sb.length >= 2) tokens.add(sb.toString())
+    return if (tokens.size <= 8) tokens else tokens.subList(0, 8)
+}

memo-core/src/test/kotlin/memo/core/ChunkerTest.kt

@@ -0,0 +1,60 @@
+package memo.core
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ChunkerTest {
+
+    @Test
+    fun splitsByHeadingLevels() {
+        val input = "# A\nbodyA\n## B\nbodyB\n### C\nbodyC"
+        val chunks = chunkMarkdown(input)
+        assertEquals(3, chunks.size)
+        assertEquals(listOf("A", "B", "C"), chunks.map { it.heading })
+        assertEquals(listOf(1, 3, 5), chunks.map { it.line })
+        assertEquals(listOf(0, 1, 2), chunks.map { it.ord })
+    }
+
+    @Test
+    fun textBeforeFirstHeadingBecomesChunkWithEmptyHeading() {
+        val input = "преамбула\n# Заголовок\nтело"
+        val chunks = chunkMarkdown(input)
+        assertEquals(2, chunks.size)
+        assertEquals("", chunks[0].heading)
+        assertEquals(1, chunks[0].line)
+        assertEquals("Заголовок", chunks[1].heading)
+    }
+
+    @Test
+    fun fourHashesIsNotAHeading() {
+        val input = "# A\nbody\n#### не заголовок\nmore"
+        val chunks = chunkMarkdown(input)
+        assertEquals(1, chunks.size)
+        assertEquals("A", chunks[0].heading)
+        assertTrue(chunks[0].text.contains("#### не заголовок"))
+        assertTrue(chunks[0].text.contains("more"))
+    }
+
+    @Test
+    fun emptySectionsAreDropped() {
+        val input = "# A\nsome text\n## B\n## C"
+        val chunks = chunkMarkdown(input)
+        assertEquals(1, chunks.size)
+        assertEquals("A", chunks[0].heading)
+    }
+
+    @Test
+    fun longSectionIsSplitWithOverlap() {
+        val body = "а".repeat(6000)
+        val input = "# A\n$body"
+        val chunks = chunkMarkdown(input)
+        assertEquals(2, chunks.size)
+        assertEquals(4000, chunks[0].text.length)
+        assertEquals(2600, chunks[1].text.length)
+        assertEquals(
+            chunks[0].text.substring(4000 - 600),
+            chunks[1].text.substring(0, 600),
+        )
+    }
+}

memo-core/src/test/kotlin/memo/core/CollectionsTest.kt

@@ -0,0 +1,88 @@
+package memo.core
+
+import java.io.File
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class CollectionsTest {
+
+    private fun newRoot(): File {
+        val root = File.createTempFile("memo-collections-", "")
+        assertTrue(root.delete(), "temp cleanup")
+        assertTrue(root.mkdirs(), "temp mkdir")
+        root.deleteOnExit()
+        return root
+    }
+
+    private fun touch(parent: File, vararg rel: String): File {
+        var cur = parent
+        for (seg in rel.dropLast(1)) {
+            cur = File(cur, seg)
+            cur.mkdirs()
+        }
+        val f = File(cur, rel.last())
+        f.writeText("# ${rel.last()}\n")
+        f.deleteOnExit()
+        return f
+    }
+
+    @Test
+    fun findCollectionsReturnsOnlyDirsWithDirectMarkdown() {
+        val root = newRoot()
+        touch(root, "a.md")
+        touch(root, "sub", "b.md")
+        touch(root, "sub", "deep", "c.md")
+        File(root, "empty").mkdirs()
+        touch(root, "nested", "only", "deep", "d.md")
+        File(root, "fakemd").mkdirs()
+        File(root, "fakemd/submd").mkdirs()
+        File(root, "readme.txt").writeText("не markdown")
+
+        val got = findCollections(root).map { it.absolutePath }.toSet()
+        val want = setOf(
+            root.absolutePath,
+            File(root, "sub").absolutePath,
+            File(root, "sub/deep").absolutePath,
+            File(root, "nested/only/deep").absolutePath,
+        )
+        assertEquals(want, got)
+        assertTrue(File(root, "empty").absolutePath !in got, "empty must not be a collection")
+        assertTrue(File(root, "nested").absolutePath !in got, "nested must not be a collection")
+        assertTrue(File(root, "nested/only").absolutePath !in got, "nested/only must not be a collection")
+        assertTrue(File(root, "fakemd").absolutePath !in got, "fakemd must not be a collection")
+    }
+
+    @Test
+    fun parentDirWithoutDirectMarkdownIsNotCollection() {
+        val root = newRoot()
+        touch(root, "top", "inner", "x.md")
+
+        val got = findCollections(root).map { it.absolutePath }.toSet()
+        assertEquals(setOf(File(root, "top/inner").absolutePath), got)
+    }
+
+    @Test
+    fun resolveCollectionRaisesToNearestWithMarkdown() {
+        val root = newRoot()
+        val note = touch(root, "top", "inner", "x.md")
+
+        val fileResult = resolveCollection(note)
+        assertEquals(File(root, "top/inner").absolutePath, fileResult.absolutePath)
+
+        val dirResult = resolveCollection(File(root, "top"))
+        assertEquals(File(root, "top/inner").absolutePath, dirResult.absolutePath)
+    }
+
+    @Test
+    fun hiddenDirsAreSkipped() {
+        val root = newRoot()
+        touch(root, ".hidden", "a.md")
+        touch(root, "vis", "b.md")
+        File(root, ".memo").mkdirs()
+        File(File(root, ".memo"), "index.db").writeText("")
+
+        val got = findCollections(root).map { it.absolutePath }.toSet()
+        assertEquals(setOf(File(root, "vis").absolutePath), got)
+    }
+}

memo-core/src/test/kotlin/memo/core/CoreSmokeTest.kt

@@ -3,6 +3,7 @@ package memo.core
 import java.io.File
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import kotlin.test.fail
 import pw.binom.db.ksqlite.SQLiteConnection
@@ -180,4 +181,56 @@ class CoreSmokeTest {
             assertTrue(v.none { it.isNaN() }, "embedding contains NaN")
         }
     }
+
+    @Test
+    fun indexerSkipsUnchangedFile() {
+        val tempDir = File.createTempFile("memo-indexer-", "")
+        assertTrue(tempDir.delete(), "temp dir cleanup")
+        assertTrue(tempDir.mkdir(), "temp dir create")
+        tempDir.deleteOnExit()
+
+        val note = File(tempDir, "note.md")
+        note.writeText("# Заголовок\nтело заметки\n## Второй\nещё текст")
+        note.deleteOnExit()
+
+        val dbFile = File(tempDir, "index.db")
+        dbFile.deleteOnExit()
+
+        val modelDir = System.getenv("MEMO_MODEL_DIR") ?: "/root/WORK/memo/models/siglip2"
+        val modelPath = "$modelDir/text_model_int8.onnx"
+        val tokenizerPath = "$modelDir/tokenizer.model"
+
+        Db(dbFile.absolutePath).use { db ->
+            db.init()
+            Embedder(modelPath, tokenizerPath).use { embedder ->
+                val indexer = Indexer(db, embedder)
+
+                assertTrue(indexer.indexFile(note), "первый indexFile обязан переиндексировать")
+                assertFalse(
+                    indexer.indexFile(note),
+                    "второй indexFile без изменений обязан вернуть false",
+                )
+
+                note.appendText("\n## Третий\nновый текст\n")
+                assertTrue(
+                    indexer.indexFile(note),
+                    "indexFile после изменения содержимого обязан вернуть true",
+                )
+
+                val stmt = db.conn.prepare("SELECT count(*) FROM chunks")
+                try {
+                    val rs = stmt.executeQuery()
+                    try {
+                        assertTrue(rs.next(), "SELECT count(*) должен вернуть строку")
+                        val count = rs.getLong(0)!!
+                        assertTrue(count > 0, "ожидались чанки, получено $count")
+                    } finally {
+                        rs.close()
+                    }
+                } finally {
+                    stmt.close()
+                }
+            }
+        }
+    }
 }

memo-core/src/test/kotlin/memo/core/SearcherTest.kt

@@ -0,0 +1,142 @@
+package memo.core
+
+import java.io.File
+import java.nio.file.Files
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class SearcherTest {
+
+    private class Fixture : AutoCloseable {
+        val tempDir: File = Files.createTempDirectory("memo-searcher-").toFile()
+        val db = Db(File(tempDir, "index.db").absolutePath)
+        val embedder: Embedder
+
+        init {
+            db.init()
+            val modelDir = System.getenv("MEMO_MODEL_DIR") ?: "/root/WORK/memo/models/siglip2"
+            val modelPath = "$modelDir/text_model_int8.onnx"
+            val tokenizerPath = "$modelDir/tokenizer.model"
+            embedder = Embedder(modelPath, tokenizerPath)
+        }
+
+        fun addChunk(path: String, heading: String, line: Int, text: String) {
+            val conn = db.conn
+            val insChunk = conn.prepare(
+                "INSERT INTO chunks(path, heading, line, ord, text, hash) VALUES (?, ?, ?, ?, ?, ?)"
+            )
+            try {
+                insChunk.bindText(1, path)
+                insChunk.bindText(2, heading)
+                insChunk.bindLong(3, line.toLong())
+                insChunk.bindLong(4, 0L)
+                insChunk.bindText(5, text)
+                insChunk.bindText(6, "$path#$line")
+                insChunk.executeUpdate()
+            } finally {
+                insChunk.close()
+            }
+            val id = conn.lastInsertRowId
+            val insFts = conn.prepare(
+                "INSERT INTO chunks_fts(rowid, text, heading) VALUES (?, ?, ?)"
+            )
+            try {
+                insFts.bindLong(1, id)
+                insFts.bindText(2, text)
+                insFts.bindText(3, heading)
+                insFts.executeUpdate()
+            } finally {
+                insFts.close()
+            }
+            val insVec = conn.prepare(
+                "INSERT INTO chunks_vec(rowid, embedding) VALUES (?, ?)"
+            )
+            try {
+                insVec.bindLong(1, id)
+                insVec.bindVector(2, embedder.embed(text))
+                insVec.executeUpdate()
+            } finally {
+                insVec.close()
+            }
+        }
+
+        override fun close() {
+            embedder.close()
+            db.close()
+            tempDir.deleteRecursively()
+        }
+    }
+
+    @Test
+    fun lexModeFindsExactValue() {
+        Fixture().use { f ->
+            f.addChunk("/a.md", "A", 1, "Прокси корпоративных доменов на 76.132")
+            f.addChunk("/b.md", "B", 1, "Список контактов службы поддержки")
+            f.addChunk("/c.md", "C", 1, "Описание архитектуры сетевого шлюза")
+            val s = Searcher(f.db, f.embedder)
+            val hits = s.search(f.tempDir, "76.132", k = 8, mode = SearchMode.LEX)
+            assertTrue(hits.isNotEmpty(), "ожидались хиты, получено 0")
+            assertTrue(hits[0].text.contains("76.132"), "первый хит должен содержать 76.132")
+        }
+    }
+
+    @Test
+    fun vecModeFindsSemanticMatch() {
+        Fixture().use { f ->
+            f.addChunk("/server.md", "Server", 1, "Настройка сервера приложений и конфигурация Tomcat")
+            f.addChunk("/book.md", "Book", 1, "Аннотация книги по истории Древнего Рима")
+            f.addChunk("/ci.md", "CI", 1, "Пайплайн выпуска приложения: сборка, тесты, деплой в Kubernetes")
+            val s = Searcher(f.db, f.embedder)
+            val hits = s.search(f.tempDir, "настройку выпуска приложения", k = 1, mode = SearchMode.VEC)
+            assertTrue(hits.isNotEmpty(), "ожидались хиты, получено 0")
+            assertEquals("/ci.md", hits[0].path, "первый хит должен быть чанк про CI")
+        }
+    }
+
+    @Test
+    fun lexModeIgnoresVectorOnlyMatch() {
+        Fixture().use { f ->
+            f.addChunk("/p.md", "P", 1, "опрос")
+            f.addChunk("/s.md", "S", 1, "случай")
+            f.addChunk("/z.md", "Z", 1, "знание")
+            val s = Searcher(f.db, f.embedder)
+            val lex = s.search(f.tempDir, "автомобиль", k = 8, mode = SearchMode.LEX)
+            val vec = s.search(f.tempDir, "автомобиль", k = 8, mode = SearchMode.VEC)
+            assertTrue(lex.isEmpty(), "LEX должен быть пустым, получили ${lex.size} хитов")
+            assertTrue(vec.isNotEmpty(), "VEC должен быть непустым, получили 0")
+        }
+    }
+
+    @Test
+    fun hybridCombinesBoth() {
+        Fixture().use { f ->
+            f.addChunk("/exact.md", "Exact", 1, "Прокси корпоративных доменов на 76.132")
+            f.addChunk("/sem.md", "Sem", 1, "Конвейер поставки продуктов: компиляция, испытания, выкладка в кластер")
+            f.addChunk("/other.md", "Other", 1, "Заметки о книге по истории")
+            val s = Searcher(f.db, f.embedder)
+            val hits = s.search(f.tempDir, "выпуск приложения 76.132", k = 5, mode = SearchMode.HYBRID)
+            val paths = hits.map { it.path }.toSet()
+            assertTrue(paths.contains("/exact.md"), "чанк exact отсутствует в: $paths")
+            assertTrue(paths.contains("/sem.md"), "чанк sem отсутствует в: $paths")
+            assertEquals("/exact.md", hits[0].path, "exact.md должен быть первым в HYBRID за счёт лекс-буста, получено: ${hits.map { it.path }}")
+        }
+    }
+
+    @Test
+    fun resultsRespectKAndTextLength() {
+        Fixture().use { f ->
+            f.addChunk("/a.md", "A", 1, "Первый фрагмент про сервер")
+            f.addChunk("/b.md", "B", 1, "Второй фрагмент про книгу")
+            f.addChunk("/c.md", "C", 1, "Третий фрагмент про CI")
+            f.addChunk("/d.md", "D", 1, "Четвёртый фрагмент про настройку")
+            val s = Searcher(f.db, f.embedder)
+            val hits = s.search(f.tempDir, "фрагмент", k = 2, mode = SearchMode.HYBRID)
+            assertEquals(2, hits.size, "должно быть ровно 2 хита при k=2")
+            for (h in hits) {
+                assertTrue(h.text.isNotEmpty(), "text не должен быть пустым: $h")
+                assertTrue(h.text.length <= 1200, "длина text превышает 1200: ${h.text.length}")
+            }
+        }
+    }
+}

memo-mcp/build.gradle.kts

@@ -1,3 +1,16 @@
 plugins {
     kotlin("jvm")
-}
+    application
+    kotlin("plugin.serialization") version "2.4.10"
+}
+
+application {
+    mainClass.set("memo.mcp.McpServerKt")
+    applicationName = "memo-mcp"
+}
+
+dependencies {
+    implementation(project(":memo-core"))
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+    testImplementation(kotlin("test"))
+}

memo-mcp/src/main/kotlin/memo/mcp/McpServer.kt

@@ -0,0 +1,451 @@
+package memo.mcp
+
+import memo.core.Db
+import memo.core.Embedder
+import memo.core.Indexer
+import memo.core.RefreshHook
+import memo.core.SearchMode
+import memo.core.Searcher
+import memo.core.findCollections
+import memo.core.isCollection
+import memo.core.resolveCollection
+import java.io.File
+
+private const val PROTOCOL_VERSION = "2024-11-05"
+private const val SERVER_NAME = "memo"
+private const val SERVER_VERSION = "0.1.0"
+
+fun main(args: Array<String>) {
+    val br = System.`in`.bufferedReader()
+    while (true) {
+        val line = br.readLine() ?: break
+        if (line.isBlank()) continue
+        try {
+            val resp = handleRequest(line)
+            if (resp != null) {
+                println(resp)
+            }
+        } catch (t: Throwable) {
+            System.err.println("mcp: ${t.message}")
+        }
+    }
+}
+
+fun handleRequest(line: String): String? {
+    val parsed = try {
+        JsonParser(line).parse()
+    } catch (t: Throwable) {
+        return rpcError(null, -32700, "Parse error")
+    }
+    val obj = parsed as? Map<String, Any?> ?: return rpcError(null, -32600, "Invalid Request")
+    if (!obj.containsKey("id")) return null
+    val id = obj["id"]
+    val method = obj["method"] as? String ?: return rpcError(id, -32600, "Invalid Request")
+    val params = obj["params"]
+    return when (method) {
+        "initialize" -> result(id, initializeResult())
+        "tools/list" -> result(id, toolsListResult())
+        "tools/call" -> {
+            try {
+                val r = handleToolCall(params)
+                result(id, r)
+            } catch (t: Throwable) {
+                result(id, toolErrorContent(t.message ?: "error"))
+            }
+        }
+        else -> rpcError(id, -32601, "Method not found")
+    }
+}
+
+private fun initializeResult(): String =
+    """{"protocolVersion":"$PROTOCOL_VERSION","capabilities":{"tools":{}},"serverInfo":{"name":"$SERVER_NAME","version":"$SERVER_VERSION"}}"""
+
+private fun toolsListResult(): String =
+    """{"tools":[""" +
+        """{"name":"memo_search","description":"Гибридный поиск по индексу","inputSchema":{"type":"object","properties":{"path":{"type":"string"},"query":{"type":"string"},"k":{"type":"integer","default":8},"mode":{"type":"string","enum":["hybrid","lex","vec"],"default":"hybrid"}},"required":["path","query"]}},""" +
+        """{"name":"memo_status","description":"Статус индекса коллекции","inputSchema":{"type":"object","properties":{"path":{"type":"string"}},"required":["path"]}},""" +
+        """{"name":"memo_reindex","description":"Полная переиндексация","inputSchema":{"type":"object","properties":{"path":{"type":"string"}},"required":["path"]}}""" +
+    """]}"""
+
+private fun handleToolCall(params: Any?): String {
+    val p = params as? Map<String, Any?> ?: throw IllegalArgumentException("params required")
+    val name = p["name"] as? String ?: throw IllegalArgumentException("name required")
+    val args = p["arguments"] as? Map<String, Any?> ?: emptyMap()
+    return when (name) {
+        "memo_search" -> {
+            val path = args["path"] as? String
+            if (path.isNullOrBlank()) {
+                toolErrorContent("аргумент path обязателен")
+            } else {
+                val query = args["query"] as? String
+                if (query.isNullOrBlank()) {
+                    toolErrorContent("аргумент query обязателен")
+                } else {
+                    val k = (args["k"] as? Number)?.toInt() ?: 8
+                    val mode = when (args["mode"] as? String) {
+                        "lex" -> SearchMode.LEX
+                        "vec" -> SearchMode.VEC
+                        else -> SearchMode.HYBRID
+                    }
+                    toolOk(toolSearch(path, query, k, mode))
+                }
+            }
+        }
+        "memo_status" -> {
+            val path = args["path"] as? String
+            if (path.isNullOrBlank()) {
+                toolErrorContent("аргумент path обязателен")
+            } else {
+                toolOk(toolStatus(path))
+            }
+        }
+        "memo_reindex" -> {
+            val path = args["path"] as? String
+            if (path.isNullOrBlank()) {
+                toolErrorContent("аргумент path обязателен")
+            } else {
+                toolOk(toolReindex(path))
+            }
+        }
+        else -> toolErrorContent("unknown tool: $name")
+    }
+}
+
+fun toolSearch(path: String, query: String, k: Int, mode: SearchMode): String {
+    val root = resolveCollection(File(path))
+    val targets = selectTargets(root)
+    if (targets.isEmpty()) return "коллекции не найдены"
+    val (modelPath, tokenizerPath) = modelPaths()
+    val allHits = ArrayList<memo.core.Hit>()
+    val errors = ArrayList<String>()
+    val embedder = Embedder(modelPath, tokenizerPath)
+    try {
+        for (coll in targets) {
+            val memoDir = File(coll, ".memo")
+            val dbPath = File(memoDir, "index.db")
+            memoDir.mkdirs()
+            val existedBefore = dbPath.exists()
+            val db = Db(dbPath.absolutePath)
+            try {
+                db.init()
+                if (!existedBefore) {
+                    Indexer(db, embedder).indexTree(coll)
+                }
+                val refresh = RefreshHook { r ->
+                    val innerDbPath = File(r, ".memo/index.db")
+                    if (innerDbPath.exists()) {
+                        val innerDb = Db(innerDbPath.absolutePath)
+                        try {
+                            innerDb.init()
+                            Indexer(innerDb, embedder).indexTree(r)
+                        } finally {
+                            innerDb.close()
+                        }
+                    }
+                }
+                val hits = Searcher(db, embedder, refresh).search(coll, query, k, mode)
+                allHits.addAll(hits)
+            } catch (t: Throwable) {
+                errors.add("ошибка в ${coll.name}: ${t.message ?: t.javaClass.simpleName}")
+            } finally {
+                db.close()
+            }
+        }
+    } finally {
+        embedder.close()
+    }
+    val merged = allHits.sortedByDescending { it.score }.take(k)
+    val sb = StringBuilder()
+    for (h in merged) {
+        sb.append("${h.path}:${h.line}  ${h.heading}\n${h.text}\n")
+    }
+    for (e in errors) {
+        if (sb.isNotEmpty()) sb.append('\n')
+        sb.append(e)
+    }
+    val out = sb.toString().trimEnd('\n')
+    return if (out.isEmpty()) "ничего не найдено" else out
+}
+
+fun toolStatus(path: String): String {
+    val base = resolveCollection(File(path))
+    val collections = selectTargets(base)
+    if (collections.isEmpty()) return "коллекции не найдены"
+    val sb = StringBuilder()
+    for (coll in collections) {
+        val dbPath = File(coll, ".memo/index.db")
+        if (!dbPath.exists()) {
+            sb.append("${coll.name}: нет индекса\n")
+            continue
+        }
+        val db = Db(dbPath.absolutePath)
+        try {
+            val fileCount = countInt(db, "SELECT COUNT(*) FROM files")
+            val chunkCount = countInt(db, "SELECT COUNT(*) FROM chunks")
+            val indexedAt = maxDouble(db, "SELECT indexed_at FROM files WHERE indexed_at IS NOT NULL")
+            val date = if (indexedAt != null) {
+                java.time.Instant.ofEpochSecond(indexedAt.toLong()).toString()
+            } else {
+                "—"
+            }
+            sb.append("$coll: файлов $fileCount, чанков $chunkCount, индекс $date\n")
+        } finally {
+            db.close()
+        }
+    }
+    return sb.toString().trimEnd('\n')
+}
+
+fun toolReindex(path: String): String {
+    val root = resolveCollection(File(path))
+    val collections = selectTargets(root)
+    if (collections.isEmpty()) return "коллекции не найдены"
+    val (modelPath, tokenizerPath) = modelPaths()
+    var totalUpdated = 0
+    val embedder = Embedder(modelPath, tokenizerPath)
+    try {
+        for (coll in collections) {
+            val memoDir = File(coll, ".memo")
+            if (memoDir.exists()) {
+                memoDir.deleteRecursively()
+            }
+            memoDir.mkdirs()
+            val dbPath = File(memoDir, "index.db")
+            val db = Db(dbPath.absolutePath)
+            try {
+                db.init()
+                totalUpdated += Indexer(db, embedder).indexTree(coll)
+            } finally {
+                db.close()
+            }
+        }
+    } finally {
+        embedder.close()
+    }
+    return "переиндексировано файлов: $totalUpdated"
+}
+
+private fun selectTargets(root: File): List<File> {
+    if (!root.exists()) return emptyList()
+    if (isCollection(root)) return listOf(root)
+    return findCollections(root)
+}
+
+private fun modelPaths(): Pair<String, String> {
+    val modelDir = System.getenv("MEMO_MODEL_DIR") ?: "/root/WORK/memo/models/siglip2"
+    return "$modelDir/text_model_int8.onnx" to "$modelDir/tokenizer.model"
+}
+
+private fun countInt(db: Db, sql: String): Int {
+    val stmt = db.conn.prepare(sql)
+    return try {
+        val rs = stmt.executeQuery()
+        try {
+            if (rs.next()) rs.getInt(0) ?: 0 else 0
+        } finally {
+            rs.close()
+        }
+    } finally {
+        stmt.close()
+    }
+}
+
+private fun maxDouble(db: Db, sql: String): Double? {
+    val stmt = db.conn.prepare(sql)
+    return try {
+        val rs = stmt.executeQuery()
+        try {
+            var best: Double? = null
+            while (rs.next()) {
+                val v = rs.getDouble(0) ?: continue
+                if (best == null || v > best) best = v
+            }
+            best
+        } finally {
+            rs.close()
+        }
+    } finally {
+        stmt.close()
+    }
+}
+
+private fun toolOk(text: String): String =
+    """{"content":[{"type":"text","text":${jsonStr(text)}}],"isError":false}"""
+
+private fun toolErrorContent(text: String): String =
+    """{"content":[{"type":"text","text":${jsonStr(text)}}],"isError":true}"""
+
+private fun result(id: Any?, body: String): String =
+    """{"jsonrpc":"2.0","id":${idLiteral(id)},"result":$body}"""
+
+private fun rpcError(id: Any?, code: Int, message: String): String =
+    """{"jsonrpc":"2.0","id":${idLiteral(id)},"error":{"code":$code,"message":${jsonStr(message)}}}"""
+
+private fun idLiteral(id: Any?): String = when (id) {
+    null -> "null"
+    is Number -> if (id.toDouble().rem(1.0) == 0.0) id.toLong().toString() else id.toString()
+    is Boolean -> id.toString()
+    else -> jsonStr(id.toString())
+}
+
+private fun jsonStr(s: String): String {
+    val sb = StringBuilder(s.length + 2)
+    sb.append('"')
+    for (c in s) {
+        when (c) {
+            '"' -> sb.append("\\\"")
+            '\\' -> sb.append("\\\\")
+            '\n' -> sb.append("\\n")
+            '\r' -> sb.append("\\r")
+            '\t' -> sb.append("\\t")
+            '\b' -> sb.append("\\b")
+            '\u000C' -> sb.append("\\f")
+            else -> if (c.code < 0x20) {
+                sb.append("\\u%04x".format(c.code))
+            } else {
+                sb.append(c)
+            }
+        }
+    }
+    sb.append('"')
+    return sb.toString()
+}
+
+private class JsonParser(private val s: String) {
+    private var pos = 0
+
+    fun parse(): Any? {
+        skipWs()
+        val v = parseValue()
+        skipWs()
+        if (pos != s.length) throw IllegalArgumentException("trailing data at $pos")
+        return v
+    }
+
+    private fun parseValue(): Any? {
+        skipWs()
+        if (pos >= s.length) throw IllegalArgumentException("unexpected end")
+        return when (val c = s[pos]) {
+            '{' -> parseObject()
+            '[' -> parseArray()
+            '"' -> parseString()
+            't' -> parseLiteral("true", true)
+            'f' -> parseLiteral("false", false)
+            'n' -> parseLiteral("null", null)
+            '-', in '0'..'9' -> parseNumber()
+            else -> throw IllegalArgumentException("unexpected char '$c' at $pos")
+        }
+    }
+
+    private fun parseObject(): Map<String, Any?> {
+        expect('{')
+        val map = LinkedHashMap<String, Any?>()
+        skipWs()
+        if (peek() == '}') { pos++; return map }
+        while (true) {
+            skipWs()
+            val key = parseString()
+            skipWs()
+            expect(':')
+            map[key] = parseValue()
+            skipWs()
+            when (peek()) {
+                ',' -> { pos++; continue }
+                '}' -> { pos++; return map }
+                else -> throw IllegalArgumentException("expected ',' or '}' at $pos")
+            }
+        }
+    }
+
+    private fun parseArray(): List<Any?> {
+        expect('[')
+        val list = ArrayList<Any?>()
+        skipWs()
+        if (peek() == ']') { pos++; return list }
+        while (true) {
+            list.add(parseValue())
+            skipWs()
+            when (peek()) {
+                ',' -> { pos++; continue }
+                ']' -> { pos++; return list }
+                else -> throw IllegalArgumentException("expected ',' or ']' at $pos")
+            }
+        }
+    }
+
+    private fun parseString(): String {
+        expect('"')
+        val sb = StringBuilder()
+        while (pos < s.length) {
+            val c = s[pos]
+            if (c == '"') {
+                pos++
+                return sb.toString()
+            }
+            if (c == '\\') {
+                if (pos + 1 >= s.length) throw IllegalArgumentException("bad escape at end")
+                when (s[pos + 1]) {
+                    '"' -> sb.append('"')
+                    '\\' -> sb.append('\\')
+                    '/' -> sb.append('/')
+                    'n' -> sb.append('\n')
+                    'r' -> sb.append('\r')
+                    't' -> sb.append('\t')
+                    'b' -> sb.append('\b')
+                    'f' -> sb.append('\u000C')
+                    'u' -> {
+                        if (pos + 6 > s.length) throw IllegalArgumentException("bad unicode escape")
+                        val hex = s.substring(pos + 2, pos + 6)
+                        sb.append(hex.toInt(16).toChar())
+                        pos += 4
+                    }
+                    else -> throw IllegalArgumentException("bad escape '\\${s[pos + 1]}'")
+                }
+                pos += 2
+            } else {
+                sb.append(c)
+                pos++
+            }
+        }
+        throw IllegalArgumentException("unterminated string")
+    }
+
+    private fun parseNumber(): Any {
+        val start = pos
+        if (s[pos] == '-') pos++
+        var hasDigit = false
+        while (pos < s.length && s[pos].isDigit()) { hasDigit = true; pos++ }
+        var isFloat = false
+        if (pos < s.length && s[pos] == '.') {
+            isFloat = true; pos++
+            while (pos < s.length && s[pos].isDigit()) { hasDigit = true; pos++ }
+        }
+        if (pos < s.length && (s[pos] == 'e' || s[pos] == 'E')) {
+            isFloat = true; pos++
+            if (pos < s.length && (s[pos] == '+' || s[pos] == '-')) pos++
+            while (pos < s.length && s[pos].isDigit()) { hasDigit = true; pos++ }
+        }
+        if (!hasDigit) throw IllegalArgumentException("bad number at $start")
+        val raw = s.substring(start, pos)
+        return if (isFloat) raw.toDouble() else raw.toLong()
+    }
+
+    private fun parseLiteral(lit: String, value: Any?): Any? {
+        if (s.regionMatches(pos, lit, 0, lit.length)) {
+            pos += lit.length
+            return value
+        }
+        throw IllegalArgumentException("expected literal '$lit' at $pos")
+    }
+
+    private fun peek(): Char = if (pos < s.length) s[pos] else '\u0000'
+
+    private fun expect(c: Char) {
+        if (peek() != c) throw IllegalArgumentException("expected '$c' at $pos")
+        pos++
+    }
+
+    private fun skipWs() {
+        while (pos < s.length && s[pos].isWhitespace()) pos++
+    }
+}

memo-mcp/src/test/kotlin/memo/mcp/McpColdStartTest.kt

@@ -0,0 +1,78 @@
+package memo.mcp
+
+import memo.core.SearchMode
+import java.io.File
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+class McpColdStartTest {
+
+    private fun modelPaths(): Pair<String, String> {
+        val modelDir = System.getenv("MEMO_MODEL_DIR") ?: "/root/WORK/memo/models/siglip2"
+        return "$modelDir/text_model_int8.onnx" to "$modelDir/tokenizer.model"
+    }
+
+    private fun requireModel() {
+        val (modelPath, tokenizerPath) = modelPaths()
+        if (!File(modelPath).exists() || !File(tokenizerPath).exists()) {
+            fail("модель не найдена: ${File(modelPath).parent}")
+        }
+    }
+
+    @Test
+    fun searchIndexesCollectionOnColdStart() {
+        requireModel()
+
+        val base = File.createTempFile("memo-coldstart-", "")
+        assertTrue(base.delete(), "temp cleanup")
+        assertTrue(base.mkdir(), "temp create")
+        base.deleteOnExit()
+
+        File(base, "proxy.md").writeText(
+            "# Прокси\nвнутренние домены ходят через шлюз 76.1\n"
+        )
+        File(base, "other.md").writeText(
+            "# Прочее\nсовсем другая заметка про книгу\n"
+        )
+        File(base, "proxy.md").deleteOnExit()
+        File(base, "other.md").deleteOnExit()
+
+        val memoDir = File(base, ".memo")
+        assertFalse(memoDir.exists(), "до поиска .memo не должен существовать")
+
+        val resp = toolSearch(base.absolutePath, "внутренние домены шлюз", 5, SearchMode.HYBRID)
+        assertFalse(
+            resp.contains("коллекции не найдены"),
+            "холодный старт обязан сам индексировать, ответ: $resp"
+        )
+        assertTrue(
+            resp.contains("76.1"),
+            "ожидалось упоминание 76.1 в ответе, получено: $resp"
+        )
+
+        val dbFile = File(base, ".memo/index.db")
+        assertTrue(dbFile.exists(), "после поиска .memo/index.db обязан существовать")
+    }
+
+    @Test
+    fun searchOnEmptyDirReportsNoCollections() {
+        val base = File.createTempFile("memo-empty-", "")
+        assertTrue(base.delete(), "temp cleanup")
+        assertTrue(base.mkdir(), "temp create")
+        base.deleteOnExit()
+
+        val resp = toolSearch(base.absolutePath, "что угодно", 5, SearchMode.HYBRID)
+        assertEquals(
+            "коллекции не найдены",
+            resp,
+            "пустой каталог без .md обязан вернуть 'коллекции не найдены'"
+        )
+        assertFalse(
+            File(base, ".memo").exists(),
+            "в пустом каталоге .memo не должен создаваться"
+        )
+    }
+}

memo-mcp/src/test/kotlin/memo/mcp/McpProtocolTest.kt

@@ -0,0 +1,56 @@
+package memo.mcp
+
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class McpProtocolTest {
+
+    @Test
+    fun initializeHandshake() {
+        val resp = handleRequest(
+            """{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}"""
+        )
+        assertNotNull(resp, "initialize обязан вернуть ответ")
+        assertTrue(resp.contains("2024-11-05"), "ожидался protocolVersion 2024-11-05, получено: $resp")
+        assertTrue(resp.contains("memo"), "ожидалось имя сервера memo, получено: $resp")
+    }
+
+    @Test
+    fun toolsListHasThreeTools() {
+        val resp = handleRequest(
+            """{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}"""
+        )
+        assertNotNull(resp, "tools/list обязан вернуть ответ")
+        assertTrue(resp.contains("memo_search"), "ожидался memo_search, получено: $resp")
+        assertTrue(resp.contains("memo_status"), "ожидался memo_status, получено: $resp")
+        assertTrue(resp.contains("memo_reindex"), "ожидался memo_reindex, получено: $resp")
+    }
+
+    @Test
+    fun unknownMethodReturns32601() {
+        val resp = handleRequest(
+            """{"jsonrpc":"2.0","id":3,"method":"foo/bar"}"""
+        )
+        assertNotNull(resp, "неизвестный метод обязан вернуть JSON-RPC error")
+        assertTrue(resp.contains("-32601"), "ожидался код -32601, получено: $resp")
+    }
+
+    @Test
+    fun searchWithoutPathIsError() {
+        val resp = handleRequest(
+            """{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"memo_search","arguments":{}}}"""
+        )
+        assertNotNull(resp, "tools/call обязан вернуть ответ")
+        assertTrue(resp.contains("\"isError\":true"), "ожидался isError:true, получено: $resp")
+    }
+
+    @Test
+    fun notificationProducesNoResponse() {
+        val resp = handleRequest(
+            """{"jsonrpc":"2.0","method":"notifications/initialized"}"""
+        )
+        assertNull(resp, "уведомление не должно порождать ответ, получено: $resp")
+    }
+}

memo-watch/build.gradle.kts

@@ -1,3 +1,13 @@
 plugins {
     kotlin("jvm")
+    application
+}
+
+application {
+    mainClass.set("memo.watch.WatchMainKt")
+}
+
+dependencies {
+    implementation(project(":memo-core"))
+    testImplementation(kotlin("test"))
 }

memo-watch/src/main/kotlin/memo/watch/WatchMain.kt

@@ -0,0 +1,90 @@
+package memo.watch
+
+import memo.core.Db
+import memo.core.Embedder
+import memo.core.Indexer
+import java.io.File
+import java.util.concurrent.CountDownLatch
+import kotlin.system.exitProcess
+
+fun main(args: Array<String>) {
+    if (args.isEmpty()) {
+        System.err.println("usage: watch <path>")
+        exitProcess(2)
+    }
+    val raw = File(args[0])
+    val base = if (raw.name == ".memo") raw.parentFile ?: raw else raw
+    val collections = discoverCollections(base)
+    if (collections.isEmpty()) {
+        System.err.println("коллекции не найдены в ${base.absolutePath}")
+        exitProcess(1)
+    }
+
+    val modelDir = System.getenv("MEMO_MODEL_DIR") ?: "/root/WORK/memo/models/siglip2"
+    val modelPath = "$modelDir/text_model_int8.onnx"
+    val tokenizerPath = "$modelDir/tokenizer.model"
+
+    val ctxList = collections.map { coll ->
+        val memoDir = File(coll, ".memo")
+        memoDir.mkdirs()
+        val db = Db(File(memoDir, "index.db").absolutePath)
+        db.init()
+        val embedder = Embedder(modelPath, tokenizerPath)
+        val indexer = Indexer(db, embedder)
+        CollCtx(coll, db, embedder, indexer)
+    }
+
+    val indexersByCollection = ctxList.associateBy { it.root }
+    val watcher = Watcher(
+        collections = ctxList.map { it.root },
+        index = { coll -> indexersByCollection.getValue(coll).indexer.indexTree(coll) },
+    )
+
+    Runtime.getRuntime().addShutdownHook(
+        Thread({
+            try { watcher.close() } catch (_: Throwable) {}
+            for (ctx in ctxList) {
+                try { ctx.embedder.close() } catch (_: Throwable) {}
+                try { ctx.db.close() } catch (_: Throwable) {}
+            }
+        }, "memo-watch-shutdown")
+    )
+
+    watcher.start()
+    for (ctx in ctxList) {
+        println("наблюдаю: ${ctx.root.absolutePath}")
+    }
+
+    CountDownLatch(1).await()
+}
+
+private data class CollCtx(
+    val root: File,
+    val db: Db,
+    val embedder: Embedder,
+    val indexer: Indexer,
+)
+
+private fun discoverCollections(base: File): List<File> {
+    if (!base.isDirectory) return emptyList()
+    val candidates = LinkedHashSet<File>()
+    candidates.add(base)
+    val q = ArrayDeque<Pair<File, Int>>()
+    q.addLast(base to 0)
+    while (q.isNotEmpty()) {
+        val (d, depth) = q.removeFirst()
+        if (depth >= 2) continue
+        val children = d.listFiles() ?: continue
+        for (c in children) {
+            if (c.isDirectory && !c.name.startsWith(".")) {
+                candidates.add(c)
+                q.addLast(c to depth + 1)
+            }
+        }
+    }
+    return candidates.filter { d ->
+        d.walkTopDown()
+            .maxDepth(8)
+            .any { it.isFile && it.extension == "md" }
+    }
+}

memo-watch/src/main/kotlin/memo/watch/Watcher.kt

@@ -0,0 +1,141 @@
+package memo.watch
+
+import java.io.File
+import java.nio.file.ClosedWatchServiceException
+import java.nio.file.FileSystems
+import java.nio.file.Path
+import java.nio.file.StandardWatchEventKinds
+import java.nio.file.WatchKey
+import java.nio.file.WatchService
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+class Watcher(
+    private val collections: List<File>,
+    private val index: (File) -> Unit,
+    private val debounceMillis: Long = 500,
+    private val reconcileMillis: Long = 10 * 60 * 1000,
+) : AutoCloseable {
+
+    private val watchService: WatchService = FileSystems.getDefault().newWatchService()
+    private val keyToCollection = ConcurrentHashMap<WatchKey, File>()
+    private val running = AtomicBoolean(false)
+    private val closed = AtomicBoolean(false)
+    private val _indexCalls = AtomicInteger(0)
+
+    val indexCalls: Int get() = _indexCalls.get()
+
+    private val thread: Thread = Thread({ runLoop() }, "memo-watcher").apply { isDaemon = true }
+
+    fun start() {
+        if (!running.compareAndSet(false, true)) return
+        for (coll in collections) {
+            try {
+                registerRecursive(coll, coll)
+            } catch (t: Throwable) {
+                System.err.println("watcher: register ${coll.absolutePath} failed: ${t.message}")
+            }
+        }
+        thread.start()
+    }
+
+    private fun registerRecursive(dir: File, collection: File) {
+        if (!dir.isDirectory) return
+        if (dir.name.startsWith(".")) return
+        val key = dir.toPath().register(
+            watchService,
+            StandardWatchEventKinds.ENTRY_CREATE,
+            StandardWatchEventKinds.ENTRY_MODIFY,
+            StandardWatchEventKinds.ENTRY_DELETE,
+        )
+        keyToCollection[key] = collection
+        val children = dir.listFiles() ?: return
+        for (child in children) {
+            if (child.isDirectory && !child.name.startsWith(".")) {
+                registerRecursive(child, collection)
+            }
+        }
+    }
+
+    override fun close() {
+        if (!closed.compareAndSet(false, true)) return
+        running.set(false)
+        thread.interrupt()
+        try { watchService.close() } catch (_: Throwable) {}
+        try { thread.join(2000) } catch (_: InterruptedException) {}
+    }
+
+    private fun runLoop() {
+        var nextReconcile = System.currentTimeMillis() + reconcileMillis
+        while (running.get()) {
+            try {
+                val firstKey = watchService.poll(debounceMillis, TimeUnit.MILLISECONDS)
+                if (firstKey != null) {
+                    val affected = HashSet<File>()
+                    processKey(firstKey, affected)
+                    val endDeadline = System.currentTimeMillis() + debounceMillis
+                    while (running.get()) {
+                        val now = System.currentTimeMillis()
+                        if (now >= endDeadline) break
+                        val remaining = endDeadline - now
+                        val nextKey = watchService.poll(remaining, TimeUnit.MILLISECONDS) ?: break
+                        processKey(nextKey, affected)
+                    }
+                    for (coll in affected) {
+                        callIndex(coll)
+                    }
+                }
+                if (System.currentTimeMillis() >= nextReconcile) {
+                    nextReconcile = System.currentTimeMillis() + reconcileMillis
+                    for (coll in collections) {
+                        callIndex(coll)
+                    }
+                }
+            } catch (_: ClosedWatchServiceException) {
+                break
+            } catch (_: InterruptedException) {
+                if (!running.get()) break
+            } catch (t: Throwable) {
+                System.err.println("watcher loop: ${t.message}")
+            }
+        }
+    }
+
+    private fun processKey(key: WatchKey, affected: MutableSet<File>) {
+        val collection = keyToCollection[key] ?: return
+        for (event in key.pollEvents()) {
+            val kind = event.kind()
+            if (kind === StandardWatchEventKinds.OVERFLOW) continue
+            val ctx = event.context() as? Path ?: continue
+            val watchable = key.watchable() as? Path ?: continue
+            val ev = watchable.resolve(ctx).toFile()
+            when (kind) {
+                StandardWatchEventKinds.ENTRY_CREATE -> {
+                    affected.add(collection)
+                    if (ev.isDirectory && !ev.name.startsWith(".")) {
+                        try {
+                            registerRecursive(ev, collection)
+                        } catch (t: Throwable) {
+                            System.err.println("watcher: registerRecursive ${ev.absolutePath} failed: ${t.message}")
+                        }
+                    }
+                }
+                StandardWatchEventKinds.ENTRY_MODIFY,
+                StandardWatchEventKinds.ENTRY_DELETE -> affected.add(collection)
+            }
+        }
+        val valid = key.reset()
+        if (!valid) keyToCollection.remove(key)
+    }
+
+    private fun callIndex(coll: File) {
+        _indexCalls.incrementAndGet()
+        try {
+            index(coll)
+        } catch (t: Throwable) {
+            System.err.println("watcher: index ${coll.absolutePath} failed: ${t.message}")
+        }
+    }
+}

memo-watch/src/test/kotlin/memo/watch/WatcherTest.kt

@@ -0,0 +1,91 @@
+package memo.watch
+
+import java.io.File
+import java.nio.file.Files
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class WatcherTest {
+
+    @Test
+    fun modifyTriggersSingleIndexCall() {
+        val tempDir = Files.createTempDirectory("memo-watch-").toFile()
+        tempDir.deleteOnExit()
+        val note = File(tempDir, "note.md")
+        note.writeText("# initial")
+        note.deleteOnExit()
+        val counter = AtomicInteger(0)
+        val watcher = Watcher(
+            collections = listOf(tempDir),
+            index = { counter.incrementAndGet() },
+            debounceMillis = 200,
+            reconcileMillis = TimeUnit.HOURS.toMillis(1),
+        )
+        try {
+            watcher.start()
+            Thread.sleep(300)
+            note.appendText("\nappended")
+            assertTrue(
+                waitFor(5_000, 100) { counter.get() >= 1 },
+                "index должен сработать в течение 5с, получено ${counter.get()}",
+            )
+            Thread.sleep(1500)
+            assertEquals(1, counter.get(), "ожидался ровно 1 вызов index, получено ${counter.get()}")
+            assertTrue(watcher.indexCalls >= 1, "встроенный счётчик indexCalls не растёт, получено ${watcher.indexCalls}")
+        } finally {
+            watcher.close()
+            tempDir.deleteRecursively()
+        }
+    }
+
+    @Test
+    fun unchangedFileDoesNotTriggerIndex() {
+        val tempDir = Files.createTempDirectory("memo-watch-").toFile()
+        tempDir.deleteOnExit()
+        val note = File(tempDir, "note.md")
+        note.writeText("# initial")
+        note.deleteOnExit()
+        val counter = AtomicInteger(0)
+        val watcher = Watcher(
+            collections = listOf(tempDir),
+            index = { counter.incrementAndGet() },
+            debounceMillis = 200,
+            reconcileMillis = TimeUnit.HOURS.toMillis(1),
+        )
+        try {
+            watcher.start()
+            Thread.sleep(300)
+            Thread.sleep(1500)
+            assertEquals(0, counter.get(), "не должно быть вызовов index, получено ${counter.get()}")
+        } finally {
+            watcher.close()
+            tempDir.deleteRecursively()
+        }
+    }
+
+    @Test
+    fun closeIsIdempotentAndStopsThread() {
+        val tempDir = Files.createTempDirectory("memo-watch-").toFile()
+        tempDir.deleteOnExit()
+        val watcher = Watcher(
+            collections = listOf(tempDir),
+            index = {},
+        )
+        watcher.start()
+        watcher.close()
+        watcher.close()
+        tempDir.deleteRecursively()
+    }
+
+    private fun waitFor(timeoutMs: Long, stepMs: Long, condition: () -> Boolean): Boolean {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            if (condition()) return true
+            Thread.sleep(stepMs)
+        }
+        return condition()
+    }
+}

scripts/accept.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# Единый приёмочный прогон memo. Запускает ВСЁ, что должен пройти проект, и печатает
+# один вердикт. Возвращает 0, если все контуры зелёные.
+#
+#   bash scripts/accept.sh                # полный прогон
+#   bash scripts/accept.sh --fast         # без мутационной проверки (она самая долгая)
+#
+# Контуры:
+#   1. Юнит-тесты всех модулей (gradle test --rerun-tasks).
+#   2. Мутационная проверка тестов (e2e/mutation_check.py) — тесты обязаны падать на сломанном коде.
+#   3. Сквозной recall@5 на эталонном корпусе (e2e/run_e2e.py).
+#   4. MCP-протокол живым клиентом (scripts/mcp_probe.py), включая холодный старт.
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+CORPUS="${MEMO_CORPUS:-/root/WORK/memo-e2e}"
+export MEMO_MODEL_DIR="${MEMO_MODEL_DIR:-$ROOT/models/siglip2}"
+FAST=0
+[ "${1:-}" = "--fast" ] && FAST=1
+
+FAILED=()
+
+section() { printf '\n=== %s ===\n' "$1"; }
+
+section "0. сборка"
+if ./gradlew installDist -q >/tmp/memo-build.log 2>&1; then
+    echo "OK   сборка и установка дистрибутивов"
+else
+    echo "ПРОВАЛ сборки:"; tail -30 /tmp/memo-build.log; FAILED+=("сборка"); fi
+
+CLI="$ROOT/memo-cli/build/install/memo/bin/memo"
+MCP="$ROOT/memo-mcp/build/install/memo-mcp/bin/memo-mcp"
+
+section "1. юнит-тесты"
+if ./gradlew test --rerun-tasks >/tmp/memo-test.log 2>&1; then
+    python3 - <<'EOF'
+import glob, xml.etree.ElementTree as ET
+tot = fail = 0
+for f in glob.glob('**/build/test-results/test/*.xml', recursive=True):
+    r = ET.parse(f).getroot()
+    tot += int(r.get('tests') or 0); fail += int(r.get('failures') or 0) + int(r.get('errors') or 0)
+print(f"OK   тестов {tot}, провалов {fail}")
+EOF
+else
+    echo "ПРОВАЛ тестов:"; grep -E "FAILED|error:" /tmp/memo-test.log | head -20; FAILED+=("тесты"); fi
+
+if [ "$FAST" = "0" ]; then
+    section "2. мутационная проверка"
+    python3 e2e/mutation_check.py --gradle ./gradlew > /tmp/memo-mut.log 2>&1
+    MUT_RC=$?
+    if [ "$MUT_RC" = "0" ]; then
+        echo "OK   все мутации убиты"
+    elif [ "$MUT_RC" = "2" ]; then
+        echo "ПРОВАЛ: таблица мутаций недействительна (no-op или неприменимая мутация)"
+        grep -E "ОШИБКА ТАБЛИЦЫ|ПРОВАЛ" /tmp/memo-mut.log | head -10; FAILED+=("таблица мутаций")
+    else
+        echo "ПРОВАЛ: есть выжившие мутации"; tail -20 /tmp/memo-mut.log; FAILED+=("мутации"); fi
+fi
+
+section "3. сквозной индекс эталонного корпуса"
+# .memo лежит не только на верхнем уровне (life/books, work/jira), поэтому ищем по дереву,
+# иначе часть баз переживает очистку и прогон перестаёт быть чистым.
+find "$CORPUS" -name .memo -type d -prune -exec rm -rf {} + 2>/dev/null
+FIRST=$("$CLI" index "$CORPUS" 2>&1 | tail -1)
+SECOND=$("$CLI" index "$CORPUS" 2>&1 | tail -1)
+DBS=$(find "$CORPUS" -name index.db | wc -l)
+echo "     первый прогон : $FIRST"
+echo "     второй прогон : $SECOND"
+echo "     баз индекса   : $DBS (ожидается 3)"
+if echo "$SECOND" | grep -q "итого: 0 обновлено" && [ "$DBS" = "3" ]; then
+    echo "OK   индексация идемпотентна, коллекций 3"
+else
+    echo "ПРОВАЛ индексации (ожидалось «итого: 0 обновлено» и 3 базы)"; FAILED+=("индексация"); fi
+
+section "4. recall@5"
+if python3 e2e/run_e2e.py --cli "$CLI" --root "$CORPUS" --k 5 > /tmp/memo-e2e.log 2>&1 \
+   && grep -q "ИТОГ: ПРОЙДЕНО" /tmp/memo-e2e.log; then
+    grep -E "^(sem|lex):" /tmp/memo-e2e.log; echo "OK   recall"
+else
+    echo "ПРОВАЛ recall:"; tail -25 /tmp/memo-e2e.log; FAILED+=("recall"); fi
+
+section "5. MCP: протокол + холодный старт"
+COLD=/tmp/memo-accept-cold
+rm -rf "$COLD"; cp -r "$CORPUS" "$COLD"
+find "$COLD" -name .memo -type d -prune -exec rm -rf {} + 2>/dev/null
+if python3 scripts/mcp_probe.py --cmd "$MCP" \
+     --call memo_search \
+     --args "{\"path\":\"$COLD/infra\",\"query\":\"основа для разрешения имён в сети\",\"k\":3}" \
+     > /tmp/memo-mcp.log 2>&1; then
+    if grep -q "коллекции не найдены" /tmp/memo-mcp.log; then
+        echo "ПРОВАЛ: холодный старт не индексирует"; FAILED+=("MCP холодный старт")
+    else
+        echo "OK   MCP: протокол отвечает, холодный старт индексирует"
+        grep -E "^OK" /tmp/memo-mcp.log | sed 's/^/     /'
+    fi
+else
+    echo "ПРОВАЛ MCP:"; tail -20 /tmp/memo-mcp.log; FAILED+=("MCP протокол"); fi
+
+section "ВЕРДИКТ"
+if [ ${#FAILED[@]} -eq 0 ]; then
+    echo "ПРОЙДЕНО — все контуры зелёные"
+    exit 0
+else
+    printf 'ПРОВАЛ — контуры: %s\n' "$(IFS=', '; echo "${FAILED[*]}")"
+    exit 1
+fi