audit-tools 0.28.0

package/dist/remediate/validation/contractPipelineGates.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Structural gates for the DesignSpec contract-pipeline artifact.
+ *
+ * Extracted from contractPipeline.ts to keep gate logic (structural checks,
+ * obligation cross-checks, Kahn's topological sort) separate from the
+ * per-artifact field validators. MNT-86b18f1b.
+ *
+ * Re-exported from contractPipeline.ts for backward-compatible imports.
+ *
+ * Also contains:
+ *   validateGoalIdConsistency — ARC-86b18f1b: goal_id equality across all
+ *     contract-pipeline artifacts that carry one.
+ *   validateImplementationDAGIntegrity — ARC-86b18f1b-2: referential integrity
+ *     and bidirectional coverage for the implementation DAG.
+ */
+import { type ValidationIssue, type DispatchModelTier } from "audit-tools/shared";
+/**
+ * Deterministic structural gates run before the adversarial critic phase.
+ * Returns ValidationIssue[] — errors block the pipeline (re-emit design phase),
+ * warnings are advisory (appended to the critic prompt). Circular obligation
+ * dependency detection yields a warning (not an error) routing to N-R21.
+ *
+ * Call this with the design_spec payload and, optionally, the obligation_ledger
+ * payload for the invariant-coverage cross-check.
+ */
+export declare function validateDesignSpecGates(designSpec: unknown, obligationLedger?: unknown): ValidationIssue[];
+/**
+ * ARC-86b18f1b: validate that every contract-pipeline artifact that carries a
+ * `goal_id` field contains the SAME value. A mismatch indicates that two
+ * artifacts were produced for different goals and must not be used together.
+ *
+ * Pass in a map of artifact-name → payload. Payloads that are not records, or
+ * that have no `goal_id` field, are silently skipped (the per-artifact
+ * validators already flag missing goal_ids). Issues are errors.
+ */
+export declare function validateGoalIdConsistency(artifacts: Record<string, unknown>): ValidationIssue[];
+/**
+ * ARC-86b18f1b-2: validate the implementation_dag against the obligation_ledger
+ * and counterexample/judge artifacts for:
+ *
+ *   1. Referential integrity — every id referenced in `satisfies_obligations`,
+ *      `verification_obligation_ids`, and `addresses_counterexamples` must exist
+ *      in the obligation_ledger or as an accepted counterexample in the judge
+ *      report (respectively).
+ *
+ *   2. Bidirectional coverage — every obligation in the ledger, and every
+ *      accepted counterexample (per the judge report), must be addressed by at
+ *      least one DAG node.
+ *
+ * All issues are errors. Accepts `undefined` payloads for missing artifacts —
+ * referential checks are skipped when the target artifact is absent (the caller
+ * is responsible for ensuring the artifacts exist before calling this gate).
+ */
+export declare function validateImplementationDAGIntegrity(dagPayload: unknown, obligationLedgerPayload: unknown, counterexamplePayload: unknown, judgeReportPayload: unknown): ValidationIssue[];
+/**
+ * OBL-CO-01 — paired-obligation gate (fail-closed).
+ *
+ * Every obligation whose kind is testable (invariant / behavioral) must be
+ * covered by at least one test_validator_plan spec, and that coverage must
+ * include BOTH a positive (satisfied-path) assertion and a negative
+ * (failure-path) assertion. A single positive-only assertion set is the latent
+ * failure mode this gate exists to prevent: a narrow positive test passes while
+ * the obligation's negative half goes unverified.
+ *
+ * An obligation may opt out only via an explicit, falsifiable `inapplicable_claim`
+ * on a spec that cites that obligation id — bare omission is an error.
+ *
+ * Accepts `undefined` for a missing test_validator_plan: with testable
+ * obligations present and no plan at all, every testable obligation is reported
+ * uncovered (fail-closed).
+ */
+export declare function validatePairedObligations(obligationLedgerPayload: unknown, testValidatorPlanPayload: unknown): ValidationIssue[];
+/**
+ * OBL-CO-03 — evidence-threading gate (fail-closed).
+ *
+ * Evidence produced upstream must survive every downstream seam:
+ *
+ *  1. A contract_assessment_report finding with status "violated" must carry
+ *     non-empty evidence — a violation asserted without evidence is unfalsifiable.
+ *  2. Every judge-accepted counterexample must be threaded forward into the
+ *     implementation_dag (a node must list it in addresses_counterexamples).
+ *     This is the seam where adversarial evidence is most often dropped.
+ *  3. Every DAG node that satisfies an obligation must carry obligation-derived
+ *     evidence in its description (the node must not be an empty placeholder).
+ *
+ * Accepts `undefined` payloads — a check whose source artifact is absent is
+ * skipped, except the counterexample-threading check, which is fail-closed when
+ * accepted counterexamples exist but the DAG is missing.
+ */
+export declare function validateEvidenceThreaded(assessmentReportPayload: unknown, judgeReportPayload: unknown, dagPayload: unknown): ValidationIssue[];
+/**
+ * OBL-CO-04 — source_type-scoped digest-coverage gate (fail-closed for
+ * enumerable sources).
+ *
+ * For a `structured_audit` (enumerable) intake every enumerated finding must map
+ * to at least one obligation in the ledger, so no auditor finding silently
+ * vanishes between intake and the contract. For `conversation` / `document`
+ * sources — or any finding-enumeration explicitly marked `is_enumerable:false`
+ * — the gate passes vacuously, because there is no closed finding set to cover.
+ *
+ * The mapping is established by finding-id appearing in any obligation's
+ * `source_finding_ids` (preferred) OR being referenced by id within an
+ * obligation's `description` (word-boundary match, fallback).
+ *
+ * `sourceType` comes from goal_spec.source_type. `findingEnumerationPayload` is
+ * the intake finding-enumeration.json ({ is_enumerable, findings:[{id}] }).
+ */
+export declare function validateDigestCoverage(sourceType: string | undefined, findingEnumerationPayload: unknown, obligationLedgerPayload: unknown): ValidationIssue[];
+/**
+ * OBL-CO-12 / INV-CO-12 — reconciliation-derivation gate (fail-closed).
+ *
+ * Every mismatch reconciled in the seam_reconciliation_report must be DERIVED
+ * into the finalized_module_contracts: the report's `agreed_interface` for each
+ * mismatch must be reflected in the finalized contracts (matched against the
+ * union of every finalized module's inputs/outputs/invariants/side_effects text).
+ * A reconciliation decision that never reaches the finalized contract is a
+ * dropped derivation — the exact failure INV-CO-12 forbids.
+ *
+ * Fail-closed: if the report declares mismatches but the finalized contracts
+ * artifact is absent, every mismatch is reported as underived.
+ */
+export declare function validateReconciliationDerivation(seamReconciliationReportPayload: unknown, finalizedModuleContractsPayload: unknown): ValidationIssue[];
+export interface NodeComplexitySignals {
+    /** Number of upstream dependencies (depends_on length). */
+    dependencyCount: number;
+    /** Number of obligations the node satisfies + verifies. */
+    obligationCount: number;
+    /** Number of files in the node's declared write scope. */
+    fileScopeSize: number;
+    /** Number of accepted counterexamples the node addresses. */
+    counterexampleCount: number;
+    /** True when the node's lens is a high-stakes lens (security/correctness/etc.). */
+    highStakesLens: boolean;
+}
+/**
+ * Derive a *relative* model tier ("small" | "standard" | "deep") for an
+ * implementation DAG node from its complexity signals.
+ *
+ * INV (no-hardcoded-models): the return value is a RELATIVE rank from the shared
+ * DispatchModelTier union. This function NEVER references a model name, context
+ * window, or per-model limit — the concrete model behind each rank is discovered
+ * at the dispatch handshake. Complexity, not identity, decides the rank.
+ *
+ * Scoring (monotonic in every signal):
+ *   +1 per upstream dependency (deep coordination)
+ *   +1 per obligation beyond the first (breadth of contract)
+ *   +1 per file beyond the first two (write-scope breadth)
+ *   +2 per accepted counterexample addressed (adversarial difficulty)
+ *   +2 when the node targets a high-stakes lens
+ *
+ *   score >= 6 → "deep"   (top relative rank)
+ *   score >= 3 → "standard" (middle)
+ *   else       → "small"  (cheapest)
+ */
+export declare function deriveNodeModelTier(signals: NodeComplexitySignals): DispatchModelTier;
+/**
+ * Extract complexity signals from a raw implementation-DAG node payload, then
+ * derive its relative tier. Tolerant of partial/unknown node shapes.
+ */
+export declare function deriveNodeModelTierFromNode(nodePayload: unknown): DispatchModelTier;
+//# sourceMappingURL=contractPipelineGates.d.ts.map

package/dist/remediate/validation/contractPipelineGates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractPipelineGates.d.ts","sourceRoot":"","sources":["../../../src/remediate/validation/contractPipelineGates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EAGvB,MAAM,oBAAoB,CAAC;AAI5B;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,OAAO,EACnB,gBAAgB,CAAC,EAAE,OAAO,GACzB,eAAe,EAAE,CA6KnB;AAID;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,eAAe,EAAE,CAsBnB;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,OAAO,EACnB,uBAAuB,EAAE,OAAO,EAChC,qBAAqB,EAAE,OAAO,EAC9B,kBAAkB,EAAE,OAAO,GAC1B,eAAe,EAAE,CAkInB;AAkCD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACvC,uBAAuB,EAAE,OAAO,EAChC,wBAAwB,EAAE,OAAO,GAChC,eAAe,EAAE,CAsFnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,uBAAuB,EAAE,OAAO,EAChC,kBAAkB,EAAE,OAAO,EAC3B,UAAU,EAAE,OAAO,GAClB,eAAe,EAAE,CAmFnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,yBAAyB,EAAE,OAAO,EAClC,uBAAuB,EAAE,OAAO,GAC/B,eAAe,EAAE,CAgDnB;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gCAAgC,CAC9C,+BAA+B,EAAE,OAAO,EACxC,+BAA+B,EAAE,OAAO,GACvC,eAAe,EAAE,CAqEnB;AA0BD,MAAM,WAAW,qBAAqB;IACpC,2DAA2D;IAC3D,eAAe,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,eAAe,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mFAAmF;IACnF,cAAc,EAAE,OAAO,CAAC;CACzB;AAcD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,iBAAiB,CAWrF;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,OAAO,GAAG,iBAAiB,CAkBnF"}