devcontour-harness 0.1.0-alpha.13 → 0.1.0-alpha.18

package/lib/engine/runner.js

@@ -7,11 +7,13 @@ import { roleBinding, selectReviewer, mcpEnvironment, HarnessError, digestOf, co
 import { git } from "../environment/process.js";
 import { executionEnvironment, runSteps, withEnvironment } from "../environment/lifecycle.js";
 import { redactDeep } from "../environment/redaction.js";
-import { implementationOutputSchema, reviewOutputSchema } from "../agents/schemas.js";
+import { alreadySatisfiedReviewOutputSchema, implementationOutputSchema, reviewOutputSchema, } from "../agents/schemas.js";
 import { reviewInspection } from "../agents/inspect.js";
 import { reviewerRunsChecks } from "../agents/cli-adapter.js";
 import { gateProbePrompt, observeReproductions, probeCommand, probeGates, probeLimits, probeRecord, readProbeJournal, recoverProbeLog, probeTool, } from "../agents/review-probe.js";
 import { runGate } from "../verification/gates.js";
+import { orderedScope } from "../verification/gate-scope.js";
+import { alreadySatisfiedVerdict, contractCheckGates, withinWriteScope, } from "../verification/already-satisfied.js";
 import { assertDependencies, dependencyFreshness, removeSnapshots, snapshotDependencies, } from "../verification/dependencies.js";
 import { CleanupFailure, cleanupEnvironment } from "../environment/lifecycle.js";
 import { defaultResourceDatabase, withResources } from "../environment/resources.js";
@@ -19,31 +21,20 @@ import { REQUIREMENT_GATE, assertRequirements } from "../verification/requiremen
 import { BlockedError, classifyFailure } from "./classify.js";
 import { TaskFailure } from "./failure.js";
 import { prompt } from "./prompt.js";
-import { contractDocuments, orderCheckManifest } from "../verification/checks.js";
+import { contractDocuments, orderCheckManifest, referenceCodeNote, referenceSetFiles, setFileReference, } from "../verification/checks.js";
 import { CorpusStore, localRoots } from "../verification/corpus.js";
 import { submitCase } from "../verification/confirm.js";
 import { runSpike } from "../verification/spike.js";
-import { propertySeed } from "../verification/property.js";
+import { expectsReference, propertySeed } from "../verification/property.js";
 import { selfCheckNote, writeSelfCheck } from "../verification/self-check.js";
 import { measuredInvoke } from "./measured.js";
 import { continuableDraft, implementationBasis } from "./reuse.js";
-const ordered = (gates, ids) => {
-    const byId = new Map(gates.map((g) => [g.id, g]));
-    const out = [];
-    const seen = new Set();
-    const visit = (id) => {
-        // Псевдо-gate (актуальность требований) проверяется отдельно, а не командой.
-        if (seen.has(id) || !byId.has(id))
-            return;
-        seen.add(id);
-        for (const dep of byId.get(id)?.dependsOn ?? [])
-            if (ids.includes(dep))
-                visit(dep);
-        out.push(byId.get(id));
-    };
-    ids.forEach(visit);
-    return out;
-};
+/** Честный путь исполнителя, когда работу уже сделала зависимость. */
+const ALREADY_SATISFIED_WRITER_NOTE = 'Implement the task. Only if the work is verifiably already present on the base commit — a dependency of this task already changed the files of its write scope, or the approved check contract of this task already passes — leave the tree unchanged and report completed: true, naming the commit and the files in the summary. An unchanged tree is never accepted on a generic passing test alone: without such a basis it stops for the lead, and a wrong claim is an empty result.';
+/** Указание reviewer попытки без изменений (кандидат — база). */
+const ALREADY_SATISFIED_REVIEW_NOTE = 'The writer made no changes: the candidate is the base commit itself. Approve only if the acceptance criteria are already satisfied on it (for example, by a dependency). Then set "alreadySatisfied" to the ids of the gates of this task whose passing evidence on this SHA shows it — at least one test gate and every gate of the approved check contracts — and "evidence" to what in that evidence and in the code proves each criterion. Otherwise set approved: false and alreadySatisfied: null; the attempt is then an empty result.';
+/** Порядок области gates — общий с проверкой на SHA вне попытки (`orderedScope`). */
+const ordered = orderedScope;
 const within = (path, prefixes) => prefixes.some((p) => p === '.' || path === p || path.startsWith(p.endsWith('/') ? p : p + '/'));
 /**
  * Исполнитель очереди. Один действующий controller; попытка проходит
@@ -254,8 +245,12 @@ export class Runner {
     /** Штатная остановка: пауза `shutdown`, прерывание попыток, освобождение роли controller. */
     async stop() {
         this.engine.pause('shutdown');
-        for (const job of this.jobs.values())
+        // Прерванная остановкой попытка не упала: поручение вернётся в очередь
+        // и продолжится с кандидата или черновика (см. catch в `execute`).
+        for (const job of this.jobs.values()) {
+            job.shutdown = true;
             job.controller.abort();
+        }
         await Promise.all([...this.jobs.values()].map((j) => j.promise));
         this.release();
     }
@@ -371,7 +366,7 @@ export class Runner {
             binding,
             cwd: input.cwd,
             prompt: input.prompt,
-            outputSchema: review ? reviewOutputSchema : implementationOutputSchema,
+            outputSchema: input.outputSchema ?? (review ? reviewOutputSchema : implementationOutputSchema),
             session: { kind: 'fresh' },
             sandbox: {
                 mode: this.policy.isolation.mode,
@@ -465,7 +460,9 @@ export class Runner {
         return adapter;
     }
     /** Область записи кандидата: защищённые пути, пустой результат, выход за область поручения и роли. */
-    async assertScope(work, repo, cwd, context, range) {
+    async assertScope(work, repo, cwd, context, range, 
+    /** Пустой результат допустим (возможное «приёмка уже выполнена»): вернуть true вместо отказа. */
+    allowEmpty = false) {
         const changed = (await (range
             ? git(cwd, 'diff', '--no-renames', '--name-only', '-z', ...range)
             : git(cwd, 'diff', '--cached', '--no-renames', '--name-only', '-z')))
@@ -491,12 +488,34 @@ export class Runner {
         const forbidden = changed.filter((p) => within(p, protectedList));
         if (forbidden.length)
             throw new TaskFailure('scope-violation', `Изменены защищённые файлы: ${forbidden.join(', ')}`);
-        if (!changed.length)
+        // Ответы эталонных наборов лежат в рабочем дереве: изменённый код,
+        // который называет файл набора строковым литералом, читает эталон, а не
+        // решает. Тесты исполнителя (не артефакты контракта) проверяются так же:
+        // через них ответы тоже можно подать реализации.
+        const sets = this.engine.read((v) => referenceSetFiles(contractDocuments(work.order, v), repo.id));
+        if (sets.length) {
+            const named = [];
+            for (const path of changed) {
+                const text = await git(cwd, 'show', `${range ? range[1] : ''}:${path}`).catch(() => '');
+                if (text.length > 4 * 1024 * 1024)
+                    continue;
+                const hit = setFileReference(path, text, sets);
+                if (hit)
+                    named.push(`${path} → ${hit}`);
+            }
+            if (named.length)
+                throw new TaskFailure('scope-violation', `Реализация ссылается на файлы эталонных наборов: ${named.join(', ')}`);
+        }
+        if (!changed.length) {
+            if (allowEmpty)
+                return true;
             throw new TaskFailure('empty-result', 'Изменений нет: поручение отчиталось о выполнении пустым коммитом');
+        }
         const role = roleBinding(this.policy, work.order.role, work.order.repositoryId)?.writePaths;
         const outside = changed.filter((p) => !within(p, work.order.writeScope) || (role && !within(p, role)));
         if (outside.length)
             throw new TaskFailure('scope-violation', 'Изменены файлы вне области поручения/роли: ' + outside.join(', '));
+        return false;
     }
     /** Стадия попытки с замером: начало, конец и исход записываются под fencing. */
     async timed(attempt, stage, fn) {
@@ -757,6 +776,7 @@ export class Runner {
                                     notes: [
                                         ...this.notes(attempt, false),
                                         ...(await this.hostNotes(work, attempt, false)),
+                                        ALREADY_SATISFIED_WRITER_NOTE,
                                     ],
                                     // Открытые находки ревью с выданными ID — из истории
                                     // поручения; только когда reviewer ведёт протокол
@@ -771,14 +791,28 @@ export class Runner {
                             const result = implementationResultSchema.safeParse(response.output);
                             if (!result.success)
                                 throw new Error('Ответ исполнителя вне схемы: ' + result.error.issues[0]?.message);
+                            // Не доделано — свой класс: повтор продолжит с черновика,
+                            // а не остановится как неизвестный отказ.
                             if (!result.data.completed)
-                                throw new Error('Исполнитель сообщил о незавершённой работе');
+                                throw new TaskFailure('unfinished', 'Исполнитель сообщил о незавершённой работе: ' +
+                                    result.data.summary.slice(0, 500));
                             this.engine.heartbeat(attempt.id, attempt.token);
                             signal.throwIfAborted();
                             if ((await git(cwd, 'rev-parse', 'HEAD')) !== base)
                                 throw new TaskFailure('scope-violation', 'Исполнитель изменил HEAD; интеграцией владеет harness');
                             await git(cwd, 'add', '-A');
-                            await this.assertScope(work, repo, cwd, context);
+                            // Пустой результат — не отказ сразу: приёмку могла уже
+                            // выполнить зависимость. Кандидат — сама база (без
+                            // коммита); gates задачи на ней и подтверждение reviewer
+                            // (`alreadySatisfied`) решают, принять ли его.
+                            if (await this.assertScope(work, repo, cwd, context, undefined, true)) {
+                                await this.options.hooks?.implemented?.({
+                                    attempt,
+                                    output: result.data,
+                                    sha: base,
+                                });
+                                return base;
+                            }
                             await git(cwd, '-c', 'core.hooksPath=/dev/null', 'commit', '--no-gpg-sign', '-q', '-m', `${work.id}: ${work.order.title}`);
                             const committed = await git(cwd, 'rev-parse', 'HEAD');
                             await this.options.hooks?.implemented?.({
@@ -791,7 +825,13 @@ export class Runner {
                     rearm();
                     this.engine.phase(attempt.id, attempt.token, 'verifying', { candidateSha: sha });
                     for (const gate of gates)
-                        await this.gate(attempt, cwd, sha, 'candidate', gate, artifacts, signal, execution);
+                        await this.gate(attempt, cwd, sha, 'candidate', gate, artifacts, signal, execution).catch((error) => {
+                            // Без изменений непрошедший gate значит одно: работа не
+                            // сделана, — это пустой результат, а не дефект кода.
+                            if (sha !== base || !(error instanceof TaskFailure))
+                                throw error;
+                            throw new TaskFailure('empty-result', 'Изменений нет, а проверки задачи на базе не проходят: ' + error.message);
+                        });
                     this.requirements(attempt, work, repoPath, cwd, sha, 'candidate');
                     rearm();
                     this.engine.phase(attempt.id, attempt.token, 'reviewing');
@@ -825,6 +865,32 @@ export class Runner {
                 : error instanceof Error
                     ? error.message
                     : String(error);
+            // Штатная остановка оборвала попытку: что бы ни выбросила прерванная
+            // операция, это не отказ работы. Черновик сохраняется, поручение
+            // возвращается в очередь, бюджет попыток не тратится.
+            const shutdown = controller.signal.aborted && this.jobs.get(attempt.id)?.shutdown === true;
+            if (shutdown)
+                try {
+                    await this.keepDraft(attempt, await this.workOf(attempt), artifacts);
+                    const message = 'Попытку прервала штатная остановка controller; поручение возвращено в очередь и продолжится с кандидата или черновика';
+                    const failed = this.engine.fail(attempt.id, attempt.token, message, {
+                        kind: 'environment',
+                        interrupted: true,
+                    });
+                    // Интегрированную попытку движок в очередь не вернул: это обычный
+                    // отказ, и хост называет его причину.
+                    if (!failed.interrupted)
+                        await this.options.hooks?.failed?.({
+                            attempt,
+                            kind: 'environment',
+                            message: 'Штатная остановка прервала интегрированную попытку; нужна проверка recovery',
+                        });
+                    return;
+                }
+                catch {
+                    // Потерявшая владение попытка не публикует поздний отказ.
+                    return;
+                }
             try {
                 const kind = expired && !(error instanceof TaskFailure) ? 'timeout' : classifyFailure(error, message);
                 // Незакоммиченная работа сохраняется при любом отказе до кандидата:
@@ -990,6 +1056,10 @@ export class Runner {
         await this.timed(attempt, stage, () => this.runOneGate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer));
     }
     async runOneGate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer) {
+        // Генеративный gate — всегда; gate эталонных наборов — когда манифест
+        // поручения ждёт от него отчёта (без договора — прежний уровень).
+        const run = this.propertyRun(attempt, gate, consumer);
+        const property = gate.property || expectsReference(run.expected) ? run : undefined;
         await runGate({
             policy: this.policy,
             record: (e) => this.engine.evidence(attempt.id, attempt.token, e),
@@ -1004,7 +1074,7 @@ export class Runner {
             execution,
             boundary: this.boundary(consumer?.dependencies ?? attempt.dependencies),
             ...(consumer ? { consumer: consumer.repositoryId } : {}),
-            ...(gate.property ? { property: this.propertyRun(attempt, gate, consumer) } : {}),
+            ...(property ? { property } : {}),
         });
     }
     /**
@@ -1223,6 +1293,50 @@ export class Runner {
      * команды — засчитывается всем резервом, записанным до запуска, а его
      * пережившие процессы останавливаются (R3-F01).
      */
+    /**
+     * Решение по подтверждению «приёмка уже выполнена» (`alreadySatisfiedVerdict`).
+     * Основание по зависимости controller ищет сам: зависимость поручения,
+     * чей принятый результат входит в проверяемый SHA, а её собственный
+     * кандидат (база → кандидат) изменил файлы области записи поручения.
+     */
+    async alreadySatisfied(work, repoPath, sha, gates, claim) {
+        const { contractGates, dependencies } = this.engine.read((v) => ({
+            contractGates: contractCheckGates(contractDocuments(work.order, v)),
+            dependencies: work.order.dependsOn.flatMap((id) => {
+                const w = v.work(id);
+                const a = v
+                    .attempts(id)
+                    .findLast((x) => x.status === 'succeeded' && x.integrationSha === w?.resultSha);
+                return w?.resultSha && a?.baseSha && a.candidateSha && a.candidateSha !== a.baseSha
+                    ? [{ workId: id, resultSha: w.resultSha, base: a.baseSha, candidate: a.candidateSha }]
+                    : [];
+            }),
+        }));
+        let dependency;
+        for (const d of dependencies) {
+            const inBase = await git(repoPath, 'merge-base', '--is-ancestor', d.resultSha, sha)
+                .then(() => true)
+                .catch(() => false);
+            if (!inBase)
+                continue;
+            const paths = (await git(repoPath, 'diff', '--no-renames', '--name-only', '-z', d.base, d.candidate))
+                .split('\0')
+                .filter((p) => p && withinWriteScope(p, work.order.writeScope))
+                .slice(0, 50);
+            if (paths.length) {
+                dependency = { kind: 'dependency', workId: d.workId, sha: d.candidate, paths };
+                break;
+            }
+        }
+        return alreadySatisfiedVerdict({
+            scope: gates,
+            contractGates,
+            writeScope: work.order.writeScope,
+            dependsOn: work.order.dependsOn,
+            claim,
+            ...(dependency ? { dependency } : {}),
+        });
+    }
     async probeSpent(runs, repositoryId, phase) {
         let spent = 0;
         for (const runId of runs) {
@@ -1275,9 +1389,13 @@ export class Runner {
         const round = history.round + 1;
         // Запрос одинаков для всех вызовов логического ревью: меняется только
         // диагностика ошибки протокола.
+        // Попытка без изменений: кандидат — сама база. Принять её можно только
+        // по явному подтверждению reviewer, что приёмка уже выполнена.
+        const unchanged = phase === 'candidate' ? base === sha : attempt.candidateSha === attempt.baseSha;
         const notes = [
             ...this.notes(attempt, true, sha),
             ...(await this.hostNotes(work, attempt, true)),
+            ...(unchanged ? [ALREADY_SATISFIED_REVIEW_NOTE] : []),
         ];
         let issues = lastIssues;
         const stage = phase + '-review';
@@ -1340,6 +1458,7 @@ export class Runner {
                 ...(probe ? { probe: probe.server } : {}),
                 ...(legacy ? {} : { findings: requestFindings(history) }),
                 timeoutMs: remaining,
+                ...(unchanged ? { outputSchema: alreadySatisfiedReviewOutputSchema } : {}),
             }, signal);
             // Reviewer не меняет закреплённые зависимости, как и своё дерево.
             await assertDependencies(attempt.dependencies ?? []);
@@ -1481,6 +1600,7 @@ export class Runner {
                     {
                         property: r.property,
                         input: r.input,
+                        ...(r.inputClass?.trim() ? { inputClass: r.inputClass.trim().slice(0, 500) } : {}),
                         expected: r.expected,
                         actual: r.actual,
                         command: r.command,
@@ -1493,7 +1613,14 @@ export class Runner {
             });
             if (reproductions.length)
                 this.engine.recordReproductions(attempt.id, attempt.token, sha, reproductions);
-            const passed = verdict.result.approved;
+            // Без изменений одобрение засчитывается только с подтверждением
+            // `alreadySatisfied`, которое опирается на прошедшее evidence этой фазы.
+            const claim = verdict.result.alreadySatisfied ?? undefined;
+            const decision = unchanged && verdict.result.approved
+                ? await this.alreadySatisfied(work, this.repoPath(repo), sha, gates, claim)
+                : undefined;
+            const unconfirmed = decision && !decision.ok ? decision.problem : undefined;
+            const passed = verdict.result.approved && !unconfirmed;
             // Вердикт, новые находки с выданными ID и переходы прежних — одна запись
             // под fencing: попытка, утратившая владение, их не сохраняет.
             this.engine.evidence(attempt.id, attempt.token, {
@@ -1507,7 +1634,17 @@ export class Runner {
                 exitCode: passed ? 0 : 1,
                 log,
                 digest,
-                summary: redact(`[${inspection.mode}] ${record.summary}`).slice(0, 4000),
+                summary: redact(`[${inspection.mode}] ${record.summary}` +
+                    (unconfirmed ? ` (не подтверждено, что приёмка уже выполнена: ${unconfirmed})` : '')).slice(0, 4000),
+                ...(unchanged && passed && claim && decision?.ok
+                    ? {
+                        alreadySatisfied: {
+                            gates: claim.gates,
+                            evidence: redact(claim.evidence).slice(0, 4000),
+                            basis: decision.basis,
+                        },
+                    }
+                    : {}),
                 findings: (record.findings ?? []).map((f, i) => ({
                     severity: f.severity,
                     message: f.message,
@@ -1532,10 +1669,21 @@ export class Runner {
                     .map((f) => f.reproduction?.property)
                     .filter((p) => !!p);
                 const declared = new Set(work.order.properties ?? []);
-                throw new TaskFailure('review', 'Независимое ревью отклонило результат: ' + redact(record.summary), named.length
+                // Без изменений отказ ревью — пустой результат: работа не сделана.
+                if (unchanged)
+                    throw new TaskFailure(decision && !decision.ok ? decision.kind : 'empty-result', unconfirmed
+                        ? 'Изменений нет, и ревью не подтвердило, что приёмка уже выполнена: ' + unconfirmed
+                        : 'Изменений нет, и ревью не подтвердило, что приёмка уже выполнена: ' +
+                            redact(record.summary));
+                // Класс входов — из замаскированной записи: он попадает в состояние.
+                const classes = inputClassesOf(record.findings ?? []);
+                const pairs = classifiedOf(record.findings ?? []);
+                throw new TaskFailure('review', 'Независимое ревью отклонило результат: ' + redact(record.summary), named.length || classes.length
                     ? {
                         bound: [...new Set(named.filter((p) => declared.has(p)))],
                         unbound: [...new Set(named.filter((p) => !declared.has(p)))],
+                        ...(classes.length ? { classes } : {}),
+                        ...(pairs.length ? { pairs } : {}),
                     }
                     : undefined);
             }
@@ -1588,12 +1736,13 @@ export class Runner {
             // Воспроизведения прошлых ревью — входы, на которых поручение уже
             // ломалось. Диагностика: gate они не расширяют.
             if (reproductions.length)
-                out.push('Reproductions recorded by earlier reviews of this work order (diagnostic, not a gate; "observed" means the controller saw the reviewer run the command). Check the change against each input: ' +
+                out.push('Reproductions recorded by earlier reviews of this work order (diagnostic, not a gate; "observed" means the controller saw the reviewer run the command). Check the change against each input, and fix the whole inputClass it names rather than the single instance: ' +
                     JSON.stringify(reproductions
                         .slice(-20)
-                        .map(({ property, input, expected, actual, command, observed, runs }) => ({
+                        .map(({ property, input, inputClass, expected, actual, command, observed, runs }) => ({
                         property,
                         input,
+                        ...(inputClass ? { inputClass } : {}),
                         expected,
                         actual,
                         command,
@@ -1602,11 +1751,14 @@ export class Runner {
                     }))));
             // Согласованные контракты поручения — их текстом, по закреплённому digest.
             const contracts = contractDocuments(v.work(attempt.workId).order, v);
+            const sets = referenceCodeNote(referenceSetFiles(contracts), review);
+            if (sets)
+                out.push(sets);
             if (contracts.length)
                 out.push('Approved contracts: ' +
                     JSON.stringify(contracts.map((c) => ({ id: c.id, title: c.title, content: c.content }))));
             if (review)
-                out.push('When a finding fails on a concrete input, fill reproduction: property (the testId or acceptance criterion it violates), input (the exact input as JSON text), expected and actual, and command (argv) that shows it. If you ran it through the controller check tool, set run to the runId it returned and executed=true; the controller confirms the run from its own log and records the command that actually ran. Otherwise run=null and it is a hypothesis. Use null for findings without such an input.');
+                out.push('When a finding fails on a concrete input, fill reproduction: property (the testId or acceptance criterion it violates; required for a blocking finding), input (the exact input as JSON text), inputClass (the class of inputs this one belongs to: the generator or family that produces such failures, e.g. "ties between equal optima with more than 6 items", not the instance itself; required for a blocking finding), expected and actual, and command (argv) that shows it. If you ran it through the controller check tool, set run to the runId it returned and executed=true; the controller confirms the run from its own log and records the command that actually ran. Otherwise run=null and it is a hypothesis. Use null for findings without such an input.');
             // Reviewer видит, что controller сам записал о проверяемом SHA: gates и
             // их итоги, а не пересказ исполнителя.
             if (review && sha) {
@@ -1842,3 +1994,24 @@ function startedCalls(view, repositoryId, runId, stage) {
                 (r.outcome === 'active' ? Math.max(0, Date.now() - Date.parse(r.startedAt)) : 0)), 0),
     };
 }
+/** Свойство и класс одной блокирующей находки: оба названы. */
+function classifiedOf(findings) {
+    const out = new Map();
+    for (const f of findings) {
+        const property = f.reproduction?.property?.trim();
+        const inputClass = f.reproduction?.inputClass?.trim();
+        if (f.severity !== 'blocking' || !property || !inputClass)
+            continue;
+        const pair = { property: property.slice(0, 200), inputClass: inputClass.slice(0, 500) };
+        out.set(JSON.stringify(pair), pair);
+    }
+    return [...out.values()].slice(0, 20);
+}
+/** Классы входов блокирующих находок: без пустых и повторов, в пределах записи попытки. */
+function inputClassesOf(findings) {
+    const classes = findings.flatMap((f) => {
+        const c = f.severity === 'blocking' ? f.reproduction?.inputClass?.trim() : undefined;
+        return c ? [c.slice(0, 500)] : [];
+    });
+    return [...new Set(classes)].slice(0, 20);
+}

package/lib/explain/state.js

@@ -1,6 +1,6 @@
 import { HarnessError } from "../contracts/errors.js";
-import { repairPolicy } from "../contracts/repair-policy.js";
-import { repairDecision } from "../engine/repair.js";
+import { MAX_NEUTRAL_FAILURES, repairPolicy } from "../contracts/repair-policy.js";
+import { acceptanceGap, repairDecision } from "../engine/repair.js";
 const phaseOf = {
     running: 'implementation',
     verifying: 'gates',
@@ -295,6 +295,8 @@ function outlookOf(v, graphId, repairsUsed, options, control, budgetHeld) {
             : rule.repeats + 1;
         const retry = rule.action === 'retry' &&
             identical - 1 < rule.repeats &&
+            !acceptanceGap(v, w) &&
+            (w.neutralFailures ?? 0) < MAX_NEUTRAL_FAILURES &&
             w.attempt < options.maxAttempts &&
             used + i < options.repairBudget;
         if (!retry)

package/lib/index.d.ts

@@ -31,8 +31,8 @@ export { callDurationMs, callRecords, usageTotals } from './engine/usage.ts';
  * ожидаемая проверка поручения, сверка отчёта свойств, закреплённые версии
  * корпуса, подтверждение примера эталоном и переносимая форма корпуса.
  */
-export { contractDocuments, declarationProblems, corpusBindingHolds, effectiveChecks, orderCheckManifest, orderPropertyProblems, suiteBasis, } from './verification/checks.ts';
-export { corpusWitness, manifestDigest, propertyCoverage, propertyFailure, propertySeed, readPropertyReport, type CheckManifest, } from './verification/property.ts';
+export { contractDocuments, declarationProblems, corpusBindingHolds, effectiveChecks, isReference, obligationGates, orderCheckManifest, orderPropertyProblems, referenceCodeNote, referenceNote, referenceSetFiles, setFileReference, suiteBasis, } from './verification/checks.ts';
+export { corpusWitness, expectsReference, manifestDigest, propertyCoverage, propertyFailure, propertySeed, readPropertyReport, type CheckManifest, } from './verification/property.ts';
 export { CorpusStore, canonicalJson, caseId, corpusFile, parseCanonical, versionOf, portableSuite, scrubLocalPaths, scrubPortable, verifySuite, type PortableSuite, } from './verification/corpus.ts';
 export { caseHooks, caseInputSchema, staleArtifacts, submitCase, type CaseRequest, type ConfirmContext, } from './verification/confirm.ts';
 export { assertResult, pinnedCorpus, propertyProofProblem, resultProblems, type ReceiverContext, type ReceiverPolicy, } from './verification/acceptance.ts';
@@ -51,18 +51,20 @@ export { builtinProfiles, builtinProfilesRoot, profilePin, profileRoles, reposit
  * маскирование и ограниченный разбор по свойству.
  */
 export { WorkflowQueue, GRAPH_STAGES, type WorkflowSubjects } from './control/workflow.ts';
-export { repairDecision, type RepairDecision } from './engine/repair.ts';
+export { acceptanceGap, repairDecision, type AcceptanceGap, type RepairDecision, } from './engine/repair.ts';
 export { technicalReview, type TechnicalReviewInput } from './control/review.ts';
 export { JointRunner, type JointRunnerOptions } from './engine/joint-runner.ts';
 export { moveBase, fencedRefMove, type BaseMoved, type RefMove } from './control/base-move.ts';
 export { junitSummary, prepareReportPath, runCheck, runGate, sandboxBlockedHosts, type GateRun, } from './verification/gates.ts';
+export { runGatesAt, type GatesAtContext, type GatesAtInput, type GatesAtResult, } from './verification/gates-at.ts';
+export { explicitPrerequisites, gatePrerequisites, orderedScope, standaloneScope, } from './verification/gate-scope.ts';
 export { requirementProof, uncoveredGates, unprovenReason } from './verification/proof.ts';
 export { ReviewProbes, probeLimits, observeReproductions } from './agents/review-probe.ts';
 export { composeRedactors, outputRedactor, redactDeep, redactError, redactor, type Redactor, } from './environment/redaction.ts';
 export { closeIfBasisChanged } from './engine/property-recovery.ts';
 export { analyzeRecovery, applyCases, recoveryBrief, recoveryOutputSchema, recoveryResultSchema, } from './control/recovery.ts';
 export { BlockedError, classifyFailure, providerRefusal } from './engine/classify.ts';
-export { TaskFailure, failureFingerprint, repairPolicy, type RepairRule, } from './engine/failure.ts';
+export { TaskFailure, failureFingerprint, repairPolicy, MAX_NEUTRAL_FAILURES, type RepairRule, } from './engine/failure.ts';
 export * from './projections/index.ts';
 export { inspectPath, checkDestination, listRegularFiles, planFileWrites, applyFileWrites, type FileConflict, type FileIntent, type FileWriteInput, type FilePlanEntry, type FilePlan, } from './setup/files.ts';
 export { initProject, readProjectManifest, defaultStateDir, projectIdOf, type InitOptions, type InitData, } from './init/project.ts';

package/lib/index.js

@@ -31,8 +31,8 @@ export { callDurationMs, callRecords, usageTotals } from "./engine/usage.js";
  * ожидаемая проверка поручения, сверка отчёта свойств, закреплённые версии
  * корпуса, подтверждение примера эталоном и переносимая форма корпуса.
  */
-export { contractDocuments, declarationProblems, corpusBindingHolds, effectiveChecks, orderCheckManifest, orderPropertyProblems, suiteBasis, } from "./verification/checks.js";
-export { corpusWitness, manifestDigest, propertyCoverage, propertyFailure, propertySeed, readPropertyReport, } from "./verification/property.js";
+export { contractDocuments, declarationProblems, corpusBindingHolds, effectiveChecks, isReference, obligationGates, orderCheckManifest, orderPropertyProblems, referenceCodeNote, referenceNote, referenceSetFiles, setFileReference, suiteBasis, } from "./verification/checks.js";
+export { corpusWitness, expectsReference, manifestDigest, propertyCoverage, propertyFailure, propertySeed, readPropertyReport, } from "./verification/property.js";
 export { CorpusStore, canonicalJson, caseId, corpusFile, parseCanonical, versionOf, portableSuite, scrubLocalPaths, scrubPortable, verifySuite, } from "./verification/corpus.js";
 export { caseHooks, caseInputSchema, staleArtifacts, submitCase, } from "./verification/confirm.js";
 export { assertResult, pinnedCorpus, propertyProofProblem, resultProblems, } from "./verification/acceptance.js";
@@ -51,11 +51,13 @@ export { builtinProfiles, builtinProfilesRoot, profilePin, profileRoles, reposit
  * маскирование и ограниченный разбор по свойству.
  */
 export { WorkflowQueue, GRAPH_STAGES } from "./control/workflow.js";
-export { repairDecision } from "./engine/repair.js";
+export { acceptanceGap, repairDecision, } from "./engine/repair.js";
 export { technicalReview } from "./control/review.js";
 export { JointRunner } from "./engine/joint-runner.js";
 export { moveBase, fencedRefMove } from "./control/base-move.js";
 export { junitSummary, prepareReportPath, runCheck, runGate, sandboxBlockedHosts, } from "./verification/gates.js";
+export { runGatesAt, } from "./verification/gates-at.js";
+export { explicitPrerequisites, gatePrerequisites, orderedScope, standaloneScope, } from "./verification/gate-scope.js";
 export { requirementProof, uncoveredGates, unprovenReason } from "./verification/proof.js";
 export { ReviewProbes, probeLimits, observeReproductions } from "./agents/review-probe.js";
 export { composeRedactors, outputRedactor, redactDeep, redactError, redactor, } from "./environment/redaction.js";
@@ -64,7 +66,7 @@ export { analyzeRecovery, applyCases, recoveryBrief, recoveryOutputSchema, recov
 // Классы отказов и правила отказов: хост бросает их из своих хуков и
 // читает класс отказа попытки теми же правилами, что и движок.
 export { BlockedError, classifyFailure, providerRefusal } from "./engine/classify.js";
-export { TaskFailure, failureFingerprint, repairPolicy, } from "./engine/failure.js";
+export { TaskFailure, failureFingerprint, repairPolicy, MAX_NEUTRAL_FAILURES, } from "./engine/failure.js";
 export * from "./projections/index.js";
 export { inspectPath, checkDestination, listRegularFiles, planFileWrites, applyFileWrites, } from "./setup/files.js";
 export { initProject, readProjectManifest, defaultStateDir, projectIdOf, } from "./init/project.js";

package/lib/projections/stop.d.ts

@@ -6,7 +6,7 @@ import type { Actor, FailureKind, NextAction, PauseReason, WorkStatus } from './
  * (его ставит classifyFailure в точке отказа), текст здесь не разбирается.
  */
 export declare function stopCodeOf(kind: FailureKind | undefined): ErrorCode;
-export declare const stopCauses: readonly ["provider-auth", "environment", "timeout", "stale-base", "empty-result", "scope-violation", "gate", "review", "review-protocol", "merge", "cancelled", "budget", "unknown", "runtime-missing", "controller-busy", "operator-pause", "approval-required", "not-ready"];
+export declare const stopCauses: readonly ["provider-auth", "environment", "timeout", "stale-base", "empty-result", "unfinished", "scope-violation", "gate", "review", "review-protocol", "merge", "cancelled", "budget", "needs-lead", "unknown", "runtime-missing", "controller-busy", "operator-pause", "approval-required", "not-ready"];
 export type StopCause = (typeof stopCauses)[number];
 export declare const stopPhases: readonly ["preflight", "claim", "implementation", "gates", "review", "integration", "delivery"];
 export type StopPhase = (typeof stopPhases)[number];

package/lib/projections/stop.js

@@ -13,6 +13,8 @@ export function stopCodeOf(kind) {
             return 'GATE_FAILED';
         case 'review':
             return 'REVIEW_REJECTED';
+        case 'needs-lead':
+            return 'APPROVAL_REQUIRED';
         case 'review-protocol':
             return 'REVIEW_PROTOCOL_INVALID';
         case 'scope-violation':
@@ -38,6 +40,7 @@ export const stopCauses = [
     'timeout',
     'stale-base',
     'empty-result',
+    'unfinished',
     'scope-violation',
     'gate',
     'review',
@@ -45,6 +48,7 @@ export const stopCauses = [
     'merge',
     'cancelled',
     'budget',
+    'needs-lead',
     'unknown',
     'runtime-missing',
     'controller-busy',
@@ -68,6 +72,7 @@ const causeText = {
     timeout: 'Попытка исчерпала отведённое время.',
     'stale-base': 'База прогонов отстала от рабочей ветки.',
     'empty-result': 'Исполнитель отчитался о выполнении, не изменив ни одного файла.',
+    unfinished: 'Исполнитель не доделал работу и сообщил об этом.',
     'scope-violation': 'Изменения вышли за область поручения или роли.',
     gate: 'Настроенная проверка не прошла.',
     review: 'Независимое ревью отклонило результат.',
@@ -75,6 +80,7 @@ const causeText = {
     merge: 'Слияние с веткой интеграции не сошлось.',
     cancelled: 'Работа отменена человеком.',
     budget: 'Бюджет расходов или времени исчерпан либо не определён.',
+    'needs-lead': 'Пустой результат без механического основания считать работу сделанной: решение ведущего.',
     unknown: 'Класс отказа не определён.',
     'runtime-missing': 'Назначенный политикой runtime не найден или не отвечает на --version.',
     'controller-busy': 'Очередь ведёт другой процесс controller.',
@@ -89,6 +95,8 @@ const failurePhase = {
     timeout: 'implementation',
     unknown: 'implementation',
     'empty-result': 'implementation',
+    unfinished: 'implementation',
+    'needs-lead': 'review',
     gate: 'gates',
     review: 'review',
     'review-protocol': 'review',
@@ -262,6 +270,14 @@ function workOutcome(input, retry) {
                     actor: 'user',
                     action: 'fix-environment',
                 };
+            case 'needs-lead':
+                return {
+                    code: stopCodeOf(kind),
+                    cause: kind,
+                    phase,
+                    actor: 'lead',
+                    action: 'diagnose-failure',
+                };
             case 'review-protocol':
             case 'unknown':
                 return {