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

package/lib/engine/engine.js

@@ -3,9 +3,10 @@ import { roleBinding, executionDigest, HarnessError, WORKSPACE_OWNER, MAX_REPROD
 import { HARNESS_VERSION } from "../package.js";
 import { assertBudget, blockingBudget, budgetOverview, callAttribution, callBudgets, legacyGroupCall, workBudgets, } from "./budget.js";
 import { callDurationMs, callOwner, callRecords, ownerGone } from "./usage.js";
-import { failureFingerprint, repairPolicy } from "./failure.js";
+import { MAX_NEUTRAL_FAILURES, failureFingerprint, repairPolicy } from "./failure.js";
 import { reusableImplementation } from "./reuse.js";
 import { uncoveredGates, unprovenReason } from "../verification/proof.js";
+import { alreadySatisfiedVerdict, contractCheckGates } from "../verification/already-satisfied.js";
 import { contractDocuments, corpusBindingHolds, effectiveChecks, episodeBasis, orderPropertyProblems, } from "../verification/checks.js";
 import { afterFailure, afterSuccess, blocksClaim, closeIfBasisChanged, } from "./property-recovery.js";
 import { REQUIREMENT_GATE } from "../verification/requirements.js";
@@ -22,6 +23,16 @@ const contentDigest = (order) => digestOf({ ...order, source: { connector: order
  * решения неразделимы. Хост может только добавить запрет (`HostGuards`) и
  * дать основания (`BasisProvider`); снять отказ движка он не может.
  */
+/**
+ * Отказ, который ничего не говорит о работе, бюджет попыток поручения не
+ * тратит: окружение или провайдер не дали исполнить или проверить её.
+ * Бесконечного цикла это не открывает: такие отказы держат выдачу
+ * (`repairPolicy.blocksQueue`), а повтор ограничен пределом одинаковых
+ * отпечатков и общим бюджетом восстановлений.
+ */
+const uncounted = (kind, blocked) => blocked || kind === 'environment' || kind === 'provider-auth';
+/** Поручение исчерпало предел незасчитанных отказов: повтор — только со сбросом. */
+export const neutralExhausted = (w) => (w.neutralFailures ?? 0) >= MAX_NEUTRAL_FAILURES;
 export class Engine {
     host;
     policy;
@@ -768,6 +779,8 @@ export class Engine {
                     return false;
                 if (w.attempt >= this.policy.maxAttempts)
                     return false;
+                if (neutralExhausted(w))
+                    return false;
                 const graph = tx.graph(w.graphId);
                 // Согласование привязано к graph digest и к политике, под которой оно дано.
                 if (!graph?.approval || graph.approval.digest !== graph.digest)
@@ -1193,6 +1206,45 @@ export class Engine {
             for (const phase of ['candidate', 'integration'])
                 if (!last('review', phase, phase === 'candidate' ? a.candidateSha : sha, 'independent-review'))
                     throw new HarnessError('REVIEW_REJECTED', `Нет независимого ревью: ${phase}`);
+            // Попытка без изменений (кандидат — база) принимается только с
+            // подтверждением reviewer обеих фаз, что приёмка уже выполнена.
+            if (a.candidateSha === a.baseSha)
+                for (const phase of ['candidate', 'integration']) {
+                    const decisive = a.evidence.findLast((e) => e.kind === 'review' &&
+                        e.phase === phase &&
+                        e.sha === (phase === 'candidate' ? a.candidateSha : sha) &&
+                        e.gate === 'independent-review' &&
+                        e.consumer === undefined &&
+                        (!a.checks || e.checks === a.checks.effective));
+                    const confirmed = decisive?.alreadySatisfied;
+                    // Правило повторяется целиком по записанному: область задачи,
+                    // договор поручения и основание по зависимости, сверенное с её
+                    // принятой попыткой.
+                    const basis = confirmed?.basis;
+                    const dependency = basis?.kind === 'dependency' &&
+                        tx
+                            .attempts(basis.workId)
+                            .some((x) => x.status === 'succeeded' &&
+                            x.candidateSha === basis.sha &&
+                            x.candidateSha !== x.baseSha &&
+                            tx.work(basis.workId)?.resultSha === x.integrationSha)
+                        ? basis
+                        : undefined;
+                    const repo = this.repository(a.repositoryId);
+                    const verdict = confirmed
+                        ? alreadySatisfiedVerdict({
+                            scope: repo.gates.filter((g) => (a.requiredGates ?? []).includes(g.id)),
+                            contractGates: contractCheckGates(contractDocuments(w.order, tx)),
+                            writeScope: w.order.writeScope,
+                            dependsOn: w.order.dependsOn,
+                            claim: { gates: confirmed.gates, evidence: confirmed.evidence },
+                            ...(dependency ? { dependency } : {}),
+                        })
+                        : undefined;
+                    if (!verdict?.ok)
+                        throw new HarnessError('REVIEW_REJECTED', `Изменений нет, а ревью ${phase} не подтвердило, что приёмка уже выполнена` +
+                            (verdict ? ': ' + verdict.problem : ''));
+                }
             // Проверки потребителей — на integration, против интегрированного
             // результата: evidence потребителя закрывает только его проверку.
             for (const consumer of a.consumers ?? []) {
@@ -1283,9 +1335,13 @@ export class Engine {
                     : undefined;
             const shown = prefix ? `${prefix}. ${error}` : error;
             const blocked = Boolean(options.blocked);
+            const interrupted = Boolean(options.interrupted) && !a.integrationSha && !!w.approvedDigest;
             // Свойство отказа — только объявленное поручением: неизвестное
             // сохраняется для разбора, но счётчик эпизода не выбирает.
             const declared = new Set(w.order.properties ?? []);
+            const pairs = (options.properties?.pairs ?? [])
+                .filter((p) => !declared.has(p.property))
+                .slice(0, 20);
             const bound = [...new Set((options.properties?.bound ?? []).filter((p) => declared.has(p)))];
             const unbound = [
                 ...new Set([
@@ -1303,6 +1359,12 @@ export class Engine {
                 finishedAt: iso(this.now()),
                 ...(bound.length ? { properties: bound } : {}),
                 ...(unbound.length ? { unboundProperties: unbound } : {}),
+                ...(options.properties?.classes?.length
+                    ? { inputClasses: options.properties.classes.slice(0, 20) }
+                    : {}),
+                // Пары по объявленным свойствам ведёт эпизод разбора, не пробел приёмки.
+                ...(pairs.length ? { classified: pairs } : {}),
+                ...(interrupted ? { interrupted: 'shutdown' } : {}),
             };
             tx.putAttempt(failed);
             const next = structuredClone(w);
@@ -1312,12 +1374,26 @@ export class Engine {
                 this.recoveryEvent(tx, w, episode);
             tx.putWork({
                 ...next,
-                status: 'failed',
-                failure: shown,
-                failureKind: kind,
-                failureFingerprint: fingerprint,
+                // Прерванная остановкой работа не упала: она снова в очереди.
+                ...(interrupted
+                    ? {
+                        status: 'ready',
+                        failure: undefined,
+                        failureKind: undefined,
+                        failureFingerprint: undefined,
+                    }
+                    : {
+                        status: 'failed',
+                        failure: shown,
+                        failureKind: kind,
+                        failureFingerprint: fingerprint,
+                    }),
                 activeRunId: undefined,
-                attempt: blocked && w.attempt > 0 ? w.attempt - 1 : w.attempt,
+                attempt: (interrupted || uncounted(kind, blocked)) && w.attempt > 0 ? w.attempt - 1 : w.attempt,
+                // Отказ до работы (blocked) и штатная остановка предел не тратят.
+                ...(uncounted(kind, blocked) && !blocked && !interrupted
+                    ? { neutralFailures: (w.neutralFailures ?? 0) + 1 }
+                    : {}),
             });
             tx.emit({
                 type: 'attempt.failed',
@@ -1327,7 +1403,8 @@ export class Engine {
                 attempt: a.attempt,
                 payload: { failureKind: kind, message: shown.slice(0, 4000), blocked },
             });
-            if (repairPolicy[kind].blocksQueue) {
+            // Остановка — не неисправность окружения: её пауза уже стоит.
+            if (repairPolicy[kind].blocksQueue && !interrupted) {
                 const control = tx.control();
                 const failures = [...new Set([...(control.pauseFailures ?? []), kind])];
                 tx.setControl({
@@ -1350,6 +1427,8 @@ export class Engine {
                 runId: id,
                 kind,
                 blocked,
+                /** Работа возвращена в очередь (штатная остановка); иначе — обычный отказ. */
+                interrupted,
                 ...(bound.length ? { properties: bound } : {}),
                 ...(episode ? { recovery: { id: episode.id, status: episode.status } } : {}),
             };
@@ -2160,6 +2239,10 @@ export class Engine {
                             failureKind: 'environment',
                             failureFingerprint: fingerprint,
                             activeRunId: undefined,
+                            // Владение истекло не по вине кода: попытка не засчитывается,
+                            // но предел незасчитанных отказов тратится.
+                            attempt: w.attempt > 0 ? w.attempt - 1 : w.attempt,
+                            neutralFailures: (w.neutralFailures ?? 0) + 1,
                         });
                     tx.emit({
                         type: 'attempt.expired',
@@ -2261,7 +2344,7 @@ export class Engine {
             const w = tx.work(workId);
             if (!w)
                 throw new HarnessError('NOT_FOUND', 'Поручение не найдено: ' + workId);
-            const exhausted = w.attempt >= this.policy.maxAttempts;
+            const exhausted = w.attempt >= this.policy.maxAttempts || neutralExhausted(w);
             if (w.status === 'ready' && !exhausted)
                 return { work: w, changed: false };
             if (!['failed', 'cancelled'].includes(w.status) && !(exhausted && !w.activeRunId))
@@ -2272,6 +2355,7 @@ export class Engine {
                 ...w,
                 status: w.approvedDigest ? 'ready' : 'draft',
                 attempt: exhausted ? 0 : w.attempt,
+                neutralFailures: exhausted ? undefined : w.neutralFailures,
                 failure: undefined,
                 failureKind: undefined,
                 failureFingerprint: undefined,

package/lib/engine/failure.d.ts

@@ -1 +1 @@
-export { TaskFailure, failureFingerprint, failureKinds, repairPolicy, type FailureKind, type RepairRule, } from '../contracts/index.ts';
+export { TaskFailure, failureFingerprint, failureKinds, repairPolicy, MAX_NEUTRAL_FAILURES, type FailureKind, type RepairRule, } from '../contracts/index.ts';

package/lib/engine/failure.js

@@ -1,3 +1,3 @@
 // Таксономия отказов — часть договора (`contracts/failure.ts`): её читают и
 // хосты, в том числе в браузере, без загрузки исполнения.
-export { TaskFailure, failureFingerprint, failureKinds, repairPolicy, } from "../contracts/index.js";
+export { TaskFailure, failureFingerprint, failureKinds, repairPolicy, MAX_NEUTRAL_FAILURES, } from "../contracts/index.js";

package/lib/engine/property-recovery.d.ts

@@ -25,6 +25,7 @@ import type { AttemptState, PropertyRecovery, WorkState } from '../contracts/ind
 export declare const RECOVERY_THRESHOLD = 2;
 /** Поручение с незавершённым разбором автоматическая выдача пропускает. */
 export declare const blocksClaim: (w: Pick<WorkState, "recovery">) => boolean;
+export declare const isNeutral: (a: AttemptState) => boolean | undefined;
 /**
  * Последовательные содержательные отказы по свойству в текущем эпизоде,
  * от последней попытки к первой.

package/lib/engine/property-recovery.js

@@ -38,10 +38,13 @@ const neutral = [
     // Ошибка формата ответа reviewer о свойстве ничего не говорит.
     'review-protocol',
     'empty-result',
+    // Незавершённая работа свойство не проверяла.
+    'unfinished',
+    'needs-lead',
     'scope-violation',
 ];
 const substantive = (a) => a.failureKind === 'gate' || a.failureKind === 'review';
-const isNeutral = (a) => a.blocked || a.status === 'expired' || (a.failureKind && neutral.includes(a.failureKind));
+export const isNeutral = (a) => a.blocked || a.status === 'expired' || (a.failureKind && neutral.includes(a.failureKind));
 /** Свойство прошло проверку в попытке: его gate зелёный, отказа по нему нет. */
 function verifiedPass(a, property) {
     if (a.properties?.includes(property))

package/lib/engine/repair.d.ts

@@ -12,7 +12,33 @@ export type RepairDecision = {
     workId?: string;
     kind?: FailureKind;
     reason: string;
+    /** Остановка — пробел приёмки, а не исчерпанный бюджет (`acceptanceGap`). */
+    gap?: AcceptanceGap;
 };
+/** Свойство или класс входов, по которому ревью отклонило подряд, и эти попытки. */
+export interface AcceptanceGap {
+    /**
+     * `pair:<свойство>␀<класс>` — одно и то же необъявленное свойство с тем же
+     * классом входов; `property:<id>` — только свойство; `class:<текст>` —
+     * только класс входов.
+     */
+    key: string;
+    runs: string[];
+}
+/**
+ * Пробел приёмки: последний отказ поручения — отказ ревью, и
+ * {@link RECOVERY_THRESHOLD} содержательных отказа ревью подряд, считая его,
+ * назвали одно и то же свойство или
+ * класс входов. Каждая попытка закрывала конкретный пример, ревью находило
+ * следующий из того же класса: зелёные gates этот класс не проверяют, и
+ * третья слепая попытка ничего не даст. Объявленные свойства сюда не входят —
+ * их ведёт эпизод разбора (`property-recovery.ts`).
+ *
+ * Счёт — как у эпизода: инфраструктурный отказ не увеличивает и не обнуляет
+ * его; прохождение, отказ gate или ревью без этого названия, смена основания
+ * поручения (постановки или контрактов) обрывают серию.
+ */
+export declare function acceptanceGap(view: ExecutionView, work: WorkState): AcceptanceGap | undefined;
 /**
  * Что делать с упавшим поручением группы.
  *

package/lib/engine/repair.js

@@ -1,4 +1,67 @@
-import { repairPolicy } from "./failure.js";
+import { MAX_NEUTRAL_FAILURES, repairPolicy } from "./failure.js";
+import { RECOVERY_THRESHOLD, isNeutral } from "./property-recovery.js";
+const normalized = (c) => c.trim().toLowerCase().replace(/\s+/g, ' ');
+/** Что отклонившее ревью назвало в попытке: пары, необъявленные свойства и классы входов. */
+function namedBy(a) {
+    return new Set([
+        ...(a.classified ?? []).map((p) => 'pair:' + p.property + '\u0000' + normalized(p.inputClass)),
+        ...(a.unboundProperties ?? []).map((p) => 'property:' + p),
+        ...(a.inputClasses ?? []).map((c) => 'class:' + normalized(c)),
+    ]);
+}
+/**
+ * Сколько отказов подряд нужно для остановки. Одно и то же свойство с тем же
+ * классом — один и тот же дефект: двух хватает. Только свойство или только
+ * класс (общий класс вроде «граничные случаи» у двух разных дефектов) — слабее,
+ * ложная остановка дороже лишнего повтора: нужно три.
+ */
+const thresholdOf = (key) => key.startsWith('pair:') ? RECOVERY_THRESHOLD : RECOVERY_THRESHOLD + 1;
+/**
+ * Пробел приёмки: последний отказ поручения — отказ ревью, и
+ * {@link RECOVERY_THRESHOLD} содержательных отказа ревью подряд, считая его,
+ * назвали одно и то же свойство или
+ * класс входов. Каждая попытка закрывала конкретный пример, ревью находило
+ * следующий из того же класса: зелёные gates этот класс не проверяют, и
+ * третья слепая попытка ничего не даст. Объявленные свойства сюда не входят —
+ * их ведёт эпизод разбора (`property-recovery.ts`).
+ *
+ * Счёт — как у эпизода: инфраструктурный отказ не увеличивает и не обнуляет
+ * его; прохождение, отказ gate или ревью без этого названия, смена основания
+ * поручения (постановки или контрактов) обрывают серию.
+ */
+export function acceptanceGap(view, work) {
+    const own = view.attempts(work.id).filter((a) => a.status !== 'active');
+    const last = own.at(-1);
+    if (!last || last.status !== 'failed' || last.failureKind !== 'review')
+        return undefined;
+    for (const key of namedBy(last)) {
+        const runs = [];
+        const threshold = thresholdOf(key);
+        for (let i = own.length - 1; i >= 0 && runs.length < threshold; i--) {
+            const a = own[i];
+            if (a.episodeBasis !== last.episodeBasis)
+                break;
+            if (isNeutral(a))
+                continue;
+            if (a.status !== 'failed' || a.failureKind !== 'review' || !namedBy(a).has(key))
+                break;
+            runs.push(a.id);
+        }
+        if (runs.length >= threshold)
+            return { key, runs: runs.reverse() };
+    }
+    return undefined;
+}
+/** Предмет серии словами: свойство и класс, только свойство или только класс. */
+function gapSubject(key) {
+    const [kind, rest] = [key.slice(0, key.indexOf(':')), key.slice(key.indexOf(':') + 1)];
+    const clip = (s) => s.slice(0, 200);
+    if (kind === 'pair') {
+        const [property, inputClass] = rest.split('\u0000');
+        return `свойству «${clip(property)}» с классом входов «${clip(inputClass)}»`;
+    }
+    return kind === 'property' ? `свойству «${clip(rest)}»` : `классу входов «${clip(rest)}»`;
+}
 /**
  * Что делать с упавшим поручением группы.
  *
@@ -58,6 +121,25 @@ export function repairDecision(view, works, options) {
             kind,
             reason: `${work.id}: исчерпан бюджет попыток поручения. Устраните причину и повторите со сбросом, указав его.${detail}`,
         };
+    // Отказы окружения попытку не тратят, но их предел — свой.
+    if ((work.neutralFailures ?? 0) >= MAX_NEUTRAL_FAILURES)
+        return {
+            action: 'stop',
+            workId: work.id,
+            kind,
+            reason: `${work.id}: ${work.neutralFailures} отказов окружения или провайдера после начала работы — предел ${MAX_NEUTRAL_FAILURES}. Это неисправность среды; устраните её и повторите со сбросом, указав его.${detail}`,
+        };
+    // Тексты отказов ревью разные, и предел одинаковых отпечатков их не
+    // ловит; одно и то же нарушенное свойство или класс входов — ловит.
+    const gap = acceptanceGap(view, work);
+    if (gap)
+        return {
+            action: 'stop',
+            workId: work.id,
+            kind,
+            gap,
+            reason: `${work.id}: пробел приёмки — ревью ${gap.runs.length} раза подряд отклонило по одному и тому же ${gapSubject(gap.key)} при зелёных проверках (попытки ${gap.runs.join(', ')}). Третья слепая попытка не выдаётся: приёмка этот класс не проверяет. Решение ведущего — закрепить класс проверкой (корпус, эталонный набор, свойство в договоре проверки) или разделить задачу.${detail}`,
+        };
     const fingerprint = work.failureFingerprint;
     const identical = fingerprint
         ? view.attempts(work.id).filter((a) => a.failureFingerprint === fingerprint).length

package/lib/engine/runner.d.ts

@@ -243,6 +243,13 @@ export declare class Runner {
      * команды — засчитывается всем резервом, записанным до запуска, а его
      * пережившие процессы останавливаются (R3-F01).
      */
+    /**
+     * Решение по подтверждению «приёмка уже выполнена» (`alreadySatisfiedVerdict`).
+     * Основание по зависимости controller ищет сам: зависимость поручения,
+     * чей принятый результат входит в проверяемый SHA, а её собственный
+     * кандидат (база → кандидат) изменил файлы области записи поручения.
+     */
+    private alreadySatisfied;
     private probeSpent;
     private reviewOnce;
     /**