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

package/lib/verification/checks.d.ts

@@ -0,0 +1,72 @@
+import { type CheckDeclaration, type CheckSuite, type ContractDocument, type ExecutionView, type GatePolicy, type Obligation, type WorkOrder, type WorkState } from '../contracts/index.ts';
+import type { CheckManifest } from './property.ts';
+/**
+ * Договоры проверки поручения. Механизм включает само поручение полем
+ * `properties`; поручение без него проверяется на прежнем уровне.
+ */
+/** Документы контрактов поручения по закреплённым digest; неизвестный — отсутствует. */
+export declare function contractDocuments(order: Pick<WorkOrder, 'contracts'>, view: ExecutionView): ContractDocument[];
+type Declared = {
+    contract: ContractDocument;
+    gate: string;
+    obligation: Obligation;
+};
+/** Основание случаев корпуса: закреплённые файлы, gate и смысл обязательств. */
+export declare function suiteBasis(contract: ContractDocument): string;
+/**
+ * Привязка поручения к версии корпуса остаётся в силе, только пока среди его
+ * договоров есть договор этого корпуса с тем же нормативным основанием.
+ * Изменение постороннего контракта её не снимает; новый ID или новые правила
+ * того же ID — снимают: ожидания прежнего основания не становятся нормой для
+ * новых правил.
+ */
+export declare function corpusBindingHolds(suite: Pick<CheckSuite, 'contractId' | 'basis'> | undefined, contracts: ContractDocument[], 
+/** Основание корпуса по формуле хоста; без неё — формула harness. */
+basisOf?: (contract: ContractDocument) => string): boolean;
+/** Обязательство по property ID среди договоров поручения. */
+export declare function obligationOf(contracts: ContractDocument[], id: string): Declared | undefined;
+/**
+ * Структурные пропуски договора проверки — до вызова модели. Способ проверки
+ * обязан ссылаться на закреплённые файлы контракта: иначе происхождение
+ * эталона не закреплено ничем.
+ */
+export declare function declarationProblems(declaration: CheckDeclaration, context: {
+    gates: GatePolicy[];
+    repositoryId: string;
+    artifacts: string[];
+    spike?: (id: string) => {
+        digest: string;
+    } | undefined;
+}): string[];
+/**
+ * Свойства, объявленные поручением, существуют в его договорах и исполняются
+ * его генеративными gates. Поручение без `properties` — прежний уровень.
+ */
+export declare function orderPropertyProblems(order: Pick<WorkOrder, 'id' | 'properties' | 'gates' | 'requirements'>, contracts: ContractDocument[], 
+/** Gates репозитория поручения и раскрытая область поручения. */
+gates: {
+    configured: GatePolicy[];
+    scope?: string[];
+}): string[];
+/** Случаи корпуса, закреплённые за попыткой. */
+export interface CorpusSnapshot {
+    digest: string;
+    cases: {
+        id: string;
+        property: string;
+    }[];
+}
+/**
+ * Манифест ожидаемой проверки gate для поручения или undefined — прежний
+ * уровень доказательства (поручение не включило механизм).
+ */
+export declare function orderCheckManifest(order: Pick<WorkOrder, 'properties'>, contracts: ContractDocument[], gate: string, corpus?: CorpusSnapshot): CheckManifest | undefined;
+/**
+ * Действующая версия проверок поручения: согласованная постановка,
+ * контракты, политика и принятый snapshot корпуса. Закрепляется в попытке
+ * при выдаче и участвует в evidence, finish, recovery и reuse.
+ */
+export declare function effectiveChecks(work: Pick<WorkState, 'approvedDigest' | 'order' | 'checkVersion'>, policyDigest: string): string;
+/** Основание эпизода восстановления: согласованная постановка и контракты. */
+export declare function episodeBasis(work: Pick<WorkState, 'approvedDigest' | 'order'>): string;
+export {};

package/lib/verification/checks.js

