@rt-tools/agent-kit 0.14.0 → 0.16.0

package/assets/hooks/turn-exit-guard.sh

@@ -12,7 +12,9 @@
 # нельзя, и запрет должна держать машина.
 #
 # Что считается работой: правка файла и команда, меняющая дерево или его состояние. Чтение,
-# поиск и разговор работой не считаются — именно ими и заполняется ход, который встал.
+# поиск и разговор работой не считаются — именно ими и заполняется ход, который встал. Читающая
+# подкоманда `git` и клиента хостинга работой не считается тоже, и судится это по частям
+# составной команды: чтение, соединённое с правкой через `&&`, работой остаётся.
 #
 # Что отпускает ход:
 #   1. Работа отдана либо влита — состояние работы говорит об этом само.
@@ -74,6 +76,43 @@ case "$state" in
     работа-отдана | влито) exit 0 ;;
 esac
 
+# Записанный замысел концом хода не бывает вовсе. Обязательное действие этого состояния — делать
+# первый этап, а начавший его переводит состояние той же правкой: ход, оставшийся в прежнем
+# состоянии, первого этапа не начал по определению. Второй признак сюда не годится — заведение
+# задачи, ветки, колонки и папки он считает работой, и ход, где сделана одна подготовка,
+# проходит его насквозь. За один заход так вышло трижды; дважды это поймал соседний гард по
+# открытой заявке, третий раз не поймало ничто, а владельцу отчёт о взятой задаче неотличим от
+# остановки.
+if [ "$state" = "замысел-записан" ]; then
+    plan="$root/$tasks_dir/$branch/plan.md"
+    first_stage="$(grep -m1 '^### ' "$plan" 2>/dev/null | sed 's/^### //')"
+    [ -z "$first_stage" ] && first_stage="первый этап замысла"
+    reason="BLOCKED by turn-exit-guard: работа стоит в состоянии 'замысел-записан', а обязательное действие этого состояния — делать первый этап — за ход не начато.
+
+Заведение задачи, ветки, колонки и папки этим шагом не считается: всё это подготовка к работе, а не работа. Владельцу отчёт о взятой задаче неотличим от остановки — он видит исполнителя стоящим.
+
+Первый этап замысла: ${first_stage}
+
+Начни его этим же ходом и перепиши состояние на '- **Состояние:** \`этап-идёт\`'. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # Общий хвост отказа: два законных хода. Файл может быть не разложен — тогда хвоста нет,
+    # а причина отказа остаётся прежней.
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: замысел записан, а первый этап не начат."}\n'
+    exit 0
+fi
+
 # То же самое, но объявить это на диске уже нечем: папка задачи разбирается до открытия заявки,
 # и ход работы уезжает вместе с ней. Признак берётся из истории ветки — папка, снятая её
 # коммитом.
@@ -108,7 +147,36 @@ next_step=""
 # заполняется ход, который встал.
 work_re='git (add|commit|push|checkout|merge|rm)|npm run|pnpm (run|exec)|nx (build|test|run)|gh (pr|issue|api|run)|task:(new|move)|mkdir|cp |mv |rm |sed -i|tee |>>?[[:space:]]*[^|&]'
 
-verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re" '
+# Разведка. Те же слова, что и в образце работы, но подкоманда читающая: переключение ветки,
+# подтягивание, просмотр истории, чтение заявок и прогонов. Образец работы называет их работой,
+# потому что знает только первое слово — `git` и `gh` стоят в нём целиком, — и ход, в котором
+# исполнитель перешёл на главную ветку, прочитал историю и написал владельцу отчёт, выходил
+# отсюда нулём. Разбор — `docs/postmortems/2026-08-25-read-only-turn-counted-as-work.md`.
+#
+# Разведка выглядит работой лучше всего остального: в ней команды, числа и точные ответы. Тем
+# она и опасна — ход, набитый ею, читается как полный и владельцем, и самим заходом.
+read_re='^[[:space:]]*(([^[:space:]]*/)?git[[:space:]]+(show|log|ls-tree|ls-files|ls-remote|diff|status|branch|tag|rev-parse|remote|describe|blame|fetch|pull|(checkout|switch)(?![[:space:]]+-[bc][[:space:]]))|([^[:space:]]*/)?gh[[:space:]]+(pr|issue|run|repo)[[:space:]]+(list|view|status|checks|diff|download|logs))([[:space:]]|$)'
+
+# Части составной команды судятся по одной: ход собирает чтение и работу в одну строку через
+# `&&`, и суждение целиком отпускало бы разведку по первой же меняющей части.
+part_re='&&|\|\||;|\n'
+
+# Ожидание чужого шага. Прогон, разбор владельцем и слияние идут без исполнителя и от взгляда
+# быстрее не становятся — правило прямо говорит, что состоянием работы это не бывает. Судится
+# только ПОСЛЕДНЕЕ действие хода: ожидание в середине законно, а запуск работы в фоне работой
+# остаётся. Разбор — `docs/postmortems/2026-08-25-turn-ended-on-waiting.md`.
+#
+# Прежний признак спрашивал одно: была ли за ход работа. Ход, где разобран конфликт, сделаны
+# коммит и пуш, а последним действием стал цикл до готовности прогона, проходил его целиком —
+# работа была, и много. Именно эта полнота и обманывает: пустоты за таким ходом не видно.
+wait_re='gh[[:space:]]+(run[[:space:]]+watch|pr[[:space:]]+checks[^|]*--watch)|until[[:space:]].*sleep|while[[:space:]].*sleep|^[[:space:]]*sleep[[:space:]]'
+
+# Отдача работы и начало следующей. Правило зовёт законным концом хода отданную работу — но с
+# условием: следующая начата, и по ней сделано ДЕЙСТВИЕ, а не сказано.
+handover_re='gh[[:space:]]+pr[[:space:]]+create'
+started_re='task:new|task:move|board\.mjs[[:space:]]+move|git[[:space:]]+checkout[[:space:]]+-b|git[[:space:]]+switch[[:space:]]+-c'
+
+verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re" --arg read "$read_re" --arg part "$part_re" --arg wait "$wait_re" --arg handover "$handover_re" --arg started "$started_re" '
     def is_input:
         .type == "user"
         and (((.message.content // []) | if type == "array"
@@ -122,7 +190,29 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re
     | ($uses | map(.name // "") | any(test("^(Edit|Write|MultiEdit|NotebookEdit)$"))) as $edited
     | ($uses | map(.name // "") | any(test("AskUserQuestion"))) as $asked
     | ($uses | map((.input.command // "")) | join("\n")) as $ran
-    | ($ran | test($work)) as $ran_work
+    # Работой считается часть команды, совпавшая с образцом работы и не совпавшая с образцом
+    # разведки: переключение ветки и чтение истории тем же ходом работой не становятся.
+    | ([$ran | splits($part)] | map(test($work) and (test($read) | not)) | any) as $ran_work
+    # Последнее действие хода. Ожидание чужого шага концом хода не бывает, сколько бы работы ни
+    # было раньше: работа остаётся ровно там, где стояла.
+    | ([$uses[] | select((.name // "") == "Bash") | (.input.command // "")] | last // "") as $last
+    | ($last | test($wait)) as $waited
+    # Отдача работы: хвост хода после открытия заявки. Всё, что было до неё, сделано по сданной
+    # задаче и о следующей не говорит ничего.
+    | ([$uses[] | select((.name // "") == "Bash") | (.input.command // "")]) as $cmds
+    | (($cmds | map(test($handover)) | index(true))) as $handover_at
+    | ($handover_at != null) as $handed_over
+    | (if $handover_at == null then [] else $cmds[$handover_at:] end) as $tail
+    | (($tail | map(test($started)) | any)
+        or ($uses | map(.name // "") | any(test("^(Edit|Write|MultiEdit|NotebookEdit)$")))) as $started_next
+    # ПОСЛЕДНЕЕ ДЕЙСТВИЕ ХОДА — общий признак, из которого частные ярусы ниже только выводят
+    # понятный отказ. Девять разборов происшествий за сутки описывают девять разных остановок, и
+    # во всех девяти последним действием хода был текст владельцу: отчёт, сводка, объявление
+    # намерения. Ярус на каждый вид остановки — гонка без конца: видов столько, сколько бывает
+    # поводов заговорить. Признак поэтому один — работой должно быть ПОСЛЕДНЕЕ действие.
+    | ([$uses[] | (.name // "")] | last // "") as $last_tool
+    | (($last_tool | test("^(Edit|Write|MultiEdit|NotebookEdit)$"))
+        or ([$last | splits($part)] | map(test($work) and (test($read) | not)) | any)) as $ended_working
     # Отказ гарда и передача захода — оба кончают ход по правилу.
     | ([$turn[] | select(.type == "user") | .message.content // [] | select(type == "array") | .[]
           | select(.type == "tool_result") | .content
@@ -136,17 +226,65 @@ verdict="$(tail -n 400 "$transcript" 2>/dev/null | jq -s -r --arg work "$work_re
           | if type == "string" then . elif type == "array"
             then (map(if type == "object" then (.text // "") else "" end) | join("\n")) else "" end] | join("\n")) as $said
     | ($said | test("останов|стоп|хватит|подожди|не надо|прерв|отложи")) as $told_stop
-    | { worked: ($edited or $ran_work), released: ($asked or $denied or $handed or $told_stop), ran: $ran }
+    | { worked: ($edited or $ran_work), released: ($asked or $denied or $handed or $told_stop), waited: $waited, handed_over: $handed_over, started_next: $started_next, ended_working: $ended_working, ran: $ran }
 ' 2>/dev/null)"
 
 [ -z "$verdict" ] && exit 0
 
 worked="$(printf '%s' "$verdict" | jq -r '.worked // false' 2>/dev/null)"
+waited="$(printf '%s' "$verdict" | jq -r '.waited // false' 2>/dev/null)"
+handed_over="$(printf '%s' "$verdict" | jq -r '.handed_over // false' 2>/dev/null)"
+started_next="$(printf '%s' "$verdict" | jq -r '.started_next // false' 2>/dev/null)"
+ended_working="$(printf '%s' "$verdict" | jq -r '.ended_working // false' 2>/dev/null)"
 released="$(printf '%s' "$verdict" | jq -r '.released // false' 2>/dev/null)"
 commands="$(printf '%s' "$verdict" | jq -r '.ran // ""' 2>/dev/null)"
 
 [ "$released" = "true" ] && exit 0
 
+# Взятая, но не начатая работа. Ветка по номеру задачи заведена, а каталога задачи при ней нет
+# вовсе — значит работа объявлена взятой и не начата ни одной строкой. Ход здесь не кончается, сколько бы
+# работы в нём ни было: заведение ветки, перевод колонки и уборка соседних веток — всё это
+# команды, меняющие дерево, и второй признак отпускает такой ход целиком.
+#
+# Ровно так ход и вставал: задача взята, номер назван владельцу, отчёт написан — и следующее
+# действие состояния «задача-взята», написать замысел, не сделано. Отчёт выглядит работой лучше
+# всякой другой, а страж, знающий только «была ли за ход работа», подтверждает это: работа была.
+# Разбор — `docs/postmortems/2026-08-25-task-taken-and-turn-ended.md`.
+#
+# Папка, разобранная коммитом ветки, сюда не попадает: `archived` означает отданную работу, и её
+# судит прежний ярус. Ветка без номера задачи не судится вовсе — под пробу заводят и такие.
+if [ "$archived" != "true" ] && [ -z "$progress" ] && [ -n "$branch" ] && [ ! -d "$root/$tasks_dir/$branch" ]; then
+    task_key="${RT_TASK_KEY:-}"
+    if [ -z "$task_key" ] && [ -f "$root/.claude/rt-kit/checks.json" ]; then
+        task_key="$(jq -r '.board.taskKey // empty' "$root/.claude/rt-kit/checks.json" 2>/dev/null)"
+    fi
+    [ -z "$task_key" ] && task_key='[A-Za-z][A-Za-z0-9]*'
+    if printf '%s' "$branch" | grep -qE "^${task_key}-[0-9]+-" 2>/dev/null; then
+        reason="BLOCKED by turn-exit-guard: работа взята и не начата — ветка \`$branch\` заведена, а папки задачи при ней нет.
+
+Заведённая ветка означает состояние «задача-взята», и обязательное действие у него одно — написать замысел. Ход, кончившийся здесь, оставляет работу объявленной и не начатой: номер назван, колонка сдвинута, а на диске нет ни разбора просьбы, ни этапов. Команды заведения ветки и перевода колонки этого не заменяют — ими такой ход и заполняется.
+
+    npm run task:new -- <номер>   # если папки нет вовсе
+
+Собери \`$tasks_dir/$branch/\` и напиши замысел этим же ходом.
+
+Страж судит один ход: следующий заход не отбивается."
+
+        # shellcheck disable=SC1090
+        [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+            && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+        command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+        deny_tail_text="$(rt_deny_tail "")"
+        [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+        jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+            || printf '{"decision":"block","reason":"turn-exit-guard: работа взята и не начата — напиши замысел."}\n'
+        exit 0
+    fi
+fi
+
 # Контракт этапа. Отметка «этап сделан» — утверждение о дереве, и подтверждается оно выводом
 # команды, а не словами: этап, отмеченный по памяти, через заход неотличим от проверенного.
 # Страж сравнивает номер этапа с тем, что лежит в истории ветки, и на выросшем номере требует
@@ -199,6 +337,93 @@ ${deny_tail_text}"
     fi
 fi
 
+# Работа отдана, а следующая только названа. Работы в таком ходе больше, чем в любом другом, — и
+# вся она по сданной задаче: отдача завершает прошлую работу, а не ход. Девять разборов
+# происшествий за сутки описывают девять разных остановок, и во всех девяти последним действием
+# хода был текст владельцу: отчёт, сводка, объявление намерения.
+# Разбор — `docs/postmortems/2026-08-25-handover-turn-ends-on-intent.md`.
+if [ "$handed_over" = "true" ] && [ "$started_next" != "true" ]; then
+    reason="BLOCKED by turn-exit-guard: заявка открыта, а по следующей работе за этот ход не сделано ничего.
+
+Отданная работа кончает ход только вместе с начатой следующей — по ней должно быть сделано действие, а не сказано. «Беру такую-то» выходом не является: правило зовёт это объявлением намерения.
+
+Всё, что было до открытия заявки, сделано по сданной задаче и о следующей не говорит ничего.
+
+    npm run task:new -- <заголовок>            # завести следующую
+    git checkout -b <КЛЮЧ>-<номер>-<slug>      # взять её в работу
+
+Сделай первый шаг по следующей работе этим же ходом. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: работа отдана, а следующая не начата."}\n'
+    exit 0
+fi
+
+# Ход кончился ожиданием чужого шага. Работа в нём была — тем он и обманчив: полон, и пустоты за
+# ним не видно. Судится последнее действие, а не наличие работы.
+if [ "$waited" = "true" ]; then
+    reason="BLOCKED by turn-exit-guard: последним действием хода стало ожидание чужого шага, а оно состоянием работы не бывает.
+
+Прогон, разбор владельцем и слияние идут без исполнителя и от взгляда быстрее не становятся. Работы за ход могло быть много — она остаётся ровно там, где стояла, и владелец видит исполнителя стоящим.
+
+Следующий шаг записан в ходе работы: ${next_step}
+
+Сделай его этим же ходом либо возьми следующую задачу. Ожидание в середине хода законно — отбит именно конец.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: ход кончился ожиданием чужого шага."}\n'
+    exit 0
+fi
+
+# Общий рубеж. Работа за ход была — но последним действием стал не она, а текст владельцу.
+# Частные ярусы выше называют вид остановки точнее; сюда доходит то, чего они не знают по имени.
+if [ "$worked" = "true" ] && [ "$ended_working" != "true" ]; then
+    reason="BLOCKED by turn-exit-guard: работа за ход была, но последним действием хода стала не она.
+
+Ход кончается работой, а не рассказом о ней. Отчёт, сводка и объявление намерения выходом не являются: они выглядят завершением тем убедительнее, чем больше сделано, — и ровно на это место встаёт следующее действие.
+
+Следующий шаг записан в ходе работы: ${next_step}
+
+Сделай его этим же ходом, а сказать о сделанном можно после. Владелец сказал остановиться — так и напиши: страж читает его слово, а не пересказ.
+
+Страж судит один ход: следующий заход не отбивается."
+
+    # shellcheck disable=SC1090
+    [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" ] \
+        && . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/deny-tail.sh" 2>/dev/null
+    command -v rt_deny_tail >/dev/null 2>&1 || rt_deny_tail() { :; }
+    deny_tail_text="$(rt_deny_tail "")"
+    [ -n "$deny_tail_text" ] && reason="${reason}
+
+${deny_tail_text}"
+
+    jq -n --arg r "$reason" '{decision:"block",reason:$r}' 2>/dev/null \
+        || printf '{"decision":"block","reason":"turn-exit-guard: последним действием хода стала не работа."}\n'
+    exit 0
+fi
+
 [ "$worked" = "true" ] && exit 0
 
 if [ "$archived" = "true" ]; then

package/assets/laws/delivery.md

@@ -5,123 +5,111 @@
 приложение перестаёт отвечать, а причина этого выясняется по истории.
 
 ## Статьи
-
 - **Правка начинается с задачи, видимой в очереди работ.** Заведённой задачи мало: ту, что в
   очередь не попала, никто не видит, и работа за ней не планировалась.
-- **Правка попадает в главную ветку только через отдельную ветку.** Прямая запись в главную
-  лишает правку и обсуждения, и возможности откатить её одним движением.
+- **Правка попадает в главную ветку только через отдельную ветку.** Прямая запись в главную лишает
+  правку и обсуждения, и возможности откатить её одним движением.
 - **В очереди работ стоят задачи, а не PR о них.** У задачи и её PR один номер и одна судьба,
-  поэтому вторая карточка о той же работе ничего не добавляет — она удваивает очередь и врёт о
-  её длине. Читают очередь затем, чтобы увидеть, что сделано и что осталось; PR отвечает на
-  другой вопрос — как именно сделано, — и попадают в него из карточки задачи, где связь с ним
-  и так стоит. Карточка PR при этом живёт своей жизнью: закрывается позже задачи, висит в
-  очереди после слияния и остаётся в ней навсегда, потому что колонки под неё нет.
+  поэтому вторая карточка о той же работе ничего не добавляет — она удваивает очередь и врёт о её
+  длине. Очередь читают затем, чтобы видеть сделанное и оставшееся; PR отвечает на другой вопрос и
+  открывается из карточки задачи, где связь с ним и так стоит. Карточка PR живёт своей жизнью:
+  висит в очереди после слияния навсегда, потому что колонки под неё нет.
 - **Проверка не гоняет того, что правка не может сломать.** Набор, одинаковый для любой правки,
-  выглядит строгим, а работает наоборот: прогон, который длится вдесятеро дольше нужного, учат
-  не ждать, а обходить. Состав набора выводится из состава правки — из того, что она задела, а
-  не из того, кем она названа; правка, не тронувшая ни строки кода, не собирает образов и не
-  снимает кадров. Пропущенное при этом называется пропущенным: молча выпавший шаг читается как
-  пройденный.
-- **У задачи одна ветка, у ветки одна задача.** Откат снимает всё, что въехало этой веткой,
-  разом: две задачи в ней откатятся только вместе, а задача, въехавшая двумя ветками, после
-  отката одной останется наполовину сделанной — и в очереди работ этого не видно. Работа,
-  которая в одну ветку не влезает, делится на задачи до того, как ветка заводится. Признак
-  деления — раздельный откат, а не объём: числа файлов, строк или коммитов, за которым работа
-  становится двумя задачами, нет. Правка одного рода остаётся одной задачей, сколько бы файлов
-  она ни задела. Объём захода исполнителя признаком деления не является тоже: он говорит, какого
-  размера задачу стоит заводить среди тех, что делятся законно, и не даёт делить то, что
-  откатывается только вместе.
-- **Правка самой поставки проверяется её прогоном, а не рассуждением.** Проверить её иначе
-  нечем: она исполняется только там, где выкатывает, и в среде, которой на месте работы нет — с
-  чужими правами, чужим хранилищем ключей и чужой сетью. «Проверю после слияния» решением
-  исполнителя не бывает: за этими словами стоит выкатка, которой уже не будет, если правка
-  окажется неверной. Отложить проверку может только владелец, и он говорит это словами.
-- **Две задачи, которые чинятся одной правкой, — одна задача.** Вторая стирается вместе со
-  своим номером, а то, чего в первой не было, дописывается в неё до этого. Две строки об
-  одной работе хуже дыры в нумерации: по ним потом не понять, что сделано, а что нет. Слить
-  их можно, пока правка не въехала в главную ветку; после — обе остаются как есть.
-- **Задача, ветка под неё и PR о сделанном несут один и тот же номер в своих названиях.**
-  Иначе одну работу приходится узнавать по тексту названия, а в списке из полусотни строк это
-  делается по памяти и с ошибками.
-- **Номер пишется всюду одинаково: ключ задач, дефис, номер.** Заголовок задачи и PR
-  начинается с этой пары в квадратных скобках, имя ветки — с неё же. Одна форма, а не три
-  похожих, потому что номер читают не только глазами: из имени ветки его достаёт гард, из
-  заголовка — сверка очереди. Формы, выведенные порознь, расходятся молча и не отказывают, а
-  перестают узнавать номер: проверка, которая должна была найти работу без задачи, пропускает
-  всё подряд.
-- **Ключ задач дерево называет само, но назвать обязано.** В форме имени это единственное, что
-  у каждого дерева своё, — и единственное, что настраивается. Не названный ключ не даёт ни
-  поблажки, ни умолчания: работа с очередью отказывает и говорит, где он задаётся. Пустой ключ
-  хуже отсутствующей проверки — от имени остаётся огрызок, которому ничто не отвечает, и
-  правильно названной не выглядит ни одна задача.
-- **У задачи есть исполнитель с момента её заведения.** Задача без исполнителя выглядит
-  ничьей: по очереди работ не видно, кто её взял, и заведённая по ходу правка теряется среди
-  чужих.
-- **Состояние задачи в очереди работ отвечает тому, что с ней происходит.** Взятая в работу
-  видна взятой, а та, PR по которой ждёт разбора, — ждущей разбора. Иначе очередь показывает
-  один и тот же вид у нетронутого, у делаемого прямо сейчас и у сделанного: работа берётся
-  второй раз, а PR стоит неразобранным, пока про него не вспомнят. Состояние переставляется
-  в тот момент, когда работа переходит на следующий шаг, а не приводится в порядок потом:
-  очередь читают между этими моментами, а не после них.
-- **Попадание правки в главную ветку означает выкатку.** Всё, от чего правка зависит снаружи
-  кода — переменные окружения, секреты, записи имён, — ставится до этого момента, а не после.
-- **Признак режима исполнения объявлен в самом артефакте развёртывания, а не только в составе
-  его запуска.** Артефакт поднимают и мимо состава — руками, при разборе, на чужой машине, — и
-  без объявления он в этот момент считает себя отладочным, не сказав об этом ничего.
+  выглядит строгим, а работает наоборот: прогон, который длится вдесятеро дольше нужного, учат не
+  ждать, а обходить. Состав набора выводится из состава правки — из того, что она задела, а не из
+  того, кем она названа; правка, не тронувшая ни строки кода, не собирает образов и не снимает
+  кадров. Пропущенное при этом называется пропущенным: молча выпавший шаг читается как пройденный.
+- **У задачи одна ветка, у ветки одна задача.** Откат снимает всё, что въехало этой веткой, разом:
+  две задачи в ней откатятся только вместе, а задача, въехавшая двумя ветками, после отката одной
+  останется наполовину сделанной — и в очереди работ этого не видно. Работа, которая в одну ветку
+  не влезает, делится на задачи до заведения ветки. Признак деления — раздельный откат, а не
+  объём: числа файлов, строк или коммитов, за которым работа становится двумя задачами, нет.
+  Правка одного рода остаётся одной задачей, сколько бы файлов она ни задела; объём захода
+  говорит, какого размера задачу заводить среди тех, что делятся законно, и делить неделимое не
+  даёт.
+- **Правка самой поставки проверяется её прогоном, а не рассуждением.** Проверить её иначе нечем:
+  она исполняется только там, где выкатывает, и в среде, которой на месте работы нет — с чужими
+  правами, чужим хранилищем ключей и чужой сетью. «Проверю после слияния» решением исполнителя не
+  бывает: за этими словами стоит выкатка, которой уже не будет, если правка окажется неверной.
+  Отложить проверку может только владелец, и он говорит это словами.
+- **Две задачи, которые чинятся одной правкой, — одна задача.** Вторая стирается вместе со своим
+  номером, а то, чего в первой не было, дописывается в неё до этого. Две строки об одной работе
+  хуже дыры в нумерации: по ним потом не понять, что сделано, а что нет. Слить их можно, пока
+  правка не въехала в главную ветку; после — обе остаются как есть.
+- **Задача, ветка под неё и PR о сделанном несут один и тот же номер в своих названиях.** Иначе
+  одну работу приходится узнавать по тексту названия, а в списке из полусотни строк это делается
+  по памяти и с ошибками.
+- **Номер пишется всюду одинаково: ключ задач, дефис, номер.** Заголовок задачи и PR начинается с
+  этой пары в квадратных скобках, имя ветки — с неё же. Одна форма, а не три похожих, потому что
+  номер читают не только глазами: из имени ветки его достаёт гард, из заголовка — сверка очереди.
+  Формы, выведенные порознь, расходятся молча и не отказывают, а перестают узнавать номер:
+  проверка, которая должна была найти работу без задачи, пропускает всё подряд.
+- **Ключ задач дерево называет само, но назвать обязано.** В форме имени это единственное, что у
+  каждого дерева своё, — и единственное, что настраивается. Не названный ключ не даёт ни поблажки,
+  ни умолчания: работа с очередью отказывает и говорит, где он задаётся. Пустой ключ хуже
+  отсутствующей проверки — от имени остаётся огрызок, которому ничто не отвечает, и правильно
+  названной не выглядит ни одна задача.
+- **У задачи есть исполнитель с момента её заведения.** Задача без исполнителя выглядит ничьей: по
+  очереди работ не видно, кто её взял, и заведённая по ходу правка теряется среди чужих.
+- **Состояние задачи в очереди работ отвечает тому, что с ней происходит.** Взятая в работу видна
+  взятой, ждущая разбора — ждущей. Иначе нетронутое, делаемое и сделанное выглядят одинаково:
+  работа берётся второй раз, а PR стоит неразобранным. Состояние переставляется в тот момент,
+  когда работа переходит на следующий шаг: очередь читают между этими моментами, а не после них.
+- **Попадание правки в главную ветку означает выкатку.** Всё, от чего правка зависит снаружи кода
+  — переменные окружения, секреты, записи имён, — ставится до этого момента, а не после.
+- **Признак режима исполнения объявлен в самом артефакте развёртывания, а не только в составе его
+  запуска.** Артефакт поднимают и мимо состава — руками, при разборе, на чужой машине, — и без
+  объявления он в этот момент считает себя отладочным, не сказав об этом ничего.
 - **Выкатывается образ того коммита, который выкатывают.** Умолчание «последний» отстаёт от
   главной ветки, и приложение молча возвращается к прежней версии, продолжая отвечать.
 - **Из одного и того же коммита всегда ставятся одни и те же зависимости.** Если версия задана
-  диапазоном, установка сегодня и установка через неделю дадут разный код: сборка сломается
-  сама собой, и откатывать будет нечего. Обновление зависимости — обычная правка: у неё есть
-  автор, описание и откат.
+  диапазоном, установка сегодня и установка через неделю дадут разный код: сборка сломается сама
+  собой, и откатывать будет нечего. Обновление зависимости — обычная правка: у неё есть автор,
+  описание и откат.
 - **Порядок изменений хранилища проверяется с пустого места.** На уже работающем хранилище
   неверный порядок незаметен: он проявляется только при развёртывании с нуля.
-- **Проверка перед отправкой смотрит на содержимое репозитория, а не на состояние машины, где
-  она запущена.** На машине законно лежат недоделки, личные настройки и файлы вне истории.
-  Проверка, которая их читает, отбивает правку из-за того, чего в репозитории нет, и молчит о
-  том, что в нём есть. Проверка перед отправкой и конвейер выкатки судят по одному и тому же —
-  иначе «сошлось» значит в этих двух местах разное.
-- **Документ едет вместе с правкой, которую он описывает.** Ни сборка, ни проверки текстов
-  не читают, поэтому расхождение копится молча и потом выглядит действующей справкой.
+- **Проверка перед отправкой смотрит на содержимое репозитория, а не на состояние машины, где она
+  запущена.** На машине законно лежат недоделки, личные настройки и файлы вне истории. Проверка,
+  которая их читает, отбивает правку из-за того, чего в репозитории нет, и молчит о том, что в нём
+  есть. Проверка перед отправкой и конвейер выкатки судят по одному и тому же — иначе «сошлось»
+  значит в этих двух местах разное.
+- **Документ едет вместе с правкой, которую он описывает.** Ни сборка, ни проверки текстов не
+  читают, поэтому расхождение копится молча и потом выглядит действующей справкой.
 - **Работа, меняющая код, кончается открытым PR.** PR — единственное место, где человек видит
-  правку целиком, отвечает на неё и вливает её; коммит в ветке и запушенная ветка этого места
-  не заменяют. Пока PR не открыт, работа сделанной не считается, сколько бы её ни было в
-  истории ветки: разбор по ней невозможен, а человек о ней не знает. Открывается PR тем же
-  ходом, которым исполнитель говорит, что работу отдаёт, — а не следующим заходом и не по
-  напоминанию.
-- **PR, не готовый к слиянию, помечается черновиком.** Открытый PR читается как приглашение
-  влить, и человек нажимает слияние, не спрашивая, кончилась ли работа. Черновик разводит два
-  состояния, которые иначе выглядят одинаково: правка выложена на обозрение — и правка готова
-  поехать в главную ветку. Помечается им всё, что ждёт прогона, доработки или ответа на
-  вопрос; вопрос при этом задаётся в самом PR, а не остаётся в голове исполнителя.
+  правку целиком, отвечает на неё и вливает; коммит и запушенная ветка его не заменяют. Пока PR не
+  открыт, работа сделанной не считается: разбора по ней нет, а человек о ней не знает. Открывается
+  PR тем же ходом, которым исполнитель говорит, что работу отдаёт, — а не следующим заходом и не
+  по напоминанию.
+- **PR, не готовый к слиянию, помечается черновиком.** Открытый PR читается как приглашение влить,
+  и человек нажимает слияние, не спрашивая, кончилась ли работа. Черновик разводит два состояния,
+  которые иначе выглядят одинаково: правка выложена на обозрение — и правка готова поехать в
+  главную ветку. Помечается им всё, что ждёт прогона, доработки или ответа на вопрос; вопрос при
+  этом задаётся в самом PR, а не остаётся в голове исполнителя.
 - **Снятие черновика — отдельный ход, и им исполнитель отвечает за готовность.** Черновик
-  снимается тогда, когда проверки пройдены, доработок не осталось и работа сходится с тем,
-  ради чего заводилась задача. Пока он стоит, молчание исполнителя значит «ещё не готово», и
-  человек ничего не должен переспрашивать; после снятия оно значит «можно вливать», и цена
-  ошибки здесь — правка в главной ветке.
-- **PR о сделанном остаётся верным до самого слияния.** Он описывает дерево на день, когда
-  его написали, а разбора ждёт днями: за это время главная ветка вливается в ветку, и
-  утверждение PR о соседних файлах становится неправдой молча — тел PR не читает ни
-  одна проверка. Всё, что вливается в ветку после публикации PR, — повод перечитать его.
-- **PR в главную ветку вливает человек.** Слияние — последний момент, когда разбор ещё
-  возможен: после него правка стоит в главной ветке, работа ушла к следующей задаче, и
-  вернуться к ней уже некому. Исполнитель работы вливает свой PR только по прямому слову
-  человека и только про названный PR; молчание разрешением не бывает, а слово, сказанное об
-  одном PR, на следующий не переносится. Иначе разбор проходит тот, кого разбирают, и
-  очередь PR выглядит разобранной, не будучи ею.
+  снимается тогда, когда проверки пройдены, доработок не осталось и работа сходится с тем, ради
+  чего заводилась задача. Пока он стоит, молчание исполнителя значит «ещё не готово», и человек
+  ничего не должен переспрашивать; после снятия оно значит «можно вливать», и цена ошибки здесь —
+  правка в главной ветке.
+- **PR о сделанном остаётся верным до самого слияния.** Он описывает дерево на день, когда его
+  написали, а разбора ждёт днями: за это время главная ветка вливается в ветку, и утверждение PR о
+  соседних файлах становится неправдой молча — тел PR не читает ни одна проверка. Всё, что
+  вливается в ветку после публикации PR, — повод перечитать его.
+- **PR в главную ветку вливает человек.** Слияние — последний момент, когда разбор ещё возможен:
+  после него правка стоит в главной ветке, работа ушла к следующей задаче, и вернуться к ней уже
+  некому. Исполнитель работы вливает свой PR только по прямому слову человека и только про
+  названный PR; молчание разрешением не бывает, а слово, сказанное об одном PR, на следующий не
+  переносится. Иначе разбор проходит тот, кого разбирают, и очередь PR выглядит разобранной, не
+  будучи ею.
 - **Требование, стоящее перед необратимым шагом, стоит там, где этот шаг совершают.** Гард на
-  машине исполнителя судит его команды и молчит о том же действии, совершённом кнопкой у
-  хостинга: обход выходит не намеренным, а незамеченным — нажавший не знает, что чего-то не
-  хватало. Требование либо переносится туда, где нажимают, либо объявляется тому, кто нажимает,
-  до нажатия. Иначе оно держится не собой, а тем, что необратимый шаг каждый раз делает тот же
-  человек: папка закрытой задачи так и уехала в главную ветку вместе со своей договорённостью, и
-  вынимать её пришлось отдельной задачей.
+  машине исполнителя судит его команды и молчит о том же действии, совершённом кнопкой у хостинга:
+  обход выходит не намеренным, а незамеченным — нажавший не знает, что чего-то не хватало.
+  Требование либо переносится туда, где нажимают, либо объявляется тому, кто нажимает, до нажатия.
+  Иначе оно держится не собой, а тем, что необратимый шаг каждый раз делает тот же человек.
 - **Слияние в главную ветку ещё не означает, что правка доехала.** Отказ выкатки не трогает ни
   задачу, ни очередь работ, поэтому расхождение главной ветки с тем, что работает, обязано быть
   видно там, где очередь читают. Иначе следующие работы вливаются поверх поломки, которую не
   приносили, и каждая выглядит доехавшей.
-- **Состоявшаяся поломка разбирается записью, которая переживает задачу.** Починка уезжает
-  веткой, задача закрывается — и причина, по которой приложение встало, остаётся знанием одного
-  исполнителя. Запись называет, что сломалось, чем это стало видно и почему починка чинит
-  причину, а не признак; живёт она среди описаний состоявшегося, а не там, что умирает вместе с
-  задачей.
+- **Состоявшаяся поломка разбирается записью, которая переживает задачу.** Починка уезжает веткой,
+  задача закрывается — и причина, по которой приложение встало, остаётся знанием одного
+  исполнителя. Запись называет, что сломалось, чем это стало видно и почему починка чинит причину,
+  а не признак; живёт она среди описаний состоявшегося, а не там, что умирает вместе с задачей.

package/assets/laws/frontend-application.md

@@ -5,6 +5,10 @@
 
 ## Статьи
 
+- **У действия человека есть путь в интерфейсе.** Команда на сервере — путь того, кто держит
+  сервер: у неё свой доступ, своя оболочка и свой узел. Приложение, у которого обычное действие
+  делается заходом на сервер, интерфейса этому действию не дало, и наличие такой команды его
+  наличия не заменяет.
 - **Состояние экрана пересчитывается само, а не по команде.** Пересчёт вручную рано или
   поздно пропускают, и экран показывает прежнее значение рядом с новым.
 - **Шаблон показывает готовое, а не вычисляет.** Вычисление в шаблоне повторяется на каждой