audit-tools 0.52.5 → 0.54.0

package/dist/remediate/validation/contractPipeline.js

@@ -1,613 +0,0 @@
-import { CounterexampleSchema } from "../../shared/types/contractPipeline/obligations.js";
-// sites-pinned: tests/remediate/step-prompt-sketch-drift.test.ts, tests/remediate/contract-pipeline.test.ts
-/**
- * Validation helpers for contract-pipeline artifacts.
- * Follows the ValidationIssue[] pattern used by the rest of the remediator
- * validation layer.
- */
-import { isRecord, pushValidationIssue, findFirstCycleWitness, } from "audit-tools/shared";
-import { detectContractTokenCycles } from "../contractPipeline/phaseCut.js";
-import { ASSESSMENT_FINDING_STATUSES, ASSESSMENT_VERDICTS, CONTRACT_REPAIR_TARGETS, CONTRACT_REPAIR_TARGETS_OFFERED, CONTEXT_ENTRY_KINDS, COUNTEREXAMPLE_CLASSIFICATIONS, CONCEPTUAL_CRITIQUE_REPAIR_TARGETS, CRITIQUE_ITEM_KINDS, CRITIQUE_ITEM_SEVERITIES, CRITIQUE_VERDICTS, CYCLIC_SEAM_BREAK_STRATEGIES, CYCLIC_SEAM_RESOLUTION_STATUSES, GOAL_SOURCE_TYPES, IMPLEMENTATION_EDGE_KINDS, IMPLEMENTATION_NODE_STATUSES, JUDGE_VERDICTS, OBLIGATION_KINDS, OBLIGATION_STATUSES, SEAM_RESOLUTION_DECISIONS, TEST_SPEC_KINDS, VERIFICATION_FINDING_STATUSES, VERIFICATION_REPORT_STATUSES, VERIFICATION_TRACE_KINDS, VERIFICATION_TRACE_STATUSES, } from "../contractPipeline/sketchSource.js";
-import { CONTRACT_PIPELINE_GOAL_SPEC_VERSION, CONTRACT_PIPELINE_CONTEXT_BUNDLE_VERSION, CONTRACT_PIPELINE_CONCEPTUAL_DESIGN_CRITIQUE_VERSION, CONTRACT_PIPELINE_OBLIGATION_LEDGER_VERSION, CONTRACT_PIPELINE_CONTRACT_ASSESSMENT_REPORT_VERSION, CONTRACT_PIPELINE_COUNTEREXAMPLE_VERSION, CONTRACT_PIPELINE_JUDGE_REPORT_VERSION, CONTRACT_PIPELINE_IMPLEMENTATION_DAG_VERSION, CONTRACT_PIPELINE_VERIFICATION_REPORT_VERSION, CONTRACT_PIPELINE_TEST_VALIDATOR_PLAN_VERSION, } from "audit-tools/shared";
-// Version constant for cyclic_seam_resolution artifact.
-export const CP_CYCLIC_SEAM_RESOLUTION_VERSION = "remediate-code-contract-pipeline/cyclic-seam-resolution/v1alpha1";
-// Version constants for seam-negotiation artifacts not yet in audit-tools/shared.
-export const CP_MODULE_DECOMPOSITION_VERSION = "remediate-code-contract-pipeline/module-decomposition/v1alpha1";
-export const CP_MODULE_CONTRACTS_VERSION = "remediate-code-contract-pipeline/module-contracts/v1alpha1";
-export const CP_SEAM_RECONCILIATION_REPORT_VERSION = "remediate-code-contract-pipeline/seam-reconciliation-report/v1alpha1";
-export const CP_FINALIZED_MODULE_CONTRACTS_VERSION = "remediate-code-contract-pipeline/finalized-module-contracts/v1alpha1";
-// ── Helpers ───────────────────────────────────────────────────────────────────
-function requireString(value, path, issues) {
-    if (typeof value !== "string" || value.length === 0) {
-        pushValidationIssue(issues, path, `${path} must be a non-empty string.`);
-    }
-}
-function requireStringArray(value, path, issues) {
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-        pushValidationIssue(issues, path, `${path} must be an array of strings.`);
-    }
-}
-function requireOneOf(value, allowed, path, issues) {
-    if (!allowed.includes(String(value))) {
-        pushValidationIssue(issues, path, `${path} must be one of: ${allowed.join(", ")}.`);
-    }
-}
-/**
- * Shared envelope guard for every contract-pipeline validator (MNT-86b18f1b):
- * the isRecord guard + contract_version match + optional goal_id check that each
- * validator opened with verbatim. Returns the value narrowed to a record when it
- * is one, or `undefined` when it is not (the caller returns its issues early).
- * The trailing `created_at` check stays in each validator since it runs after
- * the artifact-specific body.
- */
-function validateEnvelope(value, path, expectedVersion, issues, opts = { goalId: true }) {
-    if (!isRecord(value)) {
-        pushValidationIssue(issues, path, `${path} must be an object.`);
-        return undefined;
-    }
-    if (value.contract_version !== expectedVersion) {
-        pushValidationIssue(issues, `${path}.contract_version`, `${path}.contract_version must be "${expectedVersion}".`);
-    }
-    if (opts.goalId !== false) {
-        requireString(value.goal_id, `${path}.goal_id`, issues);
-    }
-    return value;
-}
-// ── GoalSpec ──────────────────────────────────────────────────────────────────
-export function validateGoalSpec(value, path = "goal_spec") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_GOAL_SPEC_VERSION, issues);
-    if (!v)
-        return issues;
-    requireString(v.objective, `${path}.objective`, issues);
-    requireStringArray(v.non_goals, `${path}.non_goals`, issues);
-    requireStringArray(v.success_criteria, `${path}.success_criteria`, issues);
-    requireOneOf(v.source_type, GOAL_SOURCE_TYPES, `${path}.source_type`, issues);
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── ContextBundle ─────────────────────────────────────────────────────────────
-export function validateContextBundle(value, path = "context_bundle") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_CONTEXT_BUNDLE_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.entries)) {
-        pushValidationIssue(issues, `${path}.entries`, `${path}.entries must be an array.`);
-    }
-    else {
-        for (const [i, entry] of v.entries.entries()) {
-            if (!isRecord(entry)) {
-                pushValidationIssue(issues, `${path}.entries[${i}]`, `${path}.entries[${i}] must be an object.`);
-                continue;
-            }
-            requireString(entry.path, `${path}.entries[${i}].path`, issues);
-            requireOneOf(entry.kind, CONTEXT_ENTRY_KINDS, `${path}.entries[${i}].kind`, issues);
-            requireString(entry.relevance_reason, `${path}.entries[${i}].relevance_reason`, issues);
-        }
-    }
-    requireString(v.context_summary, `${path}.context_summary`, issues);
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── ModuleDecomposition ───────────────────────────────────────────────────────
-export function validateModuleDecomposition(value, path = "module_decomposition") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CP_MODULE_DECOMPOSITION_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.modules)) {
-        pushValidationIssue(issues, `${path}.modules`, `${path}.modules must be an array.`);
-    }
-    else {
-        for (const [i, mod] of v.modules.entries()) {
-            if (!isRecord(mod)) {
-                pushValidationIssue(issues, `${path}.modules[${i}]`, `${path}.modules[${i}] must be an object.`);
-                continue;
-            }
-            requireString(mod.name, `${path}.modules[${i}].name`, issues);
-            requireString(mod.responsibilities, `${path}.modules[${i}].responsibilities`, issues);
-            requireStringArray(mod.file_scope, `${path}.modules[${i}].file_scope`, issues);
-            if (mod.source_work_block_ids !== undefined) {
-                requireStringArray(mod.source_work_block_ids, `${path}.modules[${i}].source_work_block_ids`, issues);
-            }
-            if (mod.prepares_seam_ids !== undefined) {
-                requireStringArray(mod.prepares_seam_ids, `${path}.modules[${i}].prepares_seam_ids`, issues);
-            }
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── ModuleContracts ───────────────────────────────────────────────────────────
-function validateModuleContractEntry(entry, path, issues) {
-    requireString(entry.name, `${path}.name`, issues);
-    requireStringArray(entry.inputs, `${path}.inputs`, issues);
-    requireStringArray(entry.outputs, `${path}.outputs`, issues);
-    requireStringArray(entry.invariants, `${path}.invariants`, issues);
-    requireStringArray(entry.side_effects, `${path}.side_effects`, issues);
-    requireString(entry.validation_boundary, `${path}.validation_boundary`, issues);
-    requireStringArray(entry.failure_modes, `${path}.failure_modes`, issues);
-}
-export function validateModuleContracts(value, path = "module_contracts") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CP_MODULE_CONTRACTS_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.module_contracts)) {
-        pushValidationIssue(issues, `${path}.module_contracts`, `${path}.module_contracts must be an array.`);
-    }
-    else {
-        for (const [i, mod] of v.module_contracts.entries()) {
-            if (!isRecord(mod)) {
-                pushValidationIssue(issues, `${path}.module_contracts[${i}]`, `${path}.module_contracts[${i}] must be an object.`);
-                continue;
-            }
-            validateModuleContractEntry(mod, `${path}.module_contracts[${i}]`, issues);
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── SeamReconciliationReport ──────────────────────────────────────────────────
-export function validateSeamReconciliationReport(value, path = "seam_reconciliation_report") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CP_SEAM_RECONCILIATION_REPORT_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.mismatches)) {
-        pushValidationIssue(issues, `${path}.mismatches`, `${path}.mismatches must be an array.`);
-    }
-    else {
-        for (const [i, mismatch] of v.mismatches.entries()) {
-            if (!isRecord(mismatch)) {
-                pushValidationIssue(issues, `${path}.mismatches[${i}]`, `${path}.mismatches[${i}] must be an object.`);
-                continue;
-            }
-            requireString(mismatch.seam_id, `${path}.mismatches[${i}].seam_id`, issues);
-            requireString(mismatch.module_a, `${path}.mismatches[${i}].module_a`, issues);
-            requireString(mismatch.module_b, `${path}.mismatches[${i}].module_b`, issues);
-            requireString(mismatch.description, `${path}.mismatches[${i}].description`, issues);
-            if (!isRecord(mismatch.resolution)) {
-                pushValidationIssue(issues, `${path}.mismatches[${i}].resolution`, `${path}.mismatches[${i}].resolution must be an object (every mismatch requires a resolution decision).`);
-            }
-            else {
-                requireOneOf(mismatch.resolution.decision, SEAM_RESOLUTION_DECISIONS, `${path}.mismatches[${i}].resolution.decision`, issues);
-                requireString(mismatch.resolution.agreed_interface, `${path}.mismatches[${i}].resolution.agreed_interface`, issues);
-            }
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── FinalizedModuleContracts ──────────────────────────────────────────────────
-export function validateFinalizedModuleContracts(value, path = "finalized_module_contracts") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CP_FINALIZED_MODULE_CONTRACTS_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.module_contracts)) {
-        pushValidationIssue(issues, `${path}.module_contracts`, `${path}.module_contracts must be an array.`);
-    }
-    else {
-        for (const [i, mod] of v.module_contracts.entries()) {
-            if (!isRecord(mod)) {
-                pushValidationIssue(issues, `${path}.module_contracts[${i}]`, `${path}.module_contracts[${i}] must be an object.`);
-                continue;
-            }
-            validateModuleContractEntry(mod, `${path}.module_contracts[${i}]`, issues);
-        }
-        // A cycle in the DECLARED artifact-token graph is a validation error, not a
-        // silently dropped edge (open-bugs.md:106): implementation ordering derives
-        // from these tokens alone, and the fail-toward-later tiering would place
-        // token consumers ahead of their producers. Naming members and edges makes
-        // the ingestion re-emit actionable.
-        for (const cycle of detectContractTokenCycles(v)) {
-            pushValidationIssue(issues, `${path}.module_contracts`, `${path}.module_contracts declares a CYCLIC artifact-token dependency graph; implementation ` +
-                `ordering derives from these tokens alone, so the declared flow must be acyclic. Cycle ` +
-                `members: [${cycle.members.join(", ")}]. Edges: ${cycle.edges
-                    .map((e) => `${e.consumer} depends on ${e.producer} via artifact:${e.artifact}`)
-                    .join("; ")}. Adjust inputs/outputs so one direction owns each flow; keep the module set ` +
-                `unchanged.`);
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── DesignSpec ────────────────────────────────────────────────────────────────
-// ── DesignSpec structural gates + cross-artifact gates ────────────────────────
-// Extracted to contractPipelineGates.ts (MNT-86b18f1b). Re-exported here for
-// backward-compatible imports — callers do not need to update their import paths.
-export { validateDesignSpecGates, validateGoalIdConsistency, validateImplementationDAGIntegrity, validatePairedObligations, validateEvidenceThreaded, validateDigestCoverage, validateWorkBlockSeamPreparation, validateReconciliationDerivation, validateContractCitationGrounding, validateDecompositionFileScope, validateFinalizedModuleSetPreserved, enumerateRepoTreePaths, isInsideGitWorkTree, } from "./contractPipelineGates.js";
-// ── ConceptualDesignCritique ──────────────────────────────────────────────────
-export function validateConceptualDesignCritique(value, path = "conceptual_design_critique") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_CONCEPTUAL_DESIGN_CRITIQUE_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.items)) {
-        pushValidationIssue(issues, `${path}.items`, `${path}.items must be an array.`);
-    }
-    else {
-        for (const [i, item] of v.items.entries()) {
-            if (!isRecord(item)) {
-                pushValidationIssue(issues, `${path}.items[${i}]`, `${path}.items[${i}] must be an object.`);
-                continue;
-            }
-            requireString(item.id, `${path}.items[${i}].id`, issues);
-            requireOneOf(item.kind, CRITIQUE_ITEM_KINDS, `${path}.items[${i}].kind`, issues);
-            requireString(item.description, `${path}.items[${i}].description`, issues);
-            requireOneOf(item.severity, CRITIQUE_ITEM_SEVERITIES, `${path}.items[${i}].severity`, issues);
-        }
-    }
-    if (v.repair_target !== undefined) {
-        requireOneOf(v.repair_target, CONCEPTUAL_CRITIQUE_REPAIR_TARGETS, `${path}.repair_target`, issues);
-    }
-    requireOneOf(v.verdict, CRITIQUE_VERDICTS, `${path}.verdict`, issues);
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── ObligationLedger ──────────────────────────────────────────────────────────
-export function validateObligationLedger(value, path = "obligation_ledger") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_OBLIGATION_LEDGER_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.obligations)) {
-        pushValidationIssue(issues, `${path}.obligations`, `${path}.obligations must be an array.`);
-    }
-    else {
-        for (const [i, obl] of v.obligations.entries()) {
-            if (!isRecord(obl)) {
-                pushValidationIssue(issues, `${path}.obligations[${i}]`, `${path}.obligations[${i}] must be an object.`);
-                continue;
-            }
-            requireString(obl.id, `${path}.obligations[${i}].id`, issues);
-            requireString(obl.description, `${path}.obligations[${i}].description`, issues);
-            requireOneOf(obl.kind, OBLIGATION_KINDS, `${path}.obligations[${i}].kind`, issues);
-            requireStringArray(obl.depends_on, `${path}.obligations[${i}].depends_on`, issues);
-            requireOneOf(obl.status, OBLIGATION_STATUSES, `${path}.obligations[${i}].status`, issues);
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── TestValidatorPlan ─────────────────────────────────────────────────────────
-export function validateTestValidatorPlan(value, path = "test_validator_plan") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_TEST_VALIDATOR_PLAN_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.test_specs)) {
-        pushValidationIssue(issues, `${path}.test_specs`, `${path}.test_specs must be an array.`);
-    }
-    else {
-        for (const [i, spec] of v.test_specs.entries()) {
-            if (!isRecord(spec)) {
-                pushValidationIssue(issues, `${path}.test_specs[${i}]`, `${path}.test_specs[${i}] must be an object.`);
-                continue;
-            }
-            requireString(spec.obligation_id, `${path}.test_specs[${i}].obligation_id`, issues);
-            requireString(spec.name, `${path}.test_specs[${i}].name`, issues);
-            // A spec that disputes its obligation carries no test: it needs only its
-            // id, its name and the claim. The scaffold tells the worker to replace the
-            // spec body with the claim, and this validator used to refuse exactly that.
-            const inapplicable = spec.inapplicable_claim !== undefined;
-            if (!inapplicable || spec.kind !== undefined) {
-                requireOneOf(spec.kind, TEST_SPEC_KINDS, `${path}.test_specs[${i}].kind`, issues);
-            }
-            if (!inapplicable || spec.assertions !== undefined) {
-                if (!Array.isArray(spec.assertions) || (!inapplicable && spec.assertions.length === 0)) {
-                    pushValidationIssue(issues, `${path}.test_specs[${i}].assertions`, `${path}.test_specs[${i}].assertions must be a non-empty array of strings.`);
-                }
-                else {
-                    requireStringArray(spec.assertions, `${path}.test_specs[${i}].assertions`, issues);
-                }
-            }
-            if (inapplicable) {
-                if (!isRecord(spec.inapplicable_claim)) {
-                    pushValidationIssue(issues, `${path}.test_specs[${i}].inapplicable_claim`, `${path}.test_specs[${i}].inapplicable_claim must be an object.`);
-                }
-                else {
-                    requireString(spec.inapplicable_claim.obligation_id, `${path}.test_specs[${i}].inapplicable_claim.obligation_id`, issues);
-                    requireString(spec.inapplicable_claim.reason, `${path}.test_specs[${i}].inapplicable_claim.reason`, issues);
-                }
-            }
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── ContractAssessmentReport ──────────────────────────────────────────────────
-export function validateContractAssessmentReport(value, path = "contract_assessment_report") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_CONTRACT_ASSESSMENT_REPORT_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.findings)) {
-        pushValidationIssue(issues, `${path}.findings`, `${path}.findings must be an array.`);
-    }
-    else {
-        for (const [i, finding] of v.findings.entries()) {
-            if (!isRecord(finding)) {
-                pushValidationIssue(issues, `${path}.findings[${i}]`, `${path}.findings[${i}] must be an object.`);
-                continue;
-            }
-            requireString(finding.obligation_id, `${path}.findings[${i}].obligation_id`, issues);
-            requireOneOf(finding.status, ASSESSMENT_FINDING_STATUSES, `${path}.findings[${i}].status`, issues);
-            requireStringArray(finding.evidence, `${path}.findings[${i}].evidence`, issues);
-            requireString(finding.rationale, `${path}.findings[${i}].rationale`, issues);
-        }
-    }
-    requireOneOf(v.verdict, ASSESSMENT_VERDICTS, `${path}.verdict`, issues);
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── CounterexampleReport ──────────────────────────────────────────────────────
-export function validateCounterexample(value, path = "counterexample") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_COUNTEREXAMPLE_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.counterexamples)) {
-        pushValidationIssue(issues, `${path}.counterexamples`, `${path}.counterexamples must be an array.`);
-    }
-    else {
-        for (const [i, entry] of v.counterexamples.entries()) {
-            if (!isRecord(entry)) {
-                pushValidationIssue(issues, `${path}.counterexamples[${i}]`, `${path}.counterexamples[${i}] must be an object.`);
-                continue;
-            }
-            const parsed = CounterexampleSchema.safeParse(entry);
-            if (!parsed.success)
-                for (const issue of parsed.error.issues) {
-                    pushValidationIssue(issues, `${path}.counterexamples[${i}].${issue.path.join(".")}`, issue.message);
-                }
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── JudgeReport ───────────────────────────────────────────────────────────────
-export function validateJudgeReport(value, path = "judge_report") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_JUDGE_REPORT_VERSION, issues);
-    if (!v)
-        return issues;
-    requireOneOf(v.verdict, JUDGE_VERDICTS, `${path}.verdict`, issues);
-    if (!Array.isArray(v.classifications)) {
-        pushValidationIssue(issues, `${path}.classifications`, `${path}.classifications must be an array.`);
-    }
-    else {
-        for (const [i, entry] of v.classifications.entries()) {
-            if (!isRecord(entry)) {
-                pushValidationIssue(issues, `${path}.classifications[${i}]`, `${path}.classifications[${i}] must be an object.`);
-                continue;
-            }
-            requireString(entry.counterexample_id, `${path}.classifications[${i}].counterexample_id`, issues);
-            requireOneOf(entry.classification, COUNTEREXAMPLE_CLASSIFICATIONS, `${path}.classifications[${i}].classification`, issues);
-            requireString(entry.rationale, `${path}.classifications[${i}].rationale`, issues);
-        }
-    }
-    if (v.verdict === "needs_repair") {
-        if (!isRecord(v.repair_directive)) {
-            pushValidationIssue(issues, `${path}.repair_directive`, `${path}.repair_directive is required when verdict is "needs_repair".`);
-        }
-    }
-    if (v.repair_directive !== undefined) {
-        if (!isRecord(v.repair_directive)) {
-            pushValidationIssue(issues, `${path}.repair_directive`, `${path}.repair_directive must be an object.`);
-        }
-        else {
-            if (v.repair_directive.target === "counterexample") {
-                // Named, not only listed: the critic's report is the input the judge
-                // rules on, so a repair of it is a new critic round, not a repair. Before,
-                // the loop swapped this target for another one in silence.
-                pushValidationIssue(issues, `${path}.repair_directive.target`, `${path}.repair_directive.target "counterexample" is not a repair target: the judge rules on the critic's report and cannot order it rewritten. Name the contract artifact that must change (${CONTRACT_REPAIR_TARGETS_OFFERED.join(", ")}), or classify the counterexample as residual_risk.`);
-            }
-            else {
-                requireOneOf(v.repair_directive.target, CONTRACT_REPAIR_TARGETS, `${path}.repair_directive.target`, issues);
-            }
-            requireString(v.repair_directive.instruction, `${path}.repair_directive.instruction`, issues);
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── ImplementationDAG ─────────────────────────────────────────────────────────
-export function validateImplementationDAG(value, path = "implementation_dag") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_IMPLEMENTATION_DAG_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.nodes)) {
-        pushValidationIssue(issues, `${path}.nodes`, `${path}.nodes must be an array.`);
-    }
-    else {
-        for (const [i, node] of v.nodes.entries()) {
-            if (!isRecord(node)) {
-                pushValidationIssue(issues, `${path}.nodes[${i}]`, `${path}.nodes[${i}] must be an object.`);
-                continue;
-            }
-            requireString(node.id, `${path}.nodes[${i}].id`, issues);
-            requireString(node.title, `${path}.nodes[${i}].title`, issues);
-            requireString(node.description, `${path}.nodes[${i}].description`, issues);
-            requireStringArray(node.satisfies_obligations, `${path}.nodes[${i}].satisfies_obligations`, issues);
-            if (node.addresses_counterexamples !== undefined) {
-                requireStringArray(node.addresses_counterexamples, `${path}.nodes[${i}].addresses_counterexamples`, issues);
-            }
-            requireStringArray(node.depends_on, `${path}.nodes[${i}].depends_on`, issues);
-            requireStringArray(node.verification_obligation_ids, `${path}.nodes[${i}].verification_obligation_ids`, issues);
-            requireStringArray(node.targeted_commands, `${path}.nodes[${i}].targeted_commands`, issues);
-            requireOneOf(node.status, IMPLEMENTATION_NODE_STATUSES, `${path}.nodes[${i}].status`, issues);
-            if (node.files_likely_touched !== undefined) {
-                requireStringArray(node.files_likely_touched, `${path}.nodes[${i}].files_likely_touched`, issues);
-            }
-            if (node.preconditions !== undefined) {
-                requireStringArray(node.preconditions, `${path}.nodes[${i}].preconditions`, issues);
-            }
-            if (node.expected_changes !== undefined && node.expected_changes !== null) {
-                if (typeof node.expected_changes !== "string") {
-                    pushValidationIssue(issues, `${path}.nodes[${i}].expected_changes`, `${path}.nodes[${i}].expected_changes must be a string when present.`);
-                }
-            }
-        }
-    }
-    // Node ids referenced by edges must point at a declared node. The nodeIds set
-    // is built in the node loop above; an edge whose from/to names a non-existent
-    // node is a dangling reference (referential-integrity violation) that would
-    // otherwise promote into a plan whose block dependencies cite phantom nodes.
-    const declaredNodeIds = new Set();
-    if (Array.isArray(v.nodes)) {
-        for (const node of v.nodes) {
-            if (isRecord(node) && typeof node.id === "string")
-                declaredNodeIds.add(node.id);
-        }
-    }
-    if (!Array.isArray(v.edges)) {
-        pushValidationIssue(issues, `${path}.edges`, `${path}.edges must be an array.`);
-    }
-    else {
-        for (const [i, edge] of v.edges.entries()) {
-            if (!isRecord(edge)) {
-                pushValidationIssue(issues, `${path}.edges[${i}]`, `${path}.edges[${i}] must be an object.`);
-                continue;
-            }
-            requireString(edge.from, `${path}.edges[${i}].from`, issues);
-            requireString(edge.to, `${path}.edges[${i}].to`, issues);
-            requireOneOf(edge.kind, IMPLEMENTATION_EDGE_KINDS, `${path}.edges[${i}].kind`, issues);
-            if (typeof edge.from === "string" && edge.from.length > 0 && !declaredNodeIds.has(edge.from)) {
-                pushValidationIssue(issues, `${path}.edges[${i}].from`, `${path}.edges[${i}].from "${edge.from}" does not reference a declared node id.`);
-            }
-            if (typeof edge.to === "string" && edge.to.length > 0 && !declaredNodeIds.has(edge.to)) {
-                pushValidationIssue(issues, `${path}.edges[${i}].to`, `${path}.edges[${i}].to "${edge.to}" does not reference a declared node id.`);
-            }
-        }
-    }
-    // Acyclicity: an implementation DAG must be a DAG. Node `depends_on` is the
-    // ordering the block promotion reads, so a dependency cycle would stall the
-    // phase scheduler — no node in the cycle can ever become dispatchable. The
-    // tool-derived scaffold is acyclic by construction, but a host-authored cyclic
-    // `depends_on` must be rejected too (referential integrity alone let it pass).
-    // Traverse declared nodes only (a dangling dep is ignored, as promotion drops it).
-    if (Array.isArray(v.nodes)) {
-        const dagNodes = [];
-        for (const node of v.nodes) {
-            if (!isRecord(node) || typeof node.id !== "string")
-                continue;
-            const deps = Array.isArray(node.depends_on)
-                ? node.depends_on.filter((d) => typeof d === "string" && d !== node.id && declaredNodeIds.has(d))
-                : [];
-            dagNodes.push({ id: node.id, depends_on: deps });
-        }
-        // Self-edges are stripped above and self-loops stay OFF in the core: a node
-        // that lists itself is a redundant self-reference here, not a cycle that
-        // stalls the phase scheduler.
-        const cycle = findFirstCycleWitness(dagNodes);
-        if (cycle) {
-            pushValidationIssue(issues, `${path}.nodes`, `${path} has a dependency cycle among nodes: ${cycle.join(" -> ")}. The implementation DAG must be acyclic.`);
-        }
-    }
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── VerificationReport ────────────────────────────────────────────────────────
-export function validateVerificationReport(value, path = "verification_report") {
-    const issues = [];
-    // VerificationReport has no goal_id at the top level (it carries an optional
-    // goal_id elsewhere); skip the goal_id envelope check for this artifact.
-    const v = validateEnvelope(value, path, CONTRACT_PIPELINE_VERIFICATION_REPORT_VERSION, issues, {
-        goalId: false,
-    });
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.findings)) {
-        pushValidationIssue(issues, `${path}.findings`, `${path}.findings must be an array.`);
-    }
-    else {
-        for (const [i, finding] of v.findings.entries()) {
-            if (!isRecord(finding)) {
-                pushValidationIssue(issues, `${path}.findings[${i}]`, `${path}.findings[${i}] must be an object.`);
-                continue;
-            }
-            requireString(finding.finding_id, `${path}.findings[${i}].finding_id`, issues);
-            if (!Array.isArray(finding.traces)) {
-                pushValidationIssue(issues, `${path}.findings[${i}].traces`, `${path}.findings[${i}].traces must be an array.`);
-            }
-            else {
-                for (const [j, trace] of finding.traces.entries()) {
-                    if (!isRecord(trace)) {
-                        pushValidationIssue(issues, `${path}.findings[${i}].traces[${j}]`, `${path}.findings[${i}].traces[${j}] must be an object.`);
-                        continue;
-                    }
-                    requireString(trace.trace_id, `${path}.findings[${i}].traces[${j}].trace_id`, issues);
-                    requireOneOf(trace.kind, VERIFICATION_TRACE_KINDS, `${path}.findings[${i}].traces[${j}].kind`, issues);
-                    requireString(trace.label, `${path}.findings[${i}].traces[${j}].label`, issues);
-                    requireStringArray(trace.evidence, `${path}.findings[${i}].traces[${j}].evidence`, issues);
-                    requireOneOf(trace.status, VERIFICATION_TRACE_STATUSES, `${path}.findings[${i}].traces[${j}].status`, issues);
-                }
-            }
-            requireOneOf(finding.overall_status, VERIFICATION_FINDING_STATUSES, `${path}.findings[${i}].overall_status`, issues);
-        }
-    }
-    // Report-level overall_status stays strict passed|failed — "skipped" is a
-    // per-finding-only outcome (see FindingVerificationTrace doc comment).
-    requireOneOf(v.overall_status, VERIFICATION_REPORT_STATUSES, `${path}.overall_status`, issues);
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── CyclicSeamResolution ──────────────────────────────────────────────────────
-export function validateCyclicSeamResolution(value, path = "cyclic_seam_resolution") {
-    const issues = [];
-    const v = validateEnvelope(value, path, CP_CYCLIC_SEAM_RESOLUTION_VERSION, issues);
-    if (!v)
-        return issues;
-    if (!Array.isArray(v.cycles)) {
-        pushValidationIssue(issues, `${path}.cycles`, `${path}.cycles must be an array.`);
-    }
-    else {
-        for (const [i, cycle] of v.cycles.entries()) {
-            if (!isRecord(cycle)) {
-                pushValidationIssue(issues, `${path}.cycles[${i}]`, `${path}.cycles[${i}] must be an object.`);
-                continue;
-            }
-            if (!Array.isArray(cycle.members) || cycle.members.some((m) => typeof m !== "string")) {
-                pushValidationIssue(issues, `${path}.cycles[${i}].members`, `${path}.cycles[${i}].members must be an array of strings.`);
-            }
-            // `break_strategy` was NOT validated here — it was checked later, and
-            // only on the authored-resolution path, against two inline literals. So a
-            // cycle record naming an unsanctioned strategy passed the CONTRACT
-            // validator that decides whether the artifact is admissible at all. The
-            // vocabulary now lives in the shared declaration the prompt sketch also
-            // renders, and this reads it.
-            requireOneOf(cycle.break_strategy, CYCLIC_SEAM_BREAK_STRATEGIES, `${path}.cycles[${i}].break_strategy`, issues);
-        }
-    }
-    requireOneOf(v.status, CYCLIC_SEAM_RESOLUTION_STATUSES, `${path}.status`, issues);
-    requireString(v.created_at, `${path}.created_at`, issues);
-    return issues;
-}
-// ── Validator registry ────────────────────────────────────────────────────────
-/**
- * One validator per contract-pipeline artifact payload. Used by the driver's
- * ingestion pass (worker-written raw payloads are untrusted until validated)
- * and by the artifacts validation sweep.
- */
-export const CONTRACT_PIPELINE_VALIDATORS = {
-    goal_spec: validateGoalSpec,
-    context_bundle: validateContextBundle,
-    module_decomposition: validateModuleDecomposition,
-    module_contracts: validateModuleContracts,
-    seam_reconciliation_report: validateSeamReconciliationReport,
-    finalized_module_contracts: validateFinalizedModuleContracts,
-    conceptual_design_critique: validateConceptualDesignCritique,
-    obligation_ledger: validateObligationLedger,
-    cyclic_seam_resolution: validateCyclicSeamResolution,
-    test_validator_plan: validateTestValidatorPlan,
-    contract_assessment_report: validateContractAssessmentReport,
-    counterexample: validateCounterexample,
-    judge_report: validateJudgeReport,
-    implementation_dag: validateImplementationDAG,
-    verification_report: validateVerificationReport,
-};
-//# sourceMappingURL=contractPipeline.js.map