@@ -0,0 +1,190 @@
+import { WORKSPACE_OWNER, digestOf, } from "../contracts/index.js";
+import { strongPromises } from "../contracts/index.js";
+/**
+ * Договоры проверки поручения. Механизм включает само поручение полем
+ * `properties`; поручение без него проверяется на прежнем уровне.
+ */
+/** Документы контрактов поручения по закреплённым digest; неизвестный — отсутствует. */
+export function contractDocuments(order, view) {
+    return order.contracts
+        .map((ref) => view.local('contract-documents', WORKSPACE_OWNER, ref.digest))
+        .filter((d) => !!d);
+}
+/** Обязательства договоров поручения, исполняемые данным 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 }))
+        : []);
+}
+/** Основание случаев корпуса: закреплённые файлы, gate и смысл обязательств. */
+export function suiteBasis(contract) {
+    const declaration = contract.checks;
+    return digestOf({
+        artifacts: (contract.artifacts ?? []).map((a) => ({ path: a.path, blob: a.blob })),
+        gate: declaration.gate,
+        obligations: declaration.obligations.map((o) => ({
+            property: o.property,
+            domain: o.domain,
+            answer: o.answer,
+            method: o.method,
+        })),
+    });
+}
+/**
+ * Привязка поручения к версии корпуса остаётся в силе, только пока среди его
+ * договоров есть договор этого корпуса с тем же нормативным основанием.
+ * Изменение постороннего контракта её не снимает; новый ID или новые правила
+ * того же ID — снимают: ожидания прежнего основания не становятся нормой для
+ * новых правил.
+ */
+export function corpusBindingHolds(suite, contracts, 
+/** Основание корпуса по формуле хоста; без неё — формула harness. */
+basisOf = suiteBasis) {
+    if (!suite)
+        return false;
+    const contract = contracts.find((c) => c.id === suite.contractId && c.checks);
+    return !!contract && basisOf(contract) === suite.basis;
+}
+/** Обязательство по property ID среди договоров поручения. */
+export function obligationOf(contracts, id) {
+    return declared(contracts).find((x) => x.obligation.property === id);
+}
+/**
+ * Структурные пропуски договора проверки — до вызова модели. Способ проверки
+ * обязан ссылаться на закреплённые файлы контракта: иначе происхождение
+ * эталона не закреплено ничем.
+ */
+export function declarationProblems(declaration, context) {
+    const problems = [];
+    const gate = context.gates.find((g) => g.id === declaration.gate);
+    if (!gate)
+        problems.push(`gate ${declaration.gate} не настроен в репозитории ${context.repositoryId}`);
+    const ids = declaration.obligations.map((o) => o.property);
+    for (const id of new Set(ids))
+        if (ids.filter((x) => x === id).length > 1)
+            problems.push(`свойство ${id} объявлено дважды`);
+    for (const o of declaration.obligations) {
+        const at = `свойство ${o.property}`;
+        if (o.promise === 'other' && !o.explanation)
+            problems.push(`${at}: для типа other объясните, какое это обещание`);
+        const families = o.coverage.families.map((f) => f.id);
+        if (new Set(families).size !== families.length)
+            problems.push(`${at}: id семейств входов повторяются`);
+        const sum = o.coverage.families.reduce((n, f) => n + f.minCases, 0);
+        if (sum > o.coverage.minCases)
+            problems.push(`${at}: семейства требуют ${sum} входов, больше общего минимума ${o.coverage.minCases}`);
+        for (const path of o.method.artifacts)
+            if (!context.artifacts.includes(path))
+                problems.push(`${at}: ${path} не объявлен артефактом контракта и не закреплён`);
+        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)`);
+        }
+        if (o.promise === 'performance' && !o.resources.benchmark)
+            problems.push(`${at}: для производительности укажите метод измерения и среду`);
+        if (o.coverage.corpus && !declaration.corpus)
+            problems.push(`${at}: корпус включён, но политика расширения корпуса не описана`);
+        if (o.hard) {
+            if (!o.feasibility)
+                problems.push(`${at}: тяжёлое обязательство требует ограниченного эксперимента до реализации (spike)`);
+            else {
+                const spike = context.spike?.(o.feasibility.spike);
+                if (!spike)
+                    problems.push(`${at}: эксперимент ${o.feasibility.spike} не найден`);
+                else if (spike.digest !== o.feasibility.digest)
+                    problems.push(`${at}: эксперимент ${o.feasibility.spike} изменился после ссылки на него`);
+            }
+        }
+    }
+    return problems;
+}
+/**
+ * Свойства, объявленные поручением, существуют в его договорах и исполняются
+ * его генеративными gates. Поручение без `properties` — прежний уровень.
+ */
+export function orderPropertyProblems(order, contracts, 
+/** Gates репозитория поручения и раскрытая область поручения. */
+gates) {
+    if (!order.properties?.length)
+        return [];
+    const problems = [];
+    const all = declared(contracts);
+    if (new Set(order.properties).size !== order.properties.length)
+        problems.push(`${order.id}: свойства поручения повторяются`);
+    for (const id of order.properties) {
+        const found = all.filter((x) => x.obligation.property === id);
+        if (!found.length) {
+            problems.push(`${order.id}: свойство ${id} не объявлено в договорах поручения`);
+            continue;
+        }
+        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} не генеративный — селектор свойств не подготовлен`);
+    }
+    // Сценарий, названный тем же id, проверяет тот же gate: иначе требование
+    // ссылается на свойство, а подтверждается другой проверкой.
+    for (const link of order.requirements ?? []) {
+        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}`);
+    }
+    return problems;
+}
+/**
+ * Манифест ожидаемой проверки gate для поручения или undefined — прежний
+ * уровень доказательства (поручение не включило механизм).
+ */
+export function orderCheckManifest(order, contracts, gate, corpus) {
+    if (!order.properties?.length)
+        return undefined;
+    const obligations = declared(contracts, gate).filter((x) => order.properties.includes(x.obligation.property));
+    if (!obligations.length)
+        return undefined;
+    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 })),
+        })),
+        ...(corpus && cases.length ? { corpus: { digest: corpus.digest, cases } } : {}),
+    };
+}
+/**
+ * Действующая версия проверок поручения: согласованная постановка,
+ * контракты, политика и принятый snapshot корпуса. Закрепляется в попытке
+ * при выдаче и участвует в evidence, finish, recovery и reuse.
+ */
+export function effectiveChecks(work, policyDigest) {
+    return digestOf({
+        spec: work.approvedDigest ?? null,
+        contracts: Object.fromEntries(work.order.contracts.map((c) => [c.id, c.digest])),
+        policy: policyDigest,
+        corpus: work.checkVersion?.digest ?? null,
+    });
+}
+/** Основание эпизода восстановления: согласованная постановка и контракты. */
+export function episodeBasis(work) {
+    return digestOf({
+        spec: work.approvedDigest ?? null,
+        contracts: Object.fromEntries(work.order.contracts.map((c) => [c.id, c.digest])),
+    });
+}

package/lib/verification/confirm.d.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { type ContractArtifact, type ExecutionPolicy } from '../contracts/index.ts';
+import { type CorpusStore } from './corpus.ts';
+/**
+ * Быстрый маршрут: подтверждённый пример становится обязательным случаем.
+ *
+ * Пример reviewer или ведущего — гипотеза. Controller сам запускает
+ * закреплённый эталон на этом входе (режим одного случая того же checker,
+ * что исполняет gate), повторяет проверку реализации на исходном дефектном
+ * SHA и требует воспроизводимого расхождения. Ответ эталона, а не слова
+ * reviewer, становится ожиданием. Команда из воспроизведения не исполняется
+ * никогда; данные входа не интерпретируются как shell.
+ *
+ * Маршрут только добавляет данные под тем же checker/oracle, той же областью
+ * и правилами ответа. Удаление случая, замена ожидания, допуск, покрытие,
+ * новый checker или команда — обычное изменение договора проверки.
+ */
+export declare const fastPathChanges: readonly ["add", "remove", "replace-expected", "tolerance", "coverage", "checker", "command"];
+export declare const caseInputSchema: z.ZodObject<{
+    workId: z.ZodString;
+    property: z.ZodString;
+    input: z.ZodString;
+    expected: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    actual: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reproductionId: z.ZodOptional<z.ZodString>;
+    sourceSha: z.ZodOptional<z.ZodString>;
+    sourceRunId: z.ZodOptional<z.ZodString>;
+    adopt: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    key: z.ZodString;
+    change: z.ZodDefault<z.ZodEnum<{
+        command: "command";
+        tolerance: "tolerance";
+        coverage: "coverage";
+        add: "add";
+        remove: "remove";
+        "replace-expected": "replace-expected";
+        checker: "checker";
+    }>>;
+    origin: z.ZodDefault<z.ZodEnum<{
+        review: "review";
+        agent: "agent";
+        operator: "operator";
+        lead: "lead";
+    }>>;
+    runtime: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CaseRequest = z.input<typeof caseInputSchema>;
+/** Точка после записи версии и до принятия: тест моделирует в ней сбой. */
+export declare const caseHooks: {
+    afterRecord: () => void;
+};
+/** Что нужно подтверждению от controller. */
+export interface ConfirmContext {
+    corpus: CorpusStore;
+    policy: ExecutionPolicy;
+    stateDir: string;
+    repoPath(repo: ExecutionPolicy['repositories'][number]): string;
+    /** Закрытое проверке и открытое внутри него. */
+    boundary(): {
+        hidden: string[];
+        readable: string[];
+    };
+    /** Источник переменных окружения (по умолчанию — процесс). */
+    environment?: NodeJS.ProcessEnv;
+}
+/** Изменённые закреплённые файлы на SHA: checker должен быть утверждённой редакцией. */
+export declare function staleArtifacts(repoPath: string, sha: string, artifacts: ContractArtifact[]): Promise<string[]>;
+export declare function submitCase(ctx: ConfirmContext, raw: unknown): Promise<{
+    suite: string;
+    repeated: boolean;
+    decision: {
+        id: string;
+        property: string;
+        input: string;
+        inputHash: string;
+        outcome: "rejected" | "inconclusive" | "confirmed" | "refuted";
+        reason: string;
+        source: {
+            sha: string;
+            runId?: string | undefined;
+            taskId?: string | undefined;
+        };
+        origin: {
+            kind: "review" | "agent" | "operator" | "lead";
+            runtime?: string | undefined;
+        };
+        at: string;
+        key?: string | undefined;
+        claimed?: {
+            expected: string | null;
+            actual: string | null;
+            reproduction?: string | undefined;
+        } | undefined;
+        observed?: {
+            repeats: number;
+            durationsMs: number[];
+            expected?: string | undefined;
+            actual?: string | undefined;
+            equal?: boolean | undefined;
+        } | undefined;
+        method?: {
+            gate: string;
+            artifacts: {
+                path: string;
+                blob: string;
+            }[];
+            contract: string;
+            basis: string;
+            command?: string[] | undefined;
+        } | undefined;
+        caseId?: string | undefined;
+        version?: number | undefined;
+    };
+    version: {
+        number: number;
+        digest: string;
+        cases: number;
+    } | null;
+    adoption: {
+        awaitingOperator?: true | undefined;
+        id: string;
+        status: "completed" | "waiting";
+        results: Record<string, string>;
+    }[];
+}>;