opencode-orchestrator-uni 0.4.0 → 0.5.1

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,12 +56,21 @@ 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. Доводи до конца: исправления → повторная проверка → пока критерии не выполнены. Без «оставил на потом» без явной фиксации владельцу.
 7. Итог: краткая сводка — что сделано, чем подтверждено, что осталось или принято как риск.
 
+ГИГИЕНА СЕССИИ (протокол `session-discipline.md`):
+- Один срез = одна сессия. Бюджет: оценка промпта ≤150k токенов, ≤1 компакция; при пороге — `/handoff`, коммит и новая сессия, без «дожимания».
+- Разведка и проверка — субагентам (чистый контекст, ответ 1–2k токенов); реализация — одному писателю; сведение и решения — тебе.
+- Батчинг: ≥3 независимых команд за ход или один скрипт; для чтения — `read` с `limit`/`offset`, а не `cat`.
+- Вывод >20k символов — в файл и путём; скриншоты — файлом, не base64; в `execute` ограничивай результат сам.
+- Модель по умолчанию — дешёвая; дорогая — только решения и ревью.
+- В конце среза — handoff по шаблону и commit; следующая сессия стартует с `state` и SPEC.
+- Метрики среза — `orch_uni_session_stats` (промпт, компакции, тулы/ход, урезанные выводы).
+
 АУДИТОРСКИЙ РЕЖИМ включается, когда задача — проверить изменение (diff/PR/диапазон), план (документ/ADR) или релиз (тег/публикация): цикл до полного ready по документам комплекта (`call-mechanics.md`, `process-ready-loop.md`, `root-runbook.md`, `instruction-other-session.md`) — в каталоге комплекта (каталог задаётся владельцем/заданием). Если документы недоступны — работай по инлайн-скелету ниже и сообщи владельцу. Релизные ворота = публикация релиза/тега; при них мета (`meta`) обязательна.
 - Цепочка: факт-чек актуальности (`factcheck`) → пара `empiric` ∥ `invariant` → арбитр (`arbiter`) на расхождения → правки → повторный аудит тех же сессий → до полного ready; на релизных воротах — `redteam` и `meta`.
 - Ограниченная среда (Code Mode: действия только через `execute`+каталог, `subagent`/прямые инструменты недоступны): перед аудиторской фазой проверь наличие `subagent`; нет — цикл не запускай. Итог в такой среде — «готово; штатный аудит отложен» (ревизия + компенсирующие проверки списком + план прогона в обычной сессии); самопроверка и `ai`-ревью аудитом не называются (детали — `call-mechanics.md` §8).
@@ -46,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

@@ -5,6 +5,8 @@
 - **Root (the primary agent)** — does not audit: forms the brief, launches subagents, consolidates the reports; for the "unprovable" — the owner's decision: the root frames the question, records the risk and escalates. Maintains the registry of accepted risks, makes fixes as separate commits, decides on "ship".
 - **Subagents** (read-only): `factcheck`, `empiric`, `invariant`, `arbiter`, (at the gates) `redteam`, `meta`.
 
