audit-tools 0.52.5 → 0.53.0

package/dist/remediate/steps/contractPipeline.d.ts

@@ -1,677 +1,23 @@
-import { type ConceptualCritiqueRepairTarget } from "../../shared/types/contractPipeline/design.js";
-import { type ValidationIssue, type JudgeReport, type WorkBlock, type WorkBlockSeam, type AuditRead } from "audit-tools/shared";
-import { OBLIGATION_KIND_PRIORITY, type ObligationKind } from "../contractPipeline/obligationKinds.js";
-import { readIntakeRiskSignal, type AdversarialDepth } from "../riskSignal.js";
-import type { JudgeRepairTarget } from "audit-tools/shared";
-import { type ContractPipelineCrossGateInputs, type GateOutcome } from "../validation/contractPipelineGates.js";
-import type { ContractPipelineArtifactName } from "../contractPipeline/artifactStore.js";
 import type { RemediationStep } from "./types.js";
-import { intakePaths } from "../intake.js";
-/**
- * Runaway backstop for the judge↔repair loop — the LOUD exception path, NOT the
- * normal terminator. The loop normally terminates by *convergence*: it keeps
- * repairing only while each round surfaces a genuinely NEW accepted counterexample
- * (real progress), reaches a fixpoint when the judge approves, and escalates to the
- * user the moment a round re-accepts an already-addressed counterexample without
- * progress (a stall/oscillation). This ceiling exists only so a pathological run
- * that keeps minting brand-new accepted counterexamples forever cannot loop without
- * bound; hitting it is itself an escalation (loud), never a silent proceed. It is
- * deliberately generous — a genuinely deep but converging design (each round a new
- * real defect) must not be cut mid-convergence (the failure mode of the former N=2).
- */
-export declare const MAX_CONTRACT_REPAIR_ITERATIONS = 8;
-/** Maximum implementation_dag regenerations after traceability rejections. */
-export declare const MAX_DAG_REGENERATION_ATTEMPTS = 2;
-/**
- * Maximum LLM cycle-break resolution attempts before routing to user-decision
- * (and, if that also fails, to `blocked`).
- */
-export declare const MAX_CYCLIC_SEAM_RESOLUTION_ATTEMPTS = 2;
-export interface CyclicSeamRepairState {
-    schema_version: "remediate-code-contract-pipeline/cyclic-seam-repair-state/v1alpha1";
-    /**
-     * Each attempt to resolve the detected cycles (keyed by obligation_ledger
-     * hash). `recheck_reason` records WHY the re-check rejected an attempt, so the
-     * next resolution prompt can state it instead of re-asking for the same claim
-     * and burning the attempt cap on an unexplained retry.
-     */
-    attempts: {
-        ledger_hash: string;
-        at: string;
-        recheck_passed: boolean;
-        recheck_reason?: string;
-    }[];
-    /** Whether a user-decision step has been emitted. */
-    user_decision_emitted: boolean;
-}
-export declare function readCyclicSeamRepairState(artifactsDir: string): Promise<CyclicSeamRepairState>;
-export declare function writeCyclicSeamRepairState(artifactsDir: string, state: CyclicSeamRepairState): Promise<void>;
-/** Outcome of an archive attempt. */
-export interface ArchiveOutcome {
-    /**
-     * Timestamped history path the original was moved to, or undefined when the
-     * source did not exist (nothing to archive).
-     */
-    archivedPath?: string;
-    /**
-     * True when the original path is now free for a fresh Write (the move
-     * succeeded, or there was nothing to archive). False when the move failed and
-     * the original was preserved in place — the caller must NOT assume the path is
-     * re-authorable.
-     */
-    originalFree: boolean;
-}
-/**
- * Archive an artifact into `<contract>/history/` instead of deleting it, so a
- * repair loop never silently destroys an LLM output. Two disjoint files exist
- * per artifact (D3): the host's plain INPUT (`<name>.input.json` — the LLM
- * emission) and the tool's canonical envelope (`<name>.json` — regenerable
- * bookkeeping). On a stale/invalid re-emit BOTH are moved to history: the input
- * to preserve the LLM output AND free its path for a fresh host Write, the
- * canonical so the completion gate (`contractArtifactExists`) re-fires and the
- * producing phase re-emits. The returned `archivedPath` references the input
- * archive when present (what the host re-authors), else the canonical archive.
- * A tool-derived artifact with no input file (e.g. a merged-shard artifact)
- * archives only its canonical envelope. If any move throws, the rest are left
- * in place (`originalFree: false`) rather than silently dropped. `renameFn` is a
- * DI seam so a failed history move is testable.
- */
-export declare function archiveContractArtifact(artifactsDir: string, name: ContractPipelineArtifactName, label: "stale" | "invalid", renameFn?: (from: string, to: string) => Promise<void>): Promise<ArchiveOutcome>;
-/**
- * The explicit re-author signpost appended to every inline rejection re-emit:
- * the prior output was archived, so the worker must Write a fresh complete
- * artifact at the ORIGINAL path — never Edit the previous (now-archived) file.
- */
-export declare function rejectionRewriteInstruction(archived: {
-    archivedPath?: string;
-    originalFree?: boolean;
-} | string | undefined): string;
-export interface ContractIngestionResult {
-    /** Raw worker payloads that validated and were wrapped into envelopes. */
-    ingested: ContractPipelineArtifactName[];
-    /** Raw worker payloads that failed validation (archived; phase re-emitted). */
-    invalid: {
-        name: ContractPipelineArtifactName;
-        issues: ValidationIssue[];
-        unavailable?: boolean;
-    }[];
-    /** Previously reviewed context changed; freshness work must run upstream-first. */
-    stale?: ContractPipelineArtifactName[];
-}
-/**
- * Derive validated canonical envelopes from the host's plain INPUT files (D3).
- * The host writes the bare payload the role schema describes to
- * `<name>.input.json`; the tool reads it here, validates it, and writes the
- * content-hash envelope to the canonical `<name>.json` — the host's input file
- * is never mutated in place. CP_ARTIFACT_NAMES is dependency-ordered, so
- * dependencies are enveloped before their dependents and dependency hashes are
- * always available.
- */
-export declare function ingestContractArtifacts(artifactsDir: string, adversarialDepth?: AdversarialDepth): Promise<ContractIngestionResult>;
-export interface ContractPipelineCheckResult {
-    /** True when the contract pipeline should handle the next step. */
-    shouldHandleContractPipeline: boolean;
-    /** True when all pipeline phases (up to implementation_dag) are complete. */
-    pipelineComplete: boolean;
-}
-/**
- * Determine whether the contract pipeline should be entered for this run.
- * The pipeline is entered for ALL intake source types (structured_audit,
- * document, conversation) when an extracted-plan.json has not yet been
- * produced. Path A (structured_audit) seeds the pipeline via a path_a_seed.json
- * before the first phase step, so goal_normalization and context_collection
- * prompts can reference the auditor findings.
- */
-export declare function shouldEnterContractPipeline(artifactsDir: string, _intakeSourceType: string | undefined): ContractPipelineCheckResult;
-/** Return the first pipeline phase whose output artifact does not exist. */
-export declare function nextMissingContractPhase(artifactsDir: string): string | null;
+export { readApprovedExecutionPlan } from "../contractPipeline/executionPlan.js";
 export interface ContractPipelineStepOptions {
     root: string;
     artifactsDir: string;
     runId: string;
     sourcePaths?: string[];
-    /**
-     * The same DI seam {@link archiveContractArtifact} already exposes, lifted to
-     * the entry point so a FAILED history move is reachable from an end-to-end
-     * test. Undefined uses `node:fs/promises` rename, so production behavior is
-     * unchanged. It exists because the archive-failure branch (COR-114e4941) is a
-     * correctness gate whose whole point is what the pipeline does when the move
-     * does not succeed — a branch no fixture can reach by arranging files.
-     */
-    renameFn?: (from: string, to: string) => Promise<void>;
-}
-export interface PathASeed {
-    schema_version: "remediate-code-contract-pipeline/path-a-seed/v1alpha2";
-    /** Absolute path to the audit-findings.json source file. */
-    audit_findings_path: string;
-    /** Number of findings in the report. */
-    finding_count: number;
-    /** Short per-finding summaries (id + title + lens). */
-    findings_summary: Array<{
-        id: string;
-        title: string;
-        lens: string;
-    }>;
-    /** Repo-relative paths cited as affected_files across all findings. */
-    affected_files: string[];
-    /** Auditor-produced bounded work topology. */
-    work_blocks: WorkBlock[];
-    /** Explicit cross-block overlaps; required seams must be prepared before refactors. */
-    work_block_seams: WorkBlockSeam[];
-    /**
-     * Seed source-digest binding. One sha256 per source path the seed was built
-     * FROM, recorded at seed-build time: the audit-findings file itself plus every
-     * `affected_files` path that existed on disk. `buildNextContractPipelineStep`
-     * re-hashes each on entry and refuses when one no longer matches, instead of
-     * spending a whole design pipeline on content that no longer holds the
-     * findings the seed enumerates.
-     *
-     * OPTIONAL for READING, always written for WRITING: a seed persisted before
-     * this field existed carries none, and an absent list binds nothing rather
-     * than blocking a run mid-flight. Paths are stored exactly as the seed knows
-     * them — the findings path absolute, `affected_files` repo-relative — and the
-     * verifier resolves a relative entry against the repo root it is handed.
-     */
-    source_digests?: Array<{
-        path: string;
-        sha256: string;
-    }>;
-    created_at: string;
-}
-/**
- * Write a Path-A seed file from a parsed audit-findings report.
- * The seed is written once (idempotent: skipped when it already exists).
- * goal_normalization and context_collection prompts detect the seed and
- * include its contents so every pipeline node traces to an auditor finding.
- */
-export declare function writePathASeedFromFindings(artifactsDir: string, auditFindingsPath: string, auditFindings: unknown): Promise<void>;
-/** One seed-recorded source path whose content no longer matches its digest. */
-export interface SeedSourceDigestMismatch {
-    path: string;
-    expected: string;
-    /** The path's current sha256, or `null` when it is no longer readable. */
-    actual: string | null;
-}
-/**
- * The tool-named accept lane for seed-source drift — the file an OPERATOR writes
- * to record "this drift is reviewed and does not invalidate the findings".
- *
- * A digest is a whole-file byte binding, so it moves for changes no finding is
- * about: a release `version` bump in `package.json` moves the digest of every
- * finding that cited `package.json` and blocked the run. The alarm was right
- * that SOMETHING moved and wrong about whether the findings still held — there
- * was no way to say so, and the run's remaining options were re-auditing or
- * deleting the seed.
- *
- * WHY THE ACCEPT IS AN OPERATOR FILE AND NOT A DERIVED VERDICT. The tempting
- * mechanical predicate is "do the drifted file's cited locations still exist"
- * (line N still present). It is unsound in the direction that matters: a finding
- * asserting "the config parser returns null on malformed input" cites line 42,
- * and rewriting that line to throw leaves line 42 present, the digest
- * moved, and the finding FALSE — the predicate accepts and the run designs
- * against a claim the code no longer makes. That inference cannot be made from
- * line counts by a language-neutral tool, and a predicate that is right about
- * version bumps and wrong about behaviour changes is worse than no predicate:
- * it silently converts "the alarm fired" into "the alarm was satisfied". So the
- * judgment stays where it can actually be made — with the operator, recorded,
- * and attributable — and the tool enforces only the shape of the record.
- */
-export interface SeedSourceAcceptance {
-    /** The seed-recorded source path this decision covers (repo-relative). */
-    path: string;
-    /** Why the drift does not invalidate the findings. Required, non-empty. */
-    rationale: string;
-    /**
-     * Who decided. Attributable identity, like the counterexample waiver and the
-     * loop-core review attestation — no mechanical channel can prove WHO decided,
-     * so the record names the decider rather than pretending to verify them.
-     */
-    accepted_by: string;
+    forceRevision?: boolean;
 }
-/** The tool-named host lane: the operator's drift acceptances land here. */
-export declare function seedSourceAcceptancesPath(artifactsDir: string): string;
-/**
- * Read the operator's acceptances, keyed by the same path normalization the
- * mismatch side uses. A malformed entry is DROPPED, never widened: an acceptance
- * missing its rationale or its decider records no decision, and treating it as
- * one would turn a shape defect into a silent bypass of the alarm.
- */
-export declare function readSeedSourceAcceptances(artifactsDir: string): Promise<Map<string, SeedSourceAcceptance>>;
-/**
- * The seed paths the operator's acceptance file covers, applied to the drifted
- * set under the ONE path normalization both sides share; everything else blocks.
- *
- * This is the accept path and it is deliberately the ONLY automatic one: the
- * gate cannot tell a benign drift from a falsifying one, and the one predicate
- * that claimed to (cited line counts) was unsound — see {@link SeedSourceAcceptance}.
- */
-export declare function partitionSeedSourceDrift(artifactsDir: string, mismatches: readonly SeedSourceDigestMismatch[]): Promise<{
-    accepted: Array<SeedSourceAcceptance & {
-        mismatch: SeedSourceDigestMismatch;
-    }>;
-    blocking: SeedSourceDigestMismatch[];
-}>;
-/**
- * Seed source-digest binding — re-hash every path the path_a seed recorded and
- * report the ones that moved. Pure over (root, seed): the caller decides what a
- * mismatch means, so this is directly red-green testable without a pipeline.
- *
- * A seed with no `source_digests` (written before the field existed) binds
- * nothing and yields no mismatches.
- */
-export declare function detectSeedSourceDigestMismatches(root: string, seed: PathASeed | undefined): Promise<SeedSourceDigestMismatch[]>;
-/**
- * When a judge report omits `repair_directive`, infer the repair target from
- * the failing classifications. Post-redesign the default is
- * `finalized_module_contracts` (not `design_spec`).
- */
-type ExtendedRepairTarget = Exclude<JudgeRepairTarget, "design_spec">;
-/**
- * Infer the most appropriate repair target from judge classifications when no
- * explicit repair_directive is provided. Examines only accepted classifications
- * and keyword-matches their rationale text.
- *
- * Priority (first match wins):
- *   obligation/ledger/invariant/constraint keywords → obligation_ledger
- *   assessment/finding/gap keywords                 → contract_assessment_report
- *   fallback                                        → finalized_module_contracts
- */
-export declare function inferRepairTarget(classifications: JudgeReport["classifications"] | undefined): ExtendedRepairTarget;
-type JudgeGate = {
-    kind: "proceed";
-} | {
-    kind: "escalate";
-    reason: "stall" | "runaway" | "invalid_waivers";
-    /** Accepted counterexample ids still standing — waived ones excluded. */
-    outstanding: string[];
-    note: string;
-    /** Present only for reason "invalid_waivers": why the file was refused. */
-    waiverIssues?: string[];
-} | {
-    kind: "repair";
-    directive: {
-        target: ExtendedRepairTarget;
-        instruction: string;
-    };
-    judgeHash: string;
-    acceptedCeIds: string[];
-    addressedCeFingerprints: string[];
-};
-/**
- * Decide whether implementation planning may proceed. Convergence-terminated,
- * NOT capped at an arbitrary count:
- *   - approved verdict ⇒ proceed (the fixpoint);
- *   - a needs_repair verdict that surfaces a NEW accepted counterexample (one not
- *     already addressed by a prior repair) ⇒ repair (genuine progress);
- *   - a needs_repair verdict whose accepted counterexamples were ALL already
- *     addressed ⇒ escalate (stall/oscillation — the repair loop is not converging,
- *     surface the outstanding counterexamples to the user instead of silently
- *     shipping residual risk or looping);
- *   - the runaway backstop (MAX_CONTRACT_REPAIR_ITERATIONS) ⇒ escalate (loud).
- * The former fixed N=2 cap that proceeded-with-residual-risk at an arbitrary count
- * is gone: a deep-but-converging run is no longer cut mid-convergence, and a
- * genuinely non-converging run is surfaced rather than buried.
- */
-export declare function evaluateJudgeGate(artifactsDir: string): Promise<JudgeGate>;
-type CritiqueGate = {
-    kind: "proceed";
-} | {
-    kind: "escalate";
-    reason: "stall" | "runaway" | "unsupported_target";
-    blocking: string[];
-    note: string;
-} | {
-    kind: "repair";
-    critiqueHash: string;
-    blockingIds: string[];
-    target: ConceptualCritiqueRepairTarget;
-};
-/**
- * Decide whether the pipeline may advance past the conceptual-design critique.
- *
- * The routing signal is MECHANICAL and derived only from the critique items: a
- * critique carrying ANY `severity: "blocking"` item means the design is not
- * approved and must be repaired — regardless of the author-stated `verdict`
- * string. This closes the contradictory-combo gap: a critique that marks items
- * `blocking` while declaring `approved` / `approved_with_concerns` (which the
- * pipeline previously waved through, since only a judge verdict ever gated
- * anything) no longer silently proceeds. Enforce-in-tooling: the verdict label
- * is advisory display; the blocking-item set is the contract.
- *
- * Convergence-terminated, mirroring {@link evaluateJudgeGate}: the first blocking
- * critique ⇒ repair its declared owner (legacy: `finalized_module_contracts`); repairing it
- * re-stales and re-emits the critique (it depends on the finalized contracts), so
- * a clean re-critique ⇒ proceed (the fixpoint). A fresh critique whose blocking
- * ids were ALL already addressed by a prior repair, with none new ⇒ escalate
- * (stall — the design loop is not converging) rather than repair forever; the
- * runaway backstop also escalates (loud).
- */
-export declare function evaluateCritiqueGate(artifactsDir: string): Promise<CritiqueGate>;
-export interface DagTraceabilityResult {
-    ok: boolean;
-    violations: string[];
-}
-/**
- * The traceability invariant: no implementation_dag node may exist without
- * tracing to an obligation from the ledger (satisfies_obligations or
- * verification_obligation_ids) or to a judge-accepted counterexample
- * (addresses_counterexamples). Untraceable nodes are unattributable work — the
- * exact thing the contract pipeline exists to prevent.
- */
-export declare function validateImplementationDagTraceability(artifactsDir: string): Promise<DagTraceabilityResult>;
-export interface ContractObligationsGateResult {
-    ok: boolean;
-    violations: string[];
-}
-/**
- * Run the fail-closed contract-obligation gates against the persisted contract
- * artifacts: paired obligations, evidence threading, source-scoped digest
- * coverage, and INV-CO-12 reconciliation derivation.
- *
- * Branch on `evaluated` before trusting emptiness. This no longer flattens four `ValidationIssue[]`
- * into one array, where a gate that never RAN and a gate that ran CLEAN both
- * contributed nothing and were indistinguishable. It consumes the shared
- * gate-outcome record and branches on `evaluated` first: at this boundary every
- * phase artifact exists, so a skipped gate is a violation, not a pass. See
- * {@link consumeGateOutcomes} for the per-boundary `required` policy and the one
- * declared exception (`digest_coverage`).
- */
-export declare function evaluateContractObligationsPromotionGate(artifactsDir: string, root?: string, inputs?: ContractPipelineCrossGateInputs): Promise<ContractObligationsGateResult>;
-/**
- * Pre-adversarial structural floor (S5). The subset of the contract-obligation
- * gates whose inputs all exist by the time the critic phase is reached
- * (paired-obligation coverage, source-scoped digest coverage, and seam
- * reconciliation derivation — none of which need the judge verdict or the
- * implementation_dag). Running them BEFORE the expensive critic/judge loop means
- * the adversarial phases only ever see structurally-sound obligations, tests, and
- * contracts, and a structural gap is re-emitted to the precise responsible phase
- * instead of being discovered at promotion (after the adversarial budget is spent)
- * and re-emitted to the wrong phase. The full {@link evaluateContractObligationsPromotionGate}
- * — including the evidence-threading check that needs the judge + DAG — still runs
- * at promotion as the fail-closed backstop; this gate never replaces it.
- *
- * Returns the first failing gate's responsible phase + rendered error lines, or
- * null when the structural floor is clean. Branches on each outcome's
- * `evaluated` before its empty issue list is allowed to mean clean
- * (the branch-on-evaluated rule); `contract_finalization`, `seam_reconciliation`
- * and `test_validator_plan` all precede `critic` in the phase order, so a
- * skipped gate here is a malformed payload rather than an absent one.
- */
-export declare function evaluatePreCriticStructuralGate(artifactsDir: string, root?: string, inputs?: ContractPipelineCrossGateInputs): Promise<{
-    phase: "contract_finalization" | "test_validator_plan";
-    errorLines: string[];
-} | null>;
-/**
- * Promotion-backstop citation grounding over the promoted extracted-plan
- * findings. Returns rendered violation lines, or null when every finding grounds.
- */
-export declare function evaluatePromotedPlanCitationGrounding(artifactsDir: string, repoRoot: string): Promise<{
-    violations: string[];
-} | null>;
-/** The phase(s) that fan out per module, and the artifact each produces. */
-declare const PARALLEL_MODULE_PHASES: {
-    readonly module_contract_drafting: "module_contracts";
-};
-type ParallelModulePhase = keyof typeof PARALLEL_MODULE_PHASES;
-export declare function isParallelModulePhase(phase: string): phase is ParallelModulePhase;
-/**
- * Resolve the adversarial-depth dial for a run (extracted from
- * buildNextContractPipelineStep for testability; behavior-preserving).
- *
- * The depth derives from the intake risk signal (the slice-2 shared signal).
- * Escalate-on-evidence (optimistic-start): the run begins at the cheap intake
- * tier; once decomposition reveals the work's actual shape, the tier is raised
- * for THIS and every subsequent next-step. The raise is idempotent + convergent
- * (escalateRiskSignal no-ops once the tier already covers the evidence), and the
- * signal is rewritten only on a real raise. Absent signal ⇒ undefined ⇒ the
- * renderer applies its fail-safe full depth (floor is `light`, never off).
- */
 export declare function resolveAdversarialDepth(artifactsDir: string): Promise<{
-    riskSignal: Awaited<ReturnType<typeof readIntakeRiskSignal>>;
-    adversarialDepth: AdversarialDepth | undefined;
+    riskSignal: import("../riskSignal.js").IntakeRiskSignal | undefined;
+    adversarialDepth: import("../riskSignal.js").AdversarialDepth;
 }>;
-/**
- * Everything a gate is handed. Assembled once per invocation, then passed to
- * every gate in the walk, so each gate is a module-level function that can be
- * called and tested on its own.
- *
- * Two fields are deliberately MUTABLE, each written by exactly one gate:
- *   • `artifactsSettled` — set by the staleness gate once this invocation's own
- *     ingestion + archive pass has run. {@link readCrossGatePayloads} REFUSES
- *     before it is set, which is how the branch-on-evaluated invariant's freshness
- *     half is enforced mechanically instead of by a caller remembering to
- *     re-read: a payload cached from before the pass is unrepresentable.
- *   • `nextPhase` — the phase frontier, resolved AFTER the archive pass because
- *     archiving a stale artifact re-opens its producing phase.
- */
-export interface ContractGateContext {
-    readonly options: ContractPipelineStepOptions;
-    readonly root: string;
-    readonly artifactsDir: string;
-    readonly runId: string;
-    readonly sourcePaths?: string[];
-    readonly paths: ReturnType<typeof intakePaths>;
-    readonly artifactPaths: Partial<Record<ContractPipelineArtifactName, string>>;
-    readonly artifactReadPaths: Partial<Record<ContractPipelineArtifactName, string>>;
-    /** Present only for structured_audit (path-A) runs. */
-    readonly pathASeedPath?: string;
-    readonly riskSignal: Awaited<ReturnType<typeof readIntakeRiskSignal>>;
-    readonly adversarialDepth: AdversarialDepth | undefined;
-    artifactsSettled: boolean;
-    nextPhase: string | null;
-}
-/** The verdict a call site derives from a subset of the shared gate outcomes. */
-export interface CrossGateVerdict {
-    ok: boolean;
-    violations: string[];
-}
-/**
- * Consume a subset of the shared cross-gate outcomes, branching on `evaluated`
- * BEFORE an empty `issues` array is allowed to mean "clean".
- *
- * `required` is DECLARED PER CALL SITE, as data, because "did not run" means
- * different things at different boundaries. At a boundary whose upstream phase
- * order guarantees the gate's input exists, a skip is a refusal — its empty
- * issue list is proof of nothing. Earlier in the pipeline the same skip means
- * "not applicable yet", and the gate is simply not required there.
- *
- * THE UNCOVERED HALF, stated rather than implied: `digest_coverage` is the one
- * gate of the eight whose skip is a DOMAIN non-applicability (a source that is
- * not finding-enumerable) rather than a missing payload, so no boundary lists
- * it as required and a genuinely absent finding-enumeration file for an
- * enumerable source still skips silently. Closing that needs the gate module to
- * expose its enumerability predicate — an edit outside this work item's write
- * scope.
- */
-export declare function consumeGateOutcomes(outcomes: readonly GateOutcome[], selected: readonly GateOutcome["gate"][], required: ReadonlySet<GateOutcome["gate"]>): CrossGateVerdict;
-/**
- * The ONE worker prompt for cyclic-seam resolution. The gate emits it for each
- * attempt, and every generic re-emit of the phase (a refused ingestion, a stale
- * archive, a goal-id mismatch) emits it too — a second, shorter text used to
- * reach the worker on those re-emits and left out the ledger rewrite that the
- * re-check requires, so the retry was refused for a rule it was never told.
- *
- * The worker writes only `resolved`: `no_cycles` is the tool's own record, and
- * the re-check refuses any record while the ledger still has a cycle.
- */
-export declare function renderCyclicSeamResolutionPrompt(params: {
-    cycleDescriptions: string;
-    ledgerInputPath: string;
-    outputPath: string;
-    extraSection?: string;
-}): string;
-/**
- * The gate walk order, exported so a drift guard reads the real set instead of
- * reconstructing one by reflecting over a chain of `if` statements.
- *
- * This and the scaffold's `handledKeys` are BOTH `Object.keys` of the SAME
- * object literal, and the walk consumes `handledKeys` directly — so the two
- * agree by construction, not by a test that compares them. No such test exists,
- * and none is needed: there is no second list to drift from.
- */
-export declare const CONTRACT_PIPELINE_GATE_ORDER: readonly string[];
-/**
- * Build and write the next contract-pipeline step.
- * Returns null when the pipeline is complete and the extracted plan is ready.
- */
+export declare function writePathASeedFromFindings(artifactsDir: string, sourcePath: string, payload: unknown): Promise<void>;
+/** One author/revision loop, with independent review over the executable plan itself. */
 export declare function buildNextContractPipelineStep(options: ContractPipelineStepOptions): Promise<RemediationStep | null>;
-/**
- * The obligation-kind vocabulary, in priority order (higher index = higher
- * priority; `invariant` is highest).
- *
- * MNT-114e4941-3: this used to be a THIRD independent copy of the vocabulary —
- * a local `type ObligationKind` union beside derive.ts's `TESTABLE_KINDS` and
- * contractPipelineGates.ts's `TESTABLE_OBLIGATION_KINDS`, with nothing forcing
- * the three to agree, while the ledger's own `obligation.kind` is typed as a
- * bare `string`. The consequence was not theoretical: an unrecognized kind was
- * CAST to this union, scored -1 by `indexOf`, and then indexed the lens map to
- * `undefined` — so a ledger kind outside these four promoted a finding with
- * `lens: undefined`.
- *
- * Membership and priority are now derived from the single definition list in
- * `contractPipeline/obligationKinds.ts`. An unrecognized kind is not dropped or
- * cast: it is routed through the shared `isTestablePhaseObligation` predicate.
- */
-export { OBLIGATION_KIND_PRIORITY };
-export type { ObligationKind };
-/**
- * Classify a raw ledger `kind` string (which the ledger types as a bare
- * `string`) into this module's vocabulary. A recognized kind maps to itself; an
- * unrecognized one is classified by the SHARED testability predicate rather
- * than guessed here — testable ⇒ `behavioral` (the testable default, so it
- * carries a real lens and a mid severity), otherwise ⇒ `structural`.
- */
-export declare function classifyObligationKind(kind: string): ObligationKind;
-/**
- * Normalize one block's declared write scope into repo-relative, forward-slashed,
- * unique, sorted paths, refusing outright anything that leaves the repository.
- *
- * Case is PRESERVED (`repoRelativePath`, not the lowercasing
- * `normalizeRepoPath`): this string is the write scope a host enforces against a
- * landed diff on a case-sensitive filesystem, so lowercasing it would make a
- * legitimate edit look out of scope. Lowercasing is used only as a MATCH key,
- * never as the stored value.
- *
- * The tracked-tree half is NOT here: see
- * {@link evaluatePromotedPlanWriteScope}, which runs at this same promotion
- * boundary with a bounded re-emit instead of an unrecoverable throw.
- */
 export interface BlockWriteScopeNormalization {
-    /** The entries that normalized cleanly, repo-relative, unique and sorted. */
     touched_files: string[];
-    /** One line per REFUSED entry. Non-empty ⇒ the caller must not promote. */
     refusals: string[];
 }
-export declare function normalizeBlockTouchedFiles(root: string, files: readonly string[], blockId: string): BlockWriteScopeNormalization;
-/**
- * The tracked-tree half of The normalized-write-scope invariant, run against
- * the PROMOTED plan so a violation takes the same bounded re-emit path the M-B3
- * citation gate takes, rather than throwing out of the promotion.
- *
- * It exists because the citation gate is NOT a superset: a finding grounds if
- * ANY cited path OR SYMBOL is real, so a node whose prose names a real symbol
- * can ground while its declared write scope is still fabricated — and the write
- * scope is what a host binds a worker to.
- *
- * A path that is not tracked but whose parent directory IS stays legal: a
- * remediation block legitimately creates new files, and dropping a declared
- * write target is the failure mode that strands an implementer with an
- * obligation it has no scope to discharge. Fail-open on an unreadable tree, as
- * the citation gate does.
- */
-export declare function evaluatePromotedPlanWriteScope(artifactsDir: string, root: string): Promise<{
-    violations: string[];
-} | null>;
-/**
- * Tracked-tree parity for a POST-promotion write-scope widening
- * (open-bugs.md:110): a clarification scope delta must clear the same rule the
- * promotion gate enforced, or the delta lane becomes a bypass of it. Returns
- * violation lines; [] on an unreadable tree (fail-open, exactly as the
- * promotion gate degrades).
- */
+export declare function normalizeBlockTouchedFiles(root: string, files: readonly string[], id: string): BlockWriteScopeNormalization;
 export declare function checkWriteScopePathsAgainstTrackedTree(root: string, paths: readonly string[], label: string): Promise<string[]>;
-/**
- * Refuse a targeted command that leaves the declared shape — a single
- * invocation with no shell chaining, substitution or redirection. Deliberately
- * ecosystem-neutral: this module never asserts WHICH runner is legitimate
- * (language-neutral by contract), only that the string handed to a shell cannot
- * do more than invoke one command.
- *
- * The RULE is not here. It is `commandLeavesDeclaredShape`
- * (`audit-tools/shared`), the one predicate the host-handoff consumer and the
- * triage re-verification spawn also ask. This function owns only the WORDING and
- * the refusals-as-data contract. It used to own a second, quote-BLIND regex
- * instead, and the two disagreed in both directions: `pytest -k 'not slow'`
- * cleared promotion and then dead-ended at the consumer as
- * `block_contract_invalid`, while `echo "a & b"` was refused here though the
- * consumer admits it.
- *
- * Refusals are RETURNED, never thrown: the promotion boundary turns them into
- * the same bounded re-emit every other promotion rejection takes, so a
- * malformed command re-emits implementation_planning instead of wedging every
- * subsequent next-step with an unclassified stack.
- */
-export interface BlockCommandNormalization {
-    targeted_commands: string[];
-    /** One line per REFUSED command. Non-empty ⇒ the caller must not promote. */
-    refusals: string[];
-}
-export declare function normalizeBlockTargetedCommands(commands: readonly string[], blockId: string): BlockCommandNormalization;
-/**
- * Collect every write-scope and command refusal the promotion WOULD hit, before
- * a plan is written. Runs the same two normalizers over the same derived node
- * scope the promoter uses, so this pre-check and the promotion cannot disagree
- * about what is refusable — and the refusal reaches the host as the bounded
- * `implementation_planning` re-emit every other promotion rejection takes,
- * rather than as a thrown stack that wedges every subsequent next-step.
- */
-export declare function collectDagWriteScopeRefusals(artifactsDir: string, root: string): Promise<string[]>;
-/**
- * Path-A canonical-block membership validation, run BEFORE anything is promoted
- * (OBL-seam-prep-remediate-core-inv-2 / COR-114e4941). These are exactly the
- * checks the promoter itself performs while building its node→canonical-group
- * map — but there they THROW out of `promoteImplementationDagToExtractedPlan`,
- * an unclassified stack that wedged every subsequent next-step. Hoisted here so
- * an invalid `source_finding_ids` declaration takes the same bounded re-emit as
- * every other promotion rejection, with no gate having executed past it.
- *
- * The checks themselves are {@link evaluatePathACanonicalGroups} — the ONE body
- * both this gate and the promoter call, so the gate can never certify a DAG the
- * promoter then refuses.
- *
- * Returns one line per violation; empty means the DAG is promotable on this
- * axis (or Path A is not in play at all).
- */
-export declare function collectPathARefusals(artifactsDir: string): Promise<string[]>;
-/**
- * What the AUDIT read, for the run whose Path-A seed lives in `artifactsDir` —
- * the value plan application stamps onto `state.plan.audit_read`.
- *
- * Read by the TOOL from the seed's own source report, which passed the strict
- * shared validator (`projectApprovedFindings`) before it may answer. It never
- * rides `extracted-plan.json`: that file is host-writable, and the close
- * phase's evidence leg turns this commit into terminal dispositions, so a
- * host-supplied value would let a host author its own `refuted`.
- *
- * BOUND TO THE SEED'S OWN DIGEST. The seed recorded a sha256 of the source
- * report when it was built (`source_digests`); the bytes read here must hash to
- * it, so a report swapped afterwards — even for another VALID report — answers
- * `null`. The file is read ONCE and the same bytes are hashed and parsed. A seed
- * that carries no digest for its source binds nothing, and an unbound commit is
- * not one this function will vouch for.
- *
- * `null` — "no commit is known" — when there is no seed (the run did not start
- * from a findings report), the source is unbound, changed, unreadable or
- * invalid, or the report itself states `null`.
- */
-export declare function readSeedAuditRead(artifactsDir: string): Promise<AuditRead | null>;
-/**
- * Convert a completed ImplementationDAG into the extracted-plan.json format
- * that the existing handlePendingExtractedPlan/applyPlanPipeline path consumes.
- *
- * `root` defaults to the repository that owns `artifactsDir`, so the existing
- * one-argument callers keep working while the pipeline passes the run's real
- * root for write-scope normalization.
- */
-export declare function promoteImplementationDagToExtractedPlan(artifactsDir: string, root?: string): Promise<void>;
 //# sourceMappingURL=contractPipeline.d.ts.map