/**
 * Remediation adapters — HOW DO WE MAKE IT HAPPEN?
 *
 * The diagnose chain ends by feeding existing improvement machinery,
 * not by building new machinery:
 *
 *   - `toAnalystFindings` → the analyst contract (`makeFinding`), so
 *     responsibility evidence flows into the same registry / steering /
 *     diff pipeline every other analyst feeds.
 *   - `toCorpusRecord` → the RL corpus (`CorpusRecord`), pinning the
 *     diagnosed failure + validated repair as a permanent scenario.
 *   - `suggestInvariant` → a plain-data hint in the shape the
 *     trace-contracts machinery consumes (`never` / `without` clauses).
 */
import type { AnalystFinding, AnalystSeverity } from '../analyst/types';
import type { CounterfactualMutation } from '../counterfactual';
import type { CorpusRecord } from '../rl/corpus';
import type { RunRecord } from '../run-record';
import type { CausalResponsibilityReport, StepResponsibility } from './causal-sweep';
import type { RepairReport, ValidatedRepair } from './repair';
export declare const DIAGNOSE_ANALYST_ID = "diagnose-causal-sweep";
/** Severity from causal effect size. Effects whose CI includes zero are
 *  'info' regardless of magnitude — an indistinguishable-from-noise effect
 *  must not steer remediation priority. */
export declare function severityFromEffect(responsibility: StepResponsibility): AnalystSeverity;
/** Deterministic human-readable rendering of a mutation — used in
 *  recommended actions, corpus completions, and invariant hints. */
export declare function describeMutation(mutation: CounterfactualMutation): string;
/**
 * Lift a responsibility report (and optionally its validated repairs) into
 * `AnalystFinding`s via the real `makeFinding` factory. One finding per
 * probed step; a validated repair for that step upgrades the finding with
 * a `recommended_action` + the replay-validation evidence.
 *
 * Findings are OBSERVED causal probes (replay deltas), not judge verdicts,
 * so `derived_from_judge` stays unset and they may steer.
 */
export declare function toAnalystFindings(report: CausalResponsibilityReport, repairs?: RepairReport): AnalystFinding[];
/**
 * Pin the diagnosed failure as a permanent corpus scenario. Takes the
 * original run's `RunRecord` projection plus a validated repair and emits
 * a fresh `CorpusRecord` (new runId, so corpus dedup keeps both the raw
 * failure and the diagnosed entry).
 *
 * `completion` defaults to the validated mutation's rendering — "what
 * should have happened" in machine-derived form. Supply `prompt` (and
 * optionally a richer `completion`) when the trajectory text is available
 * so the record is harvestable by `buildDatasetFromCorpus`.
 */
export declare function toCorpusRecord(run: RunRecord, repair: ValidatedRepair, opts?: {
    prompt?: string;
    completion?: string;
}): CorpusRecord;
/** Plain-data invariant hint. The trace-contracts machinery consumes this
 *  shape: `never` is a pattern that must not appear in a passing trace;
 *  `without` is a guard whose absence makes the failure reachable. */
export interface InvariantHint {
    description: string;
    never?: string;
    without?: string;
}
/**
 * Derive an invariant hint from a validated repair. Deterministic per
 * mutation kind — the hint names the contract a trace must satisfy so
 * the diagnosed failure cannot silently recur.
 */
export declare function suggestInvariant(repair: ValidatedRepair): InvariantHint;
//# sourceMappingURL=remediation.d.ts.map