+Slice session hygiene — boundaries, context budget (≤150k tokens, ≤1 compaction) and the handoff — in `session-discipline.md`.
+
 ## Brief template `case-<id>.md` (common to all steps)
 
 ```
@@ -26,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

@@ -0,0 +1,230 @@
+# Session discipline: how to run development
+
+This document defines the session protocol: where a session starts and ends, its
+context budget, when to delegate, how to treat tool output, and what survives the
+session. It complements `context-efficiency.md` (the instruction-file budget) and
+`root-runbook.md` (the audit loop): those cover artifacts and verdicts, this one
+covers keeping context small and decisions pinned.
+
+## Why it matters
+
+- Context is a consumable resource, not the project's memory. As input grows,
+  quality degrades even on simple tasks (context rot); "it fits the window" does
+  not mean "the model uses it".
+- Compaction is a lossy summary. After it the agent remembers a paraphrase of
+  decisions, not the decisions; a second compaction paraphrases a paraphrase.
+- A measured long session: 13 253 turns, 19 compactions, the median prompt grew
+  from 314k to 780k tokens. Almost all of that is re-sending history, not work.
+  This is an internal measurement of a consumer project: the artifact is not
+  attached to the repository, and the figures are not reproducible from it.
+
+The protocol keeps the working state small and the decisions in files that
+outlive the session.
+
+## 1. A session is one slice
+
+A session is one slice with a measurable DoD, not the whole project.
+
+| Rule | Value |
+| --- | --- |
+| Estimated prompt budget | ≤ 150k tokens |
+| Compactions per slice | ≤ 1 |
+| Stop signal | the first compaction |
+| Required output | handoff + commit |
+
+- At the first sign of approaching the budget, close the slice instead of pushing
+  on: handoff, commit, new session.
+- After the first compaction the slice always closes: the summary has already lost
+  details and further work runs on a paraphrase.
+- Cut work by waves, gates or fix batches; a phase change (plan → implementation →
+  acceptance) always starts a new session.
+
+## 2. Role separation
+
+- 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 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
+  sessions do not threaten the budget.
+
+Rule of thumb: delegate **investigation** broadly, **implementation** narrowly,
+keep **integration** centralized.
+
+## 3. Tool batching
+
+Every turn re-sends the whole prompt. One tool per turn multiplies the budget by
+the number of small steps.
+
+- ≥ 3 independent commands per turn, or one script instead of five to ten calls.
+- Move long WSL commands into a wrapper script: a 250-character line in every turn
+  costs more than a file read once.
+- For file reads use `read` with `limit`/`offset`, not a full `cat`.
+- Target metric: ≥ 2 tools per turn.
+
+## 4. Tool output
+
+- Anything over 20k chars goes to a file; context gets the head (4k) and the path.
+  The guard does this automatically for `shell`, `bash`, `webfetch`.
+- Screenshots and binary attachments are files plus a path, never base64 in
+  context.
+- `execute` (Code Mode) is not capped by the guard: limit the result in the script
+  itself — return a summary and a path, not hundreds of kilobytes of raw JSON.
+- `read`, `write`, `edit` and the kit's own tools are not capped: they have their
+  own contract, and losing content breaks the work.
+
+## 5. State in files
+
+- `handoff` — the required output of a slice (template below); default path
+  `docs/planning/handoff-<YYYY-MM-DD>.md`, the project root when the directory
+  does not exist.
+- `decisions` — decisions and reasons; one decision per entry; default path
+  `docs/planning/decisions-<YYYY-MM-DD>.md`.
+- `state` — branch, gates, open risks, the next three steps; refreshed before a
+  new session; default path `docs/planning/state.md`.
+- A new session starts from `state` and the target SPEC section, not from a
+  retelling of the previous session.
+
+## 6. Models
+
+- Default to the cheap model; the expensive one only for architecture decisions,
+  reviews and dispute resolution.
+- Document edits, reading and mechanical checks do not need an expensive model.
+- Measurement: 223 turns of the expensive model cost $63, 104 turns of the cheap
+  one cost $0.09. One model switch saves more than any prompt tweak. This is an
+  internal measurement of a consumer project: the artifact is not attached to the
+  repository, and the figures are not reproducible from it.
+
+## 7. Metrics
+
+| Metric | Target | Where |
+| --- | --- | --- |
+| Estimated prompt (median) | ≤ 150k | `orch_uni_session_stats` |
+| Compactions per slice | ≤ 1 | `orch_uni_session_stats` |
+| Tools per turn (`toolCalls/requests`, reported as `toolsPerTurn`) | ≥ 2 | `orch_uni_session_stats` |
+| Share of capped outputs among the tool's calls (`toolOutputsCappedByTool.shell / toolCallsByTool.shell`; likewise `bash`, `webfetch`) | < 5% | `orch_uni_session_stats` |
+| Handoff at slice end | present | working tree |
+
+`orch_uni_session_stats` reports the counters of the current plugin instance and
+the configured limits; historical runs are counted from the session database on
+the project side.
+
+## 8. Guard
+
+The guard is a set of plugin hooks plus a compaction-event subscription, not a
+set of bans:
+
+- `session.context` — estimates the prompt and adds one short reminder when it
+  crosses a budget level. The reminder is injected once at a level transition,
+  not on every request; within a level the text is stable, so the prefix cache is
+  not broken.
+- compaction events — the `session.compaction` hook is registered on every host:
+  it counts attempts (`compactionAttempts`) and sends a tentative note to the
+  nearest request when the terminal event is delayed; the note names no
+  compaction number and claims no limit. Only `session.compaction.ended`
+  confirms a compaction (deduplicated by `event.id` or the durable position);
+  only it moves `compactions` and the limit. `session.compaction.failed`
+  increments `compactionFailures`, drops the tentative note and keeps a
+  confirmed note that is still waiting for delivery. When the event stream ends
+  or throws, the guard reports `eventLive: false`, `compactionSource: "hook"` and
+  `streamFailures: 1` (the per-session `errors` stays `0`); the hook is already
+  registered, so attempts keep counting, while no confirmed compaction or stop
+  signal is invented — no false "limit reached" on that path. `guard` exposes
+  the source, liveness and stream failures.
+- `tool.execute.after` — caps the output of the configured tools and stores the
+  full text in a private per-process root
+  `os.tmpdir()/opencode-tool-output-<random>/` (POSIX 0700 for the root and the
+  session directory, 0600 for the file). Windows ignores mode (measured: 0666 for
+  the root, the session directory and the file): privacy there rests on the ACL of
+  `os.tmpdir()` and is not checked by code. The root is created
+  with `mkdtemp` at setup, so a pre-created directory or junction named
+  `opencode-tool-output` is never used; on POSIX the root must belong to the
+  current uid with no group/other access, otherwise the guard disables itself with
+  a warning (fail-open: the result is untouched). Session directories (`s-<uuid>`)
+  and files (`c-<uuid>.txt`, written with `wx`) are random, and each `realpath` is
+  proven inside the root; the root is removed when the plugin unloads (best
+  effort). A string with a lone surrogate is normalized once (U+FFFD), so the
+  file, the head and the counters describe the same string. Residual risk
+  accepted: a same-user attacker can still swap a session
+  directory between `realpath` and `writeFile` (Node has no `openat`). If `TMPDIR`
+  points inside the workspace, the files land there.
+
+Configuration (defaults):
+
+```jsonc
+{
+  "sessionGuard": {
+    "enabled": true,
+    "promptTokensSoft": 150000,
+    "maxCompactions": 1
+  },
+  "toolOutputGuard": {
+    "enabled": true,
+    "maxChars": 20000,
+    "headChars": 4000,
+    "tools": ["shell", "bash", "webfetch"]
+  }
+}
+```
+
+`maxCompactions: 0` disables the compaction limit. `guard.toolOutputEnabled` is
+`true` only when the private root exists **and** the effective tool list is not
+empty; `guard.toolOutputTools` is that list (normalized, protected and kit names
+removed) and `guard.unkeyedCalls` counts hook calls without a non-empty
+`sessionID` (such input is dropped, not bucketed under `""`). An empty `tools`
+list — explicit or after every entry was rejected — disables capping with a
+warning. Accepted limits: a session directory `s-<uuid>` lives until the plugin
+unloads — it is removed neither on `session.deleted` nor after a refused cap
+(a readonly result, for example) and is released with the root; lone-surrogate
+normalization relies on ES2024 `String.prototype.isWellFormed`/`toWellFormed`
+(the minimum runtime version is not pinned in `engines`, so on an old runtime the
+cap degrades fail-open: `errors` +1, the result is untouched).
+In the counters, `toolCalls`
+and the per-tool counters include nested Code Mode calls, and `outputCharsSaved`
+is an upper estimate in characters (the injected stub is subtracted).
+`toolCallsByTool` and `toolOutputsCappedByTool` split calls and capped outputs by
+the normalized tool name (namespace stripped, lower-case). Duplicate compaction
+events are counted once only when the host supplies `event.id` or a durable
+position; without either identity a re-delivered event may be counted again
+(fail-open in the direction of counting).
+
+The guard is fail-open: a hook error neither breaks the request nor corrupts the
+tool result. It writes nothing to the working tree (except when `TMPDIR` points
+inside the workspace — see above) and blocks nothing — it only reminds and caps
+output. Either part can be disabled with its `enabled` flag.
+
+## Handoff template
+
+```md
+# Handoff: <slice> — <YYYY-MM-DD>
+
+<!-- File: docs/planning/handoff-<YYYY-MM-DD>.md; use the project root when the directory is absent. -->
+
+## Goal and DoD
+One sentence of the goal and a verifiable definition of done.
+
+## Done
+- What changed; what proves it (command, test, commit).
+
+## Not done
+- What remains and why (blocker, owner decision, next wave).
+
+## Decisions
+- Decision — reason; link to the document or commit.
+
+## Risks and limits
+- Accepted risk — by whom and until when.
+
+## Next step
+One concrete action for the next session.
+```
+
+## Slice checklist
+
+- [ ] The slice is closed by DoD, not by "ran out of time".
+- [ ] The handoff is written and references evidence.
+- [ ] Decisions and risks are in files, not only in chat.
+- [ ] The working tree is clean or explicitly described in the handoff.
+- [ ] The next session starts from `state` and SPEC, not from a retelling.

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` целевого проекта).