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

package/lib/verification/checks.js

@@ -10,13 +10,115 @@ export function contractDocuments(order, view) {
         .map((ref) => view.local('contract-documents', WORKSPACE_OWNER, ref.digest))
         .filter((d) => !!d);
 }
+/** Gates обязательства: свои `gates` или gate договора. */
+export function obligationGates(declaration, o) {
+    return o.gates?.length ? o.gates : [declaration.gate];
+}
+/** Обязательство проверяется закреплёнными эталонными наборами. */
+export const isReference = (o) => o.verification === 'reference';
 /** Обязательства договоров поручения, исполняемые данным gate. */
 function declared(contracts, gate) {
     return contracts
         .filter((c) => c.checks)
-        .flatMap((c) => c.checks.gate === gate || gate === undefined
-        ? c.checks.obligations.map((o) => ({ contract: c, gate: c.checks.gate, obligation: o }))
-        : []);
+        .flatMap((c) => c.checks.obligations.flatMap((o) => {
+        const gates = obligationGates(c.checks, o);
+        return gate === undefined || gates.includes(gate)
+            ? [{ contract: c, gate: gates[0], gates, obligation: o }]
+            : [];
+    }));
+}
+const sameGates = (gates, gate) => gates.every((g) => g === gate);
+/**
+ * Файлы эталонных наборов договоров поручения (в репозитории `repositoryId`).
+ * Ответы наборов лежат в рабочем дереве: реализация, которая читает их или
+ * повторяет их ответы, прошла бы каждый набор, ничего не решив.
+ */
+export function referenceSetFiles(contracts, repositoryId) {
+    return [
+        ...new Set(contracts
+            .filter((c) => c.checks && (!repositoryId || !c.repositoryId || c.repositoryId === repositoryId))
+            .flatMap((c) => c.checks.obligations.flatMap((o) => isReference(o) && o.reference ? o.reference.sets.flatMap((s) => s.artifacts) : []))),
+    ];
+}
+/** Файлы без кода: упоминание набора в них ничего не читает. */
+const PROSE = /\.(md|markdown|mdx|txt|rst|adoc)$/i;
+/** Содержимое строковых литералов `'…'`, `"…"`, `` `…` `` вне комментариев `//` и `/* *\/`. */
+function stringLiterals(text) {
+    const out = [];
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === '/' && text[i + 1] === '/') {
+            const end = text.indexOf('\n', i);
+            i = end < 0 ? text.length : end + 1;
+        }
+        else if (c === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end < 0 ? text.length : end + 2;
+        }
+        else if (c === "'" || c === '"' || c === '`') {
+            let j = i + 1;
+            let value = '';
+            let closed = false;
+            while (j < text.length) {
+                if (text[j] === c) {
+                    closed = true;
+                    break;
+                }
+                if (text[j] === '\\')
+                    j++;
+                // Обычная строка не переходит строку: непарная кавычка (апостроф в
+                // регулярном выражении) — не литерал, разбор идёт со следующего знака.
+                else if (text[j] === '\n' && c !== '`')
+                    break;
+                else
+                    value += text[j];
+                j++;
+            }
+            if (closed) {
+                out.push(value);
+                i = j + 1;
+            }
+            else
+                i++;
+        }
+        else
+            i++;
+    }
+    return out;
+}
+/** Вхождение `needle` целым токеном: по краям нет буквы, цифры, `_`, `-` и `.`. */
+function token(haystack, needle) {
+    const word = /[A-Za-z0-9_.-]/;
+    for (let at = haystack.indexOf(needle); at >= 0; at = haystack.indexOf(needle, at + 1)) {
+        const before = haystack[at - 1];
+        const after = haystack[at + needle.length];
+        if ((!before || !word.test(before)) && (!after || !word.test(after)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Какой файл набора называет изменённый файл: имя файла набора (и, значит,
+ * его путь) целым токеном внутри строкового литерала. Комментарии и файлы без кода не
+ * считаются — упоминание набора в них ничего не читает. Имя, собранное во
+ * время исполнения, так не видно: это остаётся ревью кода.
+ */
+export function setFileReference(path, text, sets) {
+    if (PROSE.test(path) || path.startsWith('docs/'))
+        return undefined;
+    const literals = stringLiterals(text);
+    // Полный путь кончается именем файла после `/`: имени целым токеном
+    // достаточно и для пути, и для `../имя` или `${root}/путь`.
+    return sets.find((s) => literals.some((l) => token(l, s.split('/').at(-1))));
+}
+/** Подсказка writer или reviewer кода о файлах эталонных наборов; пусто — их нет. */
+export function referenceCodeNote(files, review) {
+    if (!files.length)
+        return '';
+    return review
+        ? `Reference answer sets pinned by the contracts (the gates compare the implementation with them): ${JSON.stringify(files)}. Implementation code that reads these files (by path, basename or a computed name), embeds or hard-codes their inputs or expected answers, or special-cases their inputs is a blocking finding: it would pass every set without solving the problem. Tests and checkers that are contract artifacts may read them.`
+        : `Reference answer sets pinned by the contracts: ${JSON.stringify(files)}. The gates compare your implementation with them. Do not read them from implementation code and do not copy their answers or special-case their inputs: the controller refuses a candidate whose changed code names a set file in a string literal, and the reviewer rejects hard-coded answers.`;
 }
 /** Основание случаев корпуса: закреплённые файлы, gate и смысл обязательств. */
 export function suiteBasis(contract) {
@@ -24,11 +126,17 @@ export function suiteBasis(contract) {
     return digestOf({
         artifacts: (contract.artifacts ?? []).map((a) => ({ path: a.path, blob: a.blob })),
         gate: declaration.gate,
+        // Поля эталонной проверки и gates обязательства входят, только когда
+        // объявлены: основание прежних договоров и их корпусов не меняется.
         obligations: declaration.obligations.map((o) => ({
             property: o.property,
             domain: o.domain,
             answer: o.answer,
             method: o.method,
+            // `gates`, равные gate договора, — то же, что поле не указано.
+            ...(o.gates && !sameGates(o.gates, declaration.gate) ? { gates: o.gates } : {}),
+            ...(o.verification ? { verification: o.verification } : {}),
+            ...(o.reference ? { reference: o.reference } : {}),
         })),
     });
 }
@@ -51,6 +159,62 @@ basisOf = suiteBasis) {
 export function obligationOf(contracts, id) {
     return declared(contracts).find((x) => x.obligation.property === id);
 }
+/**
+ * Структурные пропуски эталонной проверки. Наборы — артефакты контракта;
+ * каждый gate обязательства сверяет хотя бы один набор, а доли наборов
+ * покрывают общий минимум и минимум каждого семейства: иначе gates прошли бы,
+ * не доказав объявленного покрытия. Сверка эталона с расхождениями — не
+ * основание для эталона.
+ */
+function referenceProblems(o, gates, artifacts) {
+    const at = `свойство ${o.property}`;
+    const r = o.reference;
+    if (!r)
+        return [`${at}: для способа reference опишите эталонные наборы (reference)`];
+    const problems = [];
+    for (const c of r.crossChecks) {
+        for (const path of c.artifacts ?? [])
+            if (!artifacts.includes(path))
+                problems.push(`${at}: сверка эталона «${c.family}»: ${path} не объявлен артефактом контракта и не закреплён`);
+        if (c.matches > c.total)
+            problems.push(`${at}: сверка эталона «${c.family}»: совпало ${c.matches} из ${c.total}`);
+        else if (c.matches < c.total)
+            problems.push(`${at}: сверка эталона «${c.family}» расходится (${c.matches} из ${c.total}): эталон с расхождениями не закрепляет ответы`);
+    }
+    const families = new Map(o.coverage.families.map((f) => [f.id, 0]));
+    let total = 0;
+    for (const [i, set] of r.sets.entries()) {
+        const label = `${at}, набор ${i + 1}`;
+        if (!gates.includes(set.gate))
+            problems.push(`${label}: gate ${set.gate} не среди gates обязательства (${gates.join(', ')})`);
+        for (const path of set.artifacts)
+            if (!artifacts.includes(path))
+                problems.push(`${label}: ${path} не объявлен артефактом контракта и не закреплён`);
+        const ids = set.families.map((f) => f.id);
+        if (new Set(ids).size !== ids.length)
+            problems.push(`${label}: id семейств повторяются`);
+        const own = set.families.reduce((n, f) => n + f.minCases, 0);
+        if (own > set.minCases)
+            problems.push(`${label}: семейства требуют ${own} входов, больше минимума набора ${set.minCases}`);
+        for (const f of set.families)
+            if (!families.has(f.id))
+                problems.push(`${label}: семейство ${f.id} не объявлено в покрытии`);
+            else
+                families.set(f.id, families.get(f.id) + f.minCases);
+        total += set.minCases;
+    }
+    for (const id of gates)
+        if (!r.sets.some((s) => s.gate === id))
+            problems.push(`${at}: gate ${id} не сверяет ни одного эталонного набора`);
+    if (total < o.coverage.minCases)
+        problems.push(`${at}: наборы требуют ${total} входов, меньше общего минимума ${o.coverage.minCases}`);
+    for (const f of o.coverage.families) {
+        const seen = families.get(f.id) ?? 0;
+        if (seen < f.minCases)
+            problems.push(`${at}, семейство ${f.id}: наборы требуют ${seen} входов, меньше минимума семейства ${f.minCases}`);
+    }
+    return problems;
+}
 /**
  * Структурные пропуски договора проверки — до вызова модели. Способ проверки
  * обязан ссылаться на закреплённые файлы контракта: иначе происхождение
@@ -78,18 +242,44 @@ export function declarationProblems(declaration, context) {
         for (const path of o.method.artifacts)
             if (!context.artifacts.includes(path))
                 problems.push(`${at}: ${path} не объявлен артефактом контракта и не закреплён`);
+        const gates = obligationGates(declaration, o);
+        if (new Set(gates).size !== gates.length)
+            problems.push(`${at}: gates повторяются`);
+        const configured = (id) => context.gates.find((g) => g.id === id);
+        if (o.gates)
+            for (const id of new Set(o.gates))
+                if (id !== declaration.gate && !configured(id))
+                    problems.push(`${at}: gate ${id} не настроен в репозитории ${context.repositoryId}`);
+        const reference = isReference(o);
+        if (reference)
+            problems.push(...referenceProblems(o, gates, context.artifacts));
+        else if (o.reference)
+            problems.push(`${at}: эталонные наборы объявлены, но способ исполнения не reference`);
         if (strongPromises.has(o.promise)) {
             if (!['oracle', 'certificate', 'analytic', 'invariant'].includes(o.method.kind))
                 problems.push(`${at}: для обещания ${o.promise} нужен независимый способ проверки (эталон, сертификат, аналитическое основание или инвариант), а не ${o.method.kind}`);
             if (!o.method.artifacts.length && o.method.kind !== 'analytic')
                 problems.push(`${at}: способ проверки не ссылается на закреплённый checker или эталон`);
-            if (gate && !gate.property)
-                problems.push(`${at}: gate ${gate.id} не генеративный (нет property)`);
         }
+        // Генеративность нужна генератору: эталонная проверка сверяет
+        // реализацию с закреплёнными наборами и отчитывается тем же отчётом.
+        // Обязательство любого обещания на gate без генератора поручение выбрать
+        // не может (orderPropertyProblems): оно стало бы мёртвым договором.
+        if (!reference)
+            for (const id of new Set(gates)) {
+                const g = configured(id);
+                if (g && !g.property)
+                    problems.push(`${at}: gate ${g.id} не генеративный (нет property) — поручение не сможет выбрать это свойство; нужен генеративный gate или verification reference`);
+            }
         if (o.promise === 'performance' && !o.resources.benchmark)
             problems.push(`${at}: для производительности укажите метод измерения и среду`);
         if (o.coverage.corpus && !declaration.corpus)
             problems.push(`${at}: корпус включён, но политика расширения корпуса не описана`);
+        // Случай корпуса подтверждает и исполняет один gate договора.
+        if (o.coverage.corpus && (reference || gates.some((id) => id !== declaration.gate)))
+            problems.push(reference
+                ? `${at}: корпус пополняет генератор; эталонные наборы закреплены артефактами контракта`
+                : `${at}: корпус исполняет gate договора ${declaration.gate}, а не свои gates обязательства`);
         if (o.hard) {
             if (!o.feasibility)
                 problems.push(`${at}: тяжёлое обязательство требует ограниченного эксперимента до реализации (spike)`);
@@ -104,6 +294,40 @@ export function declarationProblems(declaration, context) {
     }
     return problems;
 }
+/**
+ * Подсказка reviewer контракта об эталонных обязательствах: что наборы
+ * доказывают, чего — нет (`gaps`), чем сверен эталон. Пустая строка — таких
+ * обязательств нет. Reviewer видит пределы способа рядом с самим договором,
+ * а не выводит их из длинного описания.
+ */
+export function referenceNote(declaration) {
+    const list = (declaration?.obligations ?? []).filter((o) => isReference(o) && o.reference);
+    if (!list.length)
+        return '';
+    return ('Reference-set obligations (verification "reference"): the gates replay pinned reference answer sets (contract artifacts) against the implementation and report the replayed inputs per property and family; the controller requires each gate to reach its declared share. Judge them as follows: the oracle must be independent of the implementation and its stated limits must not silently bias the sets toward easy inputs; a cross-check with mismatches or on an unrelated family is not evidence; a cross-check without "artifacts" (a pinned script or log that reproduces it) is an unverified claim of the author — weigh it as such and ask for the artifact where the promise rests on it; the sets prove the answer only on the inputs they contain. The "gaps" of each obligation state what the sets do not prove (generalization beyond the set, input classes outside it): a promise that rests on a gap without another declared method (a generative property, an invariant or an analytic argument) is a blocking finding. Obligations: ' +
+        JSON.stringify(list.map((o) => ({
+            property: o.property,
+            promise: o.promise,
+            gates: obligationGates(declaration, o),
+            oracle: o.reference.oracle,
+            crossChecks: o.reference.crossChecks,
+            coverage: {
+                minCases: o.coverage.minCases,
+                families: o.coverage.families.map((f) => ({
+                    id: f.id,
+                    kind: f.kind,
+                    minCases: f.minCases,
+                })),
+            },
+            sets: o.reference.sets.map((s) => ({
+                gate: s.gate,
+                artifacts: s.artifacts,
+                minCases: s.minCases,
+                families: s.families,
+            })),
+            gaps: o.reference.gaps,
+        }))));
+}
 /**
  * Свойства, объявленные поручением, существуют в его договорах и исполняются
  * его генеративными gates. Поручение без `properties` — прежний уровень.
@@ -125,16 +349,20 @@ gates) {
         }
         if (found.length > 1)
             problems.push(`${order.id}: свойство ${id} объявлено в нескольких договорах`);
-        const gate = found[0].gate;
-        if (gates.scope && !gates.scope.includes(gate))
-            problems.push(`${order.id}: свойство ${id} проверяет gate ${gate}, которого нет в поручении`);
-        // Селектор свойств передаёт controller, а исполняет harness генеративного
-        // gate: без него область поручения в общем файле проверок не выбрать.
-        const configured = gates.configured.find((g) => g.id === gate);
-        if (!configured)
-            problems.push(`${order.id}: gate ${gate} свойства ${id} не настроен`);
-        else if (!configured.property)
-            problems.push(`${order.id}: gate ${gate} свойства ${id} не генеративный — селектор свойств не подготовлен`);
+        const { gates: own, obligation } = found[0];
+        for (const gate of own) {
+            if (gates.scope && !gates.scope.includes(gate))
+                problems.push(`${order.id}: свойство ${id} проверяет gate ${gate}, которого нет в поручении`);
+            // Селектор свойств передаёт controller, а исполняет harness генеративного
+            // gate: без него область поручения в общем файле проверок не выбрать.
+            // Эталонная проверка получает тот же селектор и путь отчёта от
+            // controller по манифесту поручения, без генератора.
+            const configured = gates.configured.find((g) => g.id === gate);
+            if (!configured)
+                problems.push(`${order.id}: gate ${gate} свойства ${id} не настроен`);
+            else if (!configured.property && !isReference(obligation))
+                problems.push(`${order.id}: gate ${gate} свойства ${id} не генеративный — селектор свойств не подготовлен`);
+        }
     }
     // Сценарий, названный тем же id, проверяет тот же gate: иначе требование
     // ссылается на свойство, а подтверждается другой проверкой.
@@ -142,8 +370,8 @@ gates) {
         if (!link.testId)
             continue;
         const found = all.find((x) => x.obligation.property === link.testId);
-        if (found && found.gate !== link.gate)
-            problems.push(`${order.id}: ${link.id} ссылается на свойство ${link.testId}, но через gate ${link.gate}, а не ${found.gate}`);
+        if (found && !found.gates.includes(link.gate))
+            problems.push(`${order.id}: ${link.id} ссылается на свойство ${link.testId}, но через gate ${link.gate}, а не ${found.gates.join(' или ')}`);
     }
     return problems;
 }
@@ -160,14 +388,34 @@ export function orderCheckManifest(order, contracts, gate, corpus) {
     const ids = new Set(obligations.map((x) => x.obligation.property));
     const cases = corpus?.cases.filter((c) => ids.has(c.property)) ?? [];
     return {
-        properties: obligations.map(({ obligation: o }) => ({
-            id: o.property,
-            minCases: o.coverage.minCases,
-            families: o.coverage.families.map((f) => ({ id: f.id, minCases: f.minCases })),
-        })),
+        properties: obligations.map(({ obligation: o }) => isReference(o) && o.reference
+            ? referenceShare(o, gate)
+            : {
+                id: o.property,
+                minCases: o.coverage.minCases,
+                families: o.coverage.families.map((f) => ({ id: f.id, minCases: f.minCases })),
+            }),
         ...(corpus && cases.length ? { corpus: { digest: corpus.digest, cases } } : {}),
     };
 }
+/**
+ * Доля gate в эталонной проверке: сумма минимумов его наборов и их семейств
+ * и закреплённые файлы этих наборов. Отчёт gate обязан подтвердить именно
+ * её — общий минимум обязательства складывается из долей его gates.
+ */
+function referenceShare(o, gate) {
+    const sets = o.reference.sets.filter((s) => s.gate === gate);
+    const families = new Map();
+    for (const s of sets)
+        for (const f of s.families)
+            families.set(f.id, (families.get(f.id) ?? 0) + f.minCases);
+    return {
+        id: o.property,
+        minCases: sets.reduce((n, s) => n + s.minCases, 0),
+        families: [...families].map(([id, minCases]) => ({ id, minCases })),
+        reference: { artifacts: [...new Set(sets.flatMap((s) => s.artifacts))] },
+    };
+}
 /**
  * Действующая версия проверок поручения: согласованная постановка,
  * контракты, политика и принятый snapshot корпуса. Закрепляется в попытке

package/lib/verification/corpus.d.ts

@@ -580,6 +580,31 @@ export declare class CorpusStore {
                     };
                     hard: boolean;
                     explanation?: string | undefined;
+                    gates?: string[] | undefined;
+                    verification?: "property" | "reference" | undefined;
+                    reference?: {
+                        oracle: {
+                            description: string;
+                            limits: string;
+                        };
+                        crossChecks: {
+                            family: string;
+                            against: string;
+                            matches: number;
+                            total: number;
+                            artifacts?: string[] | undefined;
+                        }[];
+                        sets: {
+                            gate: string;
+                            artifacts: string[];
+                            minCases: number;
+                            families: {
+                                id: string;
+                                minCases: number;
+                            }[];
+                        }[];
+                        gaps: string;
+                    } | undefined;
                     feasibility?: {
                         spike: string;
                         digest: string;
@@ -635,6 +660,31 @@ export declare class CorpusStore {
             };
             hard: boolean;
             explanation?: string | undefined;
+            gates?: string[] | undefined;
+            verification?: "property" | "reference" | undefined;
+            reference?: {
+                oracle: {
+                    description: string;
+                    limits: string;
+                };
+                crossChecks: {
+                    family: string;
+                    against: string;
+                    matches: number;
+                    total: number;
+                    artifacts?: string[] | undefined;
+                }[];
+                sets: {
+                    gate: string;
+                    artifacts: string[];
+                    minCases: number;
+                    families: {
+                        id: string;
+                        minCases: number;
+                    }[];
+                }[];
+                gaps: string;
+            } | undefined;
             feasibility?: {
                 spike: string;
                 digest: string;

package/lib/verification/gate-scope.d.ts

@@ -0,0 +1,36 @@
+import { type GatePolicy } from '../contracts/index.ts';
+type Gate = Pick<GatePolicy, 'id' | 'kind' | 'dependsOn'>;
+/**
+ * Порядок исполнения области gates — один для попытки (candidate и
+ * integration) и для проверки на SHA вне попытки (`runGatesAt`): ids в
+ * порядке области, каждая предпосылка `dependsOn`, входящая в область, —
+ * раньше своего gate. Неизвестный id (псевдо-gate требований) пропускается.
+ */
+export declare function orderedScope<T extends Pick<GatePolicy, 'id' | 'dependsOn'>>(gates: T[], ids: string[]): T[];
+/** Явные предпосылки gate: замыкание по `dependsOn`, ids в порядке профиля. */
+export declare function explicitPrerequisites(gates: Gate[], id: string): string[];
+/**
+ * Предпосылки gate при исполнении вне области задачи (проверка доски на её
+ * итоговом SHA). Область задачи предпосылки называет явно, и попытка
+ * исполняет ровно её. Проверке на SHA области нет, поэтому предпосылки
+ * выводятся из профиля:
+ *
+ * - явные — замыкание по `dependsOn` (`explicitPrerequisites`); объявленный
+ *   `dependsOn`, в том числе пустой, — режим графа: других предпосылок нет;
+ * - неявные — у gate без поля `dependsOn` (режим порядка массива, где профиль
+ *   сам задаёт последовательность) все более ранние gates вида `check`
+ *   (установка, сборка, статические проверки) со своими предпосылками. Более
+ *   ранние test gates не добавляются: тесты друг от друга не зависят.
+ *
+ * Каждый gate посещается один раз, поэтому `dependsOn` на более поздний
+ * gate вместе с неявным ребром к более ранним не зацикливается. Сам gate в
+ * результат не входит. Результат — ids в порядке профиля.
+ */
+export declare function gatePrerequisites(gates: Gate[], id: string): string[];
+/**
+ * Область проверки gates вне задачи: названные gates и предпосылки каждого
+ * (`gatePrerequisites`), в порядке профиля. Исполняется `orderedScope`, как
+ * область задачи.
+ */
+export declare function standaloneScope(gates: Gate[], ids: string[]): string[];
+export {};

package/lib/verification/gate-scope.js

@@ -0,0 +1,97 @@
+import { HarnessError } from "../contracts/index.js";
+/**
+ * Порядок исполнения области gates — один для попытки (candidate и
+ * integration) и для проверки на SHA вне попытки (`runGatesAt`): ids в
+ * порядке области, каждая предпосылка `dependsOn`, входящая в область, —
+ * раньше своего gate. Неизвестный id (псевдо-gate требований) пропускается.
+ */
+export function orderedScope(gates, ids) {
+    const byId = new Map(gates.map((g) => [g.id, g]));
+    const out = [];
+    const seen = new Set();
+    const visit = (id) => {
+        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;
+}
+/** Явные предпосылки gate: замыкание по `dependsOn`, ids в порядке профиля. */
+export function explicitPrerequisites(gates, id) {
+    const byId = new Map(gates.map((g) => [g.id, g]));
+    if (!byId.has(id))
+        throw new HarnessError('NOT_FOUND', `Gate ${id} не объявлен`);
+    const out = new Set();
+    const stack = [...(byId.get(id).dependsOn ?? [])];
+    while (stack.length) {
+        const gid = stack.pop();
+        if (gid === id || out.has(gid))
+            continue;
+        const gate = byId.get(gid);
+        if (!gate)
+            throw new HarnessError('NOT_FOUND', `Gate ${gid} не объявлен`);
+        out.add(gid);
+        stack.push(...(gate.dependsOn ?? []));
+    }
+    return gates.map((g) => g.id).filter((g) => out.has(g));
+}
+/**
+ * Предпосылки gate при исполнении вне области задачи (проверка доски на её
+ * итоговом SHA). Область задачи предпосылки называет явно, и попытка
+ * исполняет ровно её. Проверке на SHA области нет, поэтому предпосылки
+ * выводятся из профиля:
+ *
+ * - явные — замыкание по `dependsOn` (`explicitPrerequisites`); объявленный
+ *   `dependsOn`, в том числе пустой, — режим графа: других предпосылок нет;
+ * - неявные — у gate без поля `dependsOn` (режим порядка массива, где профиль
+ *   сам задаёт последовательность) все более ранние gates вида `check`
+ *   (установка, сборка, статические проверки) со своими предпосылками. Более
+ *   ранние test gates не добавляются: тесты друг от друга не зависят.
+ *
+ * Каждый gate посещается один раз, поэтому `dependsOn` на более поздний
+ * gate вместе с неявным ребром к более ранним не зацикливается. Сам gate в
+ * результат не входит. Результат — ids в порядке профиля.
+ */
+export function gatePrerequisites(gates, id) {
+    const byId = new Map(gates.map((g) => [g.id, g]));
+    if (!byId.has(id))
+        throw new HarnessError('NOT_FOUND', `Gate ${id} не объявлен`);
+    const out = new Set();
+    const seen = new Set([id]);
+    const queue = [id];
+    while (queue.length) {
+        const gid = queue.shift();
+        const gate = byId.get(gid);
+        if (!gate)
+            throw new HarnessError('NOT_FOUND', `Gate ${gid} не объявлен`);
+        const next = gate.dependsOn !== undefined
+            ? gate.dependsOn
+            : gates
+                .slice(0, gates.indexOf(gate))
+                .filter((g) => g.kind === 'check')
+                .map((g) => g.id);
+        for (const n of next) {
+            if (seen.has(n))
+                continue;
+            seen.add(n);
+            out.add(n);
+            queue.push(n);
+        }
+    }
+    out.delete(id);
+    return gates.map((g) => g.id).filter((g) => out.has(g));
+}
+/**
+ * Область проверки gates вне задачи: названные gates и предпосылки каждого
+ * (`gatePrerequisites`), в порядке профиля. Исполняется `orderedScope`, как
+ * область задачи.
+ */
+export function standaloneScope(gates, ids) {
+    const all = new Set(ids.flatMap((id) => [...gatePrerequisites(gates, id), id]));
+    return gates.map((g) => g.id).filter((g) => all.has(g));
+}

package/lib/verification/gates-at.d.ts

@@ -0,0 +1,67 @@
+import { type EvidenceRecord, type ExecutionPolicy } from '../contracts/index.ts';
+type Repo = ExecutionPolicy['repositories'][number];
+/** Что нужно проверке на SHA от controller (как у эксперимента выполнимости). */
+export interface GatesAtContext {
+    policy: ExecutionPolicy;
+    /** Каталог состояния: здесь рабочее дерево, снимки зависимостей и логи. */
+    stateDir: string;
+    repoPath(repo: Repo): string;
+    /** Закрытое проверке и открытое внутри него — та же граница, что у gates попыток. */
+    boundary(): {
+        hidden: string[];
+        readable: string[];
+    };
+    environment?: NodeJS.ProcessEnv;
+    resourceDatabase?: string;
+}
+export interface GatesAtInput {
+    /** Идентификатор проверки: `runId` её evidence и `DEVCONTOUR_RUN_ID` gates. */
+    id?: string;
+    repositoryId: string;
+    /** Проверяемый коммит; evidence привязано к нему. */
+    sha: string;
+    /** Gates профиля; их предпосылки (`dependsOn`) добавляются и идут первыми. */
+    gates: string[];
+    /**
+     * Запись evidence под fencing хоста. Бросок прерывает проверку: хост,
+     * утративший право записи, результата не получает.
+     */
+    record(evidence: EvidenceRecord): void;
+    signal?: AbortSignal;
+}
+export interface GatesAtResult {
+    id: string;
+    sha: string;
+    /** Исполненные gates в порядке исполнения (с предпосылками). */
+    gates: string[];
+    evidence: EvidenceRecord[];
+    /** Первый непрошедший gate и причина (то же, что `failures[0]`). */
+    failure?: {
+        gate: string;
+        message: string;
+    };
+    /**
+     * Все непрошедшие gates. Провал не останавливает проверку: исполняются все
+     * названные gates, кроме тех, чья предпосылка не прошла (они названы здесь
+     * с этой причиной и evidence не получают).
+     */
+    failures: {
+        gate: string;
+        message: string;
+    }[];
+}
+/**
+ * Gates компонента на закреплённом SHA вне попытки — тем же исполнением, что
+ * integration поручения: отдельное рабочее дерево на SHA, снимки зависимостей
+ * компонента, ресурсы gates, lifecycle и prepare компонента, окружение фазы
+ * `integration`, песочница проверок и `runGate`. Каждое evidence (вида `test`,
+ * фазы `integration`, на этом SHA) записывается через `record` хоста до
+ * следующего gate. После gates дерево обязано остаться на SHA без изменений.
+ * Рабочее дерево и снимки убираются при любом исходе.
+ *
+ * Нужна приёмке набора поручений, когда часть gates профиля не исполнило ни
+ * одно поручение: суженные области задач — законная декомпозиция, а полный
+ * профиль проверяется один раз на итоговом SHA.
+ */
+export declare function runGatesAt(ctx: GatesAtContext, input: GatesAtInput): Promise<GatesAtResult>;
+export {};