opencode-orchestrator-uni 0.5.0 → 0.5.1

package/README.md

@@ -6,10 +6,11 @@ A native [OpenCode V2](https://opencode.ai/v2/docs/build/plugins) package plugin
 ships the **orchestrator agent kit**:
 
 - `orchestrator` — the root orchestrator (primary agent) with the audit loop as a
-  built-in mode;
+  built-in mode; it delegates every code/doc/test edit and writes only audit and
+  session-state artifacts;
 - read-only audit subagents — `factcheck`, `empiric`, `invariant`,
   `arbiter`, `meta`, `redteam`, `context-lint`;
-- `fix-runner` — the only writing subagent (applies the "to close" list);
+- `fix-runner` — the only writing subagent of the kit (applies the "to close" list);
 - the kit's process documents, exposed as the **`audit-kit` reference**
   (`call-mechanics.md`, `process-ready-loop.md`, `root-runbook.md`,
   `instruction-other-session.md`, `context-efficiency.md`, `session-discipline.md`);
@@ -17,9 +18,13 @@ ships the **orchestrator agent kit**:
   `orch_uni_snapshot`, `orch_uni_sessions`, `orch_uni_session_stats` (see [Tools](#tools));
 - three slash commands — `/agents-md`, `/spec` and `/handoff` (see [Commands](#commands)).
 
-Read-only audit agents are enforced by `edit: deny` plus the prompt ban; their shell
-permission stays allowed so they can run verification commands (an accepted risk, no
-permission is relaxed).
+Read-only audit agents are enforced at the tool level for `edit`/`write`/`patch`
+(`edit: deny`) and by the prompt ban for everything else; their `shell` permission
+stays allowed so they can run verification commands. A write through shell (redirect,
+`sed -i`, `tee`) is forbidden by the prompt, not by a sandbox — an accepted risk, same
+as I-M15; no permission is relaxed.
+
+The orchestrator itself has `edit` denied on `*`; the flat `permissions` are only a narrow fallback allowlist for audit/state artifacts, and the real guard is the `permission.hook("evaluate")` hook in `lib/write-guard.ts` with path-root semantics. The session directory is read per event (`session.get`), so a moved session is evaluated against its new directory; if the lookup fails, the setup directory is used and a warning is written — fail-open. A resource outside the session directory is denied: the guard is the workspace boundary, so `reports/`, `docs/planning/` and `audit-*` are not writable outside it. Inside it the first **root** segment decides. `reports/` is a reserved artifact root — the whole subtree is writable (even `reports/src/x.ts`), so project code must not live there (a `packages/reports/**` path counts as an artifact by contract); `docs/planning/**/*.md` is allowed (nested Markdown at any depth; a `.ts` file is not); `docs` is a separate branch, not a source root — every other `docs/**` path is denied; the source roots (`src`, `lib`, `test`, `tests`, `agents`, `tools`, `schemas`, `eval`, `.github`) are denied even under an artifact-looking prefix (`src/reports/x.ts`, `src/docs/planning/x.md`). Root artifact files (`case-*`, `risks-*`, `handoff-*`, `decisions-*`, `state.md`) are allowed only in the location root, under `reports/`, `docs/planning/` or an `audit-*` directory — `app/state.md` is denied. The hook runs after the flat rules, so a local `edit: allow` for `orchestrator` is closed too. The flat fallback carries only that artifact set as location-root rules (`reports/*`, `case-*.md`, `risks-*.md`, `handoff-*.md`, `decisions-*.md`, `state.md`, `docs/planning/*.md`) plus `audit-*/…`; the broad `*/state.md`-style patterns are gone, so `src/state.md` is denied even without the hook, but last-match still cannot express root priority everywhere (`audit-x/src/case-y.md`) — a warning is written. The fallback is narrower than the hook for nested artifact roots: `lab/x/reports/*` and similar paths are written only with the hook (the root rules cover `reports/*` at the location root only). A failing or timed-out session lookup (250 ms bound) falls back to the setup directory and writes the warning once per guard; for a moved session an absolute artifact path may then be denied (fail-closed for that class). A single `sessionWarned` flag without a counter is accepted: failures after the first warning stay silent. `shell` stays allowed for git and checks; a shell write and symlinks/junctions (the host matches the normalized lexical path, not `realpath`) are accepted risks, as is fail-open (a broken guard never breaks the session), governed by the prompt rather than a sandbox. A tool denial is a role rule — the edit goes to a subagent.
 
 The package is loaded directly from TypeScript: `exports` points at
 [`index.ts`](./index.ts). There is **no build step and no `dist/`** — OpenCode's
@@ -32,7 +37,7 @@ On setup (`ctx.agent.transform` / `ctx.reference.transform`):
 
 | Agent             | Mode       | Role                                                     |
 | ----------------- | ---------- | -------------------------------------------------------- |
-| `orchestrator`    | `primary`  | Root orchestrator; audit loop as a built-in mode         |
+| `orchestrator`    | `primary`  | Root orchestrator; delegates edits; writes audit/state artifacts |
 | `factcheck` | `subagent` | Read-only: staleness pre-pass (already done / outdated)  |
 | `empiric`   | `subagent` | Read-only: reproductions, measurements, first sources    |
 | `invariant` | `subagent` | Read-only: states, cancels, races, hostile input         |

package/README.ru.md

@@ -6,10 +6,11 @@
 который поставляет **комплект агентов-оркестраторов**:
 
 - `orchestrator` — root-оркестратор (основной агент) со встроенным режимом
-  аудиторского цикла;
+  аудиторского цикла; делегирует правки кода/доков/тестов и пишет только
+  артефакты аудита и состояния;
 - read-only субагенты аудита — `factcheck`, `empiric`, `invariant`,
   `arbiter`, `meta`, `redteam`, `context-lint`;
-- `fix-runner` — единственный пишущий субагент (применяет список «к закрытию»);
+- `fix-runner` — единственный пишущий субагент комплекта (применяет список «к закрытию»);
 - процессные документы комплекта, доступные как **reference `audit-kit`**
   (`call-mechanics.md`, `process-ready-loop.md`, `root-runbook.md`,
   `instruction-other-session.md`, `context-efficiency.md`, `session-discipline.md`);
@@ -18,8 +19,12 @@
   `orch_uni_session_stats` (см. [Инструменты](#инструменты));
 - три слэш-команды — `/agents-md`, `/spec` и `/handoff` (см. [Команды](#команды)).
 
-Read-only аудиторы держатся на `edit: deny` плюс запрете в промпте; shell-разрешение
-остаётся, чтобы запускать проверки (принятый риск, ни одно разрешение не ослаблено).
+Read-only аудиторы держатся на `edit: deny` (рантайм покрывает `edit`/`write`/`patch`)
+и запрете в промпте для остального; `shell`-разрешение остаётся, чтобы запускать
+проверки. Запись через shell (redirect, `sed -i`, `tee`) запрещена промптом, но не
+песочницей — принятый риск, как I-M15; ни одно разрешение не ослаблено.
+
+У самого оркестратора `edit` запрещён на `*`; плоские `permissions` — лишь узкий fallback-allowlist для артефактов аудита/состояния, а реальный guard — hook `permission.hook("evaluate")` в `lib/write-guard.ts` с path-root семантикой. Каталог сессии читается на каждое событие (`session.get`), поэтому перемещённая сессия оценивается от нового каталога; при ошибке чтения — setup-каталог и warning (fail-open). Ресурс вне каталога сессии — deny: guard и есть граница workspace, поэтому `reports/`, `docs/planning/` и `audit-*` вне её не пишутся. Внутри каталога первый **корневой** сегмент решает. `reports/` — зарезервированный artifact-root: всё поддерево доступно для записи (даже `reports/src/x.ts`), поэтому проектный код туда не кладём (путь `packages/reports/**` по контракту тоже считается артефактом); `docs/planning/**/*.md` разрешён (вложенный Markdown на любой глубине; `.ts` — нет); `docs` — отдельная ветвь, не source-root: остальной `docs/**` запрещён; source-корни (`src`, `lib`, `test`, `tests`, `agents`, `tools`, `schemas`, `eval`, `.github`) запрещены даже под артефактным префиксом (`src/reports/x.ts`, `src/docs/planning/x.md`). Корневые artifact-файлы (`case-*`, `risks-*`, `handoff-*`, `decisions-*`, `state.md`) разрешены только в корне location, под `reports/`, `docs/planning/` или в каталоге `audit-*` — `app/state.md` запрещён. Hook выполняется после плоских правил, поэтому локальный `edit: allow` для `orchestrator` тоже закрыт. Плоский fallback несёт только этот артефактный набор root-правилами (`reports/*`, `case-*.md`, `risks-*.md`, `handoff-*.md`, `decisions-*.md`, `state.md`, `docs/planning/*.md`) плюс `audit-*/…`; широкие `*/state.md`-шаблоны убраны, поэтому `src/state.md` запрещён и без hook, но last-match всё равно не выражает приоритет корней везде (`audit-x/src/case-y.md`) — плагин пишет warning. Fallback уже hook'а для вложенных артефактных корней: `lab/x/reports/*` и подобные пути пишутся только с hook (root-правила покрывают лишь `reports/*` от корня location). Сбой или таймаут чтения сессии (граница 250 мс) даёт fallback на setup-каталог и warning один раз на guard; у перемещённой сессии абсолютный артефакт в новом каталоге тогда может получить deny (fail-closed для этого класса). Один флаг `sessionWarned` без счётчика — принято: сбои после первого warning молчат. `shell` остаётся для git и проверок; запись через shell и symlink/junction (хост матчит нормализованный лексический путь, а не `realpath`) — принятые риски, как и fail-open (сломанный guard не роняет сессию); ими управляет промпт, а не песочница. Отказ инструмента — это правило роли, правка уходит субагенту.
 
 Пакет загружается напрямую из TypeScript: `exports` указывает на
 [`index.ts`](./index.ts). **Шага сборки и каталога `dist/` нет** — Bun-овый
@@ -32,7 +37,7 @@ Read-only аудиторы держатся на `edit: deny` плюс запр
 
 | Агент          | Режим      | Роль                                                            |
 | -------------- | ---------- | --------------------------------------------------------------- |
-| `orchestrator` | `primary`  | Root-оркестратор; аудиторский цикл как встроенный режим          |
+| `orchestrator` | `primary`  | Root-оркестратор; делегирует правки; пишет артефакты аудита/состояния |
 | `factcheck`    | `subagent` | Read-only: пред-проход на устаревание («уже сделано» / устарело) |
 | `empiric`      | `subagent` | Read-only: воспроизведения, замеры, первоисточники               |
 | `invariant`    | `subagent` | Read-only: состояния, отмены, гонки, враждебный ввод             |

package/agents/en/orchestrator.md

@@ -4,13 +4,49 @@ mode: primary
 permissions:
   - action: edit
     resource: "*"
+    effect: deny
+  - action: edit
+    resource: "reports/*"
+    effect: allow
+  - action: edit
+    resource: "case-*.md"
+    effect: allow
+  - action: edit
+    resource: "risks-*.md"
+    effect: allow
+  - action: edit
+    resource: "handoff-*.md"
+    effect: allow
+  - action: edit
+    resource: "decisions-*.md"
+    effect: allow
+  - action: edit
+    resource: "state.md"
+    effect: allow
+  - action: edit
+    resource: "docs/planning/*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/case-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/risks-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/handoff-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/decisions-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/state.md"
     effect: allow
   - action: shell
     resource: "*"
     effect: allow
 ---
 
-You are the root orchestrator. Your job is to turn the user's goal into a finished result through subagents: plan, delegate, verify, see it through to the end. You personally do only what cannot be delegated (decisions, small fixes, summaries) and remain the owner of the task context.
+You are the root orchestrator. Your job is to turn the user's goal into a finished result through subagents: plan, delegate, verify, see it through to the end. You write only audit and session-state artifacts (`reports/`, `case-*`, `risks-*`, `docs/planning/*.md`, `handoff-*`, `decisions-*`, `state.md`); code, docs and tests are edited by a subagent. Decisions, summaries and ownership of the task context stay with you.
 
 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.
@@ -20,7 +56,7 @@ GENERAL CYCLE:
    - research on code — `explore`; on topics and data — `general`;
    - verification of a change/plan/release — the audit loop (see the mode below);
    - audit of instruction files (AGENTS.md, SPEC.md, CLAUDE.md) — `context-lint` (read-only, SGR + closing_list);
-   - implementation — yourself (small) or `fix-runner` (fixes per the "to close" list), large tasks — `general`;
+   - implementation — `fix-runner` (fixes per the "to close" list) or `general` (large tasks outside the audit mode); the root does not edit code, docs or tests;
    - launch parallel tasks in one block (background) and do not poll — the notifications will arrive on their own.
 5. Verify the result: the acceptance criterion must be confirmed by evidence (a command and its actual output), not by "green tests" alone. Resolve disputed points explicitly (except in the audit mode — there disputed points go only to the arbiter); what cannot be proven → the owner's decision: the root frames the question, records the risk and escalates.
 6. Drive it to the end: fixes → re-check → until the criteria are met. No "left for later" without an explicit record to the owner.
@@ -55,11 +91,12 @@ 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:
-- 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.
+- One writer **per workspace** — `fix-runner` (medium/large ones) or `general` (large tasks outside the audit mode); the root writes only audit/session-state artifacts. 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.
+- Guard: the runtime is the `permission.hook("evaluate")` hook (`lib/write-guard.ts`) with path-root semantics. The session directory is read per event (`session.get`), so a moved session is evaluated against its new directory; if the lookup fails, the setup directory is used and a warning is written (fail-open). A resource outside the session directory is denied: the guard is the workspace boundary, so `reports/`, `docs/planning/` and `audit-*` are not writable outside it. Inside it the first **root** segment decides: the artifact root `reports` (the whole subtree is an artifact) and `docs/planning/**/*.md` — allow (nested `.md` at any depth; a `.ts` file is not); `docs` is a separate branch, not a source root — every other `docs/**` path is denied; the source roots `src`, `lib`, `test`, `tests`, `agents`, `tools`, `schemas`, `eval`, `.github` — deny. Artifact files `case-*`, `risks-*`, `handoff-*`, `decisions-*`, `state.md` — only in the location root, `reports/`, `docs/planning/` or an `audit-*` directory. The hook overrides a local `edit: allow` for `orchestrator`. The flat `permissions` are a narrow fallback: the location-root rules `reports/*`, `case-*.md`, `risks-*.md`, `handoff-*.md`, `decisions-*.md`, `state.md`, `docs/planning/*.md` plus `audit-*/…`; the broad `*/state.md`-style patterns are gone, so `src/state.md` and `src/case-x.md` are denied without the hook, but last-match still cannot express root priority everywhere (`audit-x/src/case-y.md`) — the plugin writes a warning. The fallback is narrower than the hook for nested artifact roots: `lab/x/reports/*` and similar paths are written only with the hook (the root rules cover `reports/*` at the location root only). A failing or timed-out session lookup (250 ms bound) falls back to the setup directory and writes the warning once per guard; for a moved session an absolute artifact path may then be denied (fail-closed for that class). A single `sessionWarned` flag without a counter is accepted: failures after the first warning stay silent. Accepted risks: a write through shell; symlinks/junctions (lexical path, not `realpath`); fail-open (a broken guard never breaks the session, an unreadable session falls back to the setup directory); `eval/` is a source root and `reports/` is a reserved artifact root only inside the location (project code does not go there). A tool denial is a role rule, not a failure: delegate the edit to a subagent.
 - 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.
+- 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 only writer is `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.
+- In the audit mode — do not fix before the verdict: fixes (`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.
 - Do not poll; if interrupted — continue the same session.
 - "Owner" = the user. Publication (push/PR/release) — only after ship and with the owner's confirmation.

package/agents/ru/orchestrator.md

@@ -4,13 +4,49 @@ mode: primary
 permissions:
   - action: edit
     resource: "*"
+    effect: deny
+  - action: edit
+    resource: "reports/*"
+    effect: allow
+  - action: edit
+    resource: "case-*.md"
+    effect: allow
+  - action: edit
+    resource: "risks-*.md"
+    effect: allow
+  - action: edit
+    resource: "handoff-*.md"
+    effect: allow
+  - action: edit
+    resource: "decisions-*.md"
+    effect: allow
+  - action: edit
+    resource: "state.md"
+    effect: allow
+  - action: edit
+    resource: "docs/planning/*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/case-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/risks-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/handoff-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/decisions-*.md"
+    effect: allow
+  - action: edit
+    resource: "audit-*/state.md"
     effect: allow
   - action: shell
     resource: "*"
     effect: allow
 ---
 
-Ты — root-оркестратор. Твоя работа — превращать цель пользователя в готовый результат руками субагентов: планировать, делегировать, проверять, доводить до конца. Сам делаешь только то, что нельзя делегировать (решения, мелкие правки, сводки), и остаёшься владельцем контекста задачи.
+Ты — root-оркестратор. Твоя работа — превращать цель пользователя в готовый результат руками субагентов: планировать, делегировать, проверять, доводить до конца. Сам пишешь только артефакты аудита и состояния (`reports/`, `case-*`, `risks-*`, `docs/planning/*.md`, `handoff-*`, `decisions-*`, `state.md`) — код, доки и тесты правит субагент; за тобой остаются решения, сводки и владение контекстом задачи.
 
 ОБЩИЙ ЦИКЛ:
 1. Пойми цель и рамки: что считается готовым результатом, какие ограничения (что нельзя менять/публиковать), какой бюджет.
@@ -20,7 +56,7 @@ permissions:
    - исследование по коду — `explore`; по темам и данным — `general`;
    - проверка изменения/плана/релиза — аудиторский контур (см. режим ниже);
    - аудит инструкций (AGENTS.md, SPEC.md, CLAUDE.md) — `context-lint` (read-only, SGR + closing_list);
-   - реализация — сам (мелкое) или `fix-runner` (правки по списку «к закрытию»), крупные задачи — `general`;
+   - реализация — `fix-runner` (правки по списку «к закрытию») или `general` (крупные задачи вне аудиторского режима); root код, доки и тесты не правит;
    - параллельные задачи запускай в одном блоке (background) и не опрашивай — уведомления придут сами.
 5. Проверяй результат: критерий приёмки должен быть подтверждён доказательством (команда и фактический вывод), а не «зелёными тестами» самими по себе. Спорное решай явно (кроме аудиторского режима — там спорное идёт только арбитру); недоказуемое → решение владельца: root оформляет вопрос, фиксирует риск и эскалирует.
 6. Доводи до конца: исправления → повторная проверка → пока критерии не выполнены. Без «оставил на потом» без явной фиксации владельцу.
@@ -55,11 +91,12 @@ permissions:
 - В итоге сообщай: число кругов, что закрыто, принятые риски.
 
 ПРАВИЛА:
-- Писатель один **на рабочее пространство**: root (микроправки) или `fix-runner` (средние/крупные). Не запускай двух писателей, чьи **наборы файлов** могут пересечься, — безусловно, даже в разных пространствах; пересечение считается по файлам (пути + правило поиска однотипных мест класса), а не по id списка.
+- Писатель один **на рабочее пространство** — `fix-runner` (средние/крупные) или `general` (крупные задачи вне аудита); root пишет только артефакты аудита/состояния. Не запускай двух писателей, чьи **наборы файлов** могут пересечься, — безусловно, даже в разных пространствах; пересечение считается по файлам (пути + правило поиска однотипных мест класса), а не по id списка.
+- Guard: рантайм — hook `permission.hook("evaluate")` (`lib/write-guard.ts`) с path-root семантикой. Каталог сессии читается по `sessionID` на каждое событие (`session.get`), поэтому перемещённая сессия оценивается от нового каталога; при недоступном `session.get` — setup-каталог и warning (fail-open). Ресурс вне каталога сессии — deny: guard и есть граница workspace, `reports/`, `docs/planning/` и `audit-*` вне её не пишутся. Внутри каталога первый **корневой** сегмент решает: artifact-root `reports` (всё поддерево — артефакт) и `docs/planning/**/*.md` — allow (вложенные .md, любая глубина; `.ts` — нет); `docs` — отдельная ветвь, не source-root: остальной `docs/**` — deny; source-корни `src`, `lib`, `test`, `tests`, `agents`, `tools`, `schemas`, `eval`, `.github` — deny. Artifact-файлы `case-*`, `risks-*`, `handoff-*`, `decisions-*`, `state.md` — только в корне каталога, `reports/`, `docs/planning/` или каталоге `audit-*`. Hook перекрывает локальный `edit: allow` для `orchestrator`. Плоские `permissions` — узкий fallback: root-правила `reports/*`, `case-*.md`, `risks-*.md`, `handoff-*.md`, `decisions-*.md`, `state.md`, `docs/planning/*.md` плюс `audit-*/…`; широкие `*/state.md`-шаблоны убраны, чтобы `src/state.md` и `src/case-x.md` не проходили без hook, но полной эквивалентности hook'у нет (last-match не выражает приоритет корней, например `audit-x/src/case-y.md`) — плагин пишет warning. Fallback уже hook'а для вложенных артефактных корней: `lab/x/reports/*` и подобные пути пишутся только с hook (root-правила покрывают лишь `reports/*` от корня). Сбой или таймаут чтения сессии (граница 250 мс) даёт fallback на setup-каталог и warning один раз на guard; у перемещённой сессии абсолютный артефакт в новом каталоге тогда может получить deny (fail-closed для этого класса). Один флаг `sessionWarned` без счётчика — принято: сбои после первого warning молчат. Принятые риски: запись через shell; symlink/junction (лексический путь, не `realpath`); fail-open (сломанный guard не роняет сессию, ошибка чтения сессии → setup-каталог); `eval/` — source-корень, `reports/` — зарезервированный artifact-root только внутри каталога (проектный код туда не кладём). Отказ инструмента — не сбой, а правило роли: делегируй правку субагенту.
 - Несколько `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` — только крупные задачи вне аудиторского режима.
+- Параллельные background-задачи: read-only роли — свободно; параллельные `fix-runner` — только по правилу изолированных пространств (выше); root в это время не пишет в файлы, которые правят фиксеры. В аудиторском режиме писатель — только `fix-runner`; `general` — только крупные задачи вне аудиторского режима.
 - В аудиторском режиме ты не аудируешь сам и не подменяешь вердикты аудиторов; спорное — только `arbiter`.
-- В аудиторском режиме — до вердикта не править: правки (root или `fix-runner`) начинаются только после фиксации вердикта свода, а для MAJOR — после независимой верификации/арбитража.
+- В аудиторском режиме — до вердикта не править: правки (`fix-runner`) начинаются только после фиксации вердикта свода, а для MAJOR — после независимой верификации/арбитража.
 - Субагенты универсальны; проектная конкретика — только в задании.
 - Не поллить; обрыв — продолжай ту же сессию.
 - «Владелец» = пользователь. Публикация (push/PR/релиз) — только после ship и с подтверждением владельца.

package/docs/en/call-mechanics.md

@@ -10,10 +10,12 @@
 | `arbiter` | present | resolving disputed items | only contradictions + evidence | SGR (arbiter/v1): confirmed/refuted/undecidable + prism |
 | `meta` | present | meta-audit of reports | the pair's reports + the red-team report (at the gates) + the summary `summary-<id>.md` | SGR (meta/v1): gate / closing_list / coverage_gaps |
 | `redteam` | present | acceptance run (the gates) | brief + submission + summary | SGR (redteam/v1) |
-| `fix-runner` | present | fixes per the "to close" list (the only writing subagent) | findings list + criteria | SGR (fix-runner/v1) |
+| `fix-runner` | present | fixes per the "to close" list (the only writing subagent of the kit) | findings list + criteria | SGR (fix-runner/v1) |
 | `orchestrator` | present | universal root orchestrator (`mode: primary`) | goal/task | a finished result (the audit is a built-in mode) |
 
-All agents except `orchestrator` are `mode: subagent`, with `shell` allowed (the `shell allow` rule in `permissions`), and universal (no project specifics). The auditors are read-only: the `edit deny` rule in `permissions` (`action: edit`, `resource: "*"`, `effect: deny`) and no `edit allow` rule; `fix-runner` is the only writing subagent (the `edit allow` rule); `orchestrator` is `mode: primary` (a universal root orchestrator).
+All agents except `orchestrator` are `mode: subagent`, with `shell` allowed (the `shell allow` rule in `permissions`), and universal (no project specifics). The auditors are read-only: the `edit deny` rule in `permissions` (`action: edit`, `resource: "*"`, `effect: deny`) and no `edit allow` rule; `fix-runner` is the only writing subagent of the kit (the `edit allow` rule); `orchestrator` is `mode: primary` (a universal root orchestrator).
+
+`general` is a built-in OpenCode agent and is not part of the kit: outside the audit mode the root may delegate large implementation tasks to it (it has its own `permissions`); in the audit mode the only writer is `fix-runner`.
 
 Note (K6). A second vendor is recommended for `arbiter` / `redteam` (and/or for the second voice of the audit pair from another vendor): panel heterogeneity raises recall (see `research/ready-agent-kits-vs-ours-2026-10.md`). Until a model is chosen, deepseek is the default. Execution path: a per-call `model` in the `subagent` call, or a frontmatter edit as a separate task by the owner's decision; until a second vendor is connected it remains a deferred risk (a record in the `risks-<id>.md` registry).
 
@@ -109,7 +111,7 @@ 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).
+- Only `fix-runner` makes the fixes; the root does not edit code, docs or tests — its writes are limited to audit/session-state artifacts (`reports/`, `case-*`, `risks-*`, `docs/planning/*.md`, `handoff-*`, `decisions-*`, `state.md`). The runtime restriction is the `permission.hook("evaluate")` hook (`lib/write-guard.ts`) with path-root semantics: the session directory is read per event via `sessionID` (a moved session is evaluated against its new directory; a failed lookup falls back to the setup directory with a warning — fail-open), a resource outside that directory is denied (the guard is the workspace boundary: `reports/`, `docs/planning/` and `audit-*` are not writable outside it), and inside it the first **root** segment decides; `reports/` is a reserved artifact root (the whole subtree; project code does not go there, and `packages/reports` counts as an artifact by contract), `docs/planning/**/*.md` — allow (nested `.md` at any depth; a `.ts` file is not), `docs` is a separate branch, not a source root — every other `docs/**` path is denied; the source roots `src`, `lib`, `test`, `tests`, `agents`, `tools`, `schemas`, `eval`, `.github` — deny; artifact files `case-*`, `risks-*`, `handoff-*`, `decisions-*`, `state.md` — only in the location root, `reports/`, `docs/planning/` or `audit-*`. The hook overrides a local `edit: allow`; the flat `permissions` are a narrow fallback (the location-root rules `reports/*`, `case-*.md`, `risks-*.md`, `handoff-*.md`, `decisions-*.md`, `state.md`, `docs/planning/*.md` plus `audit-*/…`); the broad `*/state.md` patterns are gone so `src/state.md` is denied without the hook, but last-match still cannot express root priority everywhere — the plugin writes a warning. The fallback is narrower than the hook for nested artifact roots: `lab/x/reports/*` and similar paths are written only with the hook (the root rules cover `reports/*` at the location root only). A failing or timed-out session lookup (250 ms bound) falls back to the setup directory and writes the warning once per guard; for a moved session an absolute artifact path may then be denied (fail-closed for that class). A single `sessionWarned` flag without a counter is accepted: failures after the first warning stay silent. Accepted risks: shell, symlinks/junctions (lexical path, not `realpath`), fail-open, `eval/` as a source root and `reports/` as an artifact root only inside the location. 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.
@@ -222,7 +224,7 @@ 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; 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.
+- The root does not audit and does not substitute for the verdicts; there is a single writer **per workspace** — `fix-runner` (medium/large ones) or `general` (large tasks outside the audit mode); the root writes only audit/session-state artifacts; 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.

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

@@ -27,14 +27,14 @@ 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. 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.
+- The auditors are read-only subagents; `fix-runner` makes the fixes (the root does not edit code, docs or tests: its writes are limited to audit/session-state artifacts). You are the orchestrator: the brief, the launch, the consolidation of the reports, decisions. You do not audit or edit 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.
 - "Owner" = the user. Publication (push/PR/release) — only after ship and with the owner's confirmation; `fix-runner` does not push anything.
 
 Steps:
-0) Prepare the working directory `audit-<id>` in your environment's temporary area: the brief `case.md` (the template below), the registry `risks.md`.
+0) Prepare the working directory `audit-<id>` in your environment's temporary area: the brief `case-<id>.md` (the template below), the registry `risks-<id>.md`.
    For the initial audit — a "blind" copy of the state (without the history of fixes); for a repeat one — with the fixes delta.
 1) Fact-check (foreground):
    subagent(agent="factcheck", prompt="Read the brief <path>. Check the theses and premises against live reality (git, upstream issues/PRs, the current code): what is stale, what is already done, which promises have diverged. Return the SGR + the "FACT-CHECK" block.")
@@ -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: 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).
+5) Fixes: only 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-<id>.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 …")
@@ -57,10 +57,10 @@ Steps:
 8) Release mode (the gates; order: red team → meta): freeze the candidate →
    subagent(agent="redteam", background=true, prompt="Brief <path>. The author's submission: <…>. The summary of previous rounds: <…>. Falsification mandate: reproduce every claim with your own instruments; available data: <…>; generate crafted inputs. Return the SGR.")
    → the same loop (fixes; the red team's MAJOR findings — with verification by the session of the opposite role as directed by the root; a dispute → `arbiter`) with the red team resumed until it is ready → subagent(agent="meta", prompt="Reports: <paths>; summary: <path to summary-<id>.md>. Check the MAJOR verification statuses in the summary (verdict + verifier_role); the evidence of every finding; the completeness of the self-checks, the absence of "green tests = checked". Return pass/fail.") → a check of the SHIP condition (below); ship only when it holds.
-   SHIP ⟺ meta.gate=pass ∧ closing_list is empty/closed ∧ coverage_gaps accepted by the owner (a record in risks.md). In all other cases ship is forbidden.
+   SHIP ⟺ meta.gate=pass ∧ closing_list is empty/closed ∧ coverage_gaps accepted by the owner (a record in risks-<id>.md). In all other cases ship is forbidden.
 9) Final: a round-by-round summary (the verdicts, what was closed, the accepted risks); save the reports in `reports/` of the audit's working directory.
 
-Brief template `case.md`:
+Brief template `case-<id>.md`:
 # Audit <id>: <name>
 State: <path, commit/range; the base>
 Context: <the goal of the change, what the author declares>
@@ -77,5 +77,5 @@ If a subagent is unavailable ("Agent not found"): check the agent files in your
 - The fact-check ran and either dismissed the stale task or gave a block for the pair.
 - The pair produced SGR reports; the conflicts (if any) were resolved by the arbiter.
 - The loop reached full ready (all verdicts ready; no open MAJORs).
-- `reports\` holds all the reports and the summary `summary-<id>.md`; `risks.md` holds the accepted risks.
+- `reports\` holds all the reports and the summary `summary-<id>.md`; `risks-<id>.md` holds the accepted risks.
 - No agent changed the project (check the target project's `git status`).

package/docs/en/root-runbook.md

@@ -28,7 +28,7 @@ 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 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`.
+6. **Fixes**: only `fix-runner` — the root does not edit code, docs or tests; its writes are limited to audit/session-state artifacts (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").

package/docs/en/session-discipline.md

@@ -44,7 +44,7 @@ A session is one slice with a measurable DoD, not the whole project.
 - Investigation and verification ("find", "understand", "reproduce") go to
   subagents: they get a clean context and return 1–2k tokens of findings instead
   of a dump.
-- Implementation goes to one writer per workspace: related decisions must be made
+- Implementation goes to one writing subagent per workspace (the root does not edit code, docs or tests — only audit/session-state artifacts): related decisions must be made
   in one context (otherwise parallel agents diverge in style and contracts).
 - Decisions, consolidation and acceptance belong to the root orchestrator.
 - The audit loop is unchanged: re-audit resumes the same sessions; short audit

package/docs/ru/call-mechanics.md

@@ -10,10 +10,12 @@
 | `arbiter` | есть | разбор спорных пунктов | только противоречия + evidence | SGR (arbiter/v1): подтверждён/опровергнут/недоказуем + призма (prism) |
 | `meta` | есть | аудит отчётов | отчёты пары + отчёт ред-тима (на воротах) + свод `summary-<id>.md` | SGR (meta/v1): gate / closing_list / coverage_gaps |
 | `redteam` | есть | приёмочный прогон (ворота) | бриф + заявка + свод | SGR (redteam/v1) |
-| `fix-runner` | есть | правки по списку «к закрытию» (единственный пишущий субагент) | список находок + критерии | SGR (fix-runner/v1) |
+| `fix-runner` | есть | правки по списку «к закрытию» (единственный пишущий субагент комплекта) | список находок + критерии | SGR (fix-runner/v1) |
 | `orchestrator` | есть | универсальный root-оркестратор (`mode: primary`) | цель/задача | готовый результат (аудит — встроенный режим) |
 
-Все, кроме `orchestrator`: `mode: subagent`, `shell` разрешён (правило `shell allow` в `permissions`), универсальные (без проектной конкретики). Аудиторы — read-only: правило `edit deny` в `permissions` (`action: edit`, `resource: "*"`, `effect: deny`) и отсутствие правила `edit allow`; `fix-runner` — единственный пишущий субагент (правило `edit allow`); `orchestrator` — `mode: primary` (универсальный root-оркестратор).
+Все, кроме `orchestrator`: `mode: subagent`, `shell` разрешён (правило `shell allow` в `permissions`), универсальные (без проектной конкретики). Аудиторы — read-only: правило `edit deny` в `permissions` (`action: edit`, `resource: "*"`, `effect: deny`) и отсутствие правила `edit allow`; `fix-runner` — единственный пишущий субагент комплекта (правило `edit allow`); `orchestrator` — `mode: primary` (универсальный root-оркестратор).
+
+`general` — встроенный агент OpenCode, не входит в комплект: вне аудиторского режима root может делегировать ему крупные задачи реализации (у него свои `permissions`); в аудиторском режиме писатель — только `fix-runner`.
 
 Примечание (K6). Рекомендуется второй вендор для `arbiter` / `redteam` (и/или для второго голоса аудиторской пары из другого вендора): гетерогенность панели повышает recall (см. `research/ready-agent-kits-vs-ours-2026-10.md`). До выбора модели — по умолчанию deepseek. Путь исполнения: per-call `model` в вызове `subagent` либо правка frontmatter отдельной задачей по решению владельца; до подключения второго вендора — отложенный риск (запись в реестре `risks-<id>.md`).
 
@@ -109,7 +111,7 @@ subagent({
 
 ### Фаза 5. Правки и повтор
 - Правки начинаются только после фиксации вердикта свода (и верификации/арбитража). До вердикта — не править.
-- Правки по порогу: микроправки (1–3 строки, тексты/доки) — root сам; средние/крупные (мультифайл, логика, тесты) — субагент `fix-runner`; спорное до делегирования решает root (после арбитра).
+- Правки вносит только `fix-runner`; root не правит код, доки и тесты — его запись ограничена артефактами аудита/состояния (`reports/`, `case-*`, `risks-*`, `docs/planning/*.md`, `handoff-*`, `decisions-*`, `state.md`). Рантайм-ограничение — hook `permission.hook("evaluate")` (`lib/write-guard.ts`) с path-root семантикой: каталог сессии читается по `sessionID` на каждое событие (перемещённая сессия оценивается от нового каталога; ошибка чтения → setup-каталог + warning, fail-open), ресурс вне каталога — deny (guard = граница workspace: `reports/`, `docs/planning/` и `audit-*` вне её не пишутся), внутри первый **корневой** сегмент решает; `reports/` — зарезервированный artifact-root (всё поддерево; проектный код туда не кладём, `packages/reports` по контракту тоже артефакт), `docs/planning/**/*.md` — allow (вложенные .md на любой глубине; `.ts` — нет), `docs` — отдельная ветвь, не source-root: остальной `docs/**` — deny; source-корни `src`, `lib`, `test`, `tests`, `agents`, `tools`, `schemas`, `eval`, `.github` — deny; artifact-файлы `case-*`, `risks-*`, `handoff-*`, `decisions-*`, `state.md` — только в корне каталога, `reports/`, `docs/planning/` или `audit-*`. Hook перекрывает локальный `edit: allow`; плоские `permissions` — узкий fallback (root-правила `reports/*`, `case-*.md`, `risks-*.md`, `handoff-*.md`, `decisions-*.md`, `state.md`, `docs/planning/*.md` плюс `audit-*/…`); широкие `*/state.md`-шаблоны убраны, чтобы `src/state.md` не проходил без hook, но last-match не выражает приоритет корней везде — плагин пишет warning. Fallback уже hook'а для вложенных артефактных корней: `lab/x/reports/*` и подобные пути пишутся только с hook (root-правила покрывают лишь `reports/*` от корня). Сбой или таймаут чтения сессии (граница 250 мс) даёт fallback на setup-каталог и warning один раз на guard; у перемещённой сессии абсолютный артефакт в новом каталоге тогда может получить deny (fail-closed для этого класса). Один флаг `sessionWarned` без счётчика — принято: сбои после первого warning молчат. Принятые риски: shell, symlink/junction (лексический путь, не `realpath`), fail-open, `eval/` как source-корень и `reports/` как artifact-root только внутри каталога. Спорное до делегирования решает 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 и решить судьбу ветки; частичный коммит без отчёта в основную ветку не вливается.
@@ -222,7 +224,7 @@ subagent({agent:"redteam", background:true,
 
 ## 7. Инварианты процесса
 
-- root не аудирует и не подменяет вердикты; писатель один **на рабочее пространство**: root (микроправки) или `fix-runner` (средние/крупные); несколько `fix-runner` — параллельно только в отдельных worktree и с последующим сведением root'ом.
+- root не аудирует и не подменяет вердикты; писатель один **на рабочее пространство** — `fix-runner` (средние/крупные) или `general` (крупные задачи вне аудита); root пишет только артефакты аудита/состояния; несколько `fix-runner` — параллельно только в отдельных worktree и с последующим сведением root'ом.
 - Не запускай двух писателей, чьи **наборы файлов** могут пересечься, — безусловно, независимо от рабочего пространства: непересекающиеся списки «к закрытию» не заменяют проверку пересечения наборов файлов (пути + правило поиска класса).
 - Аудиторы read-only; проектная конкретика — только в брифе.
 - Правки начинаются только после фиксации вердикта свода (и верификации MAJOR/арбитража). До вердикта — не править.

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

@@ -27,14 +27,14 @@
 Режим: <РЕЖИМ>
 
 Правила контура:
-- Аудиторы — read-only субагенты; правки вносишь ты (микроправки) или делегируешь `fix-runner` (средние/крупные). Ты — оркестратор: бриф, запуск, свод отчётов, решения, правки. Сам не аудируешь. Несколько `fix-runner` — только в отдельных worktree **вне дерева проекта** со своей веткой `fix/<round>-<n>`, и только без пересечения **наборов файлов** (пересечение наборов root считает до запуска ⇒ сериализация или разнесение путей); сессию фиксера сажай в её пространство (`session_move`, иначе `cd` + абсолютные пути; ни то ни другое — параллельный запуск запрещён), своди результаты строго по полному hex SHA из отчёта (проверка `^[0-9a-f]{40}$` до git-команд; имена веток из отчётов для сведения не использовать; SHA — отдельным аргументом в кавычках) и прогоняй проверки на сведённом состоянии.
+- Аудиторы — read-only субагенты; правки вносит `fix-runner` (root код, доки и тесты не правит: его запись ограничена артефактами аудита/состояния). Ты — оркестратор: бриф, запуск, свод отчётов, решения. Сам не аудируешь и не правишь. Несколько `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 оформляет вопрос, фиксирует риск и эскалирует.
 - «Владелец» = пользователь. Публикация (push/PR/релиз) — только после ship и с подтверждением владельца; `fix-runner` ничего не пушит.
 
 Шаги:
-0) Подготовь рабочий каталог `audit-<id>` во временной области вашей среды: бриф `case.md` (шаблон ниже), реестр `risks.md`.
+0) Подготовь рабочий каталог `audit-<id>` во временной области вашей среды: бриф `case-<id>.md` (шаблон ниже), реестр `risks-<id>.md`.
    Для первичного аудита — «слепая» копия состояния (без истории фиксов); для повторного — с дельтой правок.
 1) Факт-чек (foreground):
    subagent(agent="factcheck", prompt="Прочитай бриф <путь>. Сверь тезисы и премисы с живой реальностью (git, upstream issues/PR, текущий код): что устарело, что уже сделано, какие обещания разошлись. Верни SGR + блок «ФАКТ-ЧЕК».")
@@ -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-до | критерий-после>. Границы: набор файлов: <пути>; 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 с причиной).
+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-<id>.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="… то же …")
@@ -57,10 +57,10 @@
 8) Режим release (ворота; порядок: ред-тим → мета): заморозь кандидат →
    subagent(agent="redteam", background=true, prompt="Бриф <путь>. Заявка автора: <…>. Свод прошлых кругов: <…>. Мандат фальсификации: воспроизведи каждое заявление своими инструментами; доступные данные: <…>; генерируй крафтовые входы. Верни SGR.")
    → тот же цикл (правки; MAJOR-находки ред-тима — с верификацией сессией противоположной роли по указанию root; спор → `arbiter`) с resume ред-тима до его ready → subagent(agent="meta", prompt="Отчёты: <пути>; свод: <путь к summary-<id>.md>. Проверь статусы верификации MAJOR в своде (verdict + verifier_role); evidence у каждой находки; полноту самопроверок, отсутствие «зелёные тесты = проверено». Верни pass/fail.") → проверка SHIP-условия (ниже); ship только при его выполнении.
-   SHIP ⟺ meta.gate=pass ∧ closing_list пуст/закрыт ∧ coverage_gaps приняты владельцем (запись в risks.md). Во всех прочих случаях ship запрещён.
+   SHIP ⟺ meta.gate=pass ∧ closing_list пуст/закрыт ∧ coverage_gaps приняты владельцем (запись в risks-<id>.md). Во всех прочих случаях ship запрещён.
 9) Финал: сводка по кругам (вердикты, что закрыто, принятые риски); сохрани отчёты в `reports/` рабочего каталога аудита.
 
-Шаблон брифа `case.md`:
+Шаблон брифа `case-<id>.md`:
 # Аудит <id>: <название>
 Состояние: <путь, коммит/диапазон; база>
 Контекст: <цель изменения, что заявлено автором>
@@ -77,5 +77,5 @@
 - Факт-чек отработал и либо снял устаревшую задачу, либо дал блок для пары.
 - Пара выдала SGR-отчёты; конфликты (если были) разрешены арбитром.
 - Цикл дошёл до полного ready (все вердикты ready; открытых MAJOR нет).
-- В `reports\` лежат все отчёты и свод `summary-<id>.md`, в `risks.md` — принятые риски.
+- В `reports\` лежат все отчёты и свод `summary-<id>.md`, в `risks-<id>.md` — принятые риски.
 - Ни один агент не изменил проект (проверь `git status` целевого проекта).

package/docs/ru/root-runbook.md

@@ -28,7 +28,7 @@
 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 проверяет дельту раунда — `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`.
+6. **Правки**: только `fix-runner` — root код, доки и тесты не правит; его запись ограничена артефактами аудита/состояния (вход: список «к закрытию» — 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, полнота, отсутствие «зелёные тесты = проверено»).

package/docs/ru/session-discipline.md

@@ -43,7 +43,7 @@
 
 - Разведка и проверка («найти», «понять», «воспроизвести») — субагентам: у них
   чистый контекст, а в ответ возвращается 1–2k токенов выводов, а не дамп.
-- Реализация — одному писателю на рабочее пространство: связанные решения должны
+- Реализация — одному пишущему субагенту на рабочее пространство (root сам код, доки и тесты не правит — только артефакты аудита/состояния): связанные решения должны
   приниматься в одном контексте (иначе параллельные агенты расходятся в стиле и
   контрактах).
 - Решения, сведение и приёмка — root-оркестратору.

package/index.ts

@@ -55,6 +55,7 @@ import matter from "gray-matter"
 import { registerKitCommands } from "./lib/commands"
 import { createSessionBudget, readSessionBudgetOptions, safeJson } from "./lib/session-budget"
 import { registerAuditTools } from "./lib/tools"
+import { createWriteGuard } from "./lib/write-guard"
 
 /** Stable plugin id: diagnostics, enable/disable selectors, storage scope. */
 export const PLUGIN_ID = "orchestrator.uni"
@@ -419,10 +420,20 @@ async function setup(ctx: Plugin.Context): Promise<Plugin.Cleanup | undefined> {
   // tools are registered must abort that subscription too — otherwise a
   // half-registered plugin leaks an event listener for the lifetime of the server.
   const sessionBudget = await createSessionBudget(ctx, readSessionBudgetOptions(ctx.options, warn), locale, warn)
+  // The path-root write guard enforces the orchestrator's artifact-only edit
+  // contract beyond what flat `permissions` can express (see `lib/write-guard.ts`).
+  // It registers on the host's permission hook and stays a no-op on a host without
+  // that API — a missing hook is reported, never fatal. Registration happens
+  // before the tools so a later failure disposes the guard with the rest of the chain.
+  const writeGuard = await createWriteGuard(ctx, {
+    locationDirectory: String(ctx.location.directory),
+    warn,
+  })
   let toolsCleanup: () => void
   try {
     toolsCleanup = await registerAuditTools(ctx, { sessionBudget })
   } catch (error) {
+    await writeGuard.cleanup()
     await sessionBudget.cleanup()
     throw error
   }
@@ -431,6 +442,7 @@ async function setup(ctx: Plugin.Context): Promise<Plugin.Cleanup | undefined> {
     commandsCleanup = await registerKitCommands(ctx, locale)
   } catch (error) {
     toolsCleanup()
+    await writeGuard.cleanup()
     await sessionBudget.cleanup()
     throw error
   }
@@ -441,7 +453,11 @@ async function setup(ctx: Plugin.Context): Promise<Plugin.Cleanup | undefined> {
       try {
         toolsCleanup()
       } finally {
-        await sessionBudget.cleanup()
+        try {
+          await writeGuard.cleanup()
+        } finally {
+          await sessionBudget.cleanup()
+        }
       }
     }
   }

package/lib/write-guard.ts

@@ -0,0 +1,283 @@
+/**
+ * write-guard — path-root enforcement for the root orchestrator's edits.
+ *
+ * Flat `permissions` are a last-match-wins list, so they cannot express two
+ * properties at once: `reports/` is an artifact subtree (even `reports/src/x`
+ * must stay writable) while `src/`, `docs/` and the other source roots are
+ * denied at their first segment (even under an artifact-looking name such as
+ * `src/reports/x`). The rules also cannot tell a root artifact file
+ * (`state.md`) from a source file of the same name (`app/state.md`).
+ *
+ * This module implements the intended contract as a permission hook:
+ *
+ * - resolve a relative resource against the session's location directory and
+ *   strip that prefix; a resource that stays outside the location is denied —
+ *   the guard is the workspace boundary, so `reports/`, `docs/planning/` and
+ *   `audit-*` are writable only inside it. The location is read from the
+ *   session on every event (`session.get`), so a moved session is evaluated
+ *   against its new directory; the setup location is only a fallback (used when
+ *   the lookup is missing, fails or exceeds its 250 ms bound, with one warning);
+ * - normalize separators and collapse `.`/`..`, then walk the segments left to
+ *   right and let the first root decide: `reports` → allow (the whole subtree
+ *   is an artifact), `docs` + `planning` + a path whose last segment is `.md`
+ *   (any depth) → allow, any source root (`src`, `lib`, `test`, `tests`,
+ *   `agents`, `tools`, `schemas`, `eval`, `.github`) → deny. `docs` is not part
+ *   of that set: its own branch above allows nested `docs/planning/` Markdown
+ *   and denies every other `docs/` path;
+ * - with no root in the path, an artifact file (`case-*`, `risks-*`,
+ *   `handoff-*`, `decisions-*`, `state.md`) is allowed only in the location
+ *   root, under `reports/`, under `docs/planning/`, or inside an `audit-*`
+ *   directory;
+ * - everything else is denied.
+ *
+ * The hook only tightens an `edit` evaluation for the `orchestrator` agent: it
+ * runs after the flat rules, so a local `edit: allow *` on the agent (a config
+ * or a Markdown override) cannot bypass the guard. A failure anywhere in the
+ * guard is fail-open — a broken guard must never break the session.
+ */
+import type { Plugin } from "@opencode/plugin"
+
+/** Source roots that hold project code or kit content; `docs` has its own branch in `decideSegments`. */
+const SOURCE_ROOTS: ReadonlySet<string> = new Set([
+  "src",
+  "lib",
+  "test",
+  "tests",
+  "agents",
+  "tools",
+  "schemas",
+  "eval",
+  ".github",
+])
+
+/** Reserved artifact subtree: everything below it is an audit/state artifact. */
+const ARTIFACT_DIR = "reports"
+
+/** Artifact files allowed only in an artifact location (see `artifactLocation`). */
+const ARTIFACT_FILE = /^(?:case-.*|risks-.*|handoff-.*|decisions-.*|state)\.md$/
+
+/** Ad-hoc audit workspace directory; any depth below it is an artifact location. */
+const AUDIT_DIR = /^audit-/
+
+const MARKDOWN_FILE = /\.md$/
+
+/** Message attached to a denied evaluation; also shown to the model. */
+export const WRITE_GUARD_MESSAGE = "root orchestrator may edit only audit/session-state artifacts"
+
+/** Upper bound on the per-event session lookup; a hung store must not hold the edit open. */
+const SESSION_LOOKUP_TIMEOUT_MS = 250
+
+export type EditDecision = "allow" | "deny"
+
+/** Case-fold one segment the way the host resolves paths on `platform`. */
+function fold(segment: string, platform: string): string {
+  return platform === "win32" ? segment.toLowerCase() : segment
+}
+
+/** Split a path into segments, collapsing `.`/`..` and unifying separators. */
+function normalizeSegments(input: string): string[] {
+  const segments: string[] = []
+  for (const part of input.replaceAll("\\", "/").split("/")) {
+    if (part === "" || part === ".") continue
+    if (part === "..") {
+      segments.pop()
+      continue
+    }
+    segments.push(part)
+  }
+  return segments
+}
+
+/** Whether a resource names an absolute path (POSIX root or a Windows drive). */
+function isAbsolute(resource: string): boolean {
+  const normalized = resource.replaceAll("\\", "/")
+  return normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized)
+}
+
+/** Drop the location prefix when `absolute` is inside it; `undefined` otherwise. */
+function stripLocation(
+  absolute: readonly string[],
+  location: readonly string[],
+  platform: string,
+): string[] | undefined {
+  if (location.length === 0 || location.length > absolute.length) return undefined
+  for (let index = 0; index < location.length; index += 1) {
+    if (fold(absolute[index]!, platform) !== fold(location[index]!, platform)) return undefined
+  }
+  return absolute.slice(location.length)
+}
+
+/** `reports/` and `docs/planning/` already allow earlier; roots and files are checked here. */
+function artifactLocation(segments: readonly string[], platform: string): boolean {
+  if (segments.length === 1) return true
+  return segments.slice(0, -1).some((segment) => AUDIT_DIR.test(fold(segment, platform)))
+}
+
+function decideSegments(segments: readonly string[], platform: string): EditDecision {
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index]!
+    const key = fold(segment, platform)
+    if (key === ARTIFACT_DIR) return "allow"
+    // `docs` is not part of SOURCE_ROOTS: this branch allows nested planning
+    // Markdown and denies every other `docs/` path.
+    if (key === "docs") {
+      const next = segments[index + 1]
+      const last = segments.at(-1)
+      if (
+        next !== undefined &&
+        fold(next, platform) === "planning" &&
+        last !== undefined &&
+        MARKDOWN_FILE.test(fold(last, platform))
+      ) {
+        return "allow"
+      }
+      return "deny"
+    }
+    if (SOURCE_ROOTS.has(key)) return "deny"
+  }
+  const last = segments.at(-1)
+  if (last !== undefined && ARTIFACT_FILE.test(fold(last, platform)) && artifactLocation(segments, platform)) {
+    return "allow"
+  }
+  return "deny"
+}
+
+/**
+ * Decide whether the root orchestrator may write `resource` in `locationDirectory`.
+ *
+ * A relative resource is resolved against the location directory; an absolute one
+ * is used as is. The path is then reduced to its relative form: anything that stays
+ * outside the location is denied (the location is the workspace boundary), and an
+ * inside path is decided by its first segment.
+ */
+export function decideEdit(
+  resource: string,
+  locationDirectory: string,
+  platform: string = process.platform,
+): EditDecision {
+  const location = normalizeSegments(locationDirectory)
+  const raw = resource.replaceAll("\\", "/")
+  const resolved = isAbsolute(raw) ? normalizeSegments(raw) : normalizeSegments(`${location.join("/")}/${raw}`)
+  const relative = stripLocation(resolved, location, platform)
+  if (relative === undefined) return "deny"
+  return decideSegments(relative, platform)
+}
+
+export interface WriteGuardOptions {
+  /** Directory the session belongs to; relative resources resolve against it. */
+  readonly locationDirectory: string
+  /** Reports a missing host API or a registration failure (the guard stays no-op). */
+  readonly warn: (message: string) => void
+}
+
+export interface WriteGuard {
+  /** `true` when the permission hook is registered. */
+  readonly available: boolean
+  /** Disposes the hook registration; safe to call when the guard is unavailable. */
+  readonly cleanup: () => Promise<void>
+}
+
+/** The evaluate event fields the guard reads and writes (the host type is structural). */
+interface EvaluateEvent {
+  readonly sessionID?: string
+  readonly agent?: string
+  readonly action: string
+  readonly resources: readonly string[]
+  effect: "allow" | "deny" | "ask"
+  message?: string
+}
+
+/** The session surface the guard reads the current location from (structural). */
+interface SessionDirectoryApi {
+  readonly get?: (input: { readonly sessionID: string }) => Promise<unknown>
+}
+
+/**
+ * Register the path-root write guard on the host's permission hook.
+ * Never throws: an unavailable or failing host API leaves the guard as a no-op.
+ */
+export async function createWriteGuard(ctx: Plugin.Context, options: WriteGuardOptions): Promise<WriteGuard> {
+  const noop = async () => {}
+  const permission = (ctx as { readonly permission?: Plugin.Context["permission"] }).permission
+  if (permission === undefined || typeof permission.hook !== "function") {
+    options.warn("write guard: ctx.permission.hook is unavailable; the path-root guard is not registered")
+    return { available: false, cleanup: noop }
+  }
+  const session = (ctx as { readonly session?: SessionDirectoryApi }).session
+  // A failing, missing or hanging `session.get` falls back to the setup location;
+  // the warning is emitted once per guard so a persistent failure cannot flood
+  // the log on every edit (the single flag is deliberate — no counter, no reset).
+  let sessionWarned = false
+  const warnSessionOnce = (message: string): void => {
+    if (sessionWarned) return
+    sessionWarned = true
+    options.warn(message)
+  }
+  const locationFor = async (sessionID: string | undefined): Promise<string> => {
+    if (typeof session?.get !== "function") {
+      warnSessionOnce("write guard: ctx.session.get is unavailable, using the setup location")
+      return options.locationDirectory
+    }
+    if (sessionID === undefined) return options.locationDirectory
+    let timer: ReturnType<typeof setTimeout> | undefined
+    try {
+      // The lookup is bounded: a hung session store must not hold the permission
+      // event open (fail-open covers a rejection, not a promise that never settles).
+      const lookup = session.get({ sessionID })
+      const timeout = new Promise<never>((_, reject) => {
+        timer = setTimeout(() => {
+          reject(new Error(`timed out after ${SESSION_LOOKUP_TIMEOUT_MS} ms`))
+        }, SESSION_LOOKUP_TIMEOUT_MS)
+      })
+      const info = (await Promise.race([lookup, timeout])) as
+        | { readonly location?: { readonly directory?: unknown } }
+        | undefined
+      const directory = info?.location?.directory
+      if (typeof directory === "string" && directory !== "") return directory
+      warnSessionOnce("write guard: the session reports no location directory, using the setup location")
+      return options.locationDirectory
+    } catch (error) {
+      // Fail-open: an unreadable session must not break (or disable) the guard.
+      warnSessionOnce(
+        `write guard: cannot read the session directory, using the setup location: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      )
+      return options.locationDirectory
+    } finally {
+      if (timer !== undefined) clearTimeout(timer)
+    }
+  }
+  try {
+    const registration = await permission.hook("evaluate", async (event: EvaluateEvent) => {
+      try {
+        if (event.agent !== "orchestrator" || event.action !== "edit" || event.effect === "deny") return
+        // The session may have been moved since setup: the host resolves the
+        // resource against the session's current directory, so the guard must too.
+        const locationDirectory = await locationFor(event.sessionID)
+        const denied = event.resources.some((resource) => decideEdit(resource, locationDirectory) === "deny")
+        if (!denied) return
+        event.effect = "deny"
+        event.message = WRITE_GUARD_MESSAGE
+      } catch (error) {
+        // Fail-open: a broken guard must never break the session it protects.
+        options.warn(`write guard: evaluation failed: ${error instanceof Error ? error.message : String(error)}`)
+      }
+    })
+    let disposed = false
+    return {
+      available: true,
+      cleanup: async () => {
+        // Idempotent: a repeated cleanup must not dispose the registration twice.
+        if (disposed) return
+        disposed = true
+        await registration.dispose()
+      },
+    }
+  } catch (error) {
+    options.warn(
+      `write guard: cannot register the permission hook: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    return { available: false, cleanup: noop }
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-orchestrator-uni",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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",