opencode-orchestrator-uni 0.2.1 → 0.3.0

package/README.md

@@ -88,6 +88,7 @@ validates the document.
 | `E_UNKNOWN_SCHEMA`  | The report names an id that is not shipped (or no id at all)     |
 | `E_SCHEMA_MISMATCH` | The report names another schema than the expected one            |
 | `E_INVALID`         | The document does not satisfy its schema (see `errors`)          |
+| `E_SCHEMA_IO`       | `schemas/*.json` unreadable/malformed (see `directory`, `file`)  |
 | `E_ABORTED`         | The session was stopped while reading the report                 |
 
 `warnings` carry the prompt rules a *structurally valid* report can still miss — things
@@ -300,11 +301,15 @@ There is no build. `index.ts` is the shipped entry point.
 npm install          # installs gray-matter + dev tooling
 npm run typecheck    # tsc --noEmit
 npm test             # bun test ./test/ (hermetic: registration, tools, validator, snapshot, prompt↔schema + identifier guards)
+npm run check:locales # bun tools/locale-check.ts (ru↔en parity of agents + docs)
+npm run verify:kit   # bun tools/kit-verify.ts (locales, tests, lint, types — the kit's stand)
 npm run lint         # biome check . (lint + format + import order; read-only)
 npm run lint:fix     # biome check --write . (applies safe fixes)
 ```
 
-`npm test` scans only `./test/` — the shipped suite (90 tests in 8 files, up from
+The `check:locales` and `verify:kit` scripts need a git checkout of the kit — the npm package ships no `tools/` directory, so in an installed package they are unavailable (`stand: unavailable` plus your own reproducible checks).
+
+`npm test` scans only `./test/` — the shipped suite (93 tests in 8 files, up from
 72 in 5 before the identifier guards). A bare `bun test` from the repository root is red by
 design: the positional argument of `bun test` is a path substring filter, so the
 bare command also picks up the intentionally failing fixtures under `eval/cases/`

package/README.ru.md

@@ -89,6 +89,7 @@ Reference `audit-kit` указывает на per-locale каталог `docs/<l
 | `E_UNKNOWN_SCHEMA`  | Отчёт называет id, которого нет в комплекте (или не называет вовсе)   |
 | `E_SCHEMA_MISMATCH` | Отчёт называет схему, отличную от ожидаемой                          |
 | `E_INVALID`         | Документ не удовлетворяет своей схеме (см. `errors`)                 |
+| `E_SCHEMA_IO`       | Схемы комплекта недоступны или битые (см. `directory`, `file`)       |
 | `E_ABORTED`         | Сессия остановлена во время чтения отчёта                            |
 
 `warnings` несут правила промпта, которые *структурно валидный* отчёт всё ещё
@@ -307,11 +308,15 @@ Markdown-файл в `~/.config/opencode/agents/` (либо `.opencode/agents/`)
 npm install          # ставит gray-matter + dev-инструменты
 npm run typecheck    # tsc --noEmit
 npm test             # bun test ./test/ (герметично: регистрация, инструменты, валидатор, снапшот, промпт↔схемы + стражи идентификаторов)
+npm run check:locales # bun tools/locale-check.ts (паритет ru↔en: агенты + документы)
+npm run verify:kit   # bun tools/kit-verify.ts (локали, тесты, линт, типы — стенд комплекта)
 npm run lint         # biome check . (линт + формат + порядок импортов; только чтение)
 npm run lint:fix     # biome check --write . (применяет безопасные фиксы)
 ```
 
-`npm test` сканирует только `./test/` — поставляемый набор (90 тестов в 8 файлах;
+Команды `check:locales` и `verify:kit` требуют git-чекаута комплекта — в npm-пакете каталог `tools/` не поставляется, поэтому в установленном пакете они недоступны (`stand: unavailable` и собственные воспроизводимые проверки).
+
+`npm test` сканирует только `./test/` — поставляемый набор (93 теста в 8 файлах;
 до стражей идентификаторов было 72 в 5). Голый `bun test` из корня репозитория
 красный по замыслу: позиционный аргумент `bun test` — это фильтр-подстрока пути,
 поэтому голая команда подхватывает и специально падающие фикстуры в

package/agents/en/fix-runner.md

@@ -14,7 +14,7 @@ You are the fix-runner of the audit loop. The only writing subagent: all auditor
 
 INPUT (from the call prompt): a list of findings of the form
 `id | location | mechanism | class/area (paths + a search rule for similar places) | repro command (before) | acceptance criterion (after) | severity`,
-plus the boundaries (which paths/repository/branch may be changed), prohibitions, the budget/limit (time, number of fixes) and whether a commit is needed.
+plus the boundaries (which paths/**file set**/repository/branch may be changed, the workspace and the base), prohibitions, the budget/limit (time, number of fixes) and whether a commit is needed.
 
 RULES:
 1. Work ONLY on the listed findings. Do not fix anything else "along the way"; if you notice something else — record it under "noticed outside the list", do not touch it.
@@ -25,16 +25,19 @@ RULES:
 6. Mutations — only in the target paths and temporary directories. If a commit is needed — as a separate commit with the message `fix-<round>: <brief>`.
 7. Proof of closure is load-bearing: where applicable, the test/check must FAIL when the fix is rolled back and PASS with it; the check is via a reproducible command; the fix is at the level of the defect class (all similar places), not of a single site. Beyond the listed sites, only sites of the declared class/area may be changed; going beyond that — the status `needs_decision`, not improvisation.
 8. Named exits: the call budget is exhausted (time/number of fixes) → the status `budget_exceeded` (extending the budget or splitting the list is the root's/owner's decision); `needs_decision` — only for a choice/disputed question, not for the budget.
-9. Test stand (applicable when the audit object is the kit itself; in rounds on other projects — only if the stand is explicitly included in the call boundaries): the stand's tools are in the kit directory (`tools/`): **the `kit-verify` verifier** (baseline before fixes; for a project copy — with the parameter `--proj <project agents directory>`; a repeat run after the fixes) and **the `kit-sync` synchronizer** (sync of agent/doc copies and a snapshot of the configuration; the project directory is passed as a parameter). The exact launch command is in the kit's README (in your environment's syntax). Order: baseline → fixes → sync → repeat `kit-verify`; both outputs go into the report's `stand` field (result/rc + a brief output). If the tools are not shipped or the stand is not applicable — `stand: unavailable: <why>` and your own reproducible checks. Hand-written check scripts — only for specific repro cases, do not duplicate standard checks.
+9. Test stand (applicable when the audit object is the kit itself; in rounds on other projects — only if the stand is explicitly included in the call boundaries): the stand's tool is **the `kit-verify` verifier** (`tools/kit-verify` in the kit directory; baseline before the fixes, a repeat run after them). Launch command: `bun tools/kit-verify.ts` in the kit directory (for a project copy — `bun <kit>/tools/kit-verify.ts --proj <project directory>`). Order: baseline → fixes → a repeat `kit-verify`; both outputs go into the report's `stand` field (result/rc + a brief output). The stand is shipped in the kit's git checkout: the npm package does not ship the `tools/` directory, so for an installed package — `stand: unavailable` and your own reproducible checks. If the stand is not applicable — `stand: unavailable: <why>` and your own reproducible checks. Hand-written check scripts — only for specific repro cases, do not duplicate standard checks.
 10. Step economy: read only the parts named in the LIST (file:line/fragment anchors), the full file — only when a cross-check is needed; apply fixes to one file FROM THE LIST in a single pass; the search for similar places is limited to the declared class/area (paths + the search rule from the list) — everything else, including what was found nearby, goes into `out_of_scope`, not into a fix; the report is compact (status + command/result), without recounting the standard checks.
+11. File boundaries: do not go beyond the "file set" from the call boundaries (paths + the search rule for similar places of the class); a file/class shared with another writer — `needs_decision`, do not edit. Do not touch the main branch or others' worktrees; `git stash` and mutations of **others'** refs (`refs/stash`, `refs/heads/*` of other spaces) are forbidden; a commit into your own branch `fix/<round>-<n>` and `git switch -c` in your own worktree are allowed (do not use `git checkout -b`) — for the "before" use `git stash create`, `git show`, `git diff`.
+12. Preflight before the first edit (for a launch in a separate workspace): `git rev-parse --show-toplevel` must match the workspace from the boundaries; `git rev-parse --abbrev-ref HEAD` must not be the main branch (and not `HEAD`/detached); the space's canonical path must not be a subdirectory of the project root (`git -C <project> rev-parse --show-toplevel` + a comparison of path prefixes); any violation — `needs_decision` without edits. In a fresh worktree install the dependencies (`npm ci` / `bun install`) before the runs, otherwise `stand: unavailable`.
 
 BEFORE THE REPORT, reread the list and mark each finding: closed / not closed / needs a decision.
 
-REPORT FORMAT (SGR — mandatory): a short summary + json:
+REPORT FORMAT (SGR — mandatory): a short summary + json (when launched in a separate workspace the `workspace` object is mandatory: branch, worktree, base_commit — the root transfers by commit SHA; for a solo launch the object is omitted):
 {
   "schema": "fix-runner/v1",
   "round": "<id>",
   "commit": "<hash or null>",
+  "workspace": {"branch": "fix/<round>-<n>", "worktree": "<absolute path>", "base_commit": "<sha>"},
   "results": [
     {"id": "...", "status": "closed|not_closed|needs_decision|budget_exceeded",
      "change": "file:line — the gist of the fix",
@@ -56,4 +59,5 @@ CONSTRAINTS:
 - No refactorings or "improvements" outside the list.
 - **Absolutely (independent of the call boundaries):** do not change the frontmatter (mode/model/permissions) of any agents; do not change your own definition `fix-runner.md`; edits of the kit's agents/docs — only as a separate task by an explicit owner decision. Other fixes — within the limits stated in the call.
 - Do not touch others' branches and others' uncommitted changes.
+- When run in parallel you work in your own workspace (a separate worktree outside the project tree and a separate branch from the call boundaries): do not touch the main branch or other worktrees; in the report name the `workspace` object — branch, worktree and base_commit (the root transfers by commit SHA).
 - The report is in English, without fluff.

package/agents/en/orchestrator.md

@@ -15,7 +15,7 @@ You are the root orchestrator. Your job is to turn the user's goal into a finish
 GENERAL CYCLE:
 1. Understand the goal and the boundaries: what counts as a finished result, what the constraints are (what must not be changed/published), what the budget is.
 2. Gather context: read the key files; if the task is about a change — pin down the state (base/range), and, if needed, make a copy for a "blind" check.
-3. Decompose: a list of steps with acceptance criteria for each. Run independent steps in parallel (writers — strictly sequentially).
+3. Decompose: a list of steps with acceptance criteria for each. Run independent steps in parallel (one writer per workspace; several `fix-runner` instances — only in isolated workspaces and without overlapping file sets, see "Rules").
 4. Delegate to subagents:
    - research on code — `explore`; on topics and data — `general`;
    - verification of a change/plan/release — the audit loop (see the mode below);
@@ -45,8 +45,9 @@ The AUDIT MODE turns on when the task is to verify a change (diff/PR/range), a p
 - In the end, report: the number of rounds, what was closed, the accepted risks.
 
 RULES:
-- Only one writer at any moment: the root (micro-fixes) or `fix-runner` (medium/large ones); do not run two writers on the same files.
-- Parallel background tasks — read-only roles only; writers — strictly sequentially. In the audit mode the writers are only the root and `fix-runner`; `general` — only large tasks outside the audit mode.
+- One writer **per workspace**: the root (micro-fixes) or `fix-runner` (medium/large ones). Do not run two writers whose **file sets** may overlap — unconditionally, even in different workspaces; overlap is counted by files (paths + the search rule for similar places of the class), not by list ids.
+- Several `fix-runner` instances may run in parallel (background) — only in **separate workspaces**, and only when their **file sets** cannot overlap: each with its own git worktree **outside the project tree** and its own branch (`git worktree add -b fix/<round>-<n> <path> <base>`; `worktree_create` — only with an immediate `git switch -c fix/<round>-<n>`), the "to close" lists and the file sets do not overlap (the root counts the overlap of the sets before launching: an overlap ⇒ serialization or splitting the paths). Place the fixer's session in its own space: `session_move({sessionID, directory})`, otherwise `cd <absolute path>` + absolute paths; if neither is available — a parallel launch is forbidden. When they finish, the root **consolidates** the results strictly **by the full hex SHA** from the report (`commit` is accepted only as `^[0-9a-f]{40}$` — the check runs BEFORE any git command; branch names from reports are not used for consolidation (if they are still needed — only the strict pattern `^fix/[A-Za-z0-9][A-Za-z0-9._-]*$` + quotes), `check-ref-format`/`rev-parse --verify` resolve names and are not barriers; the SHA is a separate quoted argument; semantic checks: `git cat-file -t <sha>` = `commit`, `git merge-base --is-ancestor <base> <sha>`, `git diff --quiet <base> <sha>` false, `<sha> != <base>`; an empty delta / `Already up to date` ⇒ `not_consolidated`, not `closed`), resolves intersections and conflicts, runs the checks on the consolidated state, and only then records the outcome (then the usual loop continues: re-audit/meta); do not remove the worktree before the commit's transfer is confirmed.
+- Parallel background tasks: read-only roles — freely; parallel `fix-runner` — only per the isolated-workspaces rule (above); meanwhile the root does not write to the files the fixers are editing. In the audit mode the writers are only the root and `fix-runner`; `general` — only large tasks outside the audit mode.
 - In the audit mode you do not audit yourself and do not substitute for the auditors' verdicts; disputed matters — only `arbiter`.
 - In the audit mode — do not fix before the verdict: fixes (root or `fix-runner`) start only after the summary's verdict is recorded, and for MAJOR — after independent verification/arbitration.
 - The subagents are universal; project specifics — only in the task.

package/agents/ru/fix-runner.md

@@ -14,7 +14,7 @@ permissions:
 
 ВХОД (из промпта вызова): список находок вида
 `id | локация | механизм | класс/область (пути + правило поиска однотипных мест) | repro-команда (до) | критерий приёмки (после) | severity`,
-плюс границы (какие пути/репозиторий/ветку можно менять), запреты, бюджет/лимит (время, число правок) и нужно ли коммитить.
+плюс границы (какие пути/**набор файлов**/репозиторий/ветку можно менять, рабочее пространство и база), запреты, бюджет/лимит (время, число правок) и нужно ли коммитить.
 
 ПРАВИЛА:
 1. Работай ТОЛЬКО по перечисленным находкам. Ничего «заодно» рядом не исправляй; заметил другое — запиши в «замечено вне списка», не трогай.
