/**
 * Drift response dispatcher: maps (Verdict, DriftPolicy) → RuntimeAction.
 *
 * Sits between the rule evaluator (which produces `Verdict`s) and the hook
 * layer (which executes `RuntimeAction`s). A rule decides what happened;
 * the pack-declared `drift_response` policy decides what to do about it.
 * All six `DriftPolicy` variants are wired here (AUTO.4 finished the two
 * previously-deferred policies — `auto_correct` and `escalate`).
 *
 * Dispatch shape is intentionally a `Record<DriftPolicy, ...>` lookup table,
 * NOT an if/else (or switch) cascade — constraint from the design doc
 * §"Drift response policies" + Task 1.6 acceptance criteria. The lookup
 * lets a future Phase widen the policy set by appending one map entry,
 * with TS's exhaustiveness check on `DriftPolicy` guaranteeing every variant
 * has a handler (the `Record<DriftPolicy, ...>` type errors on omission).
 *
 * `auto_correct` semantics (AUTO.4): produces an action descriptor
 * `{kind: 'auto_correct', correctiveSkill, verdict}`. The dispatcher
 * resolves the corrective skill from the pack's
 * `drift_response.corrective_skills[ruleId]` map. If no corrective skill is
 * declared for the rule, the dispatcher degrades to `notify_pause` with
 * severity 'critical' and a reason naming the missing entry — no silent
 * fail-open (constraint C10). The runtime layer (`runtime/auto_correct.ts`)
 * picks up the descriptor, runs the capability gate, invokes the corrective
 * skill via the evaluator, and re-evaluates the original rule.
 *
 * `escalate` semantics (AUTO.4): produces an action descriptor
 * `{kind: 'escalate', reroutedSeverity: 'critical', verdict}`. The runtime
 * layer (`runtime/escalate.ts`) does the side-effects — applies the
 * RateLimiter (paging-fatigue prevention) then multicasts via
 * NotificationRouter using the critical-tier channel list.
 *
 * Unknown-policy fail-safe (constraint C10 — no silent fail-open): if the
 * caller hands us a policy string that isn't in `DISPATCH` (e.g. a typo in
 * pack YAML that slipped past schema validation, or a future variant the
 * dispatcher doesn't recognize), we degrade to `notify_pause` with severity
 * `'critical'` rather than silently picking a "safe default" policy. The
 * cast at the call site (`policy as DriftPolicy`) is the only path that
 * reaches this branch; the TS layer above prevents legitimate callers from
 * hitting it.
 *
 * Imports from: ./types.js.
 * Imported by: src/runtime/index.ts (re-export), runtime/hooks/ (Task 1.7),
 * runtime/auto_correct.ts + runtime/escalate.ts (action-descriptor consumers).
 */
import type { DriftPolicy, MessageVerdict, RuntimeAction, VerdictLevel } from './types.js';
/**
 * Fallback drift-response policy when a pack ships no `drift_response.yaml`
 * (no per-rule entry, no pack default). DERIVES the policy from the verdict
 * level so a rule's authored `level:` is honored without a separate policy
 * file:
 *
 *   block                              → block_tool   (hard block; exit 2)
 *   warn | surface | pass | directive  → warn         (non-blocking notice; exit 0)
 *
 * This replaces the historical blanket `block_tool` default, which silently
 * hard-blocked every warn/surface-level rule in any pack lacking the file —
 * discarding the level the author wrote. `drift_response.yaml` remains an
 * OVERRIDE (per_rule / default) layered on top of this; precedence is
 * unchanged (the dispatcher consults the file first, this fallback last).
 *
 * Total over the closed `VerdictLevel` enum by construction (single branch).
 */
export declare function defaultPolicyForLevel(level: VerdictLevel): DriftPolicy;
/**
 * T-ASC ASC.3: drift_response only processes message-bearing verdicts.
 * Directive-level verdicts flow through a separate dispatcher path
 * (DispatchResult.directives aggregation, surfaced via UserPromptSubmit
 * envelope) and never reach applyDriftResponse.
 */
type Verdict = MessageVerdict;
/**
 * Per-call dispatch context. Only `auto_correct` needs the corrective-skill
 * map; the other handlers ignore it. Field is optional so callers that only
 * use the 4 stable policies don't have to construct an empty record.
 */
export interface DriftDispatchCtx {
    correctiveSkills?: Record<string, string>;
}
export declare function applyDriftResponse(verdict: Verdict, policy: DriftPolicy, ctx?: DriftDispatchCtx): RuntimeAction;
export {};
//# sourceMappingURL=drift_response.d.ts.map