binary.yml

name: Binary

# ПОЧЕМУ ЭТА РАБОТА ЗАВЕДЕНА И ПОЧЕМУ ОНА РАЗБИТА НАДВОЕ.
#
# До неё двоичный компилятор не собирался в CI НИ РАЗУ на Linux. Собирала его
# одна `build-macos.yml` — и только на macOS, ради отдельной беды с макросом
# видимости. Следствие оказалось хуже, чем «двоичный не проверен»: всякая
# проверка, переведённая на двоичный, ТИХО переставала выполняться.
#
# Тихо — здесь главное слово. Проверка корпусного режима при
# отсутствии `bootstrap/flang` не падала, а ПРОПУСКАЛАСЬ с диагностикой, а
# «пропущено» в отчёте читается как «всё хорошо». Предохранитель на этот случай
# заведён (`FTS_REQUIRE_BINARY=1`), но не был выставлен нигде: `grep` по дереву
# находил имя ровно в двух местах, и оба — внутри самого файла пробы. Разбор —
# `docs/zettel/a-check-moved-to-the-binary-drops-out-of-ci-silently.md`.
#
# Два обходчика, целиком написанных на двоичном, не звались из CI вовсе:
# `flang/test/обход.sh` и `flang/test/обход-примеров.sh` (корпус
# `.flang` всего дерева). Здесь стояло «(98 проверок)» — число протухло молча:
# замер 30 августа 2026 даёт **180** («обходчик: чисто — проверок 180, сошлись
# все 180»), из них 18 прибыли в тот же день вместе с
# `flang/test/process-failures.flang`. Число в пометке снимается прогоном
# `sh flang/test/обход.sh`, а не памятью.
#
# После удаления реализации на JavaScript (`fe8e8a38`, 48 файлов, 56 072 строки)
# это единственная работа CI, которая вообще проверяет ЯЗЫК: `npm test` из
# `ci.yml` не доходит до первой пробы (см. пометку там).
#
# ── Почему надвое, а не одной работой ───────────────────────────────────────
#
# Потому что цена у двух половин разная на порядок, и замерена:
#
#   сборка `make -C bootstrap -j4`, четыре ядра, -O2 -flto        70 с
#   дым (`--version`, `--help`, `check` одного файла)              3 с
#   обходчик проверок на flang, 211 проверок                       3 с
#   СНЯТО 2026-09-13 строк flang/test/ledger.txt = 211
#   примеры stdlib и ядра, 3991 штук                        44 мин 07 с
#   СНЯТО 2026-10-04 примеров-в flang/stdlib/*.flang,flang/core/*.flang = 3991
#   ─────────────────────────────────────────────────────────────────
#   обходчик примеров корпуса, всё дерево                    ДЕСЯТКИ МИНУТ
#
# Первые три дёшевы и ходят на каждый пуш: полторы минуты за то, что двоичный
# вообще собирается и судит — это даром.
#
# Четвёртый дорог, и дорог НЕ ОСНАСТКОЙ, а двумя файлами дерева: `flang test`
# на `flang/self/bootstrap/compiler.flang` считается 469 с, на
# `flang/self/repl/repl.flang` — 228 с. Остальное дерево (stdlib, examples,
# core) БОЛЬШЕ НЕ дешевле этих двух: 5 сентября 2026 один только stdlib взял
# 44 минуты. Прежние «stdlib 40 с, examples 187 с, core 13 с» сняты 24 августа
# и держались без приметы — см. ниже, почему у времени приметы нет вовсе.
#
# ЗАМЕРЕНО, А НЕ ПРИКИНУТО: полный обход идёт БОЛЬШЕ ЧАСА. Два захода на этой
# машине (256 ядер, свободных больше двухсот) не уложились: первый убит на 60-й
# минуте без вывода, второй перевалил за 47 минут. Обход ОДНОПОТОЧНЫЙ — это один
# процесс `flang test . --ledger`, и свободные ядра ему не помогают ничем.
#
# Отсюда триггер: тег и рука, БЕЗ запроса слияния. Час-полтора на каждый ЗС —
# это ровно та беда, из-за которой `ci.yml` увели с пуша на тег, и повторять её
# незачем. Язык перед слиянием не остаётся неприкрытым: работа `sborka` выше
# гоняет на каждый пуш 211 проверок и 184 примера ядра. Примеры `stdlib` (3663
# из 3991 ниже) с пуша сняты на тег (задача 6890): их прогон брал 44 минуты, и
# пуш из-за них не влезал в пять минут — та самая утечка, ради которой заведено.
# СНЯТО 2026-09-13 строк flang/test/ledger.txt = 211
# СНЯТО 2026-10-04 примеров-в flang/stdlib/*.flang,flang/core/*.flang = 3991
# (число 98 стояло здесь ещё дважды после того, как строкой 21 его уже сняли
#  и назвали протухшим: одна правка прошла по одному месту из трёх.)
# Здесь же — глубокая сверка всего дерева, и её место там, где решают выпуск.
#
# `timeout-minutes: 180`, а не 90: ядра раннера медленнее здешних, и час тут
# легко станет двумя там.
#
# Node не ставится ни в одной из двух работ, и это не экономия: путь установки,
# ради которого двоичный существует, обязан обходиться без Node. Работа, которой
# Node не выдали, это доказывает, а не обещает. Проверено отдельно — `обход.sh`
# проходит в `env -i PATH=/usr/bin:/bin`, где `node` недостижим.

# ── ВЫПУСК НЕ ОПИРАЕТСЯ НА КЕШ ПРИГОВОРОВ ────────────────────────────────────
#
# `AGENTS.md`, раздел «Кеш приговоров: где живёт и чему он НЕ основание», несёт
# правило, которое отменять нельзя: «Кешу верят для СКОРОСТИ. Для ИСТИНЫ — про-
# веряльщику. Выпуск не имеет права опираться на кеш: перед меткой всё пересчи-
# тывается начисто, без `FLANG_KESH_PRIGOVOROV`.»
#
# До 2 сентября 2026 правило было записано словами и не принуждалось ничем.
# Правило, которое ничто не исполняет, — не правило: сторож столкновений имён
# уже лежал в дереве, его никто не звал, и это стоило двадцати часов машины.
# Теперь его принуждает составное действие `.github/actions/release-without-cache`
# (почему не файл в `scripts/` — разобрано в его шапке), и шаг
# «Check verdict cache» стоит ПЕРВЫМ после выкладки —
# в каждой из одиннадцати работ этого файла.
#
# ПОЧЕМУ В КАЖДОЙ РАБОТЕ, А НЕ В ОДНОЙ. Работы независимы: у каждой свой раннер
# и своя среда, и заглянуть в чужую ни одна не может. Сторож в одной работе
# ничего не говорит про остальные — а метка выпускает то, что сказали ВСЕ
# вместе. Выбрать подмножество значило бы оставить дыры ровно там, куда не
# посмотрели.
#
# ПОЧЕМУ ПАДАЕТ, А НЕ СНИМАЕТ ПЕРЕМЕННУЮ МОЛЧА. Снять её можно только блоком
# `env:` работы — а он затирает значение ДО сторожа, и сторож был бы зелен
# всегда, ничего не проверяя. Молчаливое снятие вдобавок прячет находку:
# заданная на пути выпуска переменная — признак того, что выпуск настроен
# неправильно, и это надо увидеть один раз глазами, а не глотать каждый раз.
#
# На ветке и в запросе слияния сторож молчит: кеш там разрешён и нужен, он для
# скорости. Красным он бывает только на метке — а его собственная проба, «умеет
# краснеть и умеет молчать», стоит в работе `storozha` и ходит на каждый пуш,
# так что испорченный сторож обнаружится задолго до метки.

on:
  push:
    # НЕ ГОНЯТЬ НА ТОМ, ЧТО КОДА НЕ КАСАЕТСЯ. Правка задачника или .ai/ не может
    # сломать двоичный, а прогон стоит машинного времени на чужой очереди.
    # `docs/tasks/**` стережёт `tasks:check` в хуке перед пушем — он дешёвый и
    # ходит на КАЖДЫЙ пуш, так что пропуска проверки здесь нет.
    paths-ignore:
      - "docs/tasks/**"
      - ".ai/**"
  pull_request:
  workflow_dispatch:

# ТО ЖЕ ЛЕКАРСТВО, ЧТО В `ci.yml`, И ЗДЕСЬ ОНО НУЖНЕЕ: этот файл ходит на каждый
# пуш уже сегодня, а группы отмены у него нет. «Четыре одновременно висящих
# прогона на одну ветку», из-за которых 14 августа (`11b311ae`) сняли с пуша
# `ci.yml`, происходят здесь ровно так же — просто на них никто не пожаловался.
# На метке не отменяем: метка — решение о версии, её прогон единственный.
# ФЛАГИ СБОРКИ — ОДНИМ МЕСТОМ, И `-flto=auto` ВМЕСТО ГОЛОГО `-flto`.
#
# Голый `-flto` заставляет lto-wrapper гнать 119 задач LTRANS ПОСЛЕДОВАТЕЛЬНО
# («lto-wrapper: warning: using serial compilation of 119 LTRANS jobs» печатала
# каждая сборка дерева). `-flto=auto` раздаёт их по ядрам.
#
# ЗАМЕРЕНО, одно дерево, одни и те же четыре ядра (`taskset -c 0-3`), полная
# пересборка с нуля, машина под чужой нагрузкой:
#
#   -O2 -flto        387,2 с   и 322,3 с   (два независимых замера)
#   -O2 -flto=auto   165,3 с   и 173,5 с
#
# То есть вдвое, и это не догадка: sha256 двоичных после обеих сборок
# СОВПАЛ ЗНАК В ЗНАК (238cd3b2a04e340cc4be36a2…). Значит правка чисто про
# скорость: машинный код тот же, воспроизводимость семени и гейт Г6 не
# задеты. Поведение сверено отдельно — `check` и `--version` дают то же.
#
# ПОЧЕМУ ЗДЕСЬ, А НЕ В `bootstrap/Makefile`. Makefile СГЕНЕРИРОВАН
# (`flang/self/emit-c.flang`, строка со строкой `CFLAGS ?=`), и правка в нём
# потерялась бы первой же перепечаткой. Долговечное место — одно слово в
# печатнике; здесь стоит то же значение, пока печатник не поправят.
# `CFLAGS ?=` — присваивание с умолчанием, так что передача своего законна:
# так уже делают `build-macos.yml` (флаги Homebrew, без LTO) и `pages.yml`
# (`-O0`).
env:
  FLANG_CFLAGS: "-std=c99 -Wall -Wextra -Werror -pedantic -O2 -flto=auto"

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: ${{ !startsWith(github.ref, 'refs/tags/') }}

permissions:
  contents: read