@@ -25,16 +25,19 @@ permissions:
 6. Мутации — только в целевых путях и временных каталогах. Если нужен коммит — отдельным коммитом с сообщением `fix-<round>: <кратко>`.
 7. Подтверждение закрытия — load-bearing: где применимо, тест/проверка обязан FAIL при откате правки и PASS с ней; проверка воспроизводимой командой; правка — на уровне класса дефекта (все однотипные места), а не одного сайта. Сверх перечисленных сайтов править можно только сайты объявленного класса/области; выход за неё — статус `needs_decision`, не импровизация.
 8. Named exits: исчерпание бюджета вызова (время/число правок) → статус `budget_exceeded` (расширение бюджета или разбиение списка — решение root/владельца); `needs_decision` — только для выбора/спорного вопроса, не для бюджета.
-9. Стенд проверок (применим, когда объект аудита — сам комплект; в раундах по другим проектам — только если стенд явно включён в границы вызова): инструменты стенда — в каталоге комплекта (`tools/`): **верификатор `kit-verify`** (baseline до правок; для проектной копии — с параметром `--proj <проектный каталог агентов>`; повторный прогон после правок) и **синхронизатор `kit-sync`** (синк копий агентов/доков и снимок конфигурации; проектный каталог передаётся параметром). Точная команда запуска — по README комплекта (в синтаксисе вашей среды). Порядок: baseline → правки → синк → повторный `kit-verify`; оба вывода — в поле `stand` отчёта (итог/rc + краткий вывод). Если инструменты не поставляются или стенд неприменим — `stand: unavailable: <почему>` и собственные воспроизводимые проверки. Самописные проверочные скрипты — только для специфичных repro-случаев, стандартные проверки не дублируй.
+9. Стенд проверок (применим, когда объект аудита — сам комплект; в раундах по другим проектам — только если стенд явно включён в границы вызова): инструмент стенда — **верификатор `kit-verify`** (`tools/kit-verify` каталога комплекта; baseline до правок, повторный прогон после правок). Команда запуска: `bun tools/kit-verify.ts` в каталоге комплекта (для проектной копии — `bun <kit>/tools/kit-verify.ts --proj <каталог проекта>`). Порядок: baseline → правки → повторный `kit-verify`; оба вывода — в поле `stand` отчёта (итог/rc + краткий вывод). Стенд поставляется в git-чекауте комплекта: в npm-пакете каталог `tools/` не поставляется, поэтому для установленного пакета — `stand: unavailable` и собственные воспроизводимые проверки. Если стенд неприменим — `stand: unavailable: <почему>` и собственные воспроизводимые проверки. Самописные проверочные скрипты — только для специфичных repro-случаев, стандартные проверки не дублируй.
 10. Экономия шагов: читай только участки, указанные в СПИСКЕ (якоря file:line/фрагмент), полный файл — лишь при необходимости сверки; правки одного файла ИЗ СПИСКА применяй одним заходом; поиск однотипных мест ограничен объявленным классом/областью (пути + правило поиска из списка) — всё прочее, включая найденное рядом, идёт в `out_of_scope`, а не в правку; отчёт — компактный (статус + команда/результат), без пересказа стандартных проверок.
+11. Границы по файлам: не выходи за «набор файлов» из границ вызова (пути + правило поиска однотипных мест класса); общий файл/класс с другим писателем — `needs_decision`, не правь. Основную ветку и чужие worktree не трогай; запрещены `git stash` и мутации **чужих** refs (`refs/stash`, `refs/heads/*` других пространств); коммит в свою ветку `fix/<round>-<n>` и `git switch -c` в своём worktree — разрешены (`git checkout -b` не использовать) — для «до» используй `git stash create`, `git show`, `git diff`.
+12. Preflight до первой правки (для запуска в отдельном рабочем пространстве): `git rev-parse --show-toplevel` должен совпасть с рабочим пространством из границ; `git rev-parse --abbrev-ref HEAD` не должен быть основной веткой (и не `HEAD`/detached); канонический путь пространства не должен быть подкаталогом корня проекта (`git -C <project> rev-parse --show-toplevel` + сравнение префиксов путей); любое нарушение — `needs_decision` без правок. В свежем worktree поставь зависимости (`npm ci` / `bun install`) до прогонов, иначе `stand: unavailable`.
 
 ПЕРЕД ОТЧЁТОМ перечитай список и отметь по каждой находке: закрыто / не закрыто / требует решения.
 
