# Граница принуждения хуков: что покрыто и что нет

<!-- doc-map: reader=agent; zone=quality -->

> Вынесено из [`agent-contract.md`](https://github.com/Kibertum/tausik-core/blob/v1.11.0/docs/ru/agent-contract.md) при закрытии
> `powershell-tool-bypasses-bash-firewall` — тема самостоятельная и вместе с
> матрицей покрытия каналов перестала помещаться в контракт (filesize-гейт).
> EN-зеркало: [`../en/enforcement-coverage.md`](/docs/enforcement-coverage).

Полный разбор событий и покрытия — [`hooks-events.md`](https://github.com/Kibertum/tausik-core/blob/v1.11.0/docs/ru/hooks-events.md). Кратко:

QG-0 (Rule 1) и scope-ACL (Rule 2) исторически висели только на `Write|Edit`,
поэтому **запись файла через Bash обходила обе проверки**: `cat > f <<EOF`,
`sed -i`, `tee`, `dd of=`, `python -c "open(f,'w')"` создавали и правили файлы
без активной задачи и вне объявленного `scope_paths` (подтверждено вживую в
сессиях #117/#118). С 1.8 эту дыру закрывает `bash_write_gate` (matcher `Bash`),
а `MultiEdit`/`NotebookEdit` добавлены в matcher'ы `task_gate`/`scope_write_gate`.
С 1.9 (GitHub PR #5, Okianiwa) каждый охранник записи читает ОДИН список пишущих
инструментов — `scripts/hooks/write_tools.py`: встроенные редакторы плюс
редакторы serena и windows-mcp — и один список полей payload (`file_path`,
`notebook_path`, `path`, `relative_path`, `destination`), так что ноутбук или
MCP-правка доходят до тех же гейтов, что и Write, на хостах с хуками (Claude,
Qwen, Codex — те, что берут `build_hooks_dict`; плагин QG-0 OpenCode держит
свой список редакторов того хоста); `tests/test_pr5_hook_coverage.py`
держит matcher'ы bootstrap на этом списке и отказывает неучтённой записи без задачи.

**Что гейт ловит:** редиректы (`>`, `>>`, `&>`, `N>`, включая heredoc-заголовок),
`tee`, `dd of=`, `sed -i` (GNU и BSD-форма `-i ''`), `cp`/`mv`/`install`
(назначение **и** `-t`/`--target-directory=`), `truncate`, `touch`,
`curl -o`/`--output`, `wget -O`/`--output-document`, `tar -x … -C DIR`,
`unzip … -d DIR`, а также литеральный `open(path, 'w'|'a'|'x')` внутри
`python`/`perl`/`ruby -c`. Тело heredoc'а разбором **не** сканируется (иначе
`->`/`>` в прозе или коде тела давали бы фантомную цель и блокировали честную
запись). Исключение — тело, которое заголовок отдаёт интерпретатору
(`python - <<EOF`, в том числе после `cd x;`, с префиксом `VAR=1` и с `| tail`
после `<<`): оно разбирается как программа. Цель записи — литерал, имя,
привязанное к литералу или к `Path("…")`, параметр функции-помощника с литералом
на месте вызова и переменная цикла по литеральному списку. Замер 1.10 по
транскриптам проекта: из 1085 пишущих тел интерпретатора гейт не видел цель в
917, после правки — в 74; остаток — пути в переменных оболочки и циклы по именам.
Гейтятся только цели **внутри** дерева проекта — как и у Write; запись в
scratchpad, `/tmp`, `/dev/null`, чужой репозиторий разрешена.

**Каталог Python AST.** `python_source_writes.RECOGNISED_PYTHON_WRITE_FORMS` —
единый объявленный список: литеральный `open` с режимом записи; литеральный
`Path`/`pathlib.Path` `write_text`, `write_bytes`, `open` с режимом записи,
`unlink`, `mkdir` и `rename`; `shutil.copy`/`move` в литеральное назначение;
литеральные источник и назначение у `os.replace`. Для аргумента `Path`
допускается простая строка, связанная выше в той же прямолинейной Python-области.
Тот же читатель разбирает `python -c`, файлы Python-скриптов и `python - <<PY`,
когда заголовок доказывает получение тела Python через stdin.

**Что НЕ ловит (явная остаточная граница).** Shell тьюринг-полон, поэтому
тотальный гейт невозможен. НЕ перехватываются: путь, собранный или переданный
через переменную (`f=scripts/x.py; echo >$f`, `echo > $SCRATCH/x` — токен с `$`
считается неразрешимым и пропускается); `base64 -d | sh` и прочая обфускация;
команда, собираемая из STDIN (`… | xargs -I{} bash -c '…'`) или исполняемая на
другом хосте (`ssh host 'cmd'` — там пути этого проекта ничего не значат);
`curl -O`/`wget` без `-O` (имя из URL);
`tar`/`unzip` распаковка в текущий каталог без `-C`/`-d`; `base64 -o`, `xxd -r`;
код интерпретатора, пишущий файл формой вне объявленного каталога Python AST — и то же самое ВНУТРИ скрипта, который команда запускает, если скрипт написан не на Python (shell, Node): `python_source_writes` читает Python, и парсер, не умеющий читать субстрат, не должен заявлять, что его проверил.

Разрез здесь не тот, каким его называли раньше. До смены #201 остаток описывался как «литеральный `open()` против вычисленного», из чего читалось, что `python helper.py` с литеральным `open()` ЛОВИТСЯ. Не ловился: парсер читал только ТЕКСТ КОМАНДЫ, а код лежал в файле. Замер #200: `cp x .claude/...` отклонён с печатью ACL, `python helper.py`, пишущий тот же путь, вернул ноль и правку записал. Настоящий разрез — ВСТРОЕННЫЙ КОД против КОДА В ФАЙЛЕ, и запуск скрипта из файла есть обычный способ запустить код, а не обфускация. Закрыто `bash_write_parse._script_file_writes` для формы `python [опции] скрипт.py`. Умышленно узко — `python -m pytest tests/test_x.py` не должен блокироваться литералами `open(..., "w")` из тестового файла, которых сама команда не выполняет.

**Форма закрыта целиком, а не одним написанием (смена #203).** Первая версия закрыла ту форму, которую ЗАМЕРИЛА, — `python скрипт.py`, — и оставила соседние, отличающиеся одним токеном. Замер через реальный хук: из 17 обычных написаний той же команды 10 проходили мимо ОБОИХ правил гейта разом (и scope-ACL по SENAR Rule 2, и запрет записи без активной задачи), а два написания давали ЛОЖНЫЙ БЛОК. Сейчас:

* **имя интерпретатора выводится правилом, а не перечнем.** `python`, `python3`, `python3.11`, `python2`, `pythonw`, `py`, `py -3`, с `.exe` и без. Перечень уже разошёлся с жизнью однажды — `python3.11` есть штатный способ вызова, — поэтому правило описывает ФОРМУ имени;
* **позиция флага решает, а не его присутствие.** `-m`/`-c` ДО первого позиционного означают «файла-скрипта нет»; те же `-m`/`-c` ПОСЛЕ него суть аргументы скрипта и о запуске не говорят ничего. Прежняя проверка сканировала весь список аргументов, поэтому `python helper.py -m foo` снимал защиту — а `-c` есть обычный флаг обычной программы, так что обфускация для этого не требовалась;
* **`-m`/`-c` распознаются как БУКВЫ,** покрывая слитную (`-mpytest`) и кластерную (`-um`) записи. Перечень точных токенов их не покрывал и давал на них ложный блок;
* **скрипт — ПЕРВЫЙ позиционный,** а не первый попавшийся аргумент на `.py`: точка входа без расширения (наш собственный CLI `.tausik/tausik` — ровно такая) не должна приводить к чтению файла, переданного ей аргументом;
* **связь с `_INTERPRETERS` из `bash_cmd_scan` снята.** Раньше чтение скрипта стояло за проверкой из ДРУГОГО гейта, где нет ни `py`, ни `python2`, — и эти имена были мёртвыми ветвями: константа заявляла покрытие, которого вызывающий не допускал.

**Ложный блок В ЭТОМ ЖЕ МЕСТЕ — ЗАКРЫТ для Python, который парсер читает (смена #207).** Четыре смены детектор искал по ТЕКСТУ файла и не отличал исполняемый код от текста: литерал `open(path, 'w')` внутри строки, докстринга или даже КОММЕНТАРИЯ засчитывался как запись, которой команда не делает. Замерено в #203 дважды — гейт отказал измерительному стенду самой задачи и файлу, у которого единственный `open(` стоял в комментарии, — и в #207 по всему репозиторию: из 878 файлов `.py` текстовое чтение называло цель в шести, и все шесть были фантомами; исполняемого литерального `open(..., "w")` с константным путём в дереве нет ни одного. Теперь `python_source_writes` РАЗБИРАЕТ исходник (`ast`) и считает целью только настоящий узел вызова `open` с константным путём и константным режимом записи — комментарий, докстринг и строка не дают цели по построению, у них нет такого узла. Формы, а не примеры: голый `open` и атрибутный `io.open`/`codecs.open`; режим позиционный и `mode=`; путь позиционный и `file=`; raw-строка и неявная склейка литералов; режимы `w`/`a`/`x` и `+` (прежнее чтение `r+` не видело); внутри `def`/`with`/`class`/аргумента. Вычисленный путь (f-строка, имя, конкатенация) и нелитеральный режим — по-прежнему не цель, это объявленный остаток. Встроенный payload `python -c CODE` читается тем же разбором, и ЧИТАЕТСЯ ТОЛЬКО КОД: аргументы после него — `sys.argv` программы, данные, и `python -m pytest -k "open('x','w')"` больше не называет файл, которого команда не пишет. Что осталось от фантома, ограничено и названо: (1) исходник, который парсер не читает (синтаксическая ошибка, NUL, глубина вложенности), деградирует к ПРЕЖНЕМУ текстовому чтению, а не к тишине — такой файл может исполнить интерпретатор с другой грамматикой, и «не смог проверить» не должно читаться как «проверил и чисто»; (2) текст команды вокруг НЕ-python интерпретатора (`ruby -e`, `xargs python -c`) по-прежнему читается как текст, потому что другого чтения для этого субстрата нет, и там сверх-обнаружение объявлено направлением. Стоимость: 1.9 мс на файл по репозиторию, 10 мс на самом большом тестовом модуле, при пределе 256 КБ — десятки миллисекунд однократно.

**Обёртка `bash -c` / `sh -c` — ЗАКРЫТА.** `bash -c 'echo x > scripts/foo.py'`
раньше не давал НИ ОДНОЙ цели: перенаправление живёт внутри одного закавыченного
аргумента, и разбор внутрь payload'а не шёл. То есть Rule 1 и scope-ACL
обходились однострочником того же класса, который Решение #162 закрыло для
heredoc'ов, — а остаточная граница при этом утверждала, что цена обхода поднята
до «нужно намеренно обфусцировать». `bash -c` пишут каждый день, обфускацией он
не является; формулировка была завышена. Теперь парсер РЕКУРСИВНО разбирает
payload у `bash`/`sh`/`zsh`/`dash`/`ksh`/`ash`/`busybox` при флаге `-c` (включая
слитные формы `-lc`, `-ec`), с объявленным пределом вложенности
(`_MAX_WRAPPER_DEPTH`), чтобы `bash -c "bash -c '…'"` не уходил в бесконечность.
Упоминание в кавычках (`echo 'bash -c "x > y"'`), `bash script.sh` без `-c` и
длинная опция `--color` целями не считаются.

**Прозрачные префиксы — ЗАКРЫТЫ.** `env bash -c '…'` прятал обёртку ровно так
же, как обёртка прятала перенаправление: проверка оболочки смотрела на первый
токен, а им был `env`. Найдено адверсариальным ревью САМОГО ФИКСА обёртки
(конвенция #276), а не заменённого кода. Теперь перед определением команды
снимаются `env`, `sudo`, `doas`, `nohup`, `nice`, `ionice`, `stdbuf`, `timeout`,
`command`, `exec` — вместе с их флагами, присваиваниями `VAR=val` и числовым
аргументом `timeout`/`nice`. Побочно это закрыло и «писателя за обёрткой»
(`sudo tee`), который раньше стоял в списке непойманного: писателя прятал не
`tee`, а слово перед ним. Токен, лишь НАЧИНАЮЩИЙСЯ как префикс
(`environment.py`, `timeout_test.sh`), префиксом не считается.

`TAUSIK_SKIP_HOOKS=1` по-прежнему всё отключает — но этот обход
телеметрируется (`emit_supervision_bypass`), молчаливого выключения надзора нет.

**Непарсящаяся команда.** Если команда не токенизируется (несбалансированная
кавычка), парсер падает в регулярное выражение, которое намеренно
ПЕРЕобнаруживает. `bash_write_gate` (QG-0) этот ответ принимает: худший случай —
попросят задачу, которая и так нужна. `memory_pretool_block` — нет: его блок
обвиняет агента в утечке знаний, а выходов только два (маркер, который был бы
неправдой, и постоянное исключение в конфиге ради разовой команды), поэтому
ложное срабатывание там дороже пропуска и тренирует обход. Пропуск в этом хуке
не молчаливый: пишется `fail_open_unparseable_<канал>` (`…_bash`,
`…_powershell` — причина называет тот парсер, который не справился, а не
сваливает всё на Bash), а in-tree половину deny-list всё равно пересудят гейт
`memory_route` и pre-commit до коммита.

## Покрытие ПО ПРАВИЛАМ, а не по хостам целиком

Уведомление, которое читает агент, отвечает на два разных вопроса, и второй
появился потому, что первого оказалось мало. «На этом хосте механизма реального
времени нет» — правда, но грубее правды: на Kilo каждое закрытие задачи, каждая
запись знания и каждое открытие задачи ОТКАЗЫВАЕТСЯ, потому что идут через наши
собственные инструменты. Одно предложение про хост целиком не может сказать и то
и другое, а сказать только первое — значит соврать пользователю в обратную
сторону.

Разрез проходит по тому, КТО СОВЕРШАЕТ ДЕЙСТВИЕ:

| Что держит правило | Какие правила | Где работает |
|---|---|---|
| Наша поверхность (`tausik_*` / CLI) | QG-0, QG-2, лимит смены (9.2), маршрутизация памяти | НА ЛЮБОМ хосте: точка принуждения внутри нашего кода, а MCP-сервер есть даже там, где нет ничего другого |
| Перехват действий хоста | Rule 1 (нет кода без задачи), Rule 2 (границы scope), Rule 10.12 (секреты) | ТОЛЬКО там, где развёрнут артефакт, несущий именно это правило |

Второй столбец выводится из развёрнутого, а не из списка: правило названо
артефактом (`hook:task_gate.py`, `plugin:tausik-qg0.js`), и вопрос «покрыто ли
оно здесь» есть вопрос «лежит ли этот артефакт в профиле». Поэтому OpenCode, у
которого один плагин QG-0, показывается как покрывающий Rule 1 и НЕ покрывающий
Rule 2 и Rule 10.12 — что и есть правда, а не «хост покрыт».

Замер MCP-границы (смена #232, разбор AST): 146 объявленных инструментов, 44
обработчика меняют состояние, и ни один не обращается к бэкенду напрямую.
Отказы служебного слоя доезжают до границы — и это проверяется прогоном самих
обработчиков, а не рассуждением: `tests/test_rule_coverage.py` закрывает задачу
через `tausik_task_done` без квитанции и требует, чтобы задача осталась открытой.

`.tausik/tausik doctor` печатает обе строки: покрытие по хостам и разрез по
правилам.

### У перехвата два условия, а скан видит одно

«Есть ли артефакт в профиле» — условие, на которое скан ответить может. У
хоста, охраняющего свой механизм хуков, есть второе, которое скану недоступно:
хост должен быть СОГЛАСЕН исполнять хуки проекта. Codex исполняет проектный
`.codex/hooks.json` только после того, как пользователь ему доверил, и на диске
два состояния неотличимы байт в байт. Замерено живьём в приёмке 1.9 (смена
#251): при сгенерированном, но недоверенном профиле запрещённая
`Path('outside.txt').write_text(...)` выполнилась, файл появился — ни один хук
не сработал; та же операция под доверенным профилем была отклонена до записи.
Поэтому честная формулировка для Rule 1 и Rule 2 на Codex — «hard, как только
хуки доверены», `doctor` сообщает только первое условие и говорит об этом, а
недоверенный сгенерированный профиль НЕ защищён и защищённым не называется —
см. [матрицу принуждения Codex](https://github.com/Kibertum/tausik-core/blob/v1.11.0/docs/ru/model-providers.md#матрица-принуждения-codex).

### Матрица покрытия каналов

Надзор бывает дырявым не только по ПРАВИЛУ, но и по КАНАЛУ, и второе заметить
труднее: все тесты зелёные, потому что все тесты спрашивают покрытый канал. На
win32 — первичной платформе проекта — агенту доступны ДВА инструмента-оболочки,
`Bash` и `PowerShell`, и до задачи `powershell-tool-bypasses-bash-firewall`
второй не матчился ни одним PreToolUse-хуком.

| Гейт | Write/Edit | Bash | PowerShell |
|---|---|---|---|
| `task_gate` (Rule 1) | ✅ | — ¹ | — ¹ |
| `scope_write_gate` (Rule 2) | ✅ | — ¹ | — ¹ |
| `bash_write_gate` (Rule 1 + 2 для оболочек) | н/п | ✅ | ✅ |
| `bash_firewall` (опасные команды) | н/п | ✅ | ✅ |
| `git_push_gate` (push-тикет) | н/п | ✅ | ✅ |
| `memory_pretool_block` (memory-route) | ✅ | ✅ | ✅ |
| `secret_scan` (Rule 10.12) | ✅ | ✅ ² | ✅ ² |

¹ Не пробел: оболочечный вектор судит `bash_write_gate`, который импортирует
решения `scope_write_gate`, а не копирует их. У события оболочки нет
`file_path`, читать этим хукам там нечего.

² **Пробел закрыт** (`secret-scan-covers-no-shell-channel`, Решение #178).
`secret_scan` теперь на `SHELL_MATCHER` в обоих bootstrap и пропускает
оболочечные инструменты через `shell_channel.is_shell_tool` — на обоих каналах
сразу, потому что закрывать на одной оболочке значило бы снова развести каналы.
Сканируется ВСЯ командная строка (строгое надмножество извлечения записываемого
значения: ловит heredoc-тело и `Set-Content -Value`, плюс `export KEY=…` — литерал
секрета в контексте, что Rule 10.12 тоже покрывает), без нового shell-парсинга.
Остаток тот же, что у путей: секрет, переданный переменной/env (`--token "$TOKEN"`),
не резолвится и не флагается — это корректный способ передачи, а не пробел.

### Конструкции-данные PowerShell: что закрыто, что названо

Вопрос «это команда или это текст?» надо задавать КАЖДОЙ конструкции, а не одной.
Здесь он был отвечен для кавычек и не задан для here-string — и гейт заблокировал
обычный `git commit -m @'...'@` собственного проекта, потому что `>` в прозе
сообщения прочитался как редирект. Аудит по одному:

| Конструкция | Статус | Как именно |
|---|---|---|
| `@'…'@`, `@"…"@` (here-string) | **закрыто** | Тело — ОДИН токен. Открывающая кавычка обязана заканчивать строку, терминатор `'@` признаётся только В НАЧАЛЕ строки — как требует сам PowerShell. Ослабить любое из двух условий значит снова выпустить тело как живой shell. |
| `'…'`, `"…"` | закрыто с первой версии | Упоминание в кавычках приходит одним токеном и не образует инструкции. |
| `{…}` (script block) | **сознательно НЕ данные** | Скобки — разделители, содержимое читается как обычные инструкции. Script block ИСПОЛНЯЕМ: `... \| ForEach-Object { Remove-Item -Recurse C:\ }` обязан остаться видимым. Проза внутри фигурных скобок не живёт. |
| `$(…)`, `@(…)` | **остаточная граница** | Уровнем вложенности не считаются; токен с `$` помечается неразрешимым и отбрасывается, а не угадывается. Тот же остаток, что POSIX-гейт объявляет для `$VAR`. |

**Диалект следует за ИНСТРУМЕНТОМ, а не проверяется обоими.** Соблазнительная
формулировка «читаем обоими токенизаторами и блокируем, если push увидел любой»
звучит как усиление и является ослаблением: каждый диалект неверно читает
синтаксис другого, поэтому из двух судей выигрывает НЕКОМПЕТЕНТНЫЙ. Реально
случилось: POSIX-лексер не знает here-string, ломается на апострофе в слове
«PowerShell's», и `git push --force` из прозы commit-сообщения блокирует
обычный коммит. Токенизация идёт через `shell_channel` по `tool_name` — той же
единственной картой, что и цели записи.

Остаточная граница push-гейта, названная явно: push внутри payload'а обёртки
(`powershell -Command 'git push'`) для своего диалекта — один закавыченный
токен и гейтом тикета НЕ ловится. `bash_firewall` в payload'ы спускается, поэтому
force-push этим путём по-прежнему блокируется; обычный push этим путём тикета не
требует. Закрывать это через `scan_target` (который склеивает payload
интерпретатора сырьём) НЕЛЬЗЯ — он заблокирует честный
`python -c "print('git push')"`, то есть обменяет один ложный блок на другой.

Симптом для поиска в будущем: детектор, который в одном месте умеет отличать
текст от команды, а в соседнем — нет. Цена такой асимметрии не «пропуск», а
ЛОЖНЫЙ БЛОК на рутинной операции, и он тренирует обход дороже, чем стоила бы
пропущенная команда (конв. #291).

**Остаточная граница PowerShell-канала** (сверх общей для оболочек
«обфусцированной записи»): цель, пришедшая по КОНВЕЙЕРУ
(`Get-ChildItem C:\ | Remove-Item -Recurse`), не является операндом удаляющего
командлета и не видна; `-EncodedCommand <base64>` не декодируется; вызовы .NET
(`[IO.File]::Delete`) не разбираются. `Remove-Item` файла проекта не считается
записью — это ТОЧНЫЙ паритет с Bash, где `rm` тоже не писатель; пробел общий для
обоих каналов и закрывается отдельно, а не на одной стороне. Путь скрипта с
КАВЫЧКОЙ в токене (`python "a'b\helper.py"`) сохраняет обратные косые и на
POSIX остаётся неразрешённым — правило о кавычках, защищающее payload `-c` от
замены разделителя, накрывает и его; токен с кавычкой читается как исходник, а
не как путь (ревью #208, запись #22).

**Смешанный scope (Rule 2, AC3).** Как только ЛЮБАЯ активная задача объявила
`scope_paths`, ACL-энфорсмент включается для ВСЕХ co-active задач: параллельная
задача без объявленного scope теряет legacy-свободу и должна либо объявить свою
область, либо её запись вне union'а объявленных ACL будет заблокирована (и через
Write, и через обе оболочки). Это закрывает трюк «держать одну необъявленную
задачу активной, чтобы обойти scope». Legacy-свобода остаётся только когда scope
не объявил НИКТО.