jobs:
  # ── Дешёвая половина: ходит на каждый пуш ──────────────────────────────────
  sborka:
    name: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache

      # ── СКОЛЬКО ПАМЯТИ ОСТАВАЛОСЬ, НАЗЫВАЕТСЯ ЧИСЛОМ НА КАЖДОМ ПРОГОНЕ ────
      #
      # Эта работа была красной сто прогонов подряд, и красной её делала
      # ПАМЯТЬ: `flang check flang/self/parser.flang` берёт 37,11 ГиБ (замер
      # 30 августа 2026), у раннера 15,61 ГиБ. В журнале это выглядело не
      # отказом, а обрывом — «exit code 143» либо «The runner has received a
      # shutdown signal», без кода возврата и без имени файла, — и диагнозы
      # расходились: обрыв читали то предельным временем, то бедой в семени.
      #
      # Наблюдатель отвязан от шага и живёт до конца работы; последним шагом
      # (`if: always()`) итог ложится в СВОДКУ прогона. Он называет четыре
      # разных исхода, и главный из них второй: «упало ПО СУЩЕСТВУ, а не по
      # памяти» снимает подозрение с памяти там, где дело не в ней.
      #
      # Он ничего не ограничивает и никого не снимает — только смотрит и
      # называет. Доводы, чего он НЕ ловит, — в шапке самого сторожа.
      - name: Watch memory
        run: nohup free -k -s 5 > "$FLANG_TMP/memory-headroom.log" 2>&1 &
        env:
          FLANG_TMP: ${{ runner.temp }}
          LC_ALL: C

      # ── ИЗ ЧЕГО СОБИРАЕМ — СПРАШИВАЕТСЯ ДО СБОРКИ ────────────────────────
      #
      # Работа `semya` ниже сверяет ВХОДЫ печати и ходит своим чередом. Здесь
      # спрашивается другое и раньше: то ли лежит в `bootstrap/**`, из чего
      # сейчас соберётся двоичный, которым эта же работа потом судит дерево.
      # До 31 августа 2026 этого не спрашивал никто: отпечаток покрывал вход
      # печати и молчал про её выход, и 103 байта C в `bootstrap/flang_repl.c`
      # проводили подделку через ядро как доказанную, оставляя всё зелёным
      # (/srv/tmp/dokazuemyy/Ч5-pechat/NAHODKA-podmena.md).
      #
      # Цена — 0,17 с против почти двух минут сборки. Ни двоичного, ни git,
      # ни временного каталога проверке не нужно.
      #
      # ⚠ КРАСНА СЕГОДНЯ, И ЭТО НЕ ЛЕЧИТСЯ ПЕРЕСЪЁМКОЙ ОТПЕЧАТКА — ячейка
      # Ч370 (СI не должен жечь часы на пуш, 3 сентября 2026) сперва
      # ошиблась ровно этим ходом и откатила себя же. Отказ говорит «В
      # ОТПЕЧАТКЕ НЕТ ТЕЛА СЕМЕНИ… снять заново: --otpechatok» — и это
      # ЧЕСТНЫЙ СОВЕТ ПРО НЕЧЕСТНЫЙ ПРИБОР: `--otpechatok` штампует
      # ОТПЕЧАТОК С ТЕКУЩЕГО ДЕРЕВА, включая тело, которое сам же потом и
      # сверяет, — снимок совпадает с собой тавтологически, а не
      # доказывает, что bootstrap/ напечатан из нынешних flang/self/*.
      # Разобрано и измерено ДО этого наряда:
      # docs/zettel/re-taking-a-fingerprint-turns-red-green-without-reprinting.md
      # и docs/tasks/9611 (открыта, никем не взята) — там же цена честного
      # ответа: перепечатка идёт 7–15 часов (замер по цене шага, не по
      # потолку). Это на четыре порядка дороже часового бюджета CI-ячейки
      # и не тот род работы, который эта задача решает.
      # `continue-on-error` — тем же доводом, что у `links` в ci.yml:
      # шаг остаётся в ленте красным по СУЩЕСТВУ (не спрятан), но не
      # останавливает соседние 16 шагов этой же работы, которым отпечаток
      # не нужен и предмет которых честен. Убрать continue-on-error может
      # тот, кто закроет 9611 (чинит советы прибора и/или делает
      # перепечатку) — не тот, кто просто перезапустит --otpechatok.
      - name: Check bootstrap body
        continue-on-error: true
        run: sh scripts/bootstrap-reprint.sh --telo

      # ── ДВОИЧНЫЙ БЕРЁТСЯ ГОТОВЫМ, ЕСЛИ ВХОДЫ СБОРКИ ТЕ ЖЕ (задача 6890) ─────
      #
      # Единственная работа этого файла, что собирала БЕЗУСЛОВНО. Пять соседних
      # (`self-examples`, `povtorimost`, `imena`, `storozha`, `korpus`) уже
      # берут двоичный из кеша по ключу «хеш входов сборки + флаги», и на пуше,
      # не тронувшем `bootstrap/**`, не собирают вовсе. Тот же ключ здесь:
      # разойдись байт входа или флаг — ключ другой, работа собирает честно.
      #
      # ЗАЧЕМ КЕШ, А НЕ «БЕЗ LTO НА ПУШЕ». Голый -O2 на этом дереве не дешевле,
      # а ДОРОЖЕ по обеим осям: `bootstrap/compiler_flang.c` — 607 354 строки,
      # один процесс `cc -O2` жмёт его 262-264 с при пике 2,2 ГиБ, тогда как
      # `-flto=auto` откладывает работу и раздаёт LTRANS по ядрам — 120-123 с,
      # пик 1,6 ГиБ (замер 6 сентября 2026, `taskset -c 0-3`, чистая пересборка,
      # два прогона каждого). LTO тут и быстрее, и легче по памяти; экономия на
      # пуше не в смене флагов, а в том, что на неизменном `bootstrap/**` сборки
      # нет вовсе.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      # Время сборки называется числом в логе, а не «быстро». Подорожает —
      # будет видно в логе, а не выяснится жалобой.
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: |
          set -eu
          echo "ядер: $(nproc)"
          # Имя переменной латиницей не по вкусу: `sh` и `bash` принимают в имени
          # только ASCII, и `начало=$(date +%s)` — это не присваивание, а попытка
          # запустить команду с таким именем. Поймано прогоном работы из чистого
          # клона; тот же довод записан в шапке `flang/test/обход.sh`.
          started=$(date +%s)
          make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          echo "сборка двоичного: $(( $(date +%s) - started )) с"
      # Кеш мог отдать негодное: файл есть, а не запускается. Проверяем и
      # собираем честно, если так. Молчаливого «ну и ладно» здесь нет.
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi

      # Двоичный только что собран из этого же bootstrap/, и сверка обязана
      # пройти. Стоит она здесь не ради ответа — ответ известен, — а ради самой
      # сверки: сторож, который нигде не запускается, тихо ломается и годами
      # зеленеет. Второй шаг подкладывает ему программу с заведомо чужим именем
      # и требует отказа; без него первый шаг ничего не доказывает.
      - name: Check binary origin
        run: bootstrap/flang io scripts/seed/binary-origin.fscript --plan Check --timeout 300000 -- --what "работа «Binary»"

      - name: Probe binary origin
        run: bootstrap/flang io scripts/seed/binary-origin.fscript --plan Forgery --timeout 300000

      # Собралось — ещё не значит работает. Проверяется то, что человек наберёт
      # первым, и настоящий файл дерева, а не выдуманный.
      #
      # ── ПОЧЕМУ ЗДЕСЬ core/parser.flang, А НЕ self/parser.flang ────────────
      #
      # До 30 августа 2026 здесь стоял `flang/self/parser.flang`, и работа была
      # красной подряд — сто прогонов кряду, с 26 августа и раньше. Ни один шаг
      # НИЖЕ этого за всё время не выполнился ни разу: раннер умирал тут.
      #
      # Отказ выглядел не отказом, а обрывом: печаталось `flang 0.6.2`, дальше
      # три минуты тишины и «The runner has received a shutdown signal». Это не
      # беда в файле и не предел времени работы — это кончившаяся память
      # раннера. Искать её по коду возврата бесполезно, кода нет вовсе.
      #
      # Замер 30 августа 2026 на этом дереве, `/usr/bin/time -f '%M'` вокруг
      # настоящего прогона, нынешним семенем (0.6.2):
      #
      #   flang check flang/self/parser.flang   486 с   37,1 ГиБ пика   код 0
      #   flang check flang/core/parser.flang    10 с    1,06 ГиБ пика  код 0
      #
      # У раннера GitHub 16 ГБ — то же число и тот же довод, что в шапке
      # `reprint.yml`: не «медленно», а НЕ ВЛЕЗАЕТ, вдвое с лишним больше всей
      # памяти машины. Файл при этом ИСПРАВЕН: код 0, замечаний нет. Красной
      # работу делал выбор файла, а не файл.
      #
      # И запас тут не съедет молча: тот же `self/parser.flang` 23 августа брал
      # 17,3 ГиБ (коммит f2d3c8ac), сегодня — 37,1. За неделю вдвое, потому что
      # обещания в нём прибавляются. Ставить на такой файл дешёвый гейт нельзя.
      #
      # `flang/core/parser.flang` — тоже настоящий файл дерева и тоже разборщик,
      # то есть требование шага соблюдено дословно, а запас к пределу раннера
      # пятнадцатикратный.
      #
      # Тяжёлую самопроверку сюда не вернуть ничем, кроме раннера с большой
      # памятью. Её место — там же, где побайтовая сверка семени: за переменной
      # репозитория `BOLSHAYA_PAMYAT` в `reprint.yml`.
      - name: Check binary CLI
        run: |
          set -eu
          ./bootstrap/flang --version
          ./bootstrap/flang --help | grep -q "flang check"
          ./bootstrap/flang check flang/core/parser.flang

      # Проверки, НАПИСАННЫЕ НА FLANG: программа судит сама, `sh` только возит.
      # Сверяется СПИСОК ИМЁН целиком, а не счётчик отказов, — файл, упавший
      # разом, отдаёт ноль проверок и ноль отказов, то есть выглядит чистым.
      # Проверено снятием правки: убранная строка ведомости даёт код 1 и
      # печатает, какая именно пропала.
      - name: Run flang tests
        run: sh flang/test/обход.sh

      # Примеры двух каталогов, которые СХОДЯТСЯ ЦЕЛИКОМ и потому годятся в
      # дешёвый гейт по голому коду возврата, без ведомости:
      #
      #   flang/stdlib   53 файлов, 3807 примеров, прошли все  44 мин
      #   СНЯТО 2026-10-04 файлов flang/stdlib/*.flang = 53
      #   СНЯТО 2026-10-04 примеров-в flang/stdlib/*.flang = 3807
      #   flang/core      4 файла,  184 примера,  прошли все     15 с
      #   СНЯТО 2026-09-05 файлов flang/core/*.flang = 4
      #   СНЯТО 2026-09-05 примеров-в flang/core/*.flang = 184
      #
      # У ВРЕМЕНИ ПРИМЕТЫ НЕТ, И ЭТО НЕ УПУЩЕНИЕ. Ни один из пяти приборов
      # сторожа чисел время не считает: оно зависит от машины и нагрузки, а
      # примета обязана переснимать число тем же прибором на любом дереве.
      # Числа «44 мин» и «15 с» сняты 5 сентября 2026 разбором прогона
      # 33895656055 и обходом по файлам (задача 3841) — они ЗАМЕР, а не примета,
      # и протухнут молча. Сторожат здесь ЧИСЛО ПРИМЕРОВ: вырастет оно —
      # покраснеет сторож, и время пойдут мерить заново.
      #
      # Полный обход дерева сюда не ставится (он в работе `korpus` ниже). Раньше
      # ОБА каталога шли на каждом пуше, и `stdlib` брал 44 минуты — из-за него
      # линт пуша не влезал в пять минут (задача 6890). Теперь надвое: ядро (184
      # примера, 15 с) остаётся на пуше, язык на пуше не голый; `stdlib` (2713
      # примеров, 44 минуты — разряд «десятками минут») уходит на тег и ручной
      # запуск, туда же, где полный обход корпуса.
      #
      # `examples` здесь НЕТ намеренно: там лежит файл, который двоичный
      # законно отвергает (`monad/order-total.flang`, четыре FLANG_TYPE_PARAM),
      # и код возврата у каталога ненулевой. Такому месту нужна ведомость,
      # которая держит ТОЧНОЕ число, а не порог «ноль отказов», — и она есть,
      # в работе `korpus`.
      #
      # ЗДЕСЬ ПРЕДЕЛ ШАГОВ НЕ ПЕРЕДАЁТСЯ, И ОН ВСЁ РАВНО ЕСТЬ: у команды «test»
      # своё зашитое умолчание — 40 000 000 шагов и 20 000 глубины
      # (`const char *steps = "40000000"` в flang/src/emit/c/flang_repl.c). Оно
      # не то же самое, что умолчание у «io» (10 млн), и в глаза не бросается
      # ни здесь, ни в справке. Кто будет ловить отказ «исчерпала лимит шагов»
      # на этом шаге — искать число надо там, а не в этой строке.
      #
      # Перепечатка семени его не касается: `steps` уходит в `args[3]`, то есть
      # в предел вычисляемой программы, а не в счётчик рантайма, куда кладёт
      # `fl_charge`. Та же валюта, что у «--max-steps» у «io», — см. ниже.
      - name: Run kernel examples
        run: ./bootstrap/flang test flang/core/

      # ⚠ УШЛО НА ТЕГ (задача 6890): поломка примера в `flang/stdlib/**`
      # (42 файла, 2713 примеров) на пуше БОЛЬШЕ НЕ КРАСНЕЕТ — замечается на
      # теге и ручном запуске. Это решение, а не молчаливая дыра: 44 минуты на
      # каждый пуш и есть та утечка, ради которой задача заведена. На пуше язык
      # держат обходчик (180 проверок), ядро (184 примера) и сторожа выше.
      - name: Run stdlib examples
        if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'
        run: ./bootstrap/flang test flang/stdlib/

      # ── ОПИСЬ ДЕРЕВА ПО ЯЗЫКАМ: долгу разрешено убывать и запрещено расти ──
      #
      # Счётчиков долга в дереве было три — раздел «Вне языка» в docs/ROADMAP.md,
      # docs/javascript-inventory.md и числа сайта, — и все три считали ОДИН
      # язык: JavaScript. Оболочка (47 файлов, 8930 строк), HTML, CSS, пробы на
      # СНЯТО 2026-10-04 файлов *.sh = 47 (перенос scripts/guards/proved-share-vs-tree.sh и guards-without-forgery-probe.sh на планы снял два файла оболочки; до них 49, снято 2026-10-04) (перенос flang/translation/run.sh на план flang/translation/run.fscript снял один файл оболочки; до него 50, снято 2026-10-04) (задачи 0049 и 5821: сняты flang/scripts/word-occupancy.mjs, scripts/seed/seed-freshness.sh и scripts/guards/version-derivations-guard.sh — у каждого двойник на flang доказан прогоном; до них 52, снято 2026-10-04) (задача 5821: семь скриптов scripts/** переехали с оболочки на flang; до них 101, снято 2026-09-17)
      # СНЯТО 2026-10-04 строк-в *.sh = 8930 (перенос scripts/guards/proved-share-vs-tree.sh и guards-without-forgery-probe.sh на планы снял 414 строк оболочки; до них 9344, снято 2026-10-04) (перенос flang/translation/run.sh на план flang/translation/run.fscript снял 214 строк оболочки; до него 9558, снято 2026-10-04) (задачи 0049 и 5821: сняты flang/scripts/word-occupancy.mjs, scripts/seed/seed-freshness.sh и scripts/guards/version-derivations-guard.sh — у каждого двойник на flang доказан прогоном; до них 9756, снято 2026-10-04) (задачи 1426 и 8567: поиск коммита отпечатка по содержимому прибавил 135 строк в scripts/bootstrap-reprint.sh, а отменённая хронология предела шагов убрала 141; до них 9762, снято 2026-09-17) (задача 1400: девять проб на подлог и две честные под правила Н6 и О9 прибавили 42 строки в flang/proof/checker/tests/run.sh) (задача 1416: четырнадцать объявлений ярлыков заведены в скриптах и зов «Сбора» — в хуке; до них 23372, снято 2026-09-17) (задача 5821: семь скриптов scripts/** переехали с оболочки на flang; до них 23980, снято 2026-09-22) (ADR-0046: довод в шапках двух сторожей имён — сперва почему flang/proof не судится, потом почему вошёл в область — прибавил 9 строк; до него 23971, снято 2026-09-17)
      # C, Python, awk и Erlang не считались нигде и ни в одной проверке. Долг,
      # которого никто не считает, не убывает: его не видно ни в отчёте, ни в
      # ленте, и растёт он молча.
      #
      # Здесь он виден. Проверка НЕ сверяет число строк — оно меняется каждой
      # правкой, и такая сверка краснела бы на всём подряд, а жали бы её не
      # глядя. Сверяется ЧИСЛО ФАЙЛОВ ДОЛГА, и только сверху: новый файл на
      # оболочке или на Python останавливает работу в тот же день.
      #
      # Замер на этом дереве: 17,7 с и 471 МБ, двоичному хватает `git` и `wc`.
      # Предел шагов поднят с умолчания (10 млн): опись обходит 199 файлов и
      # семнадцать языков, и в умолчание не укладывается.
      # СНЯТО 2026-10-04 файлов *.sh,*.c,*.h,*.py,*.html,*.css,*.awk,*.erl,*.js,*.mjs,*.java,*.cs,*.ex,*.go,*.rs,*.lua,*.vim,*.rb,*.cpp,*.cc,*.hpp,*.hh,ярлык,packaging/asdf/bin/download,packaging/asdf/bin/install,packaging/asdf/bin/list-all,.githooks/pre-push,.githooks/commit-msg,.githooks/pre-commit = 199 (мера починена: правило «Язык пути» описи знает только *.ex, а водители пробы на .exs и .ts языком не считает, зато считает .githooks/commit-msg и .githooks/pre-commit — их в мере не было; по прежней мере вышло бы 198, снято 2026-10-04) (задача 1413: семь водителей пробы flang/proof/probes/exact-integer-in-targets/drivers/* на C, C++, Java, C#, Go, Rust и JS — судья, который считает десятичную запись точного целого на самой цели; до них 190, снято 2026-10-04) (перенос scripts/guards/proved-share-vs-tree.sh и guards-without-forgery-probe.sh на планы снял два файла вне flang; до них 192, снято 2026-10-04) (перенос flang/translation/run.sh на план flang/translation/run.fscript снял один файл вне flang; до него 193, снято 2026-10-04) (задачи 0049 и 5821: сняты flang/scripts/word-occupancy.mjs, scripts/seed/seed-freshness.sh и scripts/guards/version-derivations-guard.sh — у каждого двойник на flang доказан прогоном; до них 196, снято 2026-10-04) (две честные пары сличителя перевода: отбор по признаку и объявленная мера; до них 194, снято 2026-09-17) (задача 5821: семь проверок scripts/** стали планами; до них 251, снято 2026-09-27) (задача 5821: семь скриптов scripts/** переехали с оболочки на flang; до них 256, снято 2026-09-17)
      #
      # СКОЛЬКО ИЗ ЭТИХ ПЯТИДЕСЯТИ МИЛЛИОНОВ УХОДИТ, замер 29 августа 2026.
      # Меряно перебором самого предела: при 10 500 000 опись умирает
      # («исчерпала лимит шагов»), при 11 000 000 доходит до вывода. Порог,
      # снятый двоичным поиском до единицы, — 10 989 990. Запас к нынешним
      # 50 млн четырёхкратный с лишним (расход 22 %), поднимать здесь нечего.
      #
      # А вот УМОЛЧАНИЮ этих десяти миллионов уже не хватает: 10 989 990 больше
      # десяти миллионов на одну десятую. Ключ выше не роскошь — без него шаг
      # красный. Это беда самого умолчания, а не перепечатки.
      #
      # ПЕРЕПЕЧАТКА СЕМЕНИ ЭТОГО ПРЕДЕЛА НЕ КАСАЕТСЯ, и это проверено, а не
      # прикинуто. Ключ «--max-steps» у команды «io» кладётся ровно в одно
      # место — `ready_args[1] = fl_number(max_steps)` в
      # flang/src/emit/c/flang_repl.c, — то есть в предел ВЫЧИСЛЯЕМОЙ ПРОГРАММЫ
      # («Машина» из interpret.flang). Счётчика рантайма `ctx->steps`, в который
      # кладёт `fl_charge`, он не трогает вовсе. Проверено двумя двоичными на
      # одном входе: семя (заряд не считает) и прибор со счётом заряда ведут
      # себя одинаково на каждом пределе — 100 000, 150 000, 180 000, 200 000
      # на scripts/guards/module-name-guard.fscript.
      #
      # Второй счётчик — потолок самого двоичного (`#define FL_MAX_STEPS`) —
      # под заряд ПОПАДАЕТ, и его запас здесь тоже снят ведомостью: шагов всего
      # 401 973 650, витков 47 580 720. Нынешнее семя считает витки и упирается
      # в свой миллиард на 4,8 %; следующее будет считать шаги, но и потолок у
      # него 300 млрд (MAX_STEPS в scripts/bootstrap-reprint.sh) — это 0,13 %.
      #
      # ⚠ НАЙДЕНО 3 сентября 2026 (ячейка Ч370, «CI не должен жечь часы на
      # пуш»): ШАГ СЕГОДНЯ КРАСНЫЙ, И ЭТО НЕ НОВАЯ ПОЛОМКА — потолок долга вне
      # JavaScript записан в самом сторожа (scripts/guards/tree-inventory.fscript,
      # функция «Потолок долга») числом 63, а живых файлов долга сейчас 90:
      # ДОЛГ ВЫРОС: файлов 90 при потолке 63 (разбор — 27 файлов сверх
      # потолка, поимённо в выводе шага; docs/benchmarks/, docs/tools/,
      # docs/editors/vim/checks/, flang/concurrency/bench/, flang/proof/, scripts/, docs/examples/web/).
      #
      # ПОЧЕМУ ЭТО НЕ УВИДЕЛИ РАНЬШЕ, СКАЗАНО ПРЯМО: этот шаг — двенадцатый из
      # двадцати одного в работе «sborka», и он идёт, только если ОБА шага до
      # него зелены. На dev шаг №5 («Тело точки раскрутки отвечает
      # отпечатку») был красным как минимум с той перепечатки, что оставила
      # отпечаток без тела (правка той же ячейки Ч370 в этом же наряде), и
      # своим кодом обрывал работу ДО этого шага. Сторож, до которого никто не
      # доходит, от отсутствующего неотличим — тот же довод, каким это дерево
      # уже объясняло себе молчание других сторожей (см. шапку `imena` ниже).
      # Сколько именно дней или недель этот шаг был красным под чужой
      # краснотой — неизвестно и не выяснялось здесь: лента прогонов GitHub
      # хранит недавнюю историю не бесконечно, а работа в разные дни падала на
      # разных более ранних шагах, так что искать первый настоящий прогон
      # именно этого шага — отдельное архивное разбирательство, не этот наряд.
      #
      # ПОЧЕМУ НЕ ПОДВИНУТ ПОТОЛОК ЗДЕСЬ ЖЕ. Это была бы ровно та порода
      # правки, которую этот же файл в другом месте называет по имени: «Границу
      # задним числом не двигаем» (см. `pravila-spisok` в ci.yml). Поднять 63
      # до 90, увидев число, — значит объявить долгом изученным то, что не
      # изучено: 27 файлов вне потолка — это неразобранная смесь (часть,
      # возможно, законный инструментарий вроде замеров производительности,
      # часть — забытый долг), и решить какая часть какая — работа над
      # СОДЕРЖАНИЕМ дерева, а не над CI. Ячейка Ч370 чинит workflow-файлы, а не
      # разбирает 27 файлов чужого хозяйства.
      #
      # ПОЭТОМУ — ВИДНО, А НЕ ГЕЙТ, ДО ОТДЕЛЬНОГО НАРЯДА. `continue-on-error`
      # тем же доводом, что у работы `links` в ci.yml: шаг остаётся в ленте,
      # печатает правду (список 27 файлов — в его собственном выводе) и не
      # красит работу. Убрать `continue-on-error` может тот, кто разберёт
      # список: часть файлов перенести под flang, часть — в потолок с
      # объяснением, часть, может быть, удалить как мёртвый груз.
      - name: Check tree inventory
        continue-on-error: true
        run: ./bootstrap/flang io scripts/guards/tree-inventory.fscript --на-веру --plan 'Опись дерева по языкам' --max-steps 50000000
      # Столбцы долга в docs/tree-inventory.md не стерёг никто: сторож чисел
      # прозы считает по образцу пути, а долг определяет правило из
      # четырнадцати ветвей (задача 2599). Сверять таблицу обязана опись —
      # она эти столбцы уже считает. Проверено пробой: подкрученное число
      # долга сторож прозы пропускал кодом 0, эта сверка краснеет (2600).
      - name: Check inventory table
        run: ./bootstrap/flang io scripts/guards/tree-inventory.fscript --на-веру --plan 'Опись сходится с документом' --max-steps 50000000
      # Шаг выше без этого — обещание проверки: сверка могла бы отвечать
      # «сходится» на любой таблице, и сказать об этом было бы некому. План
      # «Подлог» приписывает первому языку лишний файл В ПАМЯТИ (файл дерева не
      # трогается, откатывать нечего) и требует, чтобы сверка это назвала.
      # КОДЫ ПЕРЕВЁРНУТЫ, как у пары про номера решений ниже: код 1 — подлог
      # пойман, сверка жива; код 0 — сверка промолчала, ЛИБО подлог не собрался,
      # ЛИБО таблица разошлась уже без подлога. Все три случая обязаны красить
      # шаг, и все три план называет своим словом.
      # Прогнано на выпотрошенной копии сверки (задача 6612): «Беда поля»,
      # возвращающая пустой список на любом входе, даёт этому шагу код 0.
      - name: Probe inventory table
        run: |
          if ./bootstrap/flang io scripts/guards/tree-inventory.fscript --на-веру --plan 'Подлог' --max-steps 50000000; then
            echo "сверка промолчала на подложенной строке — проверять ею нечего" >&2
            exit 1
          fi

      # ── ОПИСЬ ДОКАЗАННОГО СВЕРЯЕТСЯ С ДЕРЕВОМ НА КАЖДОМ ПУШЕ ────────────────
      #
      # `scripts/guards/proved-share-vs-tree.fscript` сверяет знаменатель
      # `scripts/ledgers/proved-share-ledger.txt` со счётом по исходнику: у
      # каждого .flang с обязательствами есть строка, у каждой строки — файл, и
      # «написано» сходится со счётом. До 15 сентября 2026 его звал только хук
      # перед пушем, CI — никто: запрос слияния с новым файлом доказательств
      # проходил зелёным, а хук краснел у следующего, кто пушил поверх main.
      # 4 октября 2026 сверка перенесена с оболочки на план: двоичный к этому
      # шагу уже собран (шаги выше зовут ./bootstrap/flang), а прежний довод
      # «её зовёт хук до сборки двоичного» устарел с задачи 1219 — хук сам стал
      # планом. Считает по-прежнему git, grep и md5sum, 11 с на машине
      # разработки; FLANG_TMP больше не нужен — времянок план не заводит.
      - name: Check proved share
        run: ./bootstrap/flang run-script proved-share-tree:check
      # Четыре стороны порчи — нулевая (опись как есть, бед быть не должно) и по
      # одной на каждую беду, которую сверка обязана назвать: «написано» первой
      # мерной строки +1, строка о первом файле дерева вынута, вписана строка о
      # файле, которого нет. Порча идёт В ПАМЯТИ: файл описи не трогается, и
      # откатывать нечего даже если прогон убьют на середине.
      # КОДЫ ПЕРЕВЁРНУТЫ, как у пары про опись дерева выше: код 1 — подлог
      # пойман на всех четырёх сторонах; код 0 — сверка промолчала хотя бы на
      # одной, ЛИБО порча не собралась. Оба случая обязаны красить шаг.
      # Прогнано на выпотрошенной копии сверки («Troubles of», возвращающая
      # пустой список на любом входе): она даёт этому шагу код 0.
      # Зовётся ФАЙЛОМ, а не командой `proved-share-tree:forgery`: прибор проб
      # порчи (scripts/guards/guards-without-forgery-probe.fscript) относит
      # пробу к сторожу по файлу, а не по имени парной команды.
      - name: Probe proved share
        run: |
          if ./bootstrap/flang io scripts/guards/proved-share-vs-tree.fscript --plan Forgery; then
            echo "сверка промолчала на порченой описи — проверять ею нечего" >&2
            exit 1
          fi

      - name: Check records follow their sources
        run: ./bootstrap/flang io scripts/guards/record-follows-its-source.fscript --plan Проверка
      - name: Probe records follow their sources on a swapped source
        run: |
          set -eu
          program=flang/proof/examples/corpus-natural.flang
          cp "$program" "$RUNNER_TEMP/program"
          cp flang/proof/checker/tests/programs/lie-collision.flang "$program"
          if cmp -s "$program" "$RUNNER_TEMP/program"; then
            echo "the swap did not change the source" >&2
            exit 1
          fi
          if ./bootstrap/flang io scripts/guards/record-follows-its-source.fscript --plan Проверка > "$RUNNER_TEMP/verdict" 2>&1; then
            cp "$RUNNER_TEMP/program" "$program"
            echo "the guard stayed green on a swapped source" >&2
            exit 1
          fi
          cp "$RUNNER_TEMP/program" "$program"
          if ! grep -F 'natural-00-honest.record' "$RUNNER_TEMP/verdict"; then
            echo "the guard went red for another reason:" >&2
            tail -5 "$RUNNER_TEMP/verdict" >&2
            exit 1
          fi
          cmp "$program" "$RUNNER_TEMP/program"
      - name: Probe records follow their sources from inside
        run: |
          if ./bootstrap/flang io scripts/guards/record-follows-its-source.fscript --plan Подлог > "$RUNNER_TEMP/forgery" 2>&1; then
            cat "$RUNNER_TEMP/forgery" >&2
            exit 1
          fi
          grep -F 'подлог пойман' "$RUNNER_TEMP/forgery"

      - name: Probe short commands
        run: |
          set -u
          cp .flangrc "$RUNNER_TEMP/flangrc.before"
          printf 'script.placeholder:check = sh scripts/no-such-file.sh\n' >> .flangrc
          if bootstrap/flang run-script scripts:check; then
            cp "$RUNNER_TEMP/flangrc.before" .flangrc
            echo "проверка коротких команд промолчала на команде без файла — проверять ею нечего" >&2
            exit 1
          fi
          cp "$RUNNER_TEMP/flangrc.before" .flangrc
      - name: Check short commands
        run: |
          set -eu
          ./bootstrap/flang check scripts/shortcut-collector.fscript
          bootstrap/flang run-script scripts:check

      # Номера решений и умения ядра — две проверки, переписанные с оболочки на
      # flang 29 августа 2026 и сверенные с прежними словом в слово на шести и
      # на пяти входах соответственно. Стоят здесь, а не отдельными работами:
      # двоичный уже собран, и обе вместе отвечают за три секунды.
      - name: Check ADR numbers
        run: ./bootstrap/flang io scripts/guards/adr-numbers-guard.fscript --на-веру --plan 'Номера решений'
      - name: Probe ADR numbers
        run: |
          if ./bootstrap/flang io scripts/guards/adr-numbers-guard.fscript --на-веру --plan 'Подлог'; then
            echo "сторож промолчал на подложенной двойне — проверять им нечего" >&2
            exit 1
          fi

      # Прослеживаемость (задача 1407, ADR-0031): цепочка требование → код →
      # пример → запись доказательства проходится по всему набору, и число
      # разрывов в обе стороны сверяется с scripts/ledgers/traceability-debt.tsv.
      # Четыре шага одного файла, ~90 с каждый на sbx (11 с у двух направлений:
      # дорог не разбор, а сводка по всем 409 постусловиям). Подлог прячет
      # постусловие из flang/proof/map/abilities.flang в памяти, не на диске.
      - name: Check traceability
        run: LC_ALL=C.UTF-8 ./bootstrap/flang io scripts/guards/traceability-guard.fscript --на-веру --plan 'Разрывы' --max-steps 4000000000
      - name: Probe traceability
        run: |
          if LC_ALL=C.UTF-8 ./bootstrap/flang io scripts/guards/traceability-guard.fscript --на-веру --plan 'Подлог' --max-steps 4000000000; then
            echo "сторож промолчал на спрятанном постусловии — проверять им нечего" >&2
            exit 1
          fi
      - name: Trace requirement
        run: LC_ALL=C.UTF-8 FLANG_TRACE='У1 сумма читается в обратном порядке' ./bootstrap/flang io scripts/guards/traceability-guard.fscript --на-веру --plan 'От требования' --max-steps 4000000000
      - name: Trace source line
        run: LC_ALL=C.UTF-8 FLANG_TRACE='flang/proof/map/abilities.flang:11' ./bootstrap/flang io scripts/guards/traceability-guard.fscript --на-веру --plan 'От строки' --max-steps 4000000000

      # ── Шесть сторожей, найденных «не запускается нигде» (Ч77, 31 авг 2026) ──
      #
      # Прогнаны с этим же двоичным (`bootstrap/flang 0.6.2`) на этом же дереве:
      # все шесть дают код 0, вся пачка — 18 секунд. Порознь, а не одним шагом,
      # по тому же доводу, что у пары про номера решений выше: двоичный уже
      # собран, цена шага близка к нулю, а падение обязано называть, КАКОЙ
      # именно сторож покраснел, а не «что-то в пачке». Отдельными работами
      # не заводим: раннер и checkout стоят на порядок дороже самих проверок.
      - name: Check file extensions
        run: ./bootstrap/flang io scripts/guards/file-extensions.fscript --на-веру
      - name: Check dictionary page
        run: ./bootstrap/flang io scripts/guards/dictionary-guard.fscript --на-веру
      - name: Check man page
        run: ./bootstrap/flang io scripts/guards/manpage-guard.fscript --на-веру
      # Порча — переписанное обещание в docs/README.ru.md. Сторож держит фразу
      # дословно и обязан сказать «обещание пропало», а не промолчать. 6612.
      # Подлог ПЕРЕВЁРНУТ против первой редакции пробы: 5 сентября проза стала
      # говорить «из девяти» (целей и правда девять), и порча — вернуть ей «из
      # восьми». Выпуск 0.7.17 (11 сентября) завёл десятую цель, TypeScript, и
      # проза говорит «из десяти»; порча теперь — «из девяти». Проба краснела
      # «ПОДЛОГ НЕ СОБРАЛСЯ» на dev c8103f06d, пока фраза в ней отставала. `sed` без `-i` по той же причине, по какой его убрали из
      # пробы версии: на macOS ключ BSD-шный и работа падала бы.
      - name: Probe emit promises
        run: |
          set -u
          podlog=docs/guide/emit-walkthrough.ru.md
          cp "$podlog" "$podlog.do"
          sed 's/Здесь показаны две цели из десяти/Здесь показаны две цели из девяти/' "$podlog.do" > "$podlog"
          if cmp -s "$podlog.do" "$podlog"; then
            rm -f "$podlog.do"; git checkout -- "$podlog"
            echo "ПОДЛОГ НЕ СОБРАЛСЯ: фразы про две цели из десяти в $podlog уже нет — поправить подлог, сторож ни при чём" >&2
            exit 1
          fi
          rm -f "$podlog.do"
          if ./bootstrap/flang io scripts/guards/emit-promises-guard.fscript; then
            git checkout -- "$podlog"
            echo "сторож промолчал на подлоге — проверять им нечего" >&2
            exit 1
          fi
          git checkout -- "$podlog"
      - name: Check emit promises
        run: ./bootstrap/flang io scripts/guards/emit-promises-guard.fscript
      - name: Check proof wording
        run: LC_ALL=C.UTF-8 ./bootstrap/flang io flang/scripts/word-guard.fscript --на-веру --plan 'Сторож слов' --max-steps 2000000000
      - name: Check kernel abilities
        run: ./bootstrap/flang check --proof flang/proof/map/abilities.flang

      # Последним шагом и ВСЕГДА: без него наблюдатель выше — это запись,
      # которую никто не читает.
      - name: Report memory
        if: always() && hashFiles('bootstrap/flang') != ''
        run: bootstrap/flang io scripts/memory-headroom.fscript --plan Report -- --status "${{ job.status }}"
        env:
          FLANG_TMP: ${{ runner.temp }}
          FLANG_WATCH_STEP: 5

  # ── ПРИМЕРЫ САМОГО КОМПИЛЯТОРА: их не гонял НИКТО ─────────────────────────
  #
  # Шаги «Run kernel examples» и «Run stdlib examples» выше зовут `flang test`
  # на двух
  # каталогах, и `flang/self/` среди них нет. Каталог при этом не пустой: 64
  # файл и 5405 примеров, объявленных внутри функций.
  # СНЯТО 2026-09-17 файлов flang/self/*.flang = 64
  # СНЯТО 2026-10-05 примеров-в flang/self/*.flang = 5405 (ADR-0062, задача 5243: примеры сокращения дроби, НОД и порока канона; до них 5373, снято 2026-10-04) (задача 1908: сорок шесть примеров у вычитания с займом, умножения столбиком, сравнения и заслона канона — 36 в flang/self/interpret.flang и 11 в flang/self/types.flang, один прежний снят; до них 5327, снято 2026-10-04) (задача 1412: четыре примера у правил кольца над точным целым в flang/self/proof-kernel.flang; до них 5323, снято 2026-10-04) (задача 7182: пять примеров у печати зависимостей Makefile; до них 5318) (задача 1908: примеры точного целого
  # в типизаторе и вычислителе; до них 5297, снято 2026-10-03)
  #
  # Единственная работа, которая до них добралась бы, — `korpus` ниже
  # (`flang test . --ledger` внутри `обход-примеров.sh`). Она закрыта условием
  # «тег или рука», и НА ТЕГЕ ОНА ПАДАЕТ: на трёх последних (v0.7.8, v0.7.9,
  # v0.7.10, 4 сентября 2026) работа `corpus-examples` шла 2 ч 26 мин и была
  # снята раннером посреди обхода («The runner has received a shutdown
  # signal», прогон 33883535490). До сверки ведомости она не дошла ни разу, а
  # сама ведомость `flang/test/examples-ledger.txt` писалась 24 августа
  # (`0eec94a7`): три числа в строке вместо нынешних четырёх и 41 файл
  # `flang/self/` из 61.
  #
  # Что это стоило, числом: `flang test flang/self/proofterm.flang` отвечал
  # «примеры не запускались — программа не прошла проверку». Проверяльщик
  # термов ввозил «Печать в C» списком `только`, в котором не было «Это
  # число», а ввезённая им целиком `proof-record.flang` эту функцию зовёт — связыватель
  # отдаёт всему замыканию список, названный КОРНЕМ. Три FLANG_UNKNOWN_NAME,
  # два FLANG_NOT_TOTAL, и 1289 примеров (37 своих) не исполнялись никогда.
  # Правка — два имени в списке ввоза; после неё прошли все 1289.
  #
  # ── ПОЧЕМУ ПОФАЙЛОВО, А НЕ ОДНИМ `flang test flang/self/` ─────────────────
  #
  # Потому что одним процессом каталог не идёт, и это замерено, а не
  # предположено: `flang test flang/self/ --ledger` на 256-ядерной машине за
  # 41 мин 55 с не напечатал НИ ОДНОЙ строки и занял 34,0 ГБ, после чего снят
  # рукой. У раннера 15,61 ГиБ — то есть его убила бы память, и убила бы молча,
  # ровно так же, как убивает `korpus`. Пофайлово пик держится на 6,7 ГиБ
  # (`proofterm.flang`), и это влезает.
  #
  # ── ЧТО ПОД ПРИСМОТРОМ И ЧТО НЕТ ──────────────────────────────────────────
  #
  # Полный пофайловый обход стоит 2 ч 25 мин на шестидесяти файлах из 61 (сумма
  # `/usr/bin/time` по каждому, 5 сентября 2026, эта машина), а шестьдесят
  # первый — `flang/self/bootstrap/compiler.flang` — за 40 минут не кончился и
  # занял 33 ГБ, снят рукой. Столько на пуш не кладут, и
  # ведомость `flang/test/self-ledger.txt` держит поимённо, кто гоняется,
  # а кто нет. Правило отбора: свой пример дешевле трёх секунд прогона — плюс
  # `proofterm.flang`, взятый исключением, потому что именно его примеры и
  # оказались мёртвыми, а увидеть это может только он сам.
  #
  #   под присмотром           43 файла     55 мин
  #   прогонов примеров за раз 12530        (из них 4229 — свои у поднадзорных)
  #   прогоняется своих      4350 из 4453   (98 %)
  #   НЕ ГОНЯЕТСЯ НИГДЕ        14 файлов, 95 своих примеров
  #
  # 12530 прогонов при 4229 своих — это и есть цена пофайлового обхода: примеры
  # ввезённого замыкания считаются заново у каждого, кто его ввозит. Дешевле
  # сделать нельзя, не отказавшись от построчной ведомости.
  #
  # 4350 больше, чем своих примеров у сорока трёх поднадзорных: полный ввоз
  # («использует «М»» без «только») тянет за собой все примеры зависимости, и
  # `proof-kernel.flang`, `proof-initial.flang`, `obligations.flang` едут
  # вместе с `proofterm.flang`. Число 95 обходчик считает сам, по графу ввоза,
  # и печатает вместе с именами на каждом прогоне.
  #
  # Дорого здесь НЕ прогон примеров, а проверка ввезённого замыкания: `flang
  # check` тех же файлов стоит столько же, сколько `flang test` (замер по 61
  # файлу: emit-c 59 с против 50 с, emit-csharp 91 с против 75 с). Поэтому
  # дешёвого «только проверить, не гоняя» здесь нет и быть не может.
  #
  # 55 минут — два независимых прогона самого обходчика на этой машине
  # 5 сентября 2026: 55 мин 05 с ключом `--write` и 55 мин 19 с сверкой,
  # обе кодом 0. Ориентир для раннера у нас один и честный: `flang test
  # flang/core/` идёт здесь 18,2 с против 15 с, названных для раннера выше, —
  # то есть раннер этой работе не медленнее.
  #
  # Отдельной работой, а не шагом в `sborka`: та уже берёт 44 минуты на одних
  # примерах stdlib (задача 6163), и класть ей на плечи ещё пятьдесят пять
  # значило бы удвоить самый длинный путь. Здесь работа идёт рядом и в него не
  # входит. `timeout-minutes: 120` — двойной запас к замеру, а не к догадке.
  self-examples:
    name: self-examples
    # ⚠ УШЛА НА ТЕГ (задача 6890): 55 минут на каждый пуш — тот же разряд
    # «десятками минут», что и полный обход `korpus`. Примеры `flang/self/**`
    # (43 файла под присмотром, 4350 своих примеров) на пуше БОЛЬШЕ НЕ
    # проверяются — только на теге и ручном запуске. Решение, не дыра.
    if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'
    runs-on: ubuntu-latest
    timeout-minutes: 120
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      # Тот же наблюдатель, что в `sborka`, и по той же причине: обход берёт
      # до 6,7 ГиБ, и обрыв по памяти обязан быть назван памятью, а не «exit
      # code 143».
      - name: Watch memory
        run: nohup free -k -s 5 > "$FLANG_TMP/memory-headroom.log" 2>&1 &
        env:
          FLANG_TMP: ${{ runner.temp }}
          LC_ALL: C
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      # ПРОБА ИДЁТ ПЕРВОЙ И СТОИТ 8 СЕКУНД. Сторож, которого нельзя покрасить,
      # неотличим от выключенного, а узнать об этом после пятидесяти минут
      # обхода — узнать поздно. Проба ломает ОДИН пример в КОПИИ
      # `flang/self/mcp.flang` во временном каталоге (дерево не портится ни на
      # секунду: на общей машине соседний прогон записал бы подлог как
      # находку), проверяет `cmp`-ом, что порча легла, и требует от обходчика
      # кода 1 И ИМЕНИ сломанного примера в отказе — красный код без имени
      # чинить нечем. Потом та же копия без порчи, и от неё требуется код 0.
      - name: Probe self examples
        run: sh flang/test/обход-self.sh --подлог
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Run self examples
        run: sh flang/test/обход-self.sh
      - name: Report memory
        if: always() && hashFiles('bootstrap/flang') != ''
        run: bootstrap/flang io scripts/memory-headroom.fscript --plan Report -- --status "${{ job.status }}"
        env:
          FLANG_TMP: ${{ runner.temp }}
          FLANG_WATCH_STEP: 5

  # ── Столкновения имён: отвечает раньше сборки ─────────────────────────────
  #
  # ПОЧЕМУ ОТДЕЛЬНОЙ РАБОТОЙ, А НЕ ШАГОМ В `sborka`.
  #
  # `sborka` заведена без Node намеренно: путь установки, ради которого двоичный
  # существует, обязан обходиться без него, и работа, которой Node не выдали,
  # это доказывает, а не обещает. Сторож столкновений написан на Node — поставь
  # его шагом внутрь, и доказательство исчезнет вместе с первой же зелёной
  # галочкой.
  #
  # Отдельной работе Node от образа хватает: ни `npm ci`, ни двоичного, ни
  # сборки ей не нужно — она читает текст. Считает она замыкание компилятора
  # (29 файлов) за десятые доли секунды и отвечает РАНЬШЕ `sborka`, то есть
  # раньше двух с половиной минут сборки и на порядки раньше семнадцати минут
  # перепечатки, от которой столкновение узнавали до сих пор.
  # ── СЕМЯ ОТСТАЁТ ОТ ИСХОДНИКОВ МОЛЧА ───────────────────────────────────────
  #
  # Заведено 22 августа 2026 после ТРЕТЬЕГО случая за сутки. Правку компилятора
  # вливают, `bootstrap/` не перепечатывают, и правило лежит в исходниках, а в
  # собранной программе не работает. Всё при этом зелёное: исходник разбирается,
  # семя собирается, ни один сторож не звал сверку. Так потерялись оговорка о
  # конечности, принцип индукции по строке и правило конъюнкции.
  #
  # Сверка `sh scripts/bootstrap-reprint.sh --check` существовала всё это время и ловила
  # беду за один прогон. Её не звал никто, и причина уважительная: она ПЕЧАТАЕТ
  # ЗАНОВО — 19 мин 58 с и 25,1 ГиБ пика, замерено 22 августа на 256 ядрах; на
  # раннере дольше. На каждый пуш столько не
  # потратить, и потому механизм был построен и не использовался.
  #
  # Здесь зовётся дешёвая половина: `--bystro` не печатает, а сверяет ВХОДЫ
  # печати — содержимое файлов замыкания компилятора, файлов рантайма,
  # уезжающих в вывод дословно, и пределы печати, попадающие в напечатанный
  # байт. Замерено на этом дереве: 1,4 секунды против часов печати.
  #
  # Она не доказывает побайтового совпадения — это умеет только `--check`.
  #
  # ЧТО ИМЕННО ОНА СПРАШИВАЕТ — И ПОЧЕМУ НЕ ТО, ЧТО РАНЬШЕ. Раньше вопрос был
  # «отвечает ли семя НЫНЕШНИМ исходникам». На живом дереве ответ на него почти
  # всегда «нет», и не по нерадивости: печать идёт часами (заход 30 августа
  # 2026 — 8 ч 34 мин), а входы печати трогают с медианой в 10 минут (замер
  # 31 августа 2026 по приёмной, первый родитель, 27–30 августа, 70 касаний).
  # Значит зелёное окно после самой удачной перепечатки живёт медианные десять
  # минут. Сторож, красный по устройству, перестают читать, и он не убережёт ни
  # от чего.
  #
  # Теперь вопрос такой: отвечает ли отпечаток тому коммиту, из которого семя
  # объявлено напечатанным, и предок ли тот коммит HEAD. Отставание при этом не
  # прячется — оно печатается ЧИСЛОМ на каждом прогоне.
  #
  # Ни двоичного, ни Node, ни `npm ci` работе не нужно: sh, find, awk, sha256sum.
  semya:
    name: seed-fingerprint
    runs-on: ubuntu-latest
    timeout-minutes: 5
    steps:
      # ПОЧЕМУ ВСЯ ИСТОРИЯ, А НЕ ОДИН КОММИТ.
      #
      # Проверка спрашивает две вещи: сходится ли отпечаток с деревом того
      # коммита, из которого семя объявлено напечатанным, и предок ли тот
      # коммит нынешнего HEAD. Оба вопроса задаются git-у по истории, а
      # умолчание `actions/checkout` — один коммит. На обрезанном клоне
      # проверка отвечает кодом 5 «ПРОВЕРИТЬ НЕ УДАЛОСЬ», и это честно, но
      # бесполезно: спрашивать надо там, где ответ есть.
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
        with:
          fetch-depth: 0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      # ПОЧЕМУ ВРЕМЕННЫЙ КАТАЛОГ НАЗЫВАЕТСЯ ЗДЕСЬ, А НЕ БЕРЁТСЯ ПО УМОЛЧАНИЮ.
      #
      # Сверка заводит временный каталог, и умолчание у неё — /srv/tmp: на
      # нашей машине волатильные каталоги запрещены хуком, а печать переживает
      # перезагрузку, так что там это умолчание единственно верное.
      #
      # На раннере GitHub каталога /srv/tmp нет. С 12:20 30 августа 2026 работа
      # падала на первом же шаге, ДО всякого сравнения:
      #
      #   mktemp: failed to create directory via template
      #   ‘/srv/tmp/otpechatok.XXXXXX’: No such file or directory
      #
      # Красное при этом не значило «семя отстало» — работа до этого вопроса
      # не доходила. Проверка, красная не по своему предмету, не проверяет
      # ничего и вдобавок приучает не смотреть.
      #
      # Каталог берётся из FLANG_TMP — тем же способом, каким его называют все
      # остальные работы дерева (ci.yml, reprint.yml). Умолчание самого скрипта
      # не трогается: у нас FLANG_TMP не задан, и каталог по-прежнему в
      # /srv/tmp.
      # ⚠ КРАСНА СЕГОДНЯ, У ЭТОЙ РАБОТЫ ЭТО ЕДИНСТВЕННЫЙ ШАГ ПО СУЩЕСТВУ, И
      # ПЕРЕСЪЁМКОЙ ОТПЕЧАТКА ЭТО НЕ ЧИНИТСЯ. Тот же случай, что у
      # «Check bootstrap body» в работе `build` — один
      # разбор на оба места:
      # docs/zettel/re-taking-a-fingerprint-turns-red-green-without-reprinting.md,
      # docs/tasks/9611 (открыта). Коротко: `--otpechatok` штампует отпечаток С
      # ТЕКУЩЕГО ДЕРЕВА и потому всегда сходится сам с собой — зелёное после
      # него не значит «семя воспроизводимо» (гейт Г6), значит только
      # «снимок равен снимку». Честный ответ — перепечатка, а она стоит
      # 7–15 часов (замер по цене шага в docs/tasks/9611), не про эту ячейку и
      # не про CI-квоту одного пуша. `continue-on-error` тем же доводом,
      # что у `links` в ci.yml: красно по существу, видно в ленте, не
      # держит остальной прогон. Снять может только тот, кто закроет 9611.
      - name: Check seed inputs
        continue-on-error: true
        run: sh scripts/bootstrap-reprint.sh --bystro
        env:
          FLANG_TMP: ${{ runner.temp }}

  # ── ГЕЙТ Г6: ДЕШЁВАЯ ЕГО ПОЛОВИНА, И ЧЕСТНО НАЗВАННАЯ ПОЛОВИНОЙ ───────────
  #
  # Г6 просит дословно: «Две перепечатки из одного дерева дают побайтово
  # одинаковый двоичный, И ЭТО ПРОВЕРЯЕТСЯ АВТОМАТИЧЕСКИ, А НЕ РАЗОВО РУКАМИ».
  #
  # ПЕРВАЯ ПОЛОВИНА ДОКАЗАНА 6 сентября 2026: пара печатей с дерева `d3b121b5`
  # (клоны одного коммита), 16 404 с и 16 929 с, обе кодом 0;
  # `scripts/seed/two-prints-identical.fscript` — код 0, «печати совпали побайтово:
  # файлов 4, байт 1 229 825». ВТОРАЯ осталась открытой: сверку позвала рука.
  #
  # ТОЙ ЖЕ ПАРОЙ ВТОРУЮ ПОЛОВИНУ НЕ ЗАКРЫТЬ. 2 x 4,6 ч машины на пуш не ставят.
  # Работа, которая это делает, в дереве есть — `dve-pechati` в
  # `.github/workflows/reprint.yml`, — и она стоит на раннере `[self-hosted,
  # bolshaya-pamyat]`, которого нет: каждую неделю она пропускается. Раннер —
  # решение о железе, не о коде.
  #
  # ЧТО ЗОВЁТСЯ ЗДЕСЬ ВМЕСТО НЕЁ. Печать ОДНОГО модуля дважды, одним двоичным,
  # в нарочно разных средах (разные выходной и временный каталоги — и по имени,
  # и по длине, — разный часовой пояс, разный размер окружения, разные номера
  # процессов), и сверка байт в байт.
  #
  # ЦЕНА, ЗАМЕР 6 сентября 2026 на машине отряда, `bootstrap/flang` 0.7.11:
  #   bootstrap/flang io scripts/seed/print-is-repeatable.fscript --plan Check --timeout 600000            24,4 с   (две печати по 12,2 с)
  #   bootstrap/flang io scripts/seed/print-is-repeatable.fscript --plan Forgery --timeout 600000   12,3 с   (одна печать)
  # Для сравнения, тем же прогоном и тем же двоичным:
  #   sh scripts/bootstrap-reprint.sh --telo             0,15 с
  #   sh scripts/bootstrap-reprint.sh --bystro           1,50 с
  #   sh scripts/bootstrap-reprint.sh --check           ~4,6 ч
  #   пара печатей (dve-pechati)                ~9,2 ч
  #
  # ЧТО ЭТА РАБОТА ДОКАЗЫВАЕТ: печать этого двоичного — чистая функция от
  # входов, в напечатанные байты не течёт ни время, ни адреса, ни номер
  # процесса, ни пути, ни часовой пояс. Это ровно та порода, которую сводка
  # `dve-pechati` называет своими словами: «время, адреса, порядок обхода».
  #
  # ЧЕГО НЕ ДОКАЗЫВАЕТ, и это не придирка, а размер: печатается ОДИН МОДУЛЬ
  # (`flang/self/lexer.flang` — 12,2 с, 399 МиБ, 7 файлов, 1 676 420 байт), а
  # не замыкание компилятора (4,6 ч, 35 ГиБ, 39,5 МБ). Порода, просыпающаяся
  # только на масштабе — арена под 35 ГиБ, порядок суда ядра по всему
  # замыканию, — здесь не затронута ВООБЩЕ. **Г6 этой работой НЕ БЕРЁТСЯ
  # ЦЕЛИКОМ:** она держит НЕОБХОДИМОЕ условие на каждом пуше, а остаток —
  # полная пара печатей одного дерева — остаётся за `dve-pechati` и остаётся
  # не взятым.
  #
  # ПОЧЕМУ НЕ `sh scripts/bootstrap-reprint.sh --telo`, который стоит 0,15 с и уже
  # зовётся двумя работами выше. Он сверяет `bootstrap/**` с отпечатком,
  # снятым ТОЙ ЖЕ печатью, которая это `bootstrap/**` и положила: снимок
  # сходится со снимком. ПОКАЗАНО ПРОГОНОМ 6 сентября 2026, а не выведено из
  # общих соображений: в `bootstrap/flang_repl.c` вписаны 64 байта, от которых
  # `emit_write` стала дописывать в каждый выходной файл номер своего процесса
  # — ровно то, что делает сбитая печать; двоичный пересобран (116,1 с). После
  # этого ОДНА строка отпечатка переписана под новое тело — и `--telo` дал
  # КОД 0 на невоспроизводимой печати, а эта работа дала КОД 1 и назвала все
  # 7 разошедшихся файлов с байтом первого расхождения. Порча откачена,
  # `git status` чист.
  povtorimost:
    name: reprint-determinism
    runs-on: ubuntu-latest
    # Три печати по 12,2 с на машине отряда; на раннере GitHub одно ядро
    # медленнее, и потолок взят с запасом втрое, а не впритык.
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      # Тот же кеш и тот же ключ, что у соседних работ этого файла: на пуше,
      # не тронувшем `bootstrap/**`, сборка не идёт вовсе, и работа стоит
      # ровно три печати.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      # ПРОБА ИДЁТ ПЕРВОЙ И СТОИТ ОДНУ ПЕЧАТЬ ИЗ ТРЁХ. Сторож, которого нельзя
      # покрасить, неотличим от выключенного (scripts/guards/guards-without-forgery-probe.fscript:
      # за одни сутки 5 сентября 2026 эта порода поймана четырежды, и ни разу
      # прибором). Проба подкладывает сверщику изменённый байт и пропавший
      # файл и требует красноты, а от дословной копии — молчания.
      - name: Probe print determinism
        run: bootstrap/flang io scripts/seed/print-is-repeatable.fscript --plan Forgery --timeout 600000
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Check print determinism
        run: bootstrap/flang io scripts/seed/print-is-repeatable.fscript --plan Check --timeout 600000
        env:
          FLANG_TMP: ${{ runner.temp }}

  # ── ОПУБЛИКОВАННОЕ ПРОТИВ ДЕРЕВА ──────────────────────────────────────────
  #
  # Проект говорит о себе числами, и числа эти уезжают молча. Замерено
  # 29 августа 2026 на стволе `5f1078e1`: из 24 дешёвых ключей
  # `docs/site/numbers.json` разошлись 19. `библиотека.файлов` стоял 26 при 42 в
  # дереве, `корпус.файлов` — 322 при 212, `планировщик.примеров` — 14 при 60.
  # Ни одна работа этого не ловила: `numbers:check` умеет, но зовёт измеритель
  # по всему корпусу, и в CI её не было ни разу.
  #
  # Здесь зовётся дешёвая половина: правила счёта переписаны в
  # `scripts/guards/published-vs-tree.sh` из `docs/site/site-numbers.mjs` один в один,
  # и она отвечает за девять секунд без двоичного и без Node. Дорогие ключи
  # (`корпус.функций`, `утверждения.*`, `носители.*`, `сторож.*`, `словарь.*`)
  # она НЕ проверяет и говорит об этом вслух — их держит `numbers:check`.
  #
  # ПОЧЕМУ ЗДЕСЬ НЕ ВСЯ СВЕРКА, А ДВА ЕЁ РАЗДЕЛА ИЗ ТРЁХ. Третий раздел —
  # `--доля` — спрашивает долю доказанного, а она снимается 437 прогонами по
  # 12,7 часа (`scripts/ledgers/proved-share.json`, поле «как снято»). Требовать от
  # каждого пуша, чтобы это число было свежим, нельзя: дерево сдвигает файл с
  # обязательствами за минуту, а пересъёмка стоит половину суток. Работа,
  # красная от того, чего ни один пуш починить не может, за неделю приучает не
  # смотреть — и тогда она не ловит уже ничего.
  #
  # Поэтому устаревание доли меряется не здесь, а там, где число ПУБЛИКУЕТСЯ:
  # рядом с ним стоят дата, коммит и мера сдвига в обязательствах, и
  # `bootstrap/flang run-script published:check` (полный прогон, девять секунд) печатает её
  # человеку числом: «числитель под вопросом на N обязательств из M». Голым
  # число не публикуется нигде.
  #
  # Свежесть семени тоже не сюда: её предмет — работа `semya` выше, и она ходит
  # на тот же пуш.
  published:
    name: published-check
    runs-on: ubuntu-latest
    timeout-minutes: 5
    steps:
      # Вся история и все теги: раздел «выпуск» спрашивает, выпущена ли
      # объявленная версия, а клон по умолчанию — одна ревизия без единого тега.
      # На таком клоне «тега нет» означало бы только то, что его не выгружали, и
      # сверка честно скажет «сверить нечем» — то есть проверит ничего.
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
        with:
          fetch-depth: 0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      - name: Check site numbers
        run: sh scripts/guards/published-vs-tree.sh --числа
      - name: Check released version
        run: sh scripts/guards/published-vs-tree.sh --выпуск
      - name: Check README map
        run: sh scripts/guards/published-vs-tree.sh --карта
      # Напечатанная команда — такое же утверждение о дереве, как число, и
      # обязана проверяться так же. 29 августа 2026 команда, подтверждающая
      # «аксиом ноль», стояла на ГЛАВНОЙ странице сайта в форме, которая
      # отвечает «непонятный ключ «ноль»»» и кодом 2: имя плана написано в
      # ёлочках и без кавычек оболочки. Таких мест в дереве нашлось тридцать пять.
      - name: Check documented commands
        run: sh scripts/guards/published-vs-tree.sh --команды
      # Числа, набранные в прозе РУКОЙ, — README, шапки страниц, ROADMAP. Их не
      # держала подстановка `{{ключ}}`, и не сторожило ничто: 29 августа 2026
      # примеров было объявлено 190 при 191, «ещё 183» при 176, отпечаток семени
      # 37 файлов при 42 строках, а «три решающих правила» стояли на той же
      # странице, где двенадцать. Здесь спрашиваются только те из них, что
      # считаются без двоичного.
      - name: Check prose numbers
        run: sh scripts/guards/published-vs-tree.sh --проза
      - name: Check non-flang files
        run: sh scripts/guards/published-vs-tree.sh --перепись

  imena:
    name: link-collisions
    runs-on: ubuntu-latest
    timeout-minutes: 25
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache

      # Наблюдатель за памятью — по тому же доводу, что и в `sborka`: эту
      # работу снимали сигналом каждый прогон, и в журнале это выглядело
      # обрывом, а не отказом. Устройство и оговорки — в шапке сторожа.
      - name: Watch memory
        run: nohup free -k -s 5 > "$FLANG_TMP/memory-headroom.log" 2>&1 &
        env:
          FLANG_TMP: ${{ runner.temp }}
          LC_ALL: C

      # ── ДВА РАЗРЯДА, А НЕ ОДИН СПИСОК ─────────────────────────────────────
      #
      # Отчёт сторожа поделён надвое, и работу красит только первый разряд:
      #
      #   РАЗРЯД 1 — столкновения в замыканиях НАСТОЯЩИХ программ дерева. Такое
      #     имя связывание уже видит дважды; попади оно в замыкание
      #     `flang/self/bootstrap/compiler.flang` — падает перепечатка.
      #   РАЗРЯД 2 — столкновения в ВЫДУМАННОМ входе «вся библиотека сразу».
      #     Обе стороны такой пары не сходятся ни в одной программе дерева,
      #     связывание о них молчит, и кода они не меняют.
      #
      # Почему это понадобилось, числом. 23 августа 2026 в библиотеку приехали
      # `x25519`, `ecdsa`, `rsa`, и работа покраснела 54 столкновениями слитой
      # библиотеки. 26 августа `168b6748` завёл НАСТОЯЩЕЕ столкновение
      # «В ёлочках» в `link.flang`: отчёт вырос с 54 строк до 55, работа как
      # была красной, так и осталась. 28 августа то же столкновение нашла
      # перепечатка — за 10 мин 47 с, притом что сторож называет его за 3,6 с.
      # Пять суток красноты приучили к красноте. Разбор — задача 4929.
      #
      # Замер 29 августа 2026 на этой ветке: разряд 1 — 0, разряд 2 — 53,
      # 3,6 с, пик 275 МБ, код 0.
      - run: node flang/scripts/link-collision-guard.mjs --дерево

      # Сторож, которого не проверяли на настоящей поломке, ничего не стоит.
      # Три нарочные порчи подкладываются ЧТЕНИЕМ, дерево остаётся нетронутым:
      # настоящее столкновение в замыкании перепечатки (ждём красноту и цену
      # «РОНЯЕТ ПЕРЕПЕЧАТКУ»), настоящее в чужой программе (краснота, цена
      # другая) и отзвук слияния библиотеки (разряд 2, зелено). Расходись хоть
      # одна — работа красная.
      - run: node flang/scripts/link-collision-guard.mjs --порча

      # ── ПОЛОМКИ ОТ СЛИЯНИЯ: ПРЕДМЕТ ЗДЕСЬ, А ПРОГУЛКА — НА ДРУГОМ РАННЕРЕ ──
      #
      # Слияние двух веток, тронувших одно место, git разводит без единого знака
      # конфликта: обе добавили функцию с одним именем — в файле два объявления;
      # одна убрала функцию, другая оставила вызовы — зовущие висят в пустоту.
      # Язык ловит и то и другое, но ТОЛЬКО на том файле, который кто-то
      # проверил, а список проверяемых (`examples-ledger.txt`) короче дерева.
      #
      # ЗДЕСЬ ЭТОТ ШАГ СТОЯЛ И НЕ ПРОХОДИЛ НИ РАЗУ. Проверка переписана на flang
      # (`scripts/guards/name-splicing-guard.fscript`, коммит `fd9edd54` от 22 августа
      # 2026), `flang/scripts/srashchivanie.mjs` при этом снят. В шапку была
      # записана цена «3 мин 44 с, пик памяти 24 ГиБ» на 571 файле — и на этом
      # дело стало: у раннера GitHub 16 ГиБ. Не «медленно», а НЕ ВЛЕЗАЕТ, ровно
      # как у побайтовой сверки в `reprint.yml`.
      #
      # Замер 30 августа 2026 на стволе `6cee15cf`, 724 файла, 270 706 строк,
      # `/usr/bin/time -f '%M'`: 366,22 с, пик занятой памяти 30 711 628 кБ =
      # 29,3 ГиБ, код 0, ответ верный (объявленных имён 16 816, двойных
      # объявлений 2, званых которых нет 0). Память растёт вместе с деревом —
      # около 27 МБ на каждый пройденный файл, — и за неделю дерево выросло с
      # 571 файла до 724.
      #
      # ЧЕМ ЭТО ВЫГЛЯДЕЛО В CI. Шаг снимали сигналом на второй-третьей минуте:
      # «Process completed with exit code 143» или «The runner has received a
      # shutdown signal». Работа `imena` была красной КАЖДЫЙ прогон с 22 августа
      # — все сто прогонов, какие хранит GitHub, — и падала не на предмете, а на
      # памяти раннера.
      #
      # Уменьшить прогулку не вышло: расход не в устройстве сторожа, а в счёте.
      # Проверено замерами: одно поручение плана без работы стоит 65 кБ (проба
      # на 1500 поручений), тот же модуль с разбором одной строчки на виток —
      # 653 МБ на 900 витков и НЕ растёт; расход набегает на 541 412 посещённых
      # строчках, по 55 кБ на строчку. Первый проход один, без второго, — 13,5
      # ГиБ. То есть даже даровой второй проход не влез бы.
      #
      # ПОЭТОМУ ПРОГУЛКА ПЕРЕЕХАЛА в работу `srashchivanie` ниже, на раннер с
      # большой памятью, — тем же порядком, что и `sverka` в `reprint.yml`.
      # Здесь остаются два сторожа столкновений и потолок строк ядра: они
      # читают текст и в 16 ГиБ влезают.
      # ── ДВОИЧНЫЙ БЕРЁТСЯ ГОТОВЫМ, ЕСЛИ ВХОДЫ СБОРКИ ТЕ ЖЕ ──────────────────
      #
      # 27 работ дерева собирали одно и то же заново. Ключ кеша — хеш ВСЕХ
      # входов сборки (`bootstrap/*.c`, `*.h`, `Makefile`) ПЛЮС сами флаги:
      # разойдись хоть один байт входа или флаг — ключ другой, и работа
      # собирает честно. Тихо взять чужой двоичный ключ не позволяет.
      #
      # ЧЕМ ЭТО МЕНЯЕТ ДОВЕРИЕ, И ЭТО НАДО СКАЗАТЬ. Раньше каждая работа
      # судила дерево двоичным, собранным ЕЮ ЖЕ. Теперь — двоичным, собранным
      # из тех же байтов входа в другой работе. Равенство входов проверяет
      # ключ, а равенство ВЫХОДА при равных входах проверено отдельно:
      # sha256 двоичного после двух независимых сборок совпал знак в знак.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      # Кеш мог отдать негодное: файл есть, а не запускается. Проверяем и
      # собираем честно, если так. Молчаливого «ну и ладно» здесь нет.
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi

      # СЕРАЯ СТРОКА «Skipped» — ЭТО МОЛЧАНИЕ, А МОЛЧАНИЕ ЗДЕСЬ ЗАПРЕЩЕНО.
      # Работа `srashchivanie` без своего раннера не запускается вовсе, и в
      # ленте её не видно. Поэтому состояние называется тут, в работе, которая
      # идёт всегда, и называется в СВОДКЕ прогона — её видно, не открывая
      # логов.
      - name: Note splicing job
        if: always()
        run: |
          if [ "${BOLSHAYA_PAMYAT:-}" = "da" ]; then
            echo "Поломки от слияния считает работа «Повреждения от слияния» на своём раннере." >> "$GITHUB_STEP_SUMMARY"
          else
            echo "⚠ ПОЛОМКИ ОТ СЛИЯНИЯ НА ЭТОМ ПУШЕ НЕ СЧИТАНЫ." >> "$GITHUB_STEP_SUMMARY"
            echo "Прогулке по дереву нужно 29,3 ГиБ (замер 30.08.2026, 724 файла), у раннера GitHub — 16 ГиБ." >> "$GITHUB_STEP_SUMMARY"
            echo "Считать её не на чем, пока нет раннера с меткой «bolshaya-pamyat» и переменной BOLSHAYA_PAMYAT=da." >> "$GITHUB_STEP_SUMMARY"
            echo "::warning::поломки от слияния не считаны: нужен раннер с большой памятью (29,3 ГиБ)"
          fi
        env:
          BOLSHAYA_PAMYAT: ${{ vars.BOLSHAYA_PAMYAT }}

      # ── СКОЛЬКИМ СТРОКАМ ЯДРА ПРИХОДИТСЯ ВЕРИТЬ ───────────────────────────
      #
      # От поиска в проверяльщике отказались ради довода «прочитать целиком
      # можно только маленький». Довод работает, только если «маленький» — это
      # число, которое кто-то держит. Здесь оно держится: ядро решений (всё, до
      # чего доходит цепочка от ответа да/нет) обязано не расти.
      #
      # Прежняя программа на JavaScript (`flang/scripts/skolku-verit.mjs`)
      # снята: все двенадцать чисел сошлись число в число в трёх состояниях
      # дерева, включая подложенное нарушение, — см. шапку `.flang`. Двоичный
      # собран шагом выше. 20 с против 0,09 с; ключ --max-steps обязателен.
      #
      # ДВА МИЛЛИАРДА ЗДЕСЬ — ЗАПАС В СТО РАЗ, и это снято, а не назначено.
      # Перебор предела 29 августа 2026: при 15 000 000 счёт умирает
      # («исчерпала лимит шагов»), при 20 000 000 доходит до вердикта. Значит
      # тратится около двадцати миллионов из двух миллиардов — один процент.
      #
      # Перепечатка семени этого предела не касается: «--max-steps» у «io»
      # ограничивает вычисляемую программу, а не счётчик рантайма, в который
      # кладёт `fl_charge`. Разбор — у соседнего шага, «Опись дерева по языкам».
      # Потолок самого двоичного под заряд попадает, и он тоже снят ведомостью:
      # шагов всего 2 694 257 690, витков 71 582 071. Нынешнее семя упирается в
      # свой миллиард витками на 7,2 %; следующее считает шаги при потолке
      # 300 млрд — 0,9 %.
      - run: ./bootstrap/flang io flang/scripts/kernel-lines-to-trust.fscript --plan 'Потолок не пробит' --max-steps 2000000000

      # ЗДЕСЬ СТОЯЛ ШАГ НА ФАЙЛ, КОТОРОГО НЕТ, и он был красным на стволе:
      #
      #   - run: node --test flang/test/link-collision-guard.test.mjs
      #     Could not find 'flang/test/link-collision-guard.test.mjs'   код 1
      #
      # Файл снят коммитом `086e526c` вместе с переносом сторожа столкновений
      # имён на flang; шаг остался. `continue-on-error` при нём не стояло, так
      # что работа `imena` падала на каждом пуше — и падала НЕ на предмете, а на
      # отсутствии файла. Стоявшая тут пометка «их строгий прогон стоит в
      # `ci.yml`» тоже неправда: строки про этот файл в `ci.yml` нет ни одной.
      #
      # Само-проверка сторожа никуда не делась и лежит там, где сторож: подлог
      # (`тотальная функция «Куски таблицы»` из `flang/self/lexer.flang`,
      # подложенная в `flang/self/monad-expand.flang`) описан прогоном в шапке
      # `scripts/guards/name-collision-guard.fscript`. Шаг выше — `node
      # flang/scripts/link-collision-guard.mjs --дерево` — считает то же самое
      # второй реализацией и остаётся.

      # Последним шагом и ВСЕГДА — по тому же доводу, что и в `sborka`.
      - name: Report memory
        if: always() && hashFiles('bootstrap/flang') != ''
        run: bootstrap/flang io scripts/memory-headroom.fscript --plan Report -- --status "${{ job.status }}"
        env:
          FLANG_TMP: ${{ runner.temp }}
          FLANG_WATCH_STEP: 5

  # ── ДОРОГО И НЕ НА ЭТОМ РАННЕРЕ: сама прогулка по дереву ──────────────────
  #
  # Предмет и доводы — в работе `imena` выше, у шага «Сказать вслух». Здесь
  # только устройство.
  #
  # Замер 30 августа 2026, ствол `6cee15cf`, 724 файла: 366,22 с и 29,3 ГиБ
  # пика занятой памяти. У раннера GitHub 16 ГиБ, и до этой правки шаг стоял в
  # `imena`, где его снимали сигналом каждый прогон.
  #
  # ВКЛЮЧАЕТСЯ ПЕРЕМЕННОЙ РЕПОЗИТОРИЯ `BOLSHAYA_PAMYAT=da` — той же, что у
  # `sverka` в `reprint.yml`, и по той же причине: работа, поставленная в
  # очередь к несуществующему раннеру, висит до отмены и выглядит как «идёт»,
  # хотя не идёт. Пусть лучше её не будет видно вовсе, чем будет видно неправду.
  # Что её нет — сказано вслух в сводке прогона `imena`, а не замолчано.
  #
  # ЗАПАС ПО ВРЕМЕНИ. На этой машине прогулка идёт 366 с при 256 ядрах; у
  # раннера ядер меньше, и сборка семени добавляет свои три минуты. Полчаса —
  # запас примерно вчетверо, и он нужен: память растёт вместе с деревом,
  # около 27 МБ на файл.
  #
  # ПЕРЕМЕРЕНО 30 августа 2026 на стволе `6c6ae04a` (семя 0.6.2, тот же
  # `/usr/bin/time -f '%M'`): 367,31 с, пик 33 160 452 кБ = 31,63 ГиБ, код 0,
  # 728 файлов, объявленных имён 16 876. За сорок минут между двумя замерами
  # дерево прибавило четыре файла, а прогулка — 2,3 ГиБ. Число выше (29,3) не
  # ошибочно, оно устарело: расход растёт вместе с деревом, и запас по времени
  # тут нужнее, чем кажется.
  srashchivanie:
    name: merge-splicing
    # На self-hosted раннере: неограниченный `pull_request` на публичном
    # репозитории собирал бы и исполнял чужой код на этой машине без
    # проверки источника. Найдено Ч402 (задача 9971) — гейт ниже пускает
    # PR из ветки этого же репозитория (доверенной, там пишут только с
    # правом записи), но не из чужого форка.
    if: >-
      vars.BOLSHAYA_PAMYAT == 'da' &&
      (github.event_name != 'pull_request' ||
       github.event.pull_request.head.repo.full_name == github.repository)
    runs-on: [self-hosted, bolshaya-pamyat]
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      - name: Watch memory
        run: nohup free -k -s 5 > "$FLANG_TMP/memory-headroom.log" 2>&1 &
        env:
          FLANG_TMP: ${{ runner.temp }}
          LC_ALL: C
      # ── ДВОИЧНЫЙ БЕРЁТСЯ ГОТОВЫМ, ЕСЛИ ВХОДЫ СБОРКИ ТЕ ЖЕ ──────────────────
      #
      # 27 работ дерева собирали одно и то же заново. Ключ кеша — хеш ВСЕХ
      # входов сборки (`bootstrap/*.c`, `*.h`, `Makefile`) ПЛЮС сами флаги:
      # разойдись хоть один байт входа или флаг — ключ другой, и работа
      # собирает честно. Тихо взять чужой двоичный ключ не позволяет.
      #
      # ЧЕМ ЭТО МЕНЯЕТ ДОВЕРИЕ, И ЭТО НАДО СКАЗАТЬ. Раньше каждая работа
      # судила дерево двоичным, собранным ЕЮ ЖЕ. Теперь — двоичным, собранным
      # из тех же байтов входа в другой работе. Равенство входов проверяет
      # ключ, а равенство ВЫХОДА при равных входах проверено отдельно:
      # sha256 двоичного после двух независимых сборок совпал знак в знак.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      # Кеш мог отдать негодное: файл есть, а не запускается. Проверяем и
      # собираем честно, если так. Молчаливого «ну и ладно» здесь нет.
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      - run: ./bootstrap/flang io scripts/guards/name-splicing-guard.fscript --на-веру --max-orders 2000
      - name: Report memory
        if: always() && hashFiles('bootstrap/flang') != ''
        run: bootstrap/flang io scripts/memory-headroom.fscript --plan Report -- --status "${{ job.status }}"
        env:
          FLANG_TMP: ${{ runner.temp }}
          FLANG_WATCH_STEP: 5

  # ── Сторожа заводятся: считает ЧИСЛОМ, и сегодня число красное ────────────
  #
  # ПОЧЕМУ ЭТА РАБОТА ЕСТЬ.
  #
  # Удаление реализации на JavaScript оставило файлы проверок, ввозившие
  # `flang/bin/flang.mjs`. Они перестали ЗАГРУЖАТЬСЯ — и ни один набор этого не
  # показал: файл, упавший на ввозе, не печатает ни одного проваленного
  # утверждения, печатать нечего. Среди замолчавших был
  # `flang/test/proof-soundness.test.mjs`, называвший СВОИМ ТЕКСТОМ дыру в
  # состоятельности ядра; дыру нашли и закрыли много позже, вслепую и отдельной
  # работой.
  #
  # Сторож, который называет дыру и не заводится, от её отсутствия неотличим.
  #
  # Работа отдельная по той же причине, что и `imena`: `sborka` заведена БЕЗ
  # Node намеренно, а здесь Node — сам предмет проверки. Двоичный собирается,
  # потому что сторож написан на flang и его надо чем-то исполнить.
  #
  # ЧТО ЭТА РАБОТА НЕ СЧИТАЕТ, названо здесь, потому что имя работы шире дела.
  # Считаются только файлы `*.test.mjs` — их 15. Проверки на flang
  # (`scripts/storozh-*.flang`, `flang/scripts/*.flang`, `fspec/guard.flang`)
  # сюда не попадают: «заводится ли» спрашивается прогоном `node --test`, а
  # программу на flang заводит `flang io`. Подлогом проверено 22 августа: к
  # `scripts/guards/homebrew-formula-guard.fscript` дописана строка, после которой файл не
  # разбирается, — работа осталась зелёной. Само число теперь называет свой род
  # («файлов проверок «*.test.mjs» в дереве 15»), чтобы 15 не читалось как «все».
  # ЦЕНА, замер 31 августа 2026 на этом дереве: сборка чекера одним `cc` — 1,0 с,
  # весь набор из 156 проб — 1,1 с. Ставится в CI зелёной: 61 подделка, из них
  # принятых кодом 0 — ноль; 95 честных записей, отвергнутых — ноль.
  #
  # ТРИ ИСХОДА, А НЕ ДВА. Прогон печатает все три числа (ПРОВЕРЕНО / НЕ
  # ПРОВЕРЕНО / НЕ СОШЛОСЬ) и отдельно два класса проб. Красным он становится
  # только от двух вещей: подделка принята кодом 0 или честная запись отвергнута
  # кодом 1. Запись, о которой чекер честно говорит «проверено не всё, и вот
  # что», работу не валит — иначе третий исход слился бы с отказом, а ради него
  # всё и написано.
  chekker:
    name: proof-checker
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      - name: Build proof checker
        run: make -C flang/proof/checker
      - name: Build flang from the seed
        run: make -C bootstrap -j4
      - name: Run checker probes
        run: bootstrap/flang io flang/proof/checker/tests/run.fscript --max-steps 4000000000 --timeout 600000
        env:
          FLANG_TMP: ${{ runner.temp }}
      # ── ДЕЛО ЧЕКЕРУ НАЗЫВАЕТ ДЕРЕВО, А НЕ ЗАПИСЬ (задача 4820) ────────────
      #
      # Прежде оснастка брала путь исходника из строки «исходник» самой
      # проверяемой записи и снимала отпечаток с того, на что запись показала:
      # подсудимый выбирал себе дело. Живой прогон подлога: файл дерева
      # заменён ложью, запись зовёт исходником нетронутую копию ВНЕ коммита —
      # ядро даёт контрпример, а линейка печатала «ПРОВЕРЕНО» и не меняла
      # счёта. Теперь путь и отпечаток берутся из ведомости коммита
      # (`git archive` + `sha256sum`), и запись, назвавшая не то, что лежит в
      # коммите, роняет прогон кодом 1.
      #
      # Компилятор здесь по-прежнему не нужен и не собирается: ведомость
      # строит `git`, а не `bootstrap/flang`. В этом весь смысл работы.
      #
      # ПОЛЯРНОСТЬ ЗДЕСЬ ОБРАТНА ПРИВЫЧНОЙ, и это нарочно. У остальных проб
      # порчи в дереве сторож зовётся С ПОРЧЕЙ и обязан вернуть НЕ ноль
      # (`if sh …--подлог; then exit 1`). Здесь `--подлог` — не испорченный
      # прогон, а набор из трёх: контроль на честном дереве плюс два подлога.
      # Ноль значит «подделка отвергнута И честная запись зелена»; без
      # контроля подлог, отвергнутый по посторонней причине, читался бы как
      # работа охраны.
      - name: Probe corpus ledger
        run: |
          if ! bootstrap/flang io flang/proof/share-ledger-forgery.fscript --max-steps 4000000000 --timeout 900000; then
            echo "сторож ведомости промолчал на подлоге — проверять им нечего" >&2
            exit 1
          fi
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Check corpus ledger
        run: bootstrap/flang io flang/proof/share-measure.fscript --max-steps 4000000000 --timeout 900000 -- --set corpus
        env:
          FLANG_TMP: ${{ runner.temp }}

  # ── СЛИЧИТЕЛЬ ПЕРЕВОДА: ПРОТОКОЛ ПЕЧАТНИКА ПЕРЕИГРЫВАЕТСЯ НА C ──────────────
  #
  # ADR-0030, задача 1401: печатник C ведёт протокол перевода, и отдельная
  # программа на C (`flang/translation/matcher.c`) переигрывает его против
  # исходника и напечатанного кода. Честные пары обязаны сойтись, подделки
  # протокола и C — не приниматься. Команда `translation:check` заведена коммитом
  # 6ebd5e18e, но ни один workflow его не звал, и два сторожа — «кто зовёт
  # сторожей» и сторож проб порчи — держали на нём хук перед пушем красным.
  #
  # С 4 октября 2026 набор гоняет ПЛАН `flang/translation/run.fscript` (прежняя
  # оболочка `run.sh` снята): приговор доказан ядром, ожидания 32 опытов стоят
  # таблицей. Жалоба идёт строкой «  · <имя опыта> — ждали код N …», и проба
  # порчи ниже ищет в выводе ИМЕННО эту строку.
  #
  # Работа соседняя чекеру и отдельная по той же причине: компилятор не
  # собирается, нужны только `cc` и `sh`. Но план зовётся собранным двоичным,
  # поэтому шаг сборки семени здесь ЕСТЬ, а сличитель по-прежнему не спрашивает
  # ответ у того двоичного, о котором судит. Замер 4 октября 2026 на рабочей
  # машине: весь прогон — сборка сличителя и тридцать два опыта — 4,3 с.
  #
  # Порча внешняя, одна строка напечатанного C «Светофора»: штраф красного
  # 500 → 501 при прежнем протоколе. Прогон обязан покраснеть ИМЕННО на этой
  # паре — «честная пара с разбором», — а не на постороннем: иначе краснота
  # не показывает, что сличитель читает C, а не один протокол. `sed` без `-i`
  # — по доводу соседней пробы обещаний о печати (BSD-шный ключ на macOS).
  perevod:
    name: translation-matcher
    runs-on: ubuntu-latest
    # Было 10, пока набор гоняла оболочка: `cc` и шестнадцать опытов. План
    # зовётся двоичным, и при промахе кеша работа сперва СОБИРАЕТ семя; на
    # раннере это минуты, а не 4,3 с здешнего прогона. 20 — запас к соседней
    # работе `guards-selftest`, которая собирает то же и просит столько же.
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      # Двоичный берётся готовым по тем же правилам, что у соседних работ:
      # ключ кеша — хеш всех входов сборки плюс флаги; негодный кеш собирается
      # заново, а не принимается молча.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      - name: Probe translation matcher
        run: |
          set -u
          podlog=flang/translation/fixtures/traffic-light/svetofor.c
          cp "$podlog" "$RUNNER_TEMP/svetofor.c.do"
          sed 's/fl_t1 = fl_number(500\.0);/fl_t1 = fl_number(501.0);/' "$RUNNER_TEMP/svetofor.c.do" > "$podlog"
          if cmp -s "$RUNNER_TEMP/svetofor.c.do" "$podlog"; then
            git checkout -- "$podlog"
            echo "ПОДЛОГ НЕ СОБРАЛСЯ: строки «fl_t1 = fl_number(500.0);» в $podlog уже нет — поправить подлог, сличитель ни при чём" >&2
            exit 1
          fi
          if bootstrap/flang run-script translation:check > "$RUNNER_TEMP/perevod.out" 2>&1; then
            git checkout -- "$podlog"
            cat "$RUNNER_TEMP/perevod.out"
            echo "сличитель промолчал на подлоге — проверять им нечего" >&2
            exit 1
          fi
          git checkout -- "$podlog"
          cat "$RUNNER_TEMP/perevod.out"
          if ! grep -qF '· честная пара с разбором' "$RUNNER_TEMP/perevod.out"; then
            echo "прогон покраснел, но не на испорченной паре — краснота не по делу" >&2
            exit 1
          fi
      - name: Check C translation
        run: bootstrap/flang run-script translation:check

  storozha:
    name: guards-selftest
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      # Полная история не нужна: сторож спрашивает `git ls-files`, а не журнал.
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      # ── ДВОИЧНЫЙ БЕРЁТСЯ ГОТОВЫМ, ЕСЛИ ВХОДЫ СБОРКИ ТЕ ЖЕ ──────────────────
      #
      # 27 работ дерева собирали одно и то же заново. Ключ кеша — хеш ВСЕХ
      # входов сборки (`bootstrap/*.c`, `*.h`, `Makefile`) ПЛЮС сами флаги:
      # разойдись хоть один байт входа или флаг — ключ другой, и работа
      # собирает честно. Тихо взять чужой двоичный ключ не позволяет.
      #
      # ЧЕМ ЭТО МЕНЯЕТ ДОВЕРИЕ, И ЭТО НАДО СКАЗАТЬ. Раньше каждая работа
      # судила дерево двоичным, собранным ЕЮ ЖЕ. Теперь — двоичным, собранным
      # из тех же байтов входа в другой работе. Равенство входов проверяет
      # ключ, а равенство ВЫХОДА при равных входах проверено отдельно:
      # sha256 двоичного после двух независимых сборок совпал знак в знак.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      # Кеш мог отдать негодное: файл есть, а не запускается. Проверяем и
      # собираем честно, если так. Молчаливого «ну и ладно» здесь нет.
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      - name: Check guards start
        run: bootstrap/flang io flang/scripts/guards-start.fscript --на-веру
      # Записи корпуса доказательств могут отстать от печати ядра — та же
      # порода, что у семени: расхождение объявляют «числом», а не отказом,
      # и никто не краснеет. Прибор `--вложенность` печатает записи заново
      # нынешним двоичным и сверяет байт в байт; 46 с, двоичный уже в кеше.
      # Что НЕ ловит: отставание самого двоичного (для него — раскрутка
      # --bystro --strogo). Место здесь, не в pre-push: 46 с > бюджета хука.
      # Прибор ниже отказывает кодом 2 «нет чекера», если сверщик не собран
      # (flang/proof/corpus-share.sh:211) — и с 6 сентября (0cc9b98a) шаг был
      # красен именно этим, а не отставанием записей: чекер здесь собирала только
      # работа `proof-checker`. Секунда компиляции одного файла на C.
      #
      # ОТПЕЧАТОК СЕМЕНИ ПРИ ДВОИЧНОМ. Прибор сперва спрашивает, из этого ли
      # семени собран двоичный, и до 11 сентября спрашивал ВРЕМЯ файлов
      # (`make -q`). Здесь это врало: кеш отдаёт двоичный со старым временем,
      # checkout кладёт семя свежим — и прогон 34614243521 на dev упал кодом 2
      # «ЯДРО ОТСТАЛО ОТ СЕМЕНИ» на двоичном, собранном ровно из этого семени.
      # Теперь признак — СОДЕРЖИМОЕ: файл bootstrap/flang.seed-sha256 с sha256
      # двоичного и входов сборки, и пишет его тот, кто собрал. Здесь он
      # честен на обоих путях: либо `make` только что прошёл, либо кеш отдал
      # двоичный по ключу из хеша тех же `bootstrap/*.c`, `*.h`, `Makefile`,
      # что входят в отпечаток, — равенство входов уже проверено ключом.
      # Подлог — четыре пробы на копии bootstrap/: кеш (двоичный старше по
      # времени, семя то же — свежее), правленое семя при подмоложенном
      # двоичном (отстало — старый признак это пропускал), честная перезапись
      # (свежее), без отпечатка — прежний признак по времени (отстало).
      # Отпечатку и его подлогу чекер не нужен (они смотрят только на bootstrap/),
      # и прибор его для них не требует; шаг сборки чекера при коммите ae42220a2
      # отсюда выпал, и `--вложенность` осталась бы без него — возвращён.
      - name: Record seed fingerprint
        run: bootstrap/flang io flang/proof/binary-fingerprint.fscript
      - name: Probe seed fingerprint
        run: bootstrap/flang io flang/proof/binary-fingerprint.fscript -- --forgery
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Build proof checker
        run: make -C flang/proof/checker
      - name: Check corpus records
        run: bootstrap/flang io flang/proof/records-nesting.fscript --max-steps 4000000000 --timeout 900000
        env:
          FLANG_TMP: ${{ runner.temp }}

      # Предмет тут другой — сторож кодов, — но работа та же по той же причине,
      # по которой `imena` не стала шагом в `sborka`: сборка двоичного стоит
      # две с половиной минуты, а заводить ради этой проверки вторую сборку
      # значило бы платить лишний раз за то же самое.
      #
      # Родство прямое: сторож кодов сам себя не проверяет, и его половина
      # «а ЛОВИТ ли он» лежала в `flang/test/code-guard.test.mjs`, который не
      # заводился. Ставить её в CI отдельно от того, кто это обнаружил, незачем.
      #
      # ⚠ «14 секунд» здесь стояло раньше и устарело МОЛЧА — а сам шаг был
      # красным неизвестно сколько (найдено ячейкой Ч370, 3 сентября 2026,
      # СI не должен жечь часы на пуш). Дело не в шагах плана (это чинит
      # `--max-steps` внутри code-forgery.fscript — снято отдельно, разбор там
      # же): «Спросить сторожа» зовёт `code-guard.fscript` ПОДПРОЦЕССОМ, а у
      # `flang io` есть свой, не связанный с `--max-steps` срок на КАЖДОГО
      # потомка — 30 000 мс по умолчанию, назван и объяснён в
      # `scripts/guards/child-timeout.fscript`. Сторож кодов на нынешнем дереве идёт
      # ~32-33 с (замер трижды, устойчиво), то есть неизбежно упирается в
      # чужой срок и гибнет сигналом SIG9 — не находка про сторож, а про сам
      # срок. `--timeout` ЗДЕСЬ, на внешнем вызове, — это и есть тот рычаг:
      # он становится сроком КАЖДОГО потомка, которого заведёт этот прогон.
      # 120000 мс — почти четырёхкратный запас к измеренным 32-33 с на одного
      # потомка; сторож зовётся дважды (чистый суд и суд подлога), весь шаг
      # уложился в 67,3 с (замер локально, `time`).
      - name: Probe code guard
        run: bootstrap/flang io flang/scripts/code-forgery.fscript --на-веру --timeout 120000

      # ── А ТЕПЕРЬ САМ СУД, а не только проба над ним ───────────────────────
      #
      # Шаг выше спрашивает, УМЕЕТ ли сторож краснеть. Этот спрашивает, ЧИСТО
      # ли дерево, — и до 5 сентября 2026 его тут не было. Причина названа
      # прямо в `scripts/ledgers/uncalled-guards.json`: сторож был КРАСЕН ПО ДЕЛУ,
      # в прозе висели пять имён, которых в исходниках нет. Красный сторож в
      # CI красит работу всегда и потому выключается первым — ставить его
      # было нельзя, пока долг не закрыт.
      #
      # Долг закрыт задачей 9043: пять имён разобраны поимённо прогоном и
      # историей (`git log -S`), у каждого свой род, место и довод. Незваным
      # ему стоять больше незачем — сторож, которого никто не зовёт,
      # показывает столько же, сколько его отсутствие. Запись из ведомости
      # убрана той же задачей: сверка идёт в обе стороны, и запись «незван»
      # на званом сторожа красит перепись.
      #
      # Цена: 41–54 с на четырёх прогонах, машина под чужой перепечаткой
      # (замер 5 сентября 2026, `/usr/bin/time`). Почти всё — два `git grep`
      # по дереву и разбор их вывода. Двоичный здесь уже собран шагами выше,
      # второй раз за него платить не приходится.
      - name: Check prose codes
        run: bootstrap/flang run-script codes:check

      # ── Сторож выпуска без кеша: тот же довод, что у соседей выше ─────────
      #
      # Сторож, разучившийся краснеть, от чистого дерева неотличим, а этот
      # молчит В ПОДАВЛЯЮЩЕМ БОЛЬШИНСТВЕ прогонов по устройству: метки бывают
      # раз в недели, и его зелень на ветке ничего о нём не говорит. Проба
      # гоняет восемь пар «режим × состояние переменной» — две обязаны краснеть,
      # пять молчать, одна отвечать «смотреть нечем», — и стоит она сотые доли
      # секунды, двоичный ей не нужен.
      #
      # Работа ходит на КАЖДЫЙ пуш, поэтому испорченный сторож обнаружится
      # задолго до метки, а не в тот единственный прогон, когда он нужен.
      - name: Probe cache guard
        uses: ./.github/actions/release-without-cache
        with:
          mode: self-test

      # ВТОРАЯ ПОЛОВИНА СТОРОЖА, и без неё первая неполна. Шаг-сторож смотрит
      # среду в тот миг, когда стоит, — а шаг НИЖЕ него в той же работе может
      # задать переменную через `$GITHUB_ENV`, и проверка будет обойдена, не
      # покраснев. Здесь спрашивается разметка: ни одна работа не смеет
      # упоминать `FLANG_KESH_PRIGOVOROV` вне комментария. Сегодня таких
      # упоминаний ноль, и это храповик — появится первое, придут и подумают.
      #
      # Стоит на КАЖДОМ пуше, а не на метке: находка нужна на запросе слияния,
      # а не в тот единственный прогон по метке, когда чинить уже поздно.
      - name: Check workflow cache
        uses: ./.github/actions/release-without-cache
        with:
          mode: workflows

      # ── Слова о доказанности: сильное слово про слабое основание ──────────
      #
      # ПОЧЕМУ ЗДЕСЬ, А НЕ ОТДЕЛЬНОЙ РАБОТОЙ. Предмет тот же, что у двух шагов
      # выше, — сторож, который сам себя проверяет, — и двоичный уже собран.
      # Прогон идёт на одной подделке, секунды.
      #
      # ЧТО ЛОВИТСЯ. Ведомость произносит три разные по силе вещи: «доказано
      # ядром» (обо ВСЕХ входах), «сетка» (счёт на конечном числе значений — НЕ
      # доказательство) и «объявлено, не доказано». Число «доказано N» — то, по
      # которому судят, заслужено ли слово «формально-доказуемый»; подмешай в
      # него счёт, и число станет ложью. Сторож сверяет слово с вердиктом,
      # число с построчным счётом, прозу с машинным видом и — прогоном с
      # заглушкой — пустоту: пережившее подмену тела утверждение верно про любую
      # функцию этой подписи и про эту не говорит ничего.
      #
      # Обе половины спрашиваются одной командой: чистое обязано молчать, и
      # каждая из пяти порч обязана быть поймана. Зелёный без показанной порчи
      # ничего не значит.
      - name: Probe proof wording
        run: LC_ALL=C.UTF-8 ./bootstrap/flang io flang/scripts/word-guard.fscript --на-веру --plan 'Подлог слов' --max-steps 2000000000

      # ── ПОДДЕЛКИ ЯДРА: ни одного шага CI у них не было НИ РАЗУ ─────────────
      #
      # Состоятельность ядра доказательств держится на подделках — программах,
      # которые пытаются сказать ложь и обязаны остаться недоказанными. Обе
      # проверки лежали в дереве и не звались ниоткуда: ни из `ci.yml`, ни
      # отсюда. То есть сломай завтра правило вывода — зелёным осталось бы всё.
      #
      # Замерено на этой машине: проверка на flang — 9.6 с, пик 1.2 ГиБ.
      # Десять секунд за то, что ядро не берёт ложь, — это даром, и место ей
      # здесь, где двоичный уже собран.
      #
      # Половина «со стороны Node» отсюда снята вместе с `poddelki-yadra.mjs`:
      # спрашивала она то же самое у того же двоичного, а списком отстала —
      # закрытый перечень доводов у неё был из четырёх строк, ядро завело
      # шестую, и на стволе она отвечала «в ядре завелась аксиома» и кодом 1.
      # Сверка списка с каталогом `flang/test/fixtures` осталась целиком: её
      # держит проверка на flang, и имена подделок она берёт у соседа
      # (`flang/scripts/proof-words.json`) ровно так же.
      # ПЛАН НАЗЫВАЕТСЯ ЯВНО: с 29 августа 2026 в файле два плана — дорогой
      # «Подделки остаются недоказанными» и дешёвый «Аксиом ноль», который читает
      # текст ядра и от семени не зависит. Без имени плана двоичный отвечает
      # FLANG_UNKNOWN_PLAN и кодом 3.
      - name: Check kernel forgeries
        run: bootstrap/flang io flang/scripts/kernel-forgeries.fscript --на-веру --plan 'Подделки остаются недоказанными'

      - name: Check lying programs
        run: bootstrap/flang io flang/proof/checker/tests/programs/lie-verdict.fscript
        env:
          FLANG_BIN: ${{ github.workspace }}/bootstrap/flang

      - name: Check strict mode
        run: bootstrap/flang io flang/proof/probes/strict/run.fscript --plan Binary
      - name: Check function value probes
        run: bootstrap/flang io flang/proof/probes/function-values/run.fscript --plan Binary
      - name: Check unproven gate
        run: bootstrap/flang io flang/proof/probes/unproven/run.fscript --plan Binary
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Check library profiles
        run: bootstrap/flang io flang/proof/probes/profile/run.fscript --plan Binary
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Check syllogism probes
        run: bootstrap/flang io flang/proof/probes/syllogism/run.fscript --plan Binary
      - name: Check syllogism premises as assumptions
        run: bootstrap/flang io flang/proof/probes/syllogism/assumptions/run.fscript --plan Binary
        env:
          FLANG_TMP: ${{ runner.temp }}
      - name: Check reasoning in sentences
        run: bootstrap/flang io flang/proof/probes/syllogism/sentences/run.fscript --plan Binary --max-steps 40000000
        env:
          FLANG_TMP: ${{ runner.temp }}
      # РУССКАЯ МОРФОЛОГИЯ РАЗЛИЧАЕТ ФОРМЫ, А ГДЕ НЕ РАЗЛИЧАЕТ — ОТКАЗЫВАЕТ ВСЛУХ.
      #
      # `flang/experimental/ru-morphology.flang` читает одну словоформу и отдаёт запись
      # словаря того вида, который разбирает переводчик выше: класс слова, формы
      # по числу, формы по роду. Где форма читается двояко — все чтения и слова,
      # чем их различить; где правило формы не выводит — названная недостача со
      # списком того, что дали бы правила. Молчаливая догадка здесь дороже
      # отказа: на ней вырос бы ложный силлогизм, и сказать об этом было бы
      # некому.
      #
      # Корпус — `forms.tsv`, 83 строки, у каждой ЧЕТЫРЕ поля: форма, стоит ли
      # она в начале предложения, ПОДЛОГ (подменённая форма) и снятое прогоном
      # чтение. Набор сверяет на одной строке два разных утверждения: чтение
      # совпало — и подлог дал ДРУГОЙ ответ. Второе и есть отрицательный
      # контроль: правило, на подмене которого ответ не меняется, ничего не
      # проверяет, и набор называет его словами «правило не проверено».
      # `agreement.tsv` проверяет согласование в обе стороны: при «она» от
      # «смертен» ждут «смертна» и ОТВЕРГАЮТ «смертен», при «он» — наоборот.
      #
      # Подлог самого набора (план Forgery) сдвигает ожидания на строку вниз:
      # исправный набор обязан на этом покраснеть, и шаг падает ровно тогда,
      # когда он промолчал. Ключа `--на-веру` здесь нет и не нужно: все 51
      # утверждение модуля доказаны, сетки ноль.
      #
      # Место выбрано этим файлом, а не `ci.yml`: работа «CI» на GitHub
      # отключена вручную (`gh workflow list` — `disabled_manually`), и шаг,
      # поставленный туда, не прогонялся бы вовсе.
      - name: Probe russian morphology
        run: |
          if bootstrap/flang run-script ru-morphology:forgery; then
            echo "набор промолчал на подлоге — проверять им нечего" >&2
            exit 1
          fi
      - name: Check russian morphology
        run: bootstrap/flang run-script ru-morphology:probe
      - name: Check run verdict
        run: bootstrap/flang io flang/proof/probes/run/run.fscript --plan Binary
      - name: Check environment and argument orders
        run: bootstrap/flang io flang/proof/probes/orders/run.fscript --plan Binary
      - name: Check screen size
        run: bootstrap/flang io flang/proof/probes/screen-size/run.fscript --plan Binary
      - name: Check memory limit
        run: cd flang/proof/probes/memory-limit && ../../../../bootstrap/flang io run.fscript
        env:
          FLANG_BIN: ${{ github.workspace }}/bootstrap/flang
          FLANG_TMP: ${{ runner.temp }}

      - name: Check io timeout answers
        run: cd flang/proof/probes/io-timeout && ../../../../bootstrap/flang io run.fscript

      - name: Check module search root
        run: bootstrap/flang io flang/proof/probes/module-root/run.fscript
        env:
          FLANG_BIN: ${{ github.workspace }}/bootstrap/flang

      - name: Check non-negative field
        run: bootstrap/flang io flang/proof/probes/non-negative-field/run.fscript
        env:
          LC_ALL: C.UTF-8
          FLANG_BIN: ${{ github.workspace }}/bootstrap/flang

      - name: Check the exact integer type is in the compiler
        run: bootstrap/flang io flang/proof/probes/exact-integer/run.fscript --plan Binary

      - name: Check the exact fraction type is in the compiler
        run: bootstrap/flang io flang/proof/probes/exact-fraction/run.fscript --plan Binary

      # Цель без инструментов проба печатает со знаком «?» и на код возврата не
      # влияет, поэтому бегунок без go или dotnet её не валит. Зелёных столько,
      # сколько целей РЕАЛЬНО собрано и запущено, — число стоит в ИТОГЕ.
      - name: Check the exact integer adds beyond 2^53 in every print target
        run: cd flang/proof/probes/exact-integer-in-targets && ../../../../bootstrap/flang io run.fscript --timeout 180000
        env:
          LC_ALL: C.UTF-8

      - name: Check user programs are replayed by the checker
        run: cd flang/proof/probes/user-programs && ../../../../bootstrap/flang io run.fscript
        env:
          FLANG_TMP: ${{ runner.temp }}

      # ДВА НАБОРА НИЖЕ МЕРЯТ СЕМЯ, И ЭТОГО ИМ ДОВОЛЬНО. Обе беды живут в
      # замыкании компилятора (`corpus.flang`, `link.flang`), а не в оболочке
      # дерева, так что второй двоичный — как у работы `progony` ниже — им не
      # нужен: семя и дерево отвечают здесь одинаково. Отсюда и место: среди
      # дешёвых шагов, а не отдельной работой с девяностосекундной сборкой.
      - name: Check verdict surfaces of run blocks
        run: cd flang/proof/probes/run-verdict-surfaces && ../../../../bootstrap/flang io run.fscript --plan Binary
      - name: Check import list order
        run: cd flang/proof/probes/import-list-order && ../../../../bootstrap/flang io run.fscript --plan Binary

      # ПАМЯТЬ ВЫЗОВОВ ЯДРА НЕ СМЕЕТ МЕНЯТЬ ОТВЕТ, и до 4 октября 2026 этого не
      # спрашивал никто. Проба лежала в дереве с ветки задачи 5709 и не звалась
      # ниоткуда: ни работой, ни ярлыком, ни хуком, — на неё и краснела работа
      # `checks-nobody-calls` выключенного `ci.yml` (задача 5310).
      #
      # Место здесь, а не отдельной работой: двоичный уже собран, а все
      # двадцать её сестёр из `flang/proof/probes/**` стоят этими же шагами
      # выше. Зовём путём от корня, как сосед `plan-rules-asked`: пути
      # поручений проба считает от своего каталога, и `cd` ей не нужен.
      #
      # ЦЕНА НАЗВАНА, А НЕ СПРЯТАНА. Замер 4 октября 2026 на дереве 5604556ef,
      # двоичный 0.7.23, 256 ядер под чужой нагрузкой: 175,5 с, пик 0,36 ГиБ,
      # код 0, «kernel memo: runs 6, memo on and audit answer byte for byte as
      # memo off». Шесть прогонов `check --proof` на двух модулях stdlib при
      # FLANG_MEMO=0, =1 и =1 с пересчётом каждого попадания; ответы сверяются
      # кодом и выводом знак в знак. Работа `guards-selftest` на раннере идёт
      # 6 мин 47 с — 7 мин 01 с (заходы 37223001273 и 37223864296), и это
      # число на раннере не мерено: 175,5 с — пол, снятый на этой машине.
      #
      # ПОРОГ МОЛЧАНИЯ НАЗВАН, потому что умолчание хозяина (30 с) проба
      # перешагнула: 5 октября 2026 (заходы 37378258270 и 37378267607, дерево
      # с точным дробным) прогон `hashmap.flang` без памятки молчал дольше
      # 30 с, и хозяин оборвал его — FLANG_IO_TIMEOUT, код 3, «did not start».
      # На этой машине тот же прогон идёт 27 с: край, а не запас. Без памятки
      # ядро считает каждый вызов заново — это самый долгий из шести прогонов
      # по построению, и порог ему нужен выше умолчания. С порогом 600 с проба
      # здесь прошла за 174,0 с, пик 0,36 ГиБ, код 0 (6 октября 2026).
      - name: Check kernel memo does not change the answer
        run: bootstrap/flang io flang/proof/probes/kernel-memo/run.fscript --timeout 600000
        env:
          FLANG_BIN: ${{ github.workspace }}/bootstrap/flang

  # ── БЛОКИ «прогон»: НАЗВАНЫ ЧИСЛОМ ИЛИ ПРОХОДЯТ МОЛЧА (задача 1116) ───────
  #
  # ПОЧЕМУ ОТДЕЛЬНАЯ РАБОТА, А НЕ ШАГ У СОСЕДЕЙ ВЫШЕ. Эта проба собирает ВТОРОЙ
  # двоичный — из оболочки дерева (`flang/src/emit/c/flang_repl.c`) и логики
  # компилятора из семени, — потому что `bootstrap/flang` собран из КОПИИ этой
  # оболочки в семени и правку увидит только после перепечатки. Проба на
  # `bootstrap/flang` мерила бы семя, а не дерево: ровно та порода, из-за которой
  # «замер не в том дереве» стоит первым в списке того, что повторять нельзя.
  # Сборка — одна команда `cc` без `-flto` (замер на машине отряда 2 октября
  # 2026: 1 мин 10 с), и работа заводит её ДВАЖДЫ — на подлоге и начисто, — так
  # что держать её шагом в работе `storozha` с её потолком 20 минут нельзя.
  #
  # ЧТО СТОРОЖИТСЯ. `flang test` не исполняет блоки `прогон` (планировщик живёт в
  # `flang/self/conc.flang`, а этого слоя в двоичном нет — задача 1104) и до
  # 2 октября 2026 НЕ ГОВОРИЛ ОБ ЭТОМ НИЧЕГО: файл, у которого все ожидания в
  # блоках заведомо ложны, выходил кодом 0. Теперь блоки называются числом и код
  # 3 (ADR-0010: «сделано, но проверено не всё, и непроверенное названо»).
  #
  # ПЕРВЫЙ ШАГ — ПОДЛОГ, и он нужен не для порядка: проба, которая не умеет
  # краснеть, от чистого дерева неотличима. Подлог возвращает прежний код
  # возврата, оставляя строку о блоках на месте, — значит краснеет проба СВОИМ
  # предметом (кодом), а не сломанной сборкой.
  progony:
    name: runs-not-executed
    runs-on: ubuntu-latest
    timeout-minutes: 25
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      # Имена переменных — латиницей: POSIX не допускает кириллицу в именах
      # переменных оболочки.
      - name: Probe runs gate
        run: |
          set -u
          podlog=flang/src/emit/c/flang_repl.c
          staroe='      code = failed > 0 ? 1 : (runs > 0 ? 3 : 0);'
          novoe='      code = failed > 0 ? 1 : 0;'
          cp "$podlog" "$podlog.do"
          sed -i "s/$staroe/$novoe/" "$podlog"
          if cmp -s "$podlog.do" "$podlog"; then
            rm -f "$podlog.do"; git checkout -- "$podlog"
            echo "ПОДЛОГ НЕ СОБРАЛСЯ: строки с кодом 3 в $podlog нет — поправить подлог, проба ни при чём" >&2
            exit 1
          fi
          rm -f "$podlog.do"
          if bootstrap/flang io flang/proof/probes/runs-not-executed/run.fscript --plan Check --timeout 900000; then
            git checkout -- "$podlog"
            echo "проба промолчала на подлоге — проверять ею нечего" >&2
            exit 1
          fi
          git checkout -- "$podlog"
      - name: Check runs are named by number
        run: bootstrap/flang io flang/proof/probes/runs-not-executed/run.fscript --plan Check --timeout 900000

  # ── Дорогая половина: только тег и ручной запуск ──────────────────────────
  korpus:
    name: corpus-examples
    if: github.event_name == 'workflow_dispatch' || startsWith(github.ref, 'refs/tags/')
    runs-on: ubuntu-latest
    timeout-minutes: 180
    steps:
      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
      - name: Check verdict cache
        uses: ./.github/actions/release-without-cache
      # ── ДВОИЧНЫЙ БЕРЁТСЯ ГОТОВЫМ, ЕСЛИ ВХОДЫ СБОРКИ ТЕ ЖЕ ──────────────────
      #
      # 27 работ дерева собирали одно и то же заново. Ключ кеша — хеш ВСЕХ
      # входов сборки (`bootstrap/*.c`, `*.h`, `Makefile`) ПЛЮС сами флаги:
      # разойдись хоть один байт входа или флаг — ключ другой, и работа
      # собирает честно. Тихо взять чужой двоичный ключ не позволяет.
      #
      # ЧЕМ ЭТО МЕНЯЕТ ДОВЕРИЕ, И ЭТО НАДО СКАЗАТЬ. Раньше каждая работа
      # судила дерево двоичным, собранным ЕЮ ЖЕ. Теперь — двоичным, собранным
      # из тех же байтов входа в другой работе. Равенство входов проверяет
      # ключ, а равенство ВЫХОДА при равных входах проверено отдельно:
      # sha256 двоичного после двух независимых сборок совпал знак в знак.
      - name: Restore binary cache
        id: kesh-dvoichnogo
        uses: actions/cache@v4
        with:
          path: |
            bootstrap/flang
            bootstrap/libcompiler_flang.a
          key: flang-bootstrap-${{ runner.os }}-${{ hashFiles('bootstrap/*.c', 'bootstrap/*.h', 'bootstrap/Makefile') }}-${{ env.FLANG_CFLAGS }}
      - name: Build bootstrap
        if: steps.kesh-dvoichnogo.outputs.cache-hit != 'true'
        run: make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
      # Кеш мог отдать негодное: файл есть, а не запускается. Проверяем и
      # собираем честно, если так. Молчаливого «ну и ладно» здесь нет.
      - name: Verify cached binary
        if: steps.kesh-dvoichnogo.outputs.cache-hit == 'true'
        run: |
          set -u
          if ! ./bootstrap/flang --version >/dev/null 2>&1; then
            echo "::warning::двоичный из кеша не запускается — собираю заново"
            make -C bootstrap -j"$(nproc)" CFLAGS="$FLANG_CFLAGS"
          fi
      # Корпусный режим `flang test <каталог>` есть ТОЛЬКО у двоичного, и учить
      # ему что-то ещё незачем: он написан на самом flang
      # (`flang/self/bootstrap/corpus.flang`, 763 строки), и вторая реализация
      # этого слоя решений — ровно то, что из дерева только что удалили.
      #
      # Порога «ни одного провала» здесь нет намеренно: в дереве есть законные
      # провалы (выходы замера авторства писала модель). Ведомость строже
      # порога — она держит точное число прошедших и число СВОИХ примеров у
      # КАЖДОГО файла, и потеря файлом своих примеров краснеет диффом.
      - name: Run corpus examples
        run: sh flang/test/обход-примеров.sh

      # ── РАЗЛИЧИТЕЛЬНЫЙ ПОИСК: ядро против вычислителя ─────────────────────
      #
      # Порождает утверждения о функциях перебором — заведомо ложные вперемешку
      # с истинными — и на каждом сверяет вердикт `flang check --proof` с тем,
      # что говорит `flang run` на враждебных входах. Расхождение «доказано, а
      # нарушается» — дыра в состоятельности ядра, и работа краснеет.
      #
      # Место здесь, а не на каждом пуше: 454 утверждения и 2146 прогонов (пробы
      # идут только по 108 доказанным), двойник на flang гонит их по одной —
      # 16–17 мин на машине разработки (замер 10 сентября 2026). Это цена
      # глубокой сверки, и её место там же, где полный обход корпуса, — на теге
      # и на руке.
      - name: Run discriminating search
        run: LC_ALL=C.UTF-8 ./bootstrap/flang io flang/scripts/discriminating-search.fscript --plan 'Различительный поиск' --max-steps 2000000000 --max-orders 100000