-ФОРМАТ ОТЧЁТА (SGR — обязателен): краткое резюме + json:
+ФОРМАТ ОТЧЁТА (SGR — обязателен): краткое резюме + json (при запуске в отдельном рабочем пространстве объект `workspace` обязателен: ветка, worktree, base_commit — перенос root делает по commit SHA; для одиночного запуска объект опускается):
 {
   "schema": "fix-runner/v1",
   "round": "<id>",
   "commit": "<hash или null>",
+  "workspace": {"branch": "fix/<round>-<n>", "worktree": "<абс. путь>", "base_commit": "<sha>"},
   "results": [
     {"id": "...", "status": "closed|not_closed|needs_decision|budget_exceeded",
      "change": "file:line — суть правки",
@@ -56,4 +59,5 @@ permissions:
 - Никаких рефакторингов и «улучшений» вне списка.
 - **Абсолютно (не зависит от границ вызова):** не менять frontmatter (mode/model/permissions) любых агентов; не менять собственное определение `fix-runner.md`; правки агентов/доков кита — только отдельной задачей по явному решению владельца. Остальные правки — в пределах, указанных в вызове.
 - Не трогать чужие ветки и чужие незакоммиченные изменения.
+- При параллельном запуске ты работаешь в своём рабочем пространстве (отдельный worktree вне дерева проекта и отдельная ветка из границ вызова): не трогай основную ветку и чужие worktree; в отчёте укажи объект `workspace` — ветку, worktree и base_commit (перенос root делает по commit SHA).
 - Отчёт — по-русски, без воды.

package/agents/ru/orchestrator.md

@@ -15,7 +15,7 @@ permissions:
 ОБЩИЙ ЦИКЛ:
 1. Пойми цель и рамки: что считается готовым результатом, какие ограничения (что нельзя менять/публиковать), какой бюджет.
 2. Собери контекст: прочитай ключевые файлы; если задача про изменение — зафиксируй состояние (база/диапазон), при необходимости сделай копию для «слепой» проверки.
-3. Декомпозируй: список шагов с критериями приёмки на каждый. Независимые шаги запускай параллельно (писатели — строго последовательно).
+3. Декомпозируй: список шагов с критериями приёмки на каждый. Независимые шаги запускай параллельно (писатель один на рабочее пространство; несколько `fix-runner` — только в изолированных рабочих пространствах и без пересечения наборов файлов, см. «Правила»).
 4. Делегируй субагентам:
    - исследование по коду — `explore`; по темам и данным — `general`;
    - проверка изменения/плана/релиза — аудиторский контур (см. режим ниже);
@@ -45,8 +45,9 @@ permissions:
 - В итоге сообщай: число кругов, что закрыто, принятые риски.
 
 ПРАВИЛА:
-- Единственный писатель в каждый момент: root (микроправки) или `fix-runner` (средние/крупные); не запускай двух писателей по одним файлам.
-- Параллельные background-задачи — только read-only роли; писатели — строго последовательно. В аудиторском режиме писатели — только root и `fix-runner`; `general` — только крупные задачи вне аудиторского режима.
+- Писатель один **на рабочее пространство**: root (микроправки) или `fix-runner` (средние/крупные). Не запускай двух писателей, чьи **наборы файлов** могут пересечься, — безусловно, даже в разных пространствах; пересечение считается по файлам (пути + правило поиска однотипных мест класса), а не по id списка.
+- Несколько `fix-runner` можно запускать параллельно (background) — только в **разных рабочих пространствах**, и только когда их **наборы файлов** не могут пересечься: каждому отдельный git worktree **вне дерева проекта** и отдельная ветка (`git worktree add -b fix/<round>-<n> <путь> <base>`; `worktree_create` — только с немедленным `git switch -c fix/<round>-<n>`), списки «к закрытию» и наборы файлов не пересекаются (пересечение наборов root считает до запуска: пересечение ⇒ сериализация или разнесение путей). Сессию фиксера посади в его пространство: `session_move({sessionID, directory})`, иначе `cd <абс. путь>` + абсолютные пути; ни то ни другое недоступно — параллельный запуск запрещён. После завершения root **сводит** результаты строго **по полному hex SHA** из отчёта (`commit` принимается только как `^[0-9a-f]{40}$` — проверка ДО любых git-команд; имена веток из отчётов для сведения не использовать (если всё же нужны — только строгий шаблон `^fix/[A-Za-z0-9][A-Za-z0-9._-]*$` + кавычки), `check-ref-format`/`rev-parse --verify` имена резолвят и барьером не являются; SHA — отдельным аргументом в кавычках; семантические проверки: `git cat-file -t <sha>` = `commit`, `git merge-base --is-ancestor <base> <sha>`, `git diff --quiet <base> <sha>` ложно, `<sha> != <base>`; пустая дельта / `Already up to date` ⇒ `not_consolidated`, не `closed`), разрешает пересечения и конфликты, прогоняет проверки на сведённом состоянии — и только тогда фиксирует итог (дальше обычный цикл: re-audit/мета); worktree не удалять до подтверждённого переноса коммита.
+- Параллельные background-задачи: read-only роли — свободно; параллельные `fix-runner` — только по правилу изолированных пространств (выше); root в это время не пишет в файлы, которые правят фиксеры. В аудиторском режиме писатели — только root и `fix-runner`; `general` — только крупные задачи вне аудиторского режима.
 - В аудиторском режиме ты не аудируешь сам и не подменяешь вердикты аудиторов; спорное — только `arbiter`.
 - В аудиторском режиме — до вердикта не править: правки (root или `fix-runner`) начинаются только после фиксации вердикта свода, а для MAJOR — после независимой верификации/арбитража.
 - Субагенты универсальны; проектная конкретика — только в задании.

package/docs/en/call-mechanics.md

@@ -110,15 +110,20 @@ Outcome: confirmed → a fix; refuted → dismiss it + a record in the audit noi
 ### Phase 5. Fixes and repeat
 - Fixes start only after the summary's verdict is recorded (and verification/arbitration has been done). Do not fix before the verdict.
 - Fixes by threshold: micro-fixes (1–3 lines, texts/docs) — the root itself; medium/large ones (multi-file, logic, tests) — the `fix-runner` subagent; a disputed matter is decided by the root before delegation (after the arbiter).
+- Several `fix-runner` instances in parallel — only in separate workspaces, and only when their **file sets** cannot overlap. The rule is unconditional: "one writer per workspace; do not run two writers whose **file sets** may overlap" (even in different workspaces). Non-overlap is counted by files (paths + the search rule for similar places of the class), not by list ids; an overlap of the sets ⇒ serialization of the fixers or splitting the paths.
+- The fixer's workspace is a git worktree **outside the project tree** with its own branch: the main path is `git worktree add -b fix/<round>-<n> <path> <base>`; `worktree_create` — only with an immediate `git switch -c fix/<round>-<n>` (a detached HEAD is unusable for consolidation). Placing the session: `session_move({sessionID, directory})` if the tool is available, otherwise `cd <absolute path>` and absolute paths; if neither is available — a parallel launch is forbidden.
+- Consolidation is strictly **by the full hex SHA** from the report: `commit` is accepted only as a full hex SHA — the check `^[0-9a-f]{40}$` runs BEFORE any git command (`git check-ref-format --branch` is NOT a barrier: a refname admits `; & | > # $()` and backticks; `git rev-parse --verify '<x>^{commit}'` also resolves names). The SHA is passed to commands as a **separate quoted argument** (`git cat-file -t "$sha"`); report strings are never substituted into shell words. Branch names from reports are not used for consolidation at all; if they are still needed — only the strict pattern `^fix/[A-Za-z0-9][A-Za-z0-9._-]*$` + quotes. Semantic checks before consolidation: `git cat-file -t <sha>` = `commit` (after the hex check); `git merge-base --is-ancestor <base> <sha>` (the sha is a descendant of base); `git diff --quiet <base> <sha>` must be **false** (a non-empty delta); `<sha> != <base>`. `Already up to date` (an empty delta) ⇒ the status **`not_consolidated`**, not `closed`; no `commit` or `workspace` in the report ⇒ **`not_closed`** (the root's precondition). Do not merge a branch/commits without a `closed` report; `closed` and the acceptance proof (after/stand) are recorded on the consolidated commit SHA; do not remove the worktree before the commit's transfer is confirmed, afterwards — `git worktree remove --force` and a deliberate decision on the branch. No report arrived (`no_report`: the fixer crashed/timed out) — the root records the work (worktree, branch, base SHA) and `no_report` in the summary; the priority is a resume in the same worktree, otherwise remove the worktree and decide the branch's fate; a partial commit without a report is not merged into the main branch.
 - Calling the fix-runner:
 ```
 subagent({agent:"fix-runner", prompt:"To close:\n1) <id | location | mechanism |
  class/area (paths + a search rule for similar places) | repro command (before) |
- acceptance criterion (after) | severity>\nBoundaries: <paths/branch>; budget/limit: <time, number of
- fixes>; commit: <yes/no, message fix-<round>>. Return fix-runner/v1."})
+ acceptance criterion (after) | severity>\nBoundaries: file set: <paths>; workspace:
+ <absolute path of a worktree outside the project tree>; branch: fix/<round>-<n>; base: <sha>;
+ budget/limit: <time, number of fixes>; commit: <yes/no, message fix-<round>>.
+ Return fix-runner/v1."})
 ```
-- The root checks the delta (`git show --stat` + a key run) before the re-audit and updates the registry.
-- The round's test stand (if the kit ships a verification stand — the tools `tools/kit-verify` (the verifier) and `tools/kit-sync` (sync of copies + a snapshot) in the kit directory; in rounds on other projects — only if the stand is explicitly included in the call boundaries): baseline → fixes → sync of copies and a repeat run of the stand; the baseline→after delta is attached to the report (the `stand` field).
+- The root checks the delta (`git diff <round-base>..HEAD --stat` + a key run) before the re-audit and updates the registry.
+- The round's test stand (if the kit ships a verification stand — the tool `tools/kit-verify` (the verifier) in the kit directory; in rounds on other projects — only if the stand is explicitly included in the call boundaries): baseline → fixes → a repeat run of the stand; the baseline→after delta is attached to the report (the `stand` field). The stand is shipped in the kit's git checkout: the npm package does not ship the `tools/` directory → `stand: unavailable` and your own reproducible checks.
 - **re-audit = resuming the same sessions**:
 ```
 subagent({agent:"empiric", sessionID:<emp>, background:true,
@@ -165,7 +170,7 @@ subagent({agent:"redteam", background:true,
 | the pair → root | full SGR reports | JSON blocks |
 | root → the arbiter | only disputed items + evidence from both sides | list |
 | root → the verifier | a MAJOR finding (id, text, the author's evidence, the state revision) | text |
-| root → fix-runner | the "to close" list (id, location, class/area, repro command (before), acceptance criterion (after), severity) + boundaries/budget | text |
+| root → fix-runner | the "to close" list (id, location, class/area, repro command (before), acceptance criterion (after), severity) + boundaries (file set, workspace, branch, base) and budget | text |
 | root → re-audit | the fixes delta + the actual list of changed files + the list of what was closed | text |
 | root → redteam | the submission + the summary of all rounds | text |
 | redteam → root | SGR | JSON |
@@ -194,6 +199,7 @@ Persistence (all kit documents): the SGR reports of all roles, including **the S
 ## 5. Failures and recovery
 
 - A subagent crashed/was interrupted → resume with "continue from where you stopped, do not redo"; on `Agent not found` — check the agent files. Do not mix the sources: the agent definitions are in the kit directory (`agents/`); the copies are in your harness's global agents directory (the path depends on the OS) and the harness's project agents directory; configuration snapshot/restore is `tools/config-guard` (the kit's configuration guard, if shipped), not the agents.
+- A repeated fixer launch after an incident in the same space — a resume in the same worktree or an explicit removal/rename of the branch by the root's decision (a repeated `git worktree add -b fix/<round>-<n>` fails while the branch is busy); a `locked` worktree — `git worktree unlock` or `git worktree remove -f -f`.
 - The model/provider is unavailable → wait/switch the model by the owner's decision, keep the sessions.
 - A restricted environment (Code Mode: actions only via `execute`+directory, `subagent` unavailable) → the audit loop does not start; the outcome is "done; the regular audit is deferred" with the revision and the run plan (§8).
 - The `arbiter` is unavailable or its budget is exhausted → the root examines the disputed item one by one on facts/quotes and records it as a risk and escalates to the owner.
@@ -216,7 +222,8 @@ Persistence (all kit documents): the SGR reports of all roles, including **the S
 
 ## 7. Process invariants
 
-- The root does not audit and does not substitute for the verdicts; at any moment there is a single writer: the root (micro-fixes) or `fix-runner` (medium/large ones).
+- The root does not audit and does not substitute for the verdicts; there is a single writer **per workspace**: the root (micro-fixes) or `fix-runner` (medium/large ones); several `fix-runner` instances — in parallel only in separate worktrees, with the root consolidating afterwards.
+- Do not run two writers whose **file sets** may overlap — unconditionally, regardless of the workspace: non-overlapping "to close" lists do not replace the check of overlapping file sets (paths + the class's search rule).
 - The auditors are read-only; project specifics — only in the brief.
 - Fixes start only after the summary's verdict is recorded (and MAJOR verification/arbitration has been done). Do not fix before the verdict.
 - MAJOR findings go into fixes only after independent verification (Phase 3.5); the verifier's default is "not confirmed" (fail-closed).

package/docs/en/instruction-other-session.md

@@ -27,7 +27,7 @@ Budget: <BUDGET>
 Mode: <MODE>
 
 The loop's rules:
-- The auditors are read-only subagents; you make the fixes (micro-fixes) or delegate them to `fix-runner` (medium/large ones). You are the orchestrator: the brief, the launch, the consolidation of the reports, decisions, fixes. You do not audit yourself.
+- The auditors are read-only subagents; you make the fixes (micro-fixes) or delegate them to `fix-runner` (medium/large ones). You are the orchestrator: the brief, the launch, the consolidation of the reports, decisions, fixes. You do not audit yourself. Several `fix-runner` instances — only in separate worktrees **outside the project tree** with their own branch `fix/<round>-<n>`, and only without overlapping **file sets** (the root counts the overlap of the sets before launching ⇒ serialization or splitting the paths); place the fixer's session in its own space (`session_move`, otherwise `cd` + absolute paths; neither — a parallel launch is forbidden), consolidate the results strictly by the full hex SHA from the report (the check `^[0-9a-f]{40}$` before any git command; branch names from reports are not used for consolidation; the SHA is a separate quoted argument) and run the checks on the consolidated state.
 - Communication — via the brief file and SGR reports. Do NOT poll background subagents: the notifications arrive on their own.
 - The loop lives until FULL ready: all roles ready, no open MAJORs, MINOR/NIT closed or explicitly accepted.
 - Disputed matters are resolved by `arbiter` (disputed items only); the unprovable → the owner's decision: the root frames the question, records the risk and escalates.
@@ -49,7 +49,7 @@ Steps:
    partial/unavailable = "not confirmed"; a verifier failure/timeout — the same + noise. The refuted ones — into the refuted list; write the statuses into the summary `reports/summary-<id>.md`; an unconfirmed MAJOR does not go into fixes.
    Conflicts → subagent(agent="arbiter", prompt="Disputed items: <item → evidence A → evidence B>. For each: confirmed/refuted/undecidable + the prism (reproducibility|contract|falsification|not_applicable; for several — an array) + the method of checking. Only these items.")
    The summary's verdict (and the verification/arbitration) is recorded BEFORE the fixes and together with the state revision (hash/commit); a fix after the verdict is recorded → a repeat run (re-audit) or an explicit downgrade of the verdict: do not fix before the verdict.
-5) Fixes by threshold: micro-fixes — yourself; medium/large ones — subagent(agent="fix-runner", prompt="To close: <id | location | mechanism | class/area (paths + a search rule for similar places) | repro (before) | acceptance criterion (after)>. Boundaries: <…>; budget/limit: <time, number of fixes>; commit fix-<round>. Return fix-runner/v1."). Before the re-audit check the delta (git show --stat + a key run); update risks.md (closed / accepted-risk with a reason).
+5) Fixes by threshold: micro-fixes — yourself; medium/large ones — subagent(agent="fix-runner", prompt="To close: <id | location | mechanism | class/area (paths + a search rule for similar places) | repro (before) | acceptance criterion (after)>. Boundaries: file set: <paths>; workspace: <absolute path of a worktree outside the project tree>; branch: fix/<round>-<n>; base: <sha>; budget/limit: <time, number of fixes>; commit fix-<round>. Return fix-runner/v1."). Before the re-audit check the delta (git diff <round-base>..HEAD --stat + a key run) and the consolidation by the full hex SHA (^[0-9a-f]{40}$ before any git command + git cat-file -t <sha> = commit, git merge-base --is-ancestor <base> <sha>, a non-empty delta: git diff --quiet <base> <sha> false; an empty delta / Already up to date ⇒ not_consolidated, not closed); update risks.md (closed / accepted-risk with a reason).
 6) Re-audit — resuming the SAME sessions (background, one block):
    subagent(agent="empiric",   sessionID="<emp>", background=true, prompt="Fixes: <range + the actual list of changed files>; closed: <…>. Check the closure of your findings and the absence of regressions on the new state; return the updated SGR.")
    subagent(agent="invariant", sessionID="<inv>", background=true, prompt="… same …")

package/docs/en/process-ready-loop.md

@@ -22,6 +22,8 @@ Numbering: "[N]" — the steps of this document (`process-ready-loop.md`); "Phas
      │         for a commit/PR: SHIP if there were no fixes after the verdict (the red team and meta are not mandatory)
      └─ NO ─► [2] FIXES (close the MAJORs; MINOR/NIT — close or explicitly accept with a rationale, a record in risks-<id>.md)
                 ▼
+           [2a] CONSOLIDATION (if there were several fixers: merge the branches by commit SHA → checks on the consolidated state)
+                ▼
            [3] NEW STATE X1 (the fixes are committed/recorded)
                 ▼
            repeat [1] on X1 (both auditors, the same brief)
@@ -39,7 +41,7 @@ At the release gates the loop is the same, plus after the first full ready — t
 1. All roles (the empiric, the invariant; at the gates — the red team as well) — `verdict=ready`.
 2. No open MAJORs. MINOR/NIT: closed or **explicitly accepted** with a reason (a record in `risks-<id>.md`; in the summary/PR: "accepted as debt: …").
 3. All discrepancies are resolved by the arbiter; the unprovable → the owner's decision: the root frames the question, records the risk and escalates.
-4. The repeat run is based **on the state after the fixes**, not on the old diff. No "re-votings" on the same snapshot.
+4. The repeat run is based **on the state after the fixes**, not on the old diff. No "re-votings" on the same snapshot. With several fixers, X1 is reached by consolidating their branches by commit SHA and by checks on the consolidated state; `closed` is recorded after consolidation.
 5. At the release gates — `meta` = pass (`gate`=pass), `closing_list` is empty/closed, `coverage_gaps` accepted by the owner (a record in `risks-<id>.md`). **SHIP ⟺ `meta.gate`=pass ∧ `closing_list` is empty/closed ∧ `coverage_gaps` accepted by the owner (a record in `risks-<id>.md`); otherwise ship is forbidden.**
 6. MAJOR findings go into fixes only after independent verification; the verifier's default is "not confirmed" (fail-closed).
 7. The verdict and the verification are recorded together with the state revision (directory hash/commit); any fix after the verdict is recorded → a repeat run (re-audit) or an explicit downgrade of the verdict.

package/docs/en/root-runbook.md

@@ -26,8 +26,8 @@ A "Fact-check (pre-pass): …" block is added to the pair's prompts — 5–15 l
 3. **Summary by the root**: parse the JSON blocks; determine the verdicts (ready/not_ready), open MAJORs, intersections and discrepancies (by location+mechanism). Materialize the summary artifact `reports/summary-<id>.md` (definition — `call-mechanics.md` §4): for every MAJOR — {id, verifier_role, verdict, evidence}; the refuted list (explicit, even if empty); accepted risks; the state revision (directory hash/commit).
 4. **Verification of MAJORs (cross-verification, fail-closed)**: every MAJOR finding is confirmed independently by **the session of the opposite role** (not by the author of the finding) — `subagent(agent="<sibling>", sessionID=<session of the opposite role>, prompt="A counterpart's finding <id>: <text>. The author's evidence: <command→output>. State revision: <directory hash/commit>. Confirm or refute it by reproducing it yourself; the default is not confirmed. Return: {id, verifier_role, verdict: confirmed|refuted|partial|unavailable, evidence}.")`. `verifier_role` ≠ the author's role; `partial`/`unavailable` = "not confirmed"; `refuted` — into the refuted list for the summary; a verifier failure/timeout — "not confirmed" + noise. Not confirmed → it does not go into fixes (a dispute → step 5, the arbiter); the verification statuses are written to the summary `reports/summary-<id>.md` (step 3). If a MAJOR finding is independently reproduced by both roles in their own runs — the mutual confirmation counts as verification (both sides are recorded in the summary), a separate run is not required. The sessionID in the call is mandatory: without it this is a new session, not a continuation — a step defect.
 5. **The arbiter — only on discrepancies**: `subagent(agent="arbiter", prompt="Disputed items: <item → evidence A → evidence B>. For each: confirmed/refuted/undecidable + a command/quote.")`. The summary's verdict (and the verification/arbitration) is recorded BEFORE the fixes and **together with the state revision** (directory hash/commit); any fix after the verdict is recorded → a repeat run (re-audit) or an explicit downgrade of the verdict: do not fix before the verdict.
-6. **Fixes** by threshold: micro-fixes — the root itself; medium/large ones — `fix-runner` (input: the "to close" list — id, location, mechanism, **class/area** (paths + a search rule for similar places), repro (before), acceptance criterion (after), severity — plus the boundaries and the **budget/limit (time, number of fixes)**; output: fix-runner/v1 with before/after/`proof`/tests). Separate commits `fix-<round>`; update the registry: `closed` / `accepted-risk` (with a reason). The root checks the delta before the re-audit. The round's test stand (if the kit ships a verification stand — the tools `tools/kit-verify` and `tools/kit-sync` of the kit directory; in rounds on other projects — only if the stand is explicitly included in the call boundaries): the stand's baseline into the fixer's prompt (if the output is passed — the fixer does not duplicate the run); closure — sync of the copies and a repeat run of the stand; both outputs — in the report's `stand` field. `fix-runner` statuses: `needs_decision` → the root's decision (for a dispute — the arbiter; if the decision is the owner's — escalation) with a record in the risk registry; `not_closed` → another iteration with the same id; the `out_of_scope` field (noticed outside the list) → include in the next "to close" list or escalate.
-7. **Re-audit = resuming the same sessions** (the sessionID from step 2): "Fixes: <range + the actual list of changed files>. Check the closure of your findings and the absence of regressions; return the updated SGR." — historically, that is how it was done (a continuation of the GLM/DS sessions). The sessionID is mandatory: a call without it (a new session instead of a continuation) — a step defect.
+6. **Fixes** by threshold: micro-fixes — the root itself; medium/large ones — `fix-runner` (input: the "to close" list — id, location, mechanism, **class/area** (paths + a search rule for similar places), repro (before), acceptance criterion (after), severity — plus the boundaries and the **budget/limit (time, number of fixes)**; output: fix-runner/v1 with before/after/`proof`/tests). Separate commits `fix-<round>`; update the registry: `closed` / `accepted-risk` (with a reason). The root checks the round's delta — `git diff <round-base>..HEAD --stat` (not only `git show --stat`) — before the re-audit. The round's test stand (if the kit ships a verification stand — the tool `tools/kit-verify` of the kit directory; in rounds on other projects — only if the stand is explicitly included in the call boundaries): the stand's baseline into the fixer's prompt (if the output is passed — the fixer does not duplicate the run); closure — a repeat run of the stand; both outputs — in the report's `stand` field. The stand is shipped in the kit's git checkout: the npm package does not ship the `tools/` directory → `stand: unavailable` and your own reproducible checks. `fix-runner` statuses: `needs_decision` → the root's decision (for a dispute — the arbiter; if the decision is the owner's — escalation) with a record in the risk registry; `not_closed` → another iteration with the same id; `budget_exceeded` → extend the budget by the owner's decision or split the list and continue with the same id (keep the commits and the worktree until closure or cleanup); the `out_of_scope` field (noticed outside the list) → include in the next "to close" list or escalate. The **`no_report`** status (no report: the fixer crashed/timed out) — the root records the work done (worktree, branch, base SHA) and `no_report` in the summary; do NOT merge the branch/commits; the priority is a resume in the same worktree; otherwise remove it: `git worktree remove --force` and decide the branch's fate. A partial commit without a report is not merged into the main branch. Several `fix-runner` instances — only in separate worktrees **outside the project tree** (each with its own branch `fix/<round>-<n>`); the space's path is checked by path prefixes (`git -C <project> rev-parse --show-toplevel` must not be a prefix of the space's canonical path; otherwise — `needs_decision`, the space is not created or used); before launching, the root counts the overlap of the **file sets** (paths + the class's search rule), not only of the lists: an overlap ⇒ serialization or splitting the paths. Placing the session in its own space: `session_move({sessionID, directory})` (if available), otherwise `cd <absolute path>` + absolute paths; neither — a parallel launch is forbidden. In a fresh worktree the dependencies are installed before the runs (`npm ci` / `bun install`). Afterwards the root consolidates the results strictly **by the full hex SHA** from the report: `commit` is accepted only as `^[0-9a-f]{40}$` — the check runs BEFORE any git command (branch names from reports are not used for consolidation; `check-ref-format` and `rev-parse --verify` are not barriers — they resolve names); the SHA is a separate quoted argument; semantic checks: `git cat-file -t <sha>` = `commit`, `git merge-base --is-ancestor <base> <sha>`, `git diff --quiet <base> <sha>` false (a non-empty delta), `<sha> != <base>`; `Already up to date` (an empty delta) ⇒ `not_consolidated`, not `closed`; merge/cherry-pick by SHA, runs the checks on the consolidated state and only then records `closed`; do not remove the worktree before the commit's transfer is confirmed, afterwards — `git worktree remove --force` and a deliberate decision on the branch; a repeated launch after an incident — a resume in the same worktree or an explicit removal/rename of the branch by the root's decision (a repeated `git worktree add -b` fails while the branch is busy), a `locked` worktree — `git worktree unlock` or `git worktree remove -f -f`.
+7. **Re-audit = resuming the same sessions** (the sessionID from step 2): "Fixes: <range + the actual list of changed files>. Check the closure of your findings and the absence of regressions; return the updated SGR." — historically, that is how it was done (a continuation of the GLM/DS sessions). The sessionID is mandatory: a call without it (a new session instead of a continuation) — a step defect. Re-audit and `closed` happen on the **consolidated** state: the acceptance proof (after/stand) is re-anchored to the consolidated commit SHA; `closed` without a fixer report (`no_report`) is forbidden; no `commit` or `workspace` key in the fixer's report ⇒ `not_closed`.
 8. **Repeat steps 3–7 until full ready is reached** (the number of rounds is unlimited; all roles ready, MAJOR=0). From round 3 on, unresolved items — the arbiter one by one; recurring false ones — dismiss and record in the audit noise.
 9. **Gates (release; order: red team → meta)**: a frozen commit → `redteam` (the falsification mandate + corpora/test stands) → a loop over its findings (MAJORs — with verification by the session of the opposite role) → `meta` (input: the reports + the summary `reports/summary-<id>.md`; evidence, completeness, the absence of "green tests = checked").
    - **SHIP ⟺ `meta.gate`=pass ∧ `closing_list` is empty/closed ∧ `coverage_gaps` accepted by the owner (a record in `risks-<id>.md`); otherwise ship is forbidden.**
@@ -41,7 +41,7 @@ A "Fact-check (pre-pass): …" block is added to the pair's prompts — 5–15 l
 - the root → re-audit: the fixes range + a brief "what was closed";
 - the root → the red team: the author's submission + the summary of all previous rounds (the object of falsification);
 - the root → meta: the reports (paths) + the summary `reports/summary-<id>.md`;
-- the root → fix-runner: the "to close" list (with the class/area) + boundaries + budget/limit (time, number of fixes).
+- the root → fix-runner: the "to close" list (with the class/area) + boundaries (including the **file set**, the worktree outside the project tree, the branch `fix/<round>-<n>`, the base SHA) + budget/limit (time, number of fixes); for a parallel launch — a separate space and branch per fixer, and the root checks the file sets for overlap before launching;
 
 ## Subtleties
 

package/docs/ru/call-mechanics.md

@@ -110,15 +110,20 @@ subagent({
 ### Фаза 5. Правки и повтор
 - Правки начинаются только после фиксации вердикта свода (и верификации/арбитража). До вердикта — не править.
 - Правки по порогу: микроправки (1–3 строки, тексты/доки) — root сам; средние/крупные (мультифайл, логика, тесты) — субагент `fix-runner`; спорное до делегирования решает root (после арбитра).
+- Несколько `fix-runner` параллельно — только в отдельных рабочих пространствах, и только когда их **наборы файлов** не могут пересечься. Норма безусловна: «писатель один на рабочее пространство; не запускай двух писателей, чьи **наборы файлов** могут пересечься» (даже в разных пространствах). Непересечение считается по файлам (пути + правило поиска однотипных мест класса), а не по id списка; пересечение наборов ⇒ сериализация фиксеров либо разнесение путей.
+- Рабочее пространство фиксера — git worktree **вне дерева проекта** со своей веткой: основной путь `git worktree add -b fix/<round>-<n> <путь> <base>`; `worktree_create` — только с немедленным `git switch -c fix/<round>-<n>` (detached HEAD для сведения не годится). Посадка сессии: `session_move({sessionID, directory})`, если инструмент доступен, иначе `cd <абс. путь>` и абсолютные пути; если ни то ни другое недоступно — параллельный запуск запрещён.
+- Сведение — строго по **полному hex SHA** из отчёта: `commit` принимается только как полный hex SHA — проверка `^[0-9a-f]{40}$` ДО любых git-команд (`git check-ref-format --branch` барьером НЕ является: refname пропускает `; & | > # $()` и backticks; `git rev-parse --verify '<x>^{commit}'` тоже резолвит имена). SHA передаётся в команды **отдельным аргументом в кавычках** (`git cat-file -t "$sha"`); строки из отчётов в shell-слова не подставлять. Имена веток из отчётов для сведения не использовать вовсе; если всё же нужны — только строгий шаблон `^fix/[A-Za-z0-9][A-Za-z0-9._-]*$` + кавычки. Семантические проверки перед сведением: `git cat-file -t <sha>` = `commit` (после hex-проверки); `git merge-base --is-ancestor <base> <sha>` (sha — потомок base); `git diff --quiet <base> <sha>` должно быть **ложно** (дельта непуста); `<sha> != <base>`. `Already up to date` (пустая дельта) ⇒ статус **`not_consolidated`**, не `closed`; нет `commit` или `workspace` в отчёте ⇒ **`not_closed`** (precondition root'а). Ветку/коммиты без отчёта `closed` не сливать; `closed` и доказательство приёмки (after/stand) — на сведённом commit SHA; worktree не удалять до подтверждённого переноса коммита, после — `git worktree remove --force` и осознанное решение по ветке. Отчёт не пришёл (`no_report`: фиксер упал/таймаут) — root фиксирует в своде работу (worktree, ветка, base SHA) и `no_report`; приоритет — resume в том же worktree, иначе убрать worktree и решить судьбу ветки; частичный коммит без отчёта в основную ветку не вливается.
 - Вызов фиксера:
 ```
 subagent({agent:"fix-runner", prompt:"К закрытию:\n1) <id | локация | механизм |
  класс/область (пути + правило поиска однотипных мест) | repro-до |
- критерий-после | severity>\nГраницы: <пути/ветка>; бюджет/лимит: <время, число
- правок>; коммит: <да/нет, сообщение fix-<round>>. Верни fix-runner/v1."})
+ критерий-после | severity>\nГраницы: набор файлов: <пути>; рабочее пространство:
+ <абс. путь worktree вне дерева проекта>; ветка: fix/<round>-<n>; base: <sha>;
+ бюджет/лимит: <время, число правок>; коммит: <да/нет, сообщение fix-<round>>.
+ Верни fix-runner/v1."})
 ```
-- Root проверяет дельту (`git show --stat` + ключевой прогон) до re-audit и обновляет реестр.
-- Стенд раунда (если в комплекте поставляется проверочный стенд — инструменты `tools/kit-verify` (верификатор) и `tools/kit-sync` (синк копий + снимок) каталога комплекта; в раундах по другим проектам — только если стенд явно включён в границы вызова): baseline → правки → синк копий и повторный прогон стенда; дельта baseline→after прикладывается к отчёту (поле `stand`).
+- Root проверяет дельту (`git diff <round-base>..HEAD --stat` + ключевой прогон) до re-audit и обновляет реестр.
+- Стенд раунда (если в комплекте поставляется проверочный стенд — инструмент `tools/kit-verify` (верификатор) каталога комплекта; в раундах по другим проектам — только если стенд явно включён в границы вызова): baseline → правки → повторный прогон стенда; дельта baseline→after прикладывается к отчёту (поле `stand`). Стенд поставляется в git-чекауте комплекта: в npm-пакете каталог `tools/` не поставляется → `stand: unavailable` и собственные воспроизводимые проверки.
 - **re-audit = resume тех же сессий**:
 ```
 subagent({agent:"empiric", sessionID:<emp>, background:true,
@@ -165,7 +170,7 @@ subagent({agent:"redteam", background:true,
 | пара → root | полные SGR-отчёты | JSON-блоки |
 | root → арбитр | только спорные пункты + evidence обеих сторон | список |
 | root → верификатор | находка MAJOR (id, текст, evidence автора, ревизия состояния) | текст |
-| root → fix-runner | список «к закрытию» (id, локация, класс/область, repro-до, критерий-после, severity) + границы/бюджет | текст |
+| root → fix-runner | список «к закрытию» (id, локация, класс/область, repro-до, критерий-после, severity) + границы (набор файлов, рабочее пространство, ветка, base) и бюджет | текст |
 | root → re-audit | дельта правок + фактический список изменённых файлов + список закрытого | текст |
 | root → redteam | заявка + свод всех кругов | текст |
 | redteam → root | SGR | JSON |
@@ -194,6 +199,7 @@ subagent({agent:"redteam", background:true,
 ## 5. Отказы и восстановление
 
 - Субагент упал/прерван → resume с «продолжи с места остановки, не переделывай»; при `Agent not found` — проверить файлы агентов. Источники не смешивать: определения агентов — каталог комплекта (`agents/`), копии — глобальный каталог агентов вашего харнесса (путь зависит от ОС) и проектный каталог агентов харнесса; снимок/восстановление конфигурации — `tools/config-guard` (хранитель конфигурации комплекта, если поставляется), не агенты.
+- Повторный запуск фиксера после инцидента в том же пространстве — resume в том же worktree либо явное удаление/переименование ветки решением root'а (повторный `git worktree add -b fix/<round>-<n>` падает, пока ветка занята); `locked` worktree — `git worktree unlock` либо `git worktree remove -f -f`.
 - Модель/провайдер недоступны → подождать/сменить модель по решению владельца, сессии сохранить.
 - Ограниченная среда (Code Mode: действия только через `execute`+каталог, `subagent` недоступен) → аудиторский цикл не запускается; итог — «готово; штатный аудит отложен» с ревизией и планом прогона (§8).
 - `arbiter` недоступен или бюджет исчерпан → root разбирает спорный пункт поштучно по фактам/цитатам и фиксирует как риск и эскалирует владельцу.
@@ -216,7 +222,8 @@ subagent({agent:"redteam", background:true,
 
 ## 7. Инварианты процесса
 
-- root не аудирует и не подменяет вердикты; писатель в каждый момент один: root (микроправки) или `fix-runner` (средние/крупные).
+- root не аудирует и не подменяет вердикты; писатель один **на рабочее пространство**: root (микроправки) или `fix-runner` (средние/крупные); несколько `fix-runner` — параллельно только в отдельных worktree и с последующим сведением root'ом.
+- Не запускай двух писателей, чьи **наборы файлов** могут пересечься, — безусловно, независимо от рабочего пространства: непересекающиеся списки «к закрытию» не заменяют проверку пересечения наборов файлов (пути + правило поиска класса).
 - Аудиторы read-only; проектная конкретика — только в брифе.
 - Правки начинаются только после фиксации вердикта свода (и верификации MAJOR/арбитража). До вердикта — не править.
 - MAJOR-находки входят в правки только после независимой верификации (Фаза 3.5); дефолт верификатора — «не подтверждена» (fail-closed).

package/docs/ru/instruction-other-session.md

@@ -27,7 +27,7 @@
 Режим: <РЕЖИМ>
 
 Правила контура:
-- Аудиторы — read-only субагенты; правки вносишь ты (микроправки) или делегируешь `fix-runner` (средние/крупные). Ты — оркестратор: бриф, запуск, свод отчётов, решения, правки. Сам не аудируешь.
+- Аудиторы — read-only субагенты; правки вносишь ты (микроправки) или делегируешь `fix-runner` (средние/крупные). Ты — оркестратор: бриф, запуск, свод отчётов, решения, правки. Сам не аудируешь. Несколько `fix-runner` — только в отдельных worktree **вне дерева проекта** со своей веткой `fix/<round>-<n>`, и только без пересечения **наборов файлов** (пересечение наборов root считает до запуска ⇒ сериализация или разнесение путей); сессию фиксера сажай в её пространство (`session_move`, иначе `cd` + абсолютные пути; ни то ни другое — параллельный запуск запрещён), своди результаты строго по полному hex SHA из отчёта (проверка `^[0-9a-f]{40}$` до git-команд; имена веток из отчётов для сведения не использовать; SHA — отдельным аргументом в кавычках) и прогоняй проверки на сведённом состоянии.
 - Общение — через бриф-файл и SGR-отчёты. Фоновых субагентов НЕ поллить: уведомления приходят сами.
 - Цикл живёт до ПОЛНОГО ready: все роли ready, открытых MAJOR нет, MINOR/NIT закрыты или явно приняты.
 - Спорное решает `arbiter` (только спорные пункты); недоказуемое → решение владельца: root оформляет вопрос, фиксирует риск и эскалирует.
@@ -49,7 +49,7 @@
    partial/unavailable = «не подтверждена»; сбой/таймаут верификатора — то же + шум. Опровергнутые — в список refuted; статусы пиши в свод reports/summary-<id>.md; неподтверждённая MAJOR в правки не идёт.
    Конфликты → subagent(agent="arbiter", prompt="Спорные пункты: <пункт → evidence A → evidence B>. По каждому: подтверждён/опровергнут/недоказуем + призма (reproducibility|contract|falsification|not_applicable; несколько — массив) + способ проверки. Только эти пункты.")
    Вердикт свода (и верификация/арбитраж) фиксируются ДО правок и вместе с ревизией состояния (хэш/коммит); правка после фиксации вердикта → повторный прогон (re-audit) либо явное понижение вердикта: до вердикта — не править.
-5) Правки по порогу: микроправки — сам; средние/крупные — subagent(agent="fix-runner", prompt="К закрытию: <id | локация | механизм | класс/область (пути + правило поиска однотипных мест) | repro-до | критерий-после>. Границы: <…>; бюджет/лимит: <время, число правок>; коммит fix-<round>. Верни fix-runner/v1."). Перед re-audit проверь дельту (git show --stat + ключевой прогон); обнови risks.md (closed / accepted-risk с причиной).
+5) Правки по порогу: микроправки — сам; средние/крупные — subagent(agent="fix-runner", prompt="К закрытию: <id | локация | механизм | класс/область (пути + правило поиска однотипных мест) | repro-до | критерий-после>. Границы: набор файлов: <пути>; worktree: <абс. путь вне дерева проекта>; ветка: fix/<round>-<n>; base: <sha>; бюджет/лимит: <время, число правок>; коммит fix-<round>. Верни fix-runner/v1."). Перед re-audit проверь дельту (git diff <round-base>..HEAD --stat + ключевой прогон) и сведение по полному hex SHA (^[0-9a-f]{40}$ до git-команд + git cat-file -t <sha> = commit, git merge-base --is-ancestor <base> <sha>, непустая дельта: git diff --quiet <base> <sha> ложно; пустая дельта / Already up to date ⇒ not_consolidated, не closed); обнови risks.md (closed / accepted-risk с причиной).
 6) Re-audit — resume ТЕХ ЖЕ сессий (background, один блок):
    subagent(agent="empiric",   sessionID="<emp>", background=true, prompt="Правки: <диапазон + фактический список изменённых файлов>; закрыто: <…>. Проверь закрытие своих находок и отсутствие регрессий на новом состоянии; верни обновлённый SGR.")
    subagent(agent="invariant", sessionID="<inv>", background=true, prompt="… то же …")

package/docs/ru/process-ready-loop.md

@@ -22,6 +22,8 @@
      │         для коммита/PR: SHIP, если правок после вердикта не было (ред-тим и мета не обязательны)
      └─ НЕТ ─► [2] ПРАВКИ (закрыть MAJOR; MINOR/NIT — закрыть или явно принять с обоснованием, запись в risks-<id>.md)
                 ▼
+           [2a] СВЕДЕНИЕ (если фиксеров было несколько: сведение веток по commit SHA → проверки на сведённом состоянии)
+                ▼
            [3] НОВОЕ СОСТОЯНИЕ X1 (фиксы закоммичены/зафиксированы)
                 ▼
            повтор [1] на X1 (оба аудитора, тот же бриф)
@@ -39,7 +41,7 @@
 1. Все роли (эмпирик, инвариантщик; на воротах — и ред-тим) — `verdict=ready`.
 2. Открытых MAJOR нет. MINOR/NIT: закрыты либо **явно приняты** с причиной (запись в `risks-<id>.md`; в сводке/PR: «принято как долг: …»).
 3. Все расхождения разрешены арбитром; недоказуемое → решение владельца: root оформляет вопрос, фиксирует риск и эскалирует.
-4. Повторный прогон идёт **по состоянию после правок**, а не по старому диффу. Никаких «переголосований» на том же снапшоте.
+4. Повторный прогон идёт **по состоянию после правок**, а не по старому диффу. Никаких «переголосований» на том же снапшоте. При нескольких фиксерах X1 достигается сведением их веток по commit SHA и проверками на сведённом состоянии; `closed` ставится после сведения.
 5. На релизных воротах — `meta` = pass (`gate`=pass), `closing_list` пуст/закрыт, `coverage_gaps` приняты владельцем (запись в `risks-<id>.md`). **SHIP ⟺ `meta.gate`=pass ∧ `closing_list` пуст/закрыт ∧ `coverage_gaps` приняты владельцем (запись в `risks-<id>.md`); иначе ship запрещён.**
 6. MAJOR-находки входят в правки только после независимой верификации; дефолт верификатора — «не подтверждена» (fail-closed).
 7. Вердикт и верификация фиксируются вместе с ревизией состояния (хэш каталога/коммит); любая правка после фиксации вердикта → повторный прогон (re-audit) либо явное понижение вердикта.

package/docs/ru/root-runbook.md

@@ -26,8 +26,8 @@
 3. **Свод root'ом**: распарсить JSON-блоки; вычислить вердикты (ready/not_ready), открытые MAJOR, пересечения и расхождения (по location+механизму). Материализовать свод-артефакт `reports/summary-<id>.md` (определение — `call-mechanics.md` §4): по каждой MAJOR — {id, verifier_role, verdict, evidence}; refuted-список (явный, даже пустой); принятые риски; ревизия состояния (хэш каталога/коммит).
 4. **Верификация MAJOR (перекрёстная, fail-closed)**: каждая MAJOR-находка подтверждается независимо **сессией противоположной роли** (не автором находки) — `subagent(agent="<sibling>", sessionID=<сессия противоположной роли>, prompt="Находка <id> контрагента: <текст>. Evidence автора: <команда→вывод>. Ревизия состояния: <хэш каталога/коммит>. Подтверди или опровергни своим воспроизведением; дефолт — не подтверждена. Верни: {id, verifier_role, verdict: confirmed|refuted|partial|unavailable, evidence}.")`. `verifier_role` ≠ роль автора; `partial`/`unavailable` = «не подтверждена»; `refuted` — в список refuted для сводки; сбой/таймаут верификатора — «не подтверждена» + шум. Не подтверждена → в правки не идёт (спор → шаг 5, арбитр); статусы верификации пишутся в свод `reports/summary-<id>.md` (шаг 3). Если MAJOR-находка независимо воспроизведена обеими ролями в их собственных прогонах — взаимное подтверждение засчитывается как верификация (обе стороны в свод), отдельный прогон не требуется. sessionID при вызове обязателен: без него это новая сессия, а не продолжение — дефект шага.
 5. **Арбитр — только при расхождениях**: `subagent(agent="arbiter", prompt="Спорные пункты: <пункт → evidence A → evidence B>. По каждому: подтверждён/опровергнут/недоказуем + команда/цитата.")`. Вердикт свода (и верификация/арбитраж) фиксируются ДО правок и **вместе с ревизией состояния** (хэш каталога/коммит); любая правка после фиксации вердикта → повторный прогон (re-audit) либо явное понижение вердикта: до вердикта — не править.
-6. **Правки** по порогу: микро — root сам; средние/крупные — `fix-runner` (вход: список «к закрытию» — id, локация, механизм, **класс/область** (пути + правило поиска однотипных мест), repro-до, критерий-после, severity — плюс границы и **бюджет/лимит (время, число правок)**; выход: fix-runner/v1 с before/after/`proof`/тестами). Отдельные коммиты `fix-<round>`; обновить реестр: `closed` / `accepted-risk` (с причиной). Root проверяет дельту до re-audit. Стенд раунда (если в комплекте поставляется проверочный стенд — инструменты `tools/kit-verify` и `tools/kit-sync` каталога комплекта; в раундах по другим проектам — только если стенд явно включён в границы вызова): baseline стенда в промпт фиксера (если вывод передан — фиксер не дублирует прогон); закрытие — синк копий и повторный прогон стенда; оба вывода — в поле `stand` отчёта. Статусы `fix-runner`: `needs_decision` → решение root (при споре — арбитр; если решение за владельцем — эскалация) с фиксацией в реестре рисков; `not_closed` → повторная итерация с тем же id; поле `out_of_scope` (замечено вне списка) → включить в следующий список «к закрытию» или эскалировать.
-7. **Re-audit = resume те же сессии** (sessionID из шага 2): «Правки: <диапазон + фактический список изменённых файлов>. Проверь закрытие своих находок и отсутствие регрессий; верни обновлённый SGR.» — исторически так и делалось (продолжение сессий GLM/DS). sessionID обязателен: вызов без него (новая сессия вместо продолжения) — дефект шага.
+6. **Правки** по порогу: микро — root сам; средние/крупные — `fix-runner` (вход: список «к закрытию» — id, локация, механизм, **класс/область** (пути + правило поиска однотипных мест), repro-до, критерий-после, severity — плюс границы и **бюджет/лимит (время, число правок)**; выход: fix-runner/v1 с before/after/`proof`/тестами). Отдельные коммиты `fix-<round>`; обновить реестр: `closed` / `accepted-risk` (с причиной). Root проверяет дельту раунда — `git diff <round-base>..HEAD --stat` (не только `git show --stat`) — до re-audit. Стенд раунда (если в комплекте поставляется проверочный стенд — инструмент `tools/kit-verify` каталога комплекта; в раундах по другим проектам — только если стенд явно включён в границы вызова): baseline стенда в промпт фиксера (если вывод передан — фиксер не дублирует прогон); закрытие — повторный прогон стенда; оба вывода — в поле `stand` отчёта. Стенд поставляется в git-чекауте комплекта: в npm-пакете каталог `tools/` не поставляется → `stand: unavailable` и собственные воспроизводимые проверки. Статусы `fix-runner`: `needs_decision` → решение root (при споре — арбитр; если решение за владельцем — эскалация) с фиксацией в реестре рисков; `not_closed` → повторная итерация с тем же id; `budget_exceeded` → расширить бюджет решением владельца либо разбить список и продолжить с того же id (коммиты и worktree сохранить до закрытия или уборки); поле `out_of_scope` (замечено вне списка) → включить в следующий список «к закрытию» или эскалировать. Статус **`no_report`** (отчёта нет: фиксер упал/таймаут) — root фиксирует в своде выполненную работу (worktree, ветка, base SHA) и `no_report`; ветку/коммиты НЕ сливать; приоритет — resume в том же worktree; иначе убрать: `git worktree remove --force` и решить судьбу ветки. Частичный коммит без отчёта в основную ветку не вливается. Несколько `fix-runner` — только в отдельных worktree **вне дерева проекта** (у каждого своя ветка `fix/<round>-<n>`); путь пространства сверяется префиксами путей (`git -C <project> rev-parse --show-toplevel` не должен быть префиксом канонического пути пространства; иначе — `needs_decision`, пространство не создаётся и не используется); перед запуском root считает пересечение **наборов файлов** (пути + правило поиска класса), а не только списков: пересечение ⇒ сериализация или разнесение путей. Посадка сессии в её пространство: `session_move({sessionID, directory})` (если доступен), иначе `cd <абс. путь>` + абсолютные пути; ни то ни другое — параллельный запуск запрещён. В свежем worktree зависимости ставятся до прогонов (`npm ci` / `bun install`). После завершения root сводит результаты строго по **полному hex SHA** из отчёта: `commit` принимается только как `^[0-9a-f]{40}$` — проверка ДО любых git-команд (имена веток из отчётов для сведения не использовать; `check-ref-format` и `rev-parse --verify` барьером не являются — резолвят имена); SHA — отдельным аргументом в кавычках; семантические проверки: `git cat-file -t <sha>` = `commit`, `git merge-base --is-ancestor <base> <sha>`, `git diff --quiet <base> <sha>` ложно (дельта непуста), `<sha> != <base>`; `Already up to date` (пустая дельта) ⇒ `not_consolidated`, не `closed`; merge/cherry-pick по SHA, прогоняет проверки на сведённом состоянии и только тогда фиксирует `closed`; worktree не удалять до подтверждённого переноса коммита, после — `git worktree remove --force` и осознанное решение по ветке; повторный запуск после инцидента — resume в том же worktree либо явное удаление/переименование ветки решением root'а (повторный `git worktree add -b` падает при занятой ветке), `locked` worktree — `git worktree unlock` либо `git worktree remove -f -f`.
+7. **Re-audit = resume те же сессии** (sessionID из шага 2): «Правки: <диапазон + фактический список изменённых файлов>. Проверь закрытие своих находок и отсутствие регрессий; верни обновлённый SGR.» — исторически так и делалось (продолжение сессий GLM/DS). sessionID обязателен: вызов без него (новая сессия вместо продолжения) — дефект шага. Re-audit и `closed` — на **сведённом** состоянии: доказательство приёмки (after/stand) перепривязывается к сведённому commit SHA; `closed` без отчёта фиксера (`no_report`) запрещён; нет ключа `commit` или `workspace` в отчёте фиксера ⇒ `not_closed`.
 8. **Повторяй шаги 3–7, пока не достигнут полный ready** (число кругов не ограничено; все роли ready, MAJOR=0). С 3-го круга нерешённые пункты — арбитр поштучно; повторяющиеся ложные — снять и записать как шум аудита.
 9. **Ворота (релиз; порядок: ред-тим → мета)**: замороженный коммит → `redteam` (мандат фальсификации + корпуса/стенды) → цикл по его находкам (MAJOR — с верификацией сессией противоположной роли) → `meta` (на вход: отчёты + свод `reports/summary-<id>.md`; evidence, полнота, отсутствие «зелёные тесты = проверено»).
    - **SHIP ⟺ `meta.gate`=pass ∧ `closing_list` пуст/закрыт ∧ `coverage_gaps` приняты владельцем (запись в `risks-<id>.md`); иначе ship запрещён.**
@@ -41,7 +41,7 @@
 - root → re-audit: диапазон правок + краткое «что закрыто»;
 - root → ред-тим: заявка автора + свод всех предыдущих кругов (объект фальсификации);
 - root → мета: отчёты (пути) + свод `reports/summary-<id>.md`;
-- root → fix-runner: список «к закрытию» (с классом/областью) + границы + бюджет/лимит (время, число правок).
+- root → fix-runner: список «к закрытию» (с классом/областью) + границы (включая **набор файлов**, worktree вне дерева проекта, ветку `fix/<round>-<n>`, base SHA) + бюджет/лимит (время, число правок); при параллельном запуске — каждому отдельное пространство и ветка, а наборы файлов root проверяет на пересечение до запуска;
 
 ## Тонкости
 

package/lib/tools.ts

@@ -46,25 +46,76 @@ interface SchemaDocument {
   readonly schema: JsonSchemaNode
 }
 
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/**
+ * Typed failure of the schema registry (`schemas/*.json`): an unreadable
+ * directory, an unreadable file, malformed JSON or a document of the wrong
+ * shape. `loadSchemas` throws it on purpose — otherwise the plugin would
+ * validate against a silently smaller registry — and the `validate_report`
+ * executor converts it into an `E_SCHEMA_IO` refusal, so a caller always gets a
+ * structured code plus the directory/file instead of a raw IO/parse exception.
+ */
+export class SchemaIoError extends Error {
+  readonly code = "E_SCHEMA_IO"
+  readonly directory: string
+  readonly file: string | undefined
+
+  constructor(message: string, directory: string, file?: string) {
+    super(message)
+    this.name = "SchemaIoError"
+    this.directory = directory
+    this.file = file
+  }
+}
+
 /**
  * Read every `schemas/*.json` file into an id → schema map. Files are read in
- * sorted order; a malformed document throws (the plugin would otherwise
- * validate against a silently smaller registry).
+ * sorted order; a malformed document throws a `SchemaIoError` (fail-closed, typed).
  */
 export async function loadSchemas(directory: string = SCHEMAS_DIRECTORY): Promise<Map<string, JsonSchemaNode>> {
-  const entries = await readdir(directory, { withFileTypes: true })
-  const files = entries
-    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-    .map((entry) => entry.name)
-    .sort()
+  let names: string[]
+  try {
+    const entries = await readdir(directory, { withFileTypes: true })
+    names = entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+      .map((entry) => entry.name)
+      .sort()
+  } catch (error) {
+    throw new SchemaIoError(`cannot read schemas directory ${directory}: ${errorMessage(error)}`, directory)
+  }
   const schemas = new Map<string, JsonSchemaNode>()
-  for (const file of files) {
-    const source = await readFile(path.join(directory, file), "utf8")
-    const document = JSON.parse(source) as SchemaDocument
-    if (typeof document.id !== "string" || typeof document.schema !== "object" || document.schema === null) {
-      throw new Error(`schemas/${file}: expected { id: string, schema: object }`)
+  for (const file of names) {
+    const absolute = path.join(directory, file)
+    let source: string
+    try {
+      source = await readFile(absolute, "utf8")
+    } catch (error) {
+      throw new SchemaIoError(`cannot read schemas/${file} (${absolute}): ${errorMessage(error)}`, directory, absolute)
+    }
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(source)
+    } catch (error) {
+      throw new SchemaIoError(
+        `schemas/${file} (${absolute}) is not valid JSON: ${errorMessage(error)}`,
+        directory,
+        absolute,
+      )
+    }
+    const document = asRecord(parsed) as Partial<SchemaDocument> | undefined
+    const id = document?.id
+    const schema = document?.schema
+    if (typeof id !== "string" || typeof schema !== "object" || schema === null) {
+      throw new SchemaIoError(
+        `schemas/${file} (${absolute}): expected { id: string, schema: object }`,
+        directory,
+        absolute,
+      )
     }
-    schemas.set(document.id, document.schema)
+    schemas.set(id, schema as JsonSchemaNode)
   }
   return schemas
 }
@@ -298,13 +349,24 @@ export function resolveRoot(directory: string, input: string): string {
   return path.isAbsolute(input) ? path.normalize(input) : path.resolve(directory, input)
 }
 
+/** Optional seams for tests; the plugin calls this with no options. */
+export interface RegisterAuditToolsOptions {
+  /** Directory to read `schemas/*.json` from. Defaults to the shipped `schemas/`. */
+  readonly schemasDirectory?: string
+}
+
 /**
- * Register the audit tools on the plugin context. Loading the schemas and the
- * session index happens before the transform callback, because transforms are
- * synchronous and the executors must close over complete, immutable state.
+ * Register the audit tools on the plugin context. The session index is loaded
+ * before the transform callback, because transforms are synchronous; the report
+ * schemas are not: they are re-read on every `validate_report` call, so a schema
+ * edited while the plugin is live is applied without a reload (a price of a few
+ * small JSON reads per validation).
  */
-export async function registerAuditTools(context: Plugin.Context): Promise<() => void> {
-  const schemas = await loadSchemas()
+export async function registerAuditTools(
+  context: Plugin.Context,
+  options: RegisterAuditToolsOptions = {},
+): Promise<() => void> {
+  const schemasDirectory = options.schemasDirectory ?? SCHEMAS_DIRECTORY
   const directory = context.location.directory
   const session = context.session
   const index = new SessionIndex(context.storage)
@@ -337,6 +399,20 @@ export async function registerAuditTools(context: Plugin.Context): Promise<() =>
       }
     }
     if (toolContext.signal.aborted) return failure("E_ABORTED", "validation aborted")
+    let schemas: Map<string, JsonSchemaNode>
+    try {
+      schemas = await loadSchemas(schemasDirectory)
+    } catch (error) {
+      if (error instanceof SchemaIoError) {
+        return failure(error.code, error.message, {
+          directory: error.directory,
+          ...(error.file === undefined ? {} : { file: error.file }),
+        })
+      }
+      return failure("E_SCHEMA_IO", `cannot load schemas from ${schemasDirectory}: ${errorMessage(error)}`, {
+        directory: schemasDirectory,
+      })
+    }
     const report = checkReport(source, { ...(expectedSchema === undefined ? {} : { expectedSchema }), schemas })
     return json(report)
   }
@@ -479,7 +555,7 @@ export async function registerAuditTools(context: Plugin.Context): Promise<() =>
       description:
         "Validate an SGR report: extract the last ```json block, resolve its schema, validate it and list prompt-level warnings. " +
         "Read-only. Returns JSON {valid, schema, errors, warnings} or a typed code " +
-        "(E_INPUT|E_NO_JSON|E_PARSE|E_UNKNOWN_SCHEMA|E_SCHEMA_MISMATCH|E_INVALID|E_ABORTED).",
+        "(E_INPUT|E_NO_JSON|E_PARSE|E_UNKNOWN_SCHEMA|E_SCHEMA_MISMATCH|E_INVALID|E_SCHEMA_IO|E_ABORTED).",
       input: VALIDATE_REPORT_INPUT,
       options: { namespace: TOOL_NAMESPACE, codemode: true },
       execute: validateReport,

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-orchestrator-uni",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Native OpenCode V2 plugin that registers the orchestrator agent kit (root orchestrator, audit subagents, fix-runner) and exposes the kit's process documents as the audit-kit reference.",
   "type": "module",
   "license": "MIT",
@@ -45,6 +45,7 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "check:locales": "bun tools/locale-check.ts",
+    "verify:kit": "bun tools/kit-verify.ts",
     "eval": "bun eval/run.ts",
     "eval:selfcheck": "bun eval/selfcheck.ts",
     "eval:recompute": "bun eval/recompute.ts"

package/schemas/fix-runner.v1.json

@@ -7,6 +7,15 @@
       "schema": { "type": "string", "const": "fix-runner/v1" },
       "round": { "type": "string" },
       "commit": { "type": ["string", "null"] },
+      "workspace": {
+        "type": "object",
+        "required": ["branch", "worktree", "base_commit"],
+        "properties": {
+          "branch": { "type": "string" },
+          "worktree": { "type": "string" },
+          "base_commit": { "type": "string" }
+        }
+      },
       "results": {
         "type": "array",
         "items": {
@@ -14,10 +23,7 @@
           "required": ["id", "status", "change", "before", "after", "proof", "stand", "tests"],
           "properties": {
             "id": { "type": "string" },
-            "status": {
-              "type": "string",
-              "enum": ["closed", "not_closed", "needs_decision", "budget_exceeded"]
-            },
+            "status": { "type": "string", "enum": ["closed", "not_closed", "needs_decision", "budget_exceeded"] },
             "change": { "type": "string" },
             "before": { "type": "string" },
             "after": { "type": "string" },
@@ -33,10 +39,7 @@
         "items": {
           "type": "object",
           "required": ["note", "why_suspicious"],
-          "properties": {
-            "note": { "type": "string" },
-            "why_suspicious": { "type": "string" }
-          }
+          "properties": { "note": { "type": "string" }, "why_suspicious": { "type": "string" } }
         }
       }
     }