@bridge4dev/runner 0.42.0 → 0.44.1

package/dist/recipe-schema.d.ts

@@ -51,14 +51,14 @@ export declare const ProjectRecipePreviewSchema: z.ZodObject<{
     run: string;
     url?: string | undefined;
     project?: string | undefined;
-    timeoutSec?: number | undefined;
     stop?: string | undefined;
+    timeoutSec?: number | undefined;
 }, {
     run: string;
     url?: string | undefined;
     project?: string | undefined;
-    timeoutSec?: number | undefined;
     stop?: string | undefined;
+    timeoutSec?: number | undefined;
 }>;
 export declare const ProjectRecipeSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodOptional<z.ZodLiteral<1>>>;
@@ -201,14 +201,14 @@ export declare const ProjectRecipeSchema: z.ZodObject<{
         run: string;
         url?: string | undefined;
         project?: string | undefined;
-        timeoutSec?: number | undefined;
         stop?: string | undefined;
+        timeoutSec?: number | undefined;
     }, {
         run: string;
         url?: string | undefined;
         project?: string | undefined;
-        timeoutSec?: number | undefined;
         stop?: string | undefined;
+        timeoutSec?: number | undefined;
     }>>;
     notes: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -244,8 +244,8 @@ export declare const ProjectRecipeSchema: z.ZodObject<{
         run: string;
         url?: string | undefined;
         project?: string | undefined;
-        timeoutSec?: number | undefined;
         stop?: string | undefined;
+        timeoutSec?: number | undefined;
     } | undefined;
     notes?: string | undefined;
     health?: {
@@ -258,8 +258,8 @@ export declare const ProjectRecipeSchema: z.ZodObject<{
         run: string;
         url?: string | undefined;
         project?: string | undefined;
-        timeoutSec?: number | undefined;
         stop?: string | undefined;
+        timeoutSec?: number | undefined;
     } | undefined;
     notes?: string | undefined;
     steps?: {

package/dist/regex-guard-hook.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=regex-guard-hook.d.ts.map

package/dist/regex-guard-hook.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * Исполняемый привратник шаблонов поиска — точка входа для хука `PreToolUse`.
+ *
+ * Claude Code присылает JSON в stdin и смотрит на код возврата:
+ *   0 — пропустить, 2 — заблокировать (stderr показывается модели).
+ *
+ * Здесь только ввод-вывод. Всё решение — в `hookDecision`, и оно покрыто тестами
+ * (`regex-guard.test.ts`), потому что проверять логику через запуск процесса
+ * дорого и хрупко.
+ *
+ * Зачем это существует и когда снимать — `regex-guard.ts` и
+ * `docs/plans/active/claude-code-regex-guard.md`.
+ */
+import { hookDecision } from './regex-guard.js';
+/**
+ * Потолок на чтение stdin.
+ *
+ * Хук стоит на пути каждой команды агента. Если Claude Code однажды не закроет
+ * поток, зависший привратник остановит работу вернее любого шаблона — поэтому
+ * молчание тоже считается поводом пропустить.
+ */
+const STDIN_TIMEOUT_MS = 5_000;
+async function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        const done = (value) => {
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => done(''), STDIN_TIMEOUT_MS);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => done(data));
+        process.stdin.on('error', () => done(''));
+    });
+}
+async function main() {
+    const decision = hookDecision(await readStdin());
+    if (decision.message)
+        process.stderr.write(`${decision.message}\n`);
+    process.exit(decision.exitCode);
+}
+// Любая непойманная ошибка — пропуск, а не блокировка. См. `hookDecision`.
+main().catch(() => process.exit(0));
+//# sourceMappingURL=regex-guard-hook.js.map

package/dist/regex-guard.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Привратник шаблонов поиска — защита от дефекта движка внутри Claude Code.
+ *
+ * Claude Code подменяет `grep` собственным `ugrep`, вшитым в бинарь. На шаблонах
+ * определённой формы этот движок съедает ~5.4 ГБ и ~67 секунд ПРИ РАЗБОРЕ ШАБЛОНА —
+ * до чтения файла, поэтому размер и содержимое данных ни на что не влияют
+ * (проверено: файл 18 МБ и файл 6 байт дают одинаковый пик).
+ *
+ * На дев-сервере это валит машину в своп, демон раннера перестаёт успевать
+ * отвечать на ping за отведённые 60 секунд (`RUNNER_PING_INTERVAL_MS` ×
+ * `RUNNER_PONG_MAX_MISSES`), и 504 прилетают ПО ВСЕМ сессиям машины сразу.
+ *
+ * Полный разбор, таблица замеров и признак инцидента — `docs/standards/project-gotchas.md` §345.
+ * План и границы применимости — `docs/plans/active/claude-code-regex-guard.md`.
+ *
+ * ВРЕМЕННАЯ МЕРА. Это обход чужого дефекта, а не его исправление. Когда движок
+ * починят — снять целиком (`claude-code-regex-guard.md` §3.3).
+ */
+/**
+ * Граница числового счётчика, начиная с которой шаблон считается опасным.
+ *
+ * Измеренный порог взрыва — ровно 20, во всех сочетаниях (два счётчика, счётчик
+ * рядом с `.*`, счётчики без верхней границы, счётчик над группой). Рост
+ * экспоненциальный, примерно вчетверо на каждые +2. Замеры для двух счётчиков
+ * (`x.{0,N}y.{0,N}z`): 16 — 377 МБ, 18 — 1560 МБ, 20 — взрыв на 5.4 ГБ; для
+ * `.*` плюс один счётчик — 16 — 204 МБ, 18 — 831 МБ. Таблица целиком в §345.
+ *
+ * Берём 16 — запас в две ступени экспоненты. Ниже опускать нет смысла:
+ * повседневные шаблоны (IP, дата, semver, hex) держатся в пределах 6.
+ */
+export declare const QUANTIFIER_DANGER_BOUND = 16;
+export interface PatternVerdict {
+    dangerous: boolean;
+    /** Человеческое объяснение с готовой заменой. Заполняется только при `dangerous`. */
+    reason?: string;
+}
+/**
+ * Взорвёт ли этот шаблон встроенный движок Claude Code?
+ *
+ * Условие (полностью выведено из замеров, см. §345):
+ *   есть счётчик с границей ≥ порога, применённый к ОДИНОЧНОМУ матчеру,
+ *   И в шаблоне есть ещё хотя бы один участок переменной длины.
+ *
+ * Одиночный счётчик безопасен при любом размере (`{0,5000}` — 14 МБ), шаблон
+ * без счётчиков безопасен при любом числе `.*` — взрыв даёт именно сочетание.
+ */
+export declare function inspectPattern(pattern: string): PatternVerdict;
+/**
+ * Опасен ли шаблон внутри команды оболочки?
+ *
+ * Сегмент разбирается целиком, а не выделенный из него аргумент: надёжно
+ * вычленить шаблон из произвольной команды нельзя (кавычки, подстановки), а
+ * форма `{n,m}` вне регулярного выражения почти не встречается. Ошибка в сторону
+ * осторожности здесь стоит одного лишнего круга диалога, ошибка в другую
+ * сторону — лежащего дев-сервера.
+ *
+ * Чего НЕ ловит намеренно: разорванное слово (`gr""ep`). Привратник защищает от
+ * случайного самострела, а не от умышленного обхода — и второй линией остаётся
+ * клетка сессии (`runner-memory-ceiling.md` §6).
+ */
+export declare function inspectBashCommand(command: string): PatternVerdict;
+/**
+ * Решение по тому, что прислал Claude Code в хук `PreToolUse`.
+ *
+ * Незнакомый инструмент и любой неожиданный вход — пропуск. Привратник обязан
+ * ошибаться в сторону «пропустить»: заблокированная по недоразумению работа
+ * агента дороже пропущенного шаблона, от которого есть вторая линия защиты
+ * (клетка сессии, `runner-memory-ceiling.md` §6).
+ */
+export declare function decideForTool(toolName: string, toolInput: unknown): PatternVerdict;
+export interface HookDecision {
+    /** 0 — пропустить, 2 — заблокировать (соглашение `PreToolUse` в Claude Code). */
+    exitCode: 0 | 2;
+    /** Текст в stderr; Claude Code показывает его модели. Пуст при пропуске. */
+    message: string;
+}
+/**
+ * Превращает полезную нагрузку хука в решение.
+ *
+ * ЛЮБАЯ неожиданность — пропуск. Привратник стоит на пути каждой команды агента,
+ * и его собственная ошибка не должна останавливать работу: пропущенный шаблон
+ * прикрыт второй линией (клеткой сессии), а привратник, блокирующий всё подряд
+ * из-за смены формата входа, останавливает разработку целиком.
+ */
+export declare function hookDecision(payload: string): HookDecision;
+//# sourceMappingURL=regex-guard.d.ts.map

package/dist/regex-guard.js

@@ -0,0 +1,359 @@
+/**
+ * Привратник шаблонов поиска — защита от дефекта движка внутри Claude Code.
+ *
+ * Claude Code подменяет `grep` собственным `ugrep`, вшитым в бинарь. На шаблонах
+ * определённой формы этот движок съедает ~5.4 ГБ и ~67 секунд ПРИ РАЗБОРЕ ШАБЛОНА —
+ * до чтения файла, поэтому размер и содержимое данных ни на что не влияют
+ * (проверено: файл 18 МБ и файл 6 байт дают одинаковый пик).
+ *
+ * На дев-сервере это валит машину в своп, демон раннера перестаёт успевать
+ * отвечать на ping за отведённые 60 секунд (`RUNNER_PING_INTERVAL_MS` ×
+ * `RUNNER_PONG_MAX_MISSES`), и 504 прилетают ПО ВСЕМ сессиям машины сразу.
+ *
+ * Полный разбор, таблица замеров и признак инцидента — `docs/standards/project-gotchas.md` §345.
+ * План и границы применимости — `docs/plans/active/claude-code-regex-guard.md`.
+ *
+ * ВРЕМЕННАЯ МЕРА. Это обход чужого дефекта, а не его исправление. Когда движок
+ * починят — снять целиком (`claude-code-regex-guard.md` §3.3).
+ */
+/**
+ * Граница числового счётчика, начиная с которой шаблон считается опасным.
+ *
+ * Измеренный порог взрыва — ровно 20, во всех сочетаниях (два счётчика, счётчик
+ * рядом с `.*`, счётчики без верхней границы, счётчик над группой). Рост
+ * экспоненциальный, примерно вчетверо на каждые +2. Замеры для двух счётчиков
+ * (`x.{0,N}y.{0,N}z`): 16 — 377 МБ, 18 — 1560 МБ, 20 — взрыв на 5.4 ГБ; для
+ * `.*` плюс один счётчик — 16 — 204 МБ, 18 — 831 МБ. Таблица целиком в §345.
+ *
+ * Берём 16 — запас в две ступени экспоненты. Ниже опускать нет смысла:
+ * повседневные шаблоны (IP, дата, semver, hex) держатся в пределах 6.
+ */
+export const QUANTIFIER_DANGER_BOUND = 16;
+/**
+ * Разбирает шаблон и собирает участки переменной длины.
+ *
+ * Синтаксис не уточняется намеренно: `-G` (basic) и `-E` (extended) отличаются
+ * тем, где стоит обратный слэш, а взрывается движок одинаково в обоих. Поэтому
+ * и `\{n,m\}`, и `{n,m}` считаются счётчиком — в сторону осторожности.
+ *
+ * Группы отслеживаются стеком: группа считается широкой, если широкий матчер
+ * встретился где-то в её теле, и эта ширина поднимается наружу — счётчик над
+ * группой наследует её.
+ */
+function scan(pattern) {
+    const parts = [];
+    /** Широк ли атом непосредственно слева — то, к чему относится следующий счётчик. */
+    let lastWide = false;
+    /** По одному флагу на открытую группу: встретился ли внутри широкий матчер. */
+    const groups = [];
+    let i = 0;
+    const markWide = () => {
+        lastWide = true;
+        if (groups.length > 0)
+            groups[groups.length - 1] = true;
+    };
+    const openGroup = () => {
+        groups.push(false);
+        lastWide = false;
+    };
+    const closeGroup = () => {
+        const wide = groups.pop() ?? false;
+        lastWide = wide;
+        if (wide && groups.length > 0)
+            groups[groups.length - 1] = true;
+    };
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        // Класс символов — проглатываем целиком, иначе его содержимое
+        // (`[{}]`, `[*+]`) прочтётся как синтаксис. Класс всегда широкий.
+        if (ch === '[') {
+            const end = classEnd(pattern, i);
+            if (end === null) {
+                // Незакрытая `[` — это литерал, а не класс. Проглотить остаток строки
+                // значило бы ослепить детектор на всё, что правее (QA MEDIUM-5:
+                // `awk -F'[' … | grep 'опасное'` проходил мимо).
+                lastWide = false;
+                i += 1;
+                continue;
+            }
+            markWide();
+            i = end;
+            continue;
+        }
+        if (ch === '\\') {
+            const next = pattern[i + 1];
+            if (next === undefined)
+                break;
+            if (next === 'Q') {
+                // `\Q…\E` — всё внутри литерал, синтаксиса там нет.
+                const stop = pattern.indexOf('\\E', i + 2);
+                i = stop < 0 ? pattern.length : stop + 2;
+                lastWide = false;
+                continue;
+            }
+            if (next === '{') {
+                i = readQuantifier(pattern, i + 2, parts, lastWide, true);
+                continue;
+            }
+            if (next === '+') {
+                parts.push({ bound: null, onWide: lastWide });
+                i += 2;
+                continue;
+            }
+            if (next === ')') {
+                closeGroup();
+                i += 2;
+                continue;
+            }
+            if (next === '(') {
+                openGroup();
+                i += 2;
+                continue;
+            }
+            if (next === 'w' ||
+                next === 's' ||
+                next === 'd' ||
+                next === 'W' ||
+                next === 'S' ||
+                next === 'D') {
+                markWide();
+                i += 2;
+                continue;
+            }
+            // Любой другой экранированный символ — обычный узкий атом.
+            lastWide = false;
+            i += 2;
+            continue;
+        }
+        if (ch === '{') {
+            const after = readQuantifier(pattern, i + 1, parts, lastWide, false);
+            // `readQuantifier` вернёт исходную позицию, если это не счётчик,
+            // а обычная фигурная скобка (например `function.*{.*}`).
+            if (after === i + 1) {
+                lastWide = false;
+                i += 1;
+                continue;
+            }
+            i = after;
+            continue;
+        }
+        if (ch === '*' || ch === '+') {
+            parts.push({ bound: null, onWide: lastWide });
+            i += 1;
+            continue;
+        }
+        if (ch === '(') {
+            openGroup();
+            i += 1;
+            continue;
+        }
+        if (ch === ')') {
+            closeGroup();
+            i += 1;
+            continue;
+        }
+        if (ch === '.') {
+            markWide();
+            i += 1;
+            continue;
+        }
+        lastWide = false;
+        i += 1;
+    }
+    return parts;
+}
+/**
+ * Конец класса символов `[...]`, с учётом `[]...]` и `[^]...]`.
+ * `null` — закрывающей скобки нет, то есть это была не скобка класса, а литерал.
+ */
+function classEnd(pattern, start) {
+    let i = start + 1;
+    if (pattern[i] === '^')
+        i += 1;
+    if (pattern[i] === ']')
+        i += 1; // первый `]` — литерал
+    while (i < pattern.length && pattern[i] !== ']') {
+        if (pattern[i] === '\\')
+            i += 1;
+        i += 1;
+    }
+    return i < pattern.length ? i + 1 : null;
+}
+/**
+ * Читает тело счётчика начиная с позиции после открывающей скобки.
+ * Возвращает позицию после закрывающей — или `start`, если это не счётчик.
+ */
+function readQuantifier(pattern, start, parts, onWide, escaped) {
+    let i = start;
+    let body = '';
+    while (i < pattern.length) {
+        if (escaped && pattern[i] === '\\' && pattern[i + 1] === '}')
+            break;
+        if (!escaped && pattern[i] === '}')
+            break;
+        body += pattern[i];
+        i += 1;
+    }
+    // Незакрытый счётчик — шаблон всё равно не скомпилируется, разбор не роняем.
+    if (i >= pattern.length)
+        return start;
+    // Только цифры и запятая. `{.*}` в `function.*{.*}` — не счётчик, а скобка.
+    if (!/^\d+(,\d*)?$/.test(body))
+        return start;
+    const [minText, maxText] = body.split(',');
+    const min = Number.parseInt(minText ?? '', 10);
+    // `{n,}` — верхней границы нет, но состояний всё равно не меньше n:
+    // измерено, `x.{20,}y.{20,}z` взрывается так же, как `{0,20}`.
+    const bound = maxText === undefined || maxText === '' ? min : Number.parseInt(maxText, 10);
+    parts.push({ bound: Number.isFinite(bound) ? bound : min, onWide });
+    return i + (escaped ? 2 : 1);
+}
+/**
+ * Взорвёт ли этот шаблон встроенный движок Claude Code?
+ *
+ * Условие (полностью выведено из замеров, см. §345):
+ *   есть счётчик с границей ≥ порога, применённый к ОДИНОЧНОМУ матчеру,
+ *   И в шаблоне есть ещё хотя бы один участок переменной длины.
+ *
+ * Одиночный счётчик безопасен при любом размере (`{0,5000}` — 14 МБ), шаблон
+ * без счётчиков безопасен при любом числе `.*` — взрыв даёт именно сочетание.
+ */
+export function inspectPattern(pattern) {
+    if (typeof pattern !== 'string')
+        return { dangerous: false };
+    const parts = scan(pattern);
+    const heavy = parts.filter((p) => p.onWide && p.bound !== null && p.bound >= QUANTIFIER_DANGER_BOUND);
+    if (heavy.length === 0 || parts.length < 2)
+        return { dangerous: false };
+    const worst = Math.max(...heavy.map((p) => p.bound ?? 0));
+    return {
+        dangerous: true,
+        reason: `Поиск остановлен: счётчик {…,${worst}} рядом с ещё одним участком переменной длины. ` +
+            `Встроенный в Claude Code движок на такой форме занимает ~5.4 ГБ и ~67 секунд ещё ` +
+            `на разборе шаблона — это роняет дев-сервер и рвёт связь по всем сессиям машины ` +
+            `(подробности: docs/standards/project-gotchas.md §345). ` +
+            `Повтори через «command grep» — системный grep обрабатывает этот шаблон нормально. ` +
+            `Либо уменьши границу счётчика ниже ${QUANTIFIER_DANGER_BOUND}.`,
+    };
+}
+/**
+ * `grep` как отдельное слово — то есть вызов, который перехватит функция-обёртка
+ * Claude Code.
+ *
+ * В класс-разделитель входят кавычки и обратный слэш. Это не педантизм: `\grep`,
+ * `'grep'` и `"grep"` подавляют раскрытие АЛИАСОВ, но функцию bash не минуют —
+ * проверено стендом с локальной `function grep`, вызов происходит во всех трёх
+ * случаях. А `\grep` — общеизвестный приём «обойти обёртку», и модель, только что
+ * получившая отказ, попробует именно его.
+ *
+ * `pgrep`, `zgrep` и `/usr/bin/grep` сюда НЕ попадают: обёртка подменяет только
+ * имя команды, а полный путь и другие имена уходят мимо неё.
+ */
+const BARE_GREP = /(^|[\s;&|(`$'"\\])grep\b/;
+/**
+ * Вызовы, которые до подменённой функции не доходят.
+ *
+ * Подмена в снимке оболочки Claude Code — это функция bash с именем `grep`
+ * (`function grep { … ARGV0=ugrep … }`). Её обходит всё, что запускает бинарь
+ * напрямую, минуя разрешение имён оболочки:
+ *
+ * - `command grep` — ровно то, что привратник советует в отказе; не пропускать
+ *   его значило бы завести совет в тупик;
+ * - `git grep` — своя реализация внутри git, к движку Claude Code отношения не имеет;
+ * - `xargs`, `sudo`, `exec`, `find -exec` — исполняют файл, а не функцию.
+ *
+ * Блокировать их незачем: дефекта там нет, а совет «повтори через command grep»
+ * был бы просто непонятным.
+ */
+const BYPASS = /(^|[\s;&|(`$'"\\])(command|git|sudo|xargs|exec)\s+grep\b|-exec\s+grep\b/g;
+/**
+ * Разделители команд в оболочке.
+ *
+ * Разбор посегментно, а не по всей строке целиком, решает сразу три беды:
+ * шаблон одной команды не приписывается другой; безобидный `| grep -c ERROR`
+ * после обойдённого `command grep` не возвращает модели тот же отказ, которому
+ * она уже последовала; и синтаксический мусор из соседней команды (незакрытая
+ * скобка в аргументе `awk`) не ослепляет разбор дальше по строке.
+ */
+const SEGMENT_SPLIT = /\|\||&&|[|;\n]/;
+/**
+ * Опасен ли шаблон внутри команды оболочки?
+ *
+ * Сегмент разбирается целиком, а не выделенный из него аргумент: надёжно
+ * вычленить шаблон из произвольной команды нельзя (кавычки, подстановки), а
+ * форма `{n,m}` вне регулярного выражения почти не встречается. Ошибка в сторону
+ * осторожности здесь стоит одного лишнего круга диалога, ошибка в другую
+ * сторону — лежащего дев-сервера.
+ *
+ * Чего НЕ ловит намеренно: разорванное слово (`gr""ep`). Привратник защищает от
+ * случайного самострела, а не от умышленного обхода — и второй линией остаётся
+ * клетка сессии (`runner-memory-ceiling.md` §6).
+ */
+export function inspectBashCommand(command) {
+    if (typeof command !== 'string')
+        return { dangerous: false };
+    for (const segment of command.split(SEGMENT_SPLIT)) {
+        // `eval "grep …"` исполняет содержимое строки как команду — заглядываем внутрь.
+        const remaining = segment.replace(BYPASS, '$1__bypassed__');
+        if (!BARE_GREP.test(remaining))
+            continue;
+        const verdict = inspectPattern(segment);
+        if (verdict.dangerous)
+            return verdict;
+    }
+    return { dangerous: false };
+}
+/**
+ * Решение по тому, что прислал Claude Code в хук `PreToolUse`.
+ *
+ * Незнакомый инструмент и любой неожиданный вход — пропуск. Привратник обязан
+ * ошибаться в сторону «пропустить»: заблокированная по недоразумению работа
+ * агента дороже пропущенного шаблона, от которого есть вторая линия защиты
+ * (клетка сессии, `runner-memory-ceiling.md` §6).
+ */
+export function decideForTool(toolName, toolInput) {
+    if (!toolInput || typeof toolInput !== 'object')
+        return { dangerous: false };
+    const input = toolInput;
+    if (toolName === 'Bash') {
+        return typeof input['command'] === 'string'
+            ? inspectBashCommand(input['command'])
+            : { dangerous: false };
+    }
+    // Инструмент Grep проверяется тем же правилом намеренно, хотя движок под ним
+    // может быть другим: цена перестраховки — один круг диалога, и она измерена
+    // как нулевая на повседневных шаблонах.
+    if (toolName === 'Grep') {
+        return typeof input['pattern'] === 'string'
+            ? inspectPattern(input['pattern'])
+            : { dangerous: false };
+    }
+    return { dangerous: false };
+}
+/**
+ * Превращает полезную нагрузку хука в решение.
+ *
+ * ЛЮБАЯ неожиданность — пропуск. Привратник стоит на пути каждой команды агента,
+ * и его собственная ошибка не должна останавливать работу: пропущенный шаблон
+ * прикрыт второй линией (клеткой сессии), а привратник, блокирующий всё подряд
+ * из-за смены формата входа, останавливает разработку целиком.
+ */
+export function hookDecision(payload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        return { exitCode: 0, message: '' };
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return { exitCode: 0, message: '' };
+    const { tool_name: toolName, tool_input: toolInput } = parsed;
+    if (typeof toolName !== 'string')
+        return { exitCode: 0, message: '' };
+    const verdict = decideForTool(toolName, toolInput);
+    return verdict.dangerous
+        ? { exitCode: 2, message: verdict.reason ?? '' }
+        : { exitCode: 0, message: '' };
+}
+//# sourceMappingURL=regex-guard.js.map

package/dist/supervisor.d.ts

@@ -377,6 +377,22 @@ export declare class Supervisor {
      * resolves them and a refusal puts exactly those records back in the queue —
      * the message is retired from disk only once an agent has it.
      */
+    /**
+     * Should this failed turn be retried by itself, and if so, arm it (#252, #257).
+     *
+     * Returns `true` when a retry is armed, and the caller must then emit NOTHING —
+     * a `turn_end{ok:false}` files the session as FAILED, which is terminal, and a
+     * session we intend to retry cannot be told it has ended.
+     *
+     * The owner's standing priority governs every branch here: «лучше, чтобы ретрай
+     * не сработал, чем сработал там, где не нужно». So this reads as a list of
+     * reasons to decline, and the permission is the last thing it reaches.
+     */
+    private armApiRetry;
+    /** Fire an armed retry — re-checking, at FIRE time, everything that could have changed. */
+    private runApiRetry;
+    /** Disarm a pending retry — always through here, so no timer is ever orphaned. */
+    private clearApiRetry;
     private deliverMessage;
     /**
      * Nothing could take the message: put it back where it came from.