devcontour-harness 0.0.0-stage → 0.1.0-alpha.6

package/lib/validate.js

@@ -0,0 +1,175 @@
+import { roleBinding, HarnessError, executionPolicySchema, expandGateRefs, graphIssues, policyDigest, policyIssues, sha256, contextDigest, contextIssues, contextSnapshotSchema, workGraphDigest, workGraphSchema, } from "./contracts/index.js";
+const parse = (schema, value, root) => {
+    const parsed = schema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    throw new HarnessError('INVALID_INPUT', `${root}: вход не прошёл проверку схемы`, parsed.error.issues.map((i) => ({
+        path: [root, ...i.path],
+        message: i.message,
+    })));
+};
+/** Путь внутри одного из префиксов (как `withinPaths` DevContour). */
+export const withinPaths = (path, prefixes) => prefixes.some((p) => p === '.' || path === p || path.startsWith(p.endsWith('/') ? p : p + '/'));
+/**
+ * Связь поручений с политикой — проверки DevContour `validateTaskContext`,
+ * выполнимые без модели и без внешних источников: репозиторий и роль
+ * объявлены; ресурсы известны; область записи пересекается с областью роли;
+ * область доказательства раскрывается, замкнута по `dependsOn` gates и
+ * содержит test gate; требования не повторяются, их текст совпадает с
+ * digest, а gate — test gate из области; потребители уникальны, отличны от
+ * провайдера, зависят от него и проверяются test gate; поручение уровня
+ * workspace затрагивает минимум два известных репозитория.
+ *
+ * Не проверяется здесь: байты и digests контекста и контрактов — их
+ * сверяет движок с `ContextSource` при регистрации графа.
+ */
+export function crossIssues(graph, policy) {
+    const issues = [];
+    const repos = new Map(policy.repositories.map((r) => [r.id, r]));
+    const resources = new Set(policy.resources.map((r) => r.id));
+    const dependsOn = (consumer, provider) => {
+        const seen = new Set();
+        const visit = (id) => {
+            if (seen.has(id))
+                return false;
+            seen.add(id);
+            return (repos.get(id)?.dependsOn ?? []).some((p) => p === provider || visit(p));
+        };
+        return visit(consumer);
+    };
+    graph.prerequisites.forEach((p, i) => {
+        if (!repos.has(p.repositoryId))
+            issues.push({
+                code: 'INVALID_INPUT',
+                path: ['graph', 'prerequisites', i, 'repositoryId'],
+                message: 'Репозиторий предпосылки не объявлен политикой: ' + p.repositoryId,
+            });
+    });
+    graph.orders.forEach((order, i) => {
+        const at = (...p) => ['graph', 'orders', i, ...p];
+        const add = (code, path, message) => issues.push({ code, path, message });
+        const repo = repos.get(order.repositoryId);
+        if (!repo) {
+            add('INVALID_INPUT', at('repositoryId'), 'Репозиторий не объявлен политикой: ' + order.repositoryId);
+            return;
+        }
+        const role = roleBinding(policy, order.role, order.repositoryId);
+        if (!role)
+            add('INVALID_INPUT', at('role'), 'Роль не объявлена политикой: ' + order.role);
+        for (const r of order.resources ?? [])
+            if (!resources.has(r))
+                add('INVALID_INPUT', at('resources'), 'Неизвестный ресурс: ' + r);
+        if (role?.writePaths?.length) {
+            const reachable = order.writeScope.filter((p) => withinPaths(p, role.writePaths) || role.writePaths.some((r) => withinPaths(r, [p])));
+            if (!reachable.length)
+                add('INVALID_INPUT', at('writeScope'), `Область записи поручения не пересекается с областью роли ${order.role}: исполнитель не сможет изменить ни одного файла`);
+        }
+        const expand = (r, refs, path, label) => {
+            let gates;
+            try {
+                gates = expandGateRefs(r, refs);
+            }
+            catch (error) {
+                add(error.code ?? 'GATE_UNKNOWN', path, error.message);
+                return undefined;
+            }
+            for (const id of gates)
+                for (const parent of r.gates.find((g) => g.id === id)?.dependsOn ?? [])
+                    if (!gates.includes(parent))
+                        add('INVALID_INPUT', path, `Область ${label}: gate ${id} требует ${parent} — добавьте ${parent} явно`);
+            if (!gates.some((id) => r.gates.some((g) => g.id === id && g.kind === 'test')))
+                add('INVALID_INPUT', path, `Область ${label} должна включать test gate`);
+            return gates;
+        };
+        const own = expand(repo, order.gates, at('gates'), 'поручения');
+        const keys = new Set();
+        order.requirements.forEach((req, k) => {
+            const key = `${req.source}#${req.id}`;
+            if (keys.has(key))
+                add('INVALID_INPUT', at('requirements', k), 'Повтор требования: ' + key);
+            keys.add(key);
+            if (sha256(req.text) !== req.digest)
+                add('INVALID_INPUT', at('requirements', k, 'digest'), 'Текст требования не соответствует digest');
+            if (!repo.gates.some((g) => g.id === req.gate && g.kind === 'test'))
+                add('INVALID_INPUT', at('requirements', k, 'gate'), 'Требование должно ссылаться на test gate: ' + req.gate);
+            else if (order.gates && own && !own.includes(req.gate))
+                add('INVALID_INPUT', at('requirements', k, 'gate'), 'Требование ссылается на проверку вне области поручения: ' + req.gate);
+        });
+        const consumerIds = (order.consumers ?? []).map((c) => c.repositoryId);
+        if (new Set(consumerIds).size !== consumerIds.length)
+            add('INVALID_INPUT', at('consumers'), 'Потребитель назван дважды: объедините его проверки в одну запись');
+        order.consumers?.forEach((c, k) => {
+            const consumer = repos.get(c.repositoryId);
+            if (c.repositoryId === order.repositoryId)
+                add('INVALID_INPUT', at('consumers', k), 'Потребитель — другой компонент, а не компонент поручения');
+            else if (!consumer)
+                add('INVALID_INPUT', at('consumers', k), 'Потребитель не объявлен политикой: ' + c.repositoryId);
+            else if (!dependsOn(c.repositoryId, order.repositoryId))
+                add('INVALID_INPUT', at('consumers', k), `Компонент ${c.repositoryId} не зависит от ${order.repositoryId}: он не потребитель`);
+            else
+                expand(consumer, c.gates, at('consumers', k, 'gates'), `потребителя ${c.repositoryId}`);
+        });
+        if (order.relatedRepositories.length && new Set(order.relatedRepositories).size < 2)
+            add('INVALID_INPUT', at('relatedRepositories'), 'Поручение уровня workspace должно затрагивать минимум два компонента');
+        order.relatedRepositories.forEach((r, k) => {
+            if (!repos.has(r))
+                add('INVALID_INPUT', at('relatedRepositories', k), 'Репозиторий не объявлен политикой: ' + r);
+        });
+    });
+    return issues;
+}
+/**
+ * Снимок контекста против графа: содержимое совпадает с digests, каждый
+ * источник, названный поручением, присутствует и обязателен либо явно
+ * помечен отсутствующим дополнительным.
+ */
+function contextSnapshotIssues(graph, context) {
+    const issues = contextIssues(context).map((message) => ({
+        code: 'INVALID_INPUT',
+        path: ['context'],
+        message,
+    }));
+    const sources = new Map(context.sources.map((s) => [s.id, s]));
+    graph.orders.forEach((order, i) => order.context.forEach((id, k) => {
+        const source = sources.get(id);
+        if (!source)
+            issues.push({
+                code: 'INVALID_INPUT',
+                path: ['graph', 'orders', i, 'context', k],
+                message: 'Обязательный источник контекста отсутствует в снимке: ' + id,
+            });
+        else if (!source.required)
+            issues.push({
+                code: 'INVALID_INPUT',
+                path: ['graph', 'orders', i, 'context', k],
+                message: 'Источник, названный поручением, должен быть обязательным: ' + id,
+            });
+    }));
+    return issues;
+}
+/**
+ * Проверка входов без вызова моделей и без записи состояния. Ошибки
+ * собираются все сразу; код первой определяет класс отказа.
+ */
+export function validateInputs(input) {
+    const graph = parse(workGraphSchema, input.graph, 'graph');
+    const policy = parse(executionPolicySchema, input.policy, 'policy');
+    const context = input.context === undefined
+        ? undefined
+        : parse(contextSnapshotSchema, input.context, 'context');
+    const issues = [
+        ...(context ? contextSnapshotIssues(graph, context) : []),
+        ...graphIssues(graph).map((i) => ({ ...i, path: ['graph', ...i.path] })),
+        ...policyIssues(policy).map((i) => ({ ...i, path: ['policy', ...i.path] })),
+        ...crossIssues(graph, policy),
+    ];
+    if (issues.length)
+        throw new HarnessError(issues[0].code, `Найдено нарушений: ${issues.length}`, issues.map(({ path, message }) => ({ path, message })));
+    return {
+        graphId: graph.id,
+        graphDigest: workGraphDigest(graph),
+        policyDigest: policyDigest(policy),
+        orders: graph.orders.length,
+        ...(context ? { contextDigest: contextDigest(context) } : {}),
+    };
+}

package/lib/verification/acceptance.d.ts

@@ -0,0 +1,284 @@
+import { type CheckSuite, type ContractDocument, type EvidenceRecord, type ExecutionPolicy, type ExecutionView, type RunResult, type WorkOrder } from '../contracts/index.ts';
+import { type CorpusSnapshot } from './checks.ts';
+/**
+ * Доказательство договора проверки на границе приёмки.
+ *
+ * Бит PASS и верная версия проверок не доказывают, что генеративный gate
+ * исполнил договор поручения: сохранённое evidence без манифеста свойств
+ * или с заниженным корпусом выдало бы прежний уровень за сильный. Поэтому и
+ * `finish` (а через него recovery), и проверка переносимого результата
+ * требуют для каждого gate объявленных свойств решающую запись обеих фаз с
+ * манифестом ожидаемой проверки и исполненным обязательным корпусом
+ * закреплённой версии. Поручение без `properties` — прежний уровень.
+ */
+type ProofEvidence = Pick<EvidenceRecord, 'kind' | 'phase' | 'gate' | 'sha' | 'passed'> & {
+    consumer?: string | undefined;
+    checks?: string | undefined;
+    exitCode?: number | undefined;
+    property?: Pick<NonNullable<EvidenceRecord['property']>, 'level' | 'manifest'> | undefined;
+};
+export interface PropertyProofInput {
+    order: Pick<WorkOrder, 'properties'>;
+    contracts: ContractDocument[];
+    candidateSha: string;
+    resultSha: string;
+    /** Версия проверок попытки (`checks.effective`). */
+    effective?: string | undefined;
+    /** Случаи закреплённой версии корпуса; `null` — закреплённая версия не найдена. */
+    corpus?: CorpusSnapshot | null | undefined;
+    evidence: ProofEvidence[];
+}
+/** Gates объявленных свойств поручения и их свойства. */
+export declare function propertyGates(order: Pick<WorkOrder, 'properties'>, contracts: ContractDocument[]): {
+    problem: string;
+    byGate?: undefined;
+} | {
+    byGate: Map<string, string[]>;
+    problem?: undefined;
+};
+/** Причина отказа в доказательстве свойств или undefined. */
+export declare function propertyProofProblem(input: PropertyProofInput): string | undefined;
+/** Случаи закреплённой версии корпуса по состоянию исполнения. */
+export declare function pinnedCorpus(view: ExecutionView, binding: {
+    suite: string;
+    digest: string;
+}): CorpusSnapshot | null;
+/** Случаи версии корпуса по digest; `null` — версии нет. */
+export declare function suiteCorpus(suite: Pick<CheckSuite, 'versions' | 'cases'> | undefined, digest: string): CorpusSnapshot | null;
+/** Политика получателя: репозитории (gates, группы, зависимости, target), роли и правила ревью. */
+export type ReceiverPolicy = Pick<ExecutionPolicy, 'repositories' | 'roles' | 'review'>;
+/**
+ * Что получатель знает сам и передаёт проверке. Всё, что результат
+ * утверждает о поручении, его области, входах и ревью, сверяется с этим, а не
+ * с другими полями того же результата: согласованная сама с собой подделка
+ * иначе проходила бы.
+ */
+export interface ReceiverContext {
+    /** Постановка поручения у получателя. */
+    order: WorkOrder;
+    /** Граф, в котором получатель держит поручение. */
+    graphId: string;
+    /** Договоры поручения по его ссылкам (документы у получателя). */
+    contracts: ContractDocument[];
+    /** Политика получателя: репозиторий поручения, потребители и их зависимости, роли, ревью. */
+    policy: ReceiverPolicy;
+    /**
+     * Снимок контекста, закреплённый согласованием графа у получателя; `null` —
+     * согласование без контекста.
+     */
+    contextDigest: string | null;
+    /** Корпус по id из копии получателя. */
+    suite?: (id: string) => Pick<CheckSuite, 'versions' | 'cases' | 'contractId' | 'basis'> | undefined;
+    /** Digest согласованной постановки у хоста получателя; по умолчанию — digest поручения. */
+    specDigest?: string;
+    /** Закреплённая за поручением версия корпуса у получателя (`null` — без корпуса). */
+    checkVersion?: {
+        suite: string;
+        digest: string;
+    } | null;
+    /**
+     * Формула версии проверок хоста получателя (как `BasisProvider.checksDigest`);
+     * без неё — формула harness.
+     */
+    checksDigest?(input: {
+        specDigest: string;
+        order: WorkOrder;
+        policyDigest: string;
+        corpus?: {
+            suite: string;
+            digest: string;
+        };
+    }): string;
+    /** Основание корпуса по формуле хоста получателя (как `BasisProvider.suiteBasis`). */
+    suiteBasis?(contract: ContractDocument): string;
+    /**
+     * Результат прежнего формата хоста, в котором входы попытки не
+     * наблюдались: `dependencies` — снимков собственных зависимостей и их
+     * свежести нет; `consumers` — у потребителей нет свежести. Тогда пустые
+     * списки не сверяются с замыканием — их нет, и проверке они не подлежат;
+     * непустые, снимки зависимостей потребителя, провайдер и всё остальное
+     * сверяются как обычно. Какой результат имеет прежний формат, решает хост
+     * по своим правилам формата.
+     */
+    unobserved?: {
+        dependencies?: boolean;
+        consumers?: boolean;
+    };
+    /**
+     * Чем подтверждено ревью: `current` (по умолчанию) — writer и reviewer
+     * назначены текущей политикой получателя; `recorded` — результат несёт
+     * своё назначение (writer и reviewer записаны при приёмке) и хост
+     * перепроверяет его позже, когда назначение ролей могло смениться: тогда
+     * оба должны быть runtime политики получателя, а правило вендора роли —
+     * соблюдено.
+     */
+    assignment?: 'current' | 'recorded';
+}
+/**
+ * Модель доверия получателя: для каждого поля принятого `RunResult` — как
+ * оно участвует в вердикте.
+ *
+ * - `expected` — сверяется с ожиданием, которое получатель вычисляет сам из
+ *   `ReceiverContext` (поручение, граф, политика, договоры, корпус, контекст);
+ * - `consistency` — сверяется на согласованность с другими полями результата
+ *   (SHA фаз, свежесть со снимками, уникальность записей);
+ * - `informative` — сведение, которое ничего не доказывает: вердикт на него
+ *   не опирается, и его изменение вердикт не меняет;
+ * - `schema` — значение фиксировано схемой.
+ *
+ * Подлинность SHA, деревьев, artifacts и записей (их наличие в Git и в
+ * хранилище исполнителя) получатель не удостоверяет: это транспорт хоста.
+ * Таблица — проверяемое утверждение: `tests/receipt-trust.test.ts` строит
+ * подделку каждого поля `expected`/`consistency` и требует отказа, а изменение
+ * поля `informative` — того же вердикта.
+ */
+export declare const receiptTrust: {
+    readonly apiVersion: readonly ["schema", "литерал версии API"];
+    readonly outcome: readonly ["expected", "только accepted подтверждает приёмку"];
+    readonly workOrderId: readonly ["expected", "ID поручения получателя"];
+    readonly graphId: readonly ["expected", "граф поручения у получателя"];
+    readonly 'source.connector': readonly ["expected", "источник поручения получателя"];
+    readonly 'source.ref': readonly ["expected", "источник поручения получателя"];
+    readonly 'source.revision': readonly ["expected", "редакция поручения получателя"];
+    readonly runId: readonly ["informative", "идентификатор попытки у исполнителя"];
+    readonly attempt: readonly ["informative", "номер попытки у исполнителя"];
+    readonly repositoryId: readonly ["expected", "репозиторий поручения"];
+    readonly targetRef: readonly ["expected", "target ref репозитория в политике получателя"];
+    readonly 'inputs.harnessVersion': readonly ["informative", "версия исполнителя"];
+    readonly 'inputs.consumerVersion': readonly ["informative", "версия хоста исполнителя"];
+    readonly 'inputs.stateVersion': readonly ["schema", "литерал версии состояния"];
+    readonly 'inputs.workOrderDigest': readonly ["expected", "digest поручения получателя"];
+    readonly 'inputs.graphDigest': readonly ["informative", "граф мог получить новую редакцию при неизменном поручении; привязка — digest поручения и его источник"];
+    readonly 'inputs.policyDigest': readonly ["consistency", "входит в вычисление версии проверок"];
+    readonly 'inputs.contextDigest': readonly ["expected", "снимок контекста согласования у получателя"];
+    readonly 'inputs.checks': readonly ["expected", "версия проверок, вычисленная получателем"];
+    readonly 'inputs.corpus.suite': readonly ["expected", "корпус, закреплённый за поручением у получателя"];
+    readonly 'inputs.corpus.number': readonly ["expected", "номер этой версии в корпусе получателя"];
+    readonly 'inputs.corpus.digest': readonly ["expected", "версия корпуса, закреплённая у получателя"];
+    readonly 'inputs.corpus': readonly ["expected", "привязка к корпусу, закреплённому у получателя"];
+    readonly 'inputs.requiredGates': readonly ["expected", "область поручения, раскрытая по политике получателя; без поля — область получателя"];
+    readonly 'inputs.requiredGates[]': readonly ["expected", "ровно эта область, без повторов"];
+    readonly 'inputs.writer': readonly ["expected", "writer роли поручения; без поля — writer роли получателя"];
+    readonly 'inputs.writer.runtime': readonly ["expected", "writer роли поручения в политике получателя"];
+    readonly 'inputs.writer.model': readonly ["informative", "модель writer"];
+    readonly 'checked.dependencies': readonly ["expected", "замыкание зависимостей репозитория по политике получателя"];
+    readonly 'checked.dependencies[]': readonly ["expected", "ровно один снимок каждой зависимости замыкания"];
+    readonly 'checked.dependencies[].repositoryId': readonly ["expected", "зависимость из замыкания"];
+    readonly 'checked.dependencies[].sha': readonly ["consistency", "совпадает со снимком в свежести"];
+    readonly 'checked.dependencies[].tree': readonly ["informative", "подлинность дерева — Git хоста"];
+    readonly 'checked.dependencies[].artifacts': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.dependencies[].artifacts[]': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.dependencies[].artifacts[].path': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.dependencies[].artifacts[].digest': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.freshness': readonly ["expected", "свежесть каждой зависимости замыкания"];
+    readonly 'checked.freshness[]': readonly ["expected", "ровно одна запись на зависимость"];
+    readonly 'checked.freshness[].repositoryId': readonly ["expected", "зависимость из замыкания"];
+    readonly 'checked.freshness[].snapshot': readonly ["consistency", "совпадает со снимком зависимости"];
+    readonly 'checked.freshness[].head': readonly ["consistency", "fresh ⇔ head = snapshot; значение головы — наблюдение"];
+    readonly 'checked.freshness[].fresh': readonly ["consistency", "fresh ⇔ head = snapshot"];
+    readonly 'checked.consumers': readonly ["expected", "объявленные потребители поручения"];
+    readonly 'checked.consumers[]': readonly ["expected", "ровно одно описание каждого объявленного потребителя"];
+    readonly 'checked.consumers[].repositoryId': readonly ["expected", "объявленный потребитель"];
+    readonly 'checked.consumers[].gates': readonly ["expected", "область потребителя, раскрытая по политике получателя"];
+    readonly 'checked.consumers[].gates[]': readonly ["expected", "ровно эта область, без повторов"];
+    readonly 'checked.consumers[].sha': readonly ["consistency", "совпадает со снимком потребителя в его свежести"];
+    readonly 'checked.consumers[].tree': readonly ["informative", "подлинность дерева — Git хоста"];
+    readonly 'checked.consumers[].dependencies': readonly ["expected", "замыкание зависимостей потребителя по политике получателя"];
+    readonly 'checked.consumers[].dependencies[]': readonly ["expected", "ровно один снимок каждой зависимости замыкания"];
+    readonly 'checked.consumers[].dependencies[].repositoryId': readonly ["expected", "зависимость из замыкания"];
+    readonly 'checked.consumers[].dependencies[].sha': readonly ["consistency", "у провайдера — result SHA; у прочих — снимок в свежести"];
+    readonly 'checked.consumers[].dependencies[].tree': readonly ["informative", "подлинность дерева — Git хоста"];
+    readonly 'checked.consumers[].dependencies[].artifacts': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.consumers[].dependencies[].artifacts[]': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.consumers[].dependencies[].artifacts[].path': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.consumers[].dependencies[].artifacts[].digest': readonly ["informative", "подлинность artifacts — Git хоста"];
+    readonly 'checked.consumers[].freshness': readonly ["expected", "свежесть каждого входа потребителя, кроме провайдера, и его самого"];
+    readonly 'checked.consumers[].freshness[]': readonly ["expected", "ровно одна запись на вход"];
+    readonly 'checked.consumers[].freshness[].repositoryId': readonly ["expected", "вход потребителя"];
+    readonly 'checked.consumers[].freshness[].snapshot': readonly ["consistency", "совпадает со снимком входа"];
+    readonly 'checked.consumers[].freshness[].head': readonly ["consistency", "fresh ⇔ head = snapshot; значение головы — наблюдение"];
+    readonly 'checked.consumers[].freshness[].fresh': readonly ["consistency", "fresh ⇔ head = snapshot"];
+    readonly evidence: readonly ["expected", "решающие записи всех обязательных проверок обеих фаз"];
+    readonly 'evidence[]': readonly ["consistency", "записи уникальны по ID"];
+    readonly 'evidence[].id': readonly ["consistency", "уникален"];
+    readonly 'evidence[].kind': readonly ["consistency", "согласован с gate (ревью ⇔ independent-review) и с потребителем"];
+    readonly 'evidence[].phase': readonly ["consistency", "SHA записи — SHA её фазы"];
+    readonly 'evidence[].gate': readonly ["expected", "обязательная проверка поручения, потребителя или ревью"];
+    readonly 'evidence[].sha': readonly ["consistency", "SHA фазы: candidate или result"];
+    readonly 'evidence[].passed': readonly ["expected", "решающая запись каждой обязательной проверки — PASS"];
+    readonly 'evidence[].digest': readonly ["informative", "подлинность записи — хранилище исполнителя"];
+    readonly 'evidence[].summary': readonly ["informative", "описание записи"];
+    readonly 'evidence[].consumer': readonly ["expected", "объявленный потребитель"];
+    readonly 'evidence[].checks': readonly ["expected", "версия проверок, вычисленная получателем, у каждой записи"];
+    readonly 'evidence[].tests': readonly ["expected", "доказательство названного testcase решающей записью"];
+    readonly 'evidence[].tests[]': readonly ["expected", "элемент названного testcase; прочие элементы — сведения"];
+    readonly 'evidence[].tests[].id': readonly ["expected", "ID названного testcase"];
+    readonly 'evidence[].tests[].status': readonly ["expected", "названный testcase прошёл"];
+    readonly 'evidence[].tests[].opaque': readonly ["expected", "имя названного testcase не скрыто"];
+    readonly 'evidence[].testsTruncated': readonly ["expected", "список решающей записи полон"];
+    readonly 'evidence[].property': readonly ["expected", "доказательство договора проверки; у записи потребителя — только legacy без манифеста"];
+    readonly 'evidence[].property.level': readonly ["expected", "уровень manifest; у записи потребителя — legacy"];
+    readonly 'evidence[].property.manifest': readonly ["expected", "манифест договора поручения"];
+    readonly 'evidence[].property.manifest.digest': readonly ["expected", "манифест, вычисленный получателем"];
+    readonly 'evidence[].property.manifest.properties': readonly ["expected", "свойства поручения"];
+    readonly 'evidence[].property.manifest.properties[]': readonly ["expected", "свойства поручения"];
+    readonly 'evidence[].property.manifest.corpus': readonly ["expected", "корпус закреплённой версии"];
+    readonly 'evidence[].property.manifest.corpus.digest': readonly ["expected", "версия корпуса у получателя"];
+    readonly 'evidence[].property.manifest.corpus.cases': readonly ["expected", "число случаев этой версии"];
+    readonly 'evidence[].reviewer': readonly ["expected", "reviewer, назначенный политикой получателя"];
+    readonly 'evidence[].reviewer.runtime': readonly ["expected", "reviewer роли в политике получателя"];
+    readonly 'evidence[].reviewer.model': readonly ["informative", "модель reviewer"];
+    readonly 'evidence[].reviewer.sameVendor': readonly ["consistency", "вендоры writer и reviewer"];
+    readonly 'evidence[].review': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.round': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.call': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.protocol': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.issues': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.issues[]': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.issues[].path': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.issues[].reason': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.issues[].message': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.transitions': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.transitions[]': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.transitions[].id': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.transitions[].from': readonly ["informative", "раунд протокола ревью кода"];
+    readonly 'evidence[].review.transitions[].to': readonly ["informative", "раунд протокола ревью кода"];
+    readonly findings: readonly ["informative", "сводка находок может относиться к отклонённым раундам"];
+    readonly 'findings[]': readonly ["informative", "сводка находок"];
+    readonly 'findings[].severity': readonly ["informative", "сводка находок"];
+    readonly 'findings[].message': readonly ["informative", "сводка находок"];
+    readonly 'findings[].path': readonly ["informative", "сводка находок"];
+    readonly 'findings[].line': readonly ["informative", "сводка находок"];
+    readonly 'findings[].rule': readonly ["informative", "сводка находок"];
+    readonly 'findings[].id': readonly ["informative", "сводка находок"];
+    readonly 'findings[].status': readonly ["informative", "сводка находок"];
+    readonly limitations: readonly ["informative", "чего результат не доказывает"];
+    readonly 'limitations[]': readonly ["informative", "чего результат не доказывает"];
+    readonly finishedAt: readonly ["informative", "время окончания"];
+    readonly 'shas.base': readonly ["informative", "база кандидата; подлинность — Git хоста"];
+    readonly 'shas.candidate': readonly ["consistency", "SHA решающих записей кандидата"];
+    readonly 'shas.integration': readonly ["consistency", "равен result SHA"];
+    readonly 'shas.result': readonly ["consistency", "SHA решающих записей интеграции и снимка провайдера у потребителей"];
+};
+/**
+ * Проверка переносимого результата (receipt) принятой попытки получателем.
+ *
+ * Получатель повторяет все условия приёмки, проверяемые по результату, против
+ * того, что знает сам (`ReceiverContext`); как участвует каждое поле, задаёт
+ * `receiptTrust`. Результат не может: относиться к другому поручению,
+ * графу, редакции источника, репозиторию или ветке; сократить или подменить
+ * область gates; выдать запись другого вида или ревью за test gate;
+ * доказать testcase не решающей записью или записью другой версии; убрать
+ * проверку источника требований; опустить, повторить или выдумать
+ * потребителя, его область или входы; описать неполный, повторный или
+ * противоречивый состав зависимостей и свежести; заявить ревью reviewer-ом,
+ * которого политика получателя не назначает, или того же вендора без явного
+ * разрешения; смешать версии проверок; убрать или занизить манифест и корпус.
+ * Чего не хватает в контексте получателя, — отказ, а не PASS. Результат
+ * прежнего формата (без версии проверок, области и writer) у поручения без
+ * договора проверки читается на прежнем уровне.
+ */
+export declare function resultProblems(result: RunResult, context: ReceiverContext): string[];
+/** Отказ получателя: результат не подтверждает приёмку. */
+export declare function assertResult(...args: Parameters<typeof resultProblems>): void;
+export {};