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

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/gates.js

@@ -9,7 +9,7 @@ import { command, git } from "../environment/process.js";
 import { isolation, isolatedCommand, isolationSupport } from "../environment/isolation.js";
 import { TaskFailure } from "../engine/failure.js";
 import { redactDeep } from "../environment/redaction.js";
-import { manifestDigest, propertyCoverage, propertyFailure, propertySeed, readPropertyReport, } from "./property.js";
+import { expectsReference, manifestDigest, propertyCoverage, propertyFailure, propertySeed, readPropertyReport, } from "./property.js";
 /** Длинное имя testcase заменяется хешем, а не обрезается: обрезка дала бы ложные совпадения. */
 export const TEST_ID_LIMIT = 1000;
 export function portableTest(test) {
@@ -402,7 +402,17 @@ export async function runGate(run) {
     // тогда, когда проверка зависла и не успела ничего записать. Отчёт свойств
     // лежит в каталоге controller вне worktree: проверка пишет внутрь него, но
     // заменить сам каталог на ссылку наружу не может.
-    const property = gate.property && run.property ? run.property : undefined;
+    // Эталонная проверка поручения отчитывается тем же отчётом свойств и
+    // получает его путь и селектор и у gate без генератора.
+    const property = run.property && (gate.property || expectsReference(run.property.expected))
+        ? run.property
+        : undefined;
+    const reference = expectsReference(run.property?.expected);
+    const label = !gate.property
+        ? 'Проверка по эталонным наборам'
+        : reference
+            ? 'Проверка свойств и эталонных наборов'
+            : 'Генеративная проверка';
     const propertyDir = property
         ? await realpath(await mkdtemp(join(tmpdir(), 'harness-property-')))
         : undefined;
@@ -563,13 +573,13 @@ export async function runGate(run) {
         }
         else if (coverage.length) {
             passed = false;
-            summary = join2('Генеративная проверка не подтвердила покрытие: ' + coverage.join('; '));
+            summary = join2(`${label} не подтвердила покрытие: ` + coverage.join('; '));
         }
         else if (passed && read.problem) {
             // Прошедшая команда без отчёта не доказывает свойство: зелёный код
             // выхода был у неё и до реализации.
             passed = false;
-            summary = `Генеративная проверка не отчиталась: ${read.problem}`;
+            summary = `${label} не отчиталась: ${read.problem}`;
         }
         propertyEvidence = {
             seed,

package/lib/verification/property.d.ts

@@ -31,6 +31,13 @@ export interface CheckManifest {
             id: string;
             minCases: number;
         }[];
+        /**
+         * Эталонная проверка: доля gate в наборах и их закреплённые файлы. Поле
+         * есть только у эталонных свойств — digest прежних манифестов прежний.
+         */
+        reference?: {
+            artifacts: string[];
+        };
     }[];
     corpus?: {
         digest: string;
@@ -40,6 +47,8 @@ export interface CheckManifest {
         }[];
     };
 }
+/** Манифест ожидает эталонной проверки: путь отчёта нужен и gate без генератора. */
+export declare const expectsReference: (manifest: CheckManifest | undefined) => boolean;
 /** Свидетельство выполнения корпуса: hash отсортированных строк `id:pass|fail`. */
 export declare function corpusWitness(cases: {
     id: string;

package/lib/verification/property.js

@@ -42,6 +42,8 @@ export function propertyFailure(report) {
                     : ''));
     return [...own, ...corpus].join('; ');
 }
+/** Манифест ожидает эталонной проверки: путь отчёта нужен и gate без генератора. */
+export const expectsReference = (manifest) => !!manifest?.properties.some((p) => p.reference);
 /** Свидетельство выполнения корпуса: hash отсортированных строк `id:pass|fail`. */
 export function corpusWitness(cases) {
     return createHash('sha256')
@@ -138,8 +140,15 @@ export function propertyCoverage(report, manifest, junit) {
             for (const id of required) {
                 const found = junit.cases.filter((c) => !c.opaque && c.id === id);
                 const p = entry(id);
-                if (!found.length)
-                    problems.push(`testcase ${id} отсутствует в JUnit`);
+                if (!found.length) {
+                    // ID testcase — `classname.name`: node:test пишет classname="test",
+                    // и свойство `x` там видно как `test.x`. Подсказка называет его.
+                    const near = junit.cases.find((c) => !c.opaque && c.id.endsWith('.' + id));
+                    problems.push(`testcase ${id} отсутствует в JUnit` +
+                        (near
+                            ? ` (есть ${near.id}: ID testcase — classname.name, property ID должен совпадать с ним)`
+                            : ''));
+                }
                 else if (found.length > 1)
                     problems.push(`testcase ${id} встречается ${found.length} раза`);
                 else if (p?.status === 'passed' && found[0].status !== 'passed')

package/lib/verification/self-check.js

@@ -1,20 +1,20 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { obligationOf } from "./checks.js";
+import { isReference, obligationOf } from "./checks.js";
 export async function writeSelfCheck(input) {
     const gates = new Map();
     for (const id of input.order.properties ?? []) {
         const found = obligationOf(input.contracts, id);
-        const gate = found && input.gates.find((g) => g.id === found.gate && g.property);
-        if (!gate)
-            continue;
-        const entry = gates.get(gate.id) ?? {
-            command: gate.command,
-            ...(gate.cwd ? { cwd: gate.cwd } : {}),
-            properties: [],
-        };
-        entry.properties.push(id);
-        gates.set(gate.id, entry);
+        // Gate эталонных наборов отчитывается тем же отчётом свойств.
+        for (const gate of input.gates.filter((g) => found?.gates.includes(g.id) && (g.property || isReference(found.obligation)))) {
+            const entry = gates.get(gate.id) ?? {
+                command: gate.command,
+                ...(gate.cwd ? { cwd: gate.cwd } : {}),
+                properties: [],
+            };
+            entry.properties.push(id);
+            gates.set(gate.id, entry);
+        }
     }
     if (!gates.size)
         return undefined;
@@ -35,7 +35,7 @@ export async function writeSelfCheck(input) {
         ...(corpus ? { corpus } : {}),
         cases: input.corpus?.cases ?? 0,
         seed: input.seed,
-        properties: [...gates.values()].flatMap((g) => g.properties),
+        properties: [...new Set([...gates.values()].flatMap((g) => g.properties))],
     };
 }
 /** Строка запроса исполнителю о самопроверке. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devcontour-harness",
-  "version": "0.1.0-alpha.13",
+  "version": "0.1.0-alpha.16",
   "description": "Headless execution harness: work graph, isolated attempts, gates, independent reviews and accepted results.",
   "type": "module",
   "license": "MIT",