import type { AcEvidence, CadenceConfig, CadenceState, Draft, GateSet, Profile, Tier } from '@manehorizons/cadence-types';
import { resolveEffectiveProvider } from '../verify/verifier-factory.js';
/**
 * Resolve the effective profile for a phase. DRAFT frontmatter override wins;
 * otherwise the project default from `.cadence/config.json` applies. Falls
 * back to `'auto'` if neither is set.
 */
export declare function effectiveProfile(config: Pick<CadenceConfig, 'profile'> | null, draft: Pick<Draft, 'profile'> | null): Profile;
/**
 * Resolve the effective boundaryEnforcement mode for a phase (Phase 155,
 * AC-5). DRAFT frontmatter override wins; otherwise the project default from
 * `.cadence/config.json` applies. Falls back to `'warn'` if neither is set —
 * mirrors `effectiveProfile` above.
 */
export declare function effectiveBoundaryEnforcement(config: Pick<CadenceConfig, 'boundaryEnforcement'> | null, draft: Pick<Draft, 'boundaryEnforcement'> | null): CadenceConfig['boundaryEnforcement'];
/**
 * Resolve the effective redundantWorkEnforcement mode for a phase (subagent
 * task-redundancy monitoring). DRAFT frontmatter override wins; otherwise the
 * project default from `.cadence/config.json` applies. Falls back to
 * `'warn'` if neither is set — mirrors `effectiveBoundaryEnforcement`.
 */
export declare function effectiveRedundantWorkEnforcement(config: Pick<CadenceConfig, 'redundantWorkEnforcement'> | null, draft: Pick<Draft, 'redundantWorkEnforcement'> | null): CadenceConfig['redundantWorkEnforcement'];
/**
 * Resolve the effective `gates.evidenceFloor` for a phase (Phase 214, T2 —
 * closes the visibility-only Phase 140 evidence-ladder enforcement gap).
 * Unlike `effectiveProfile`/`effectiveBoundaryEnforcement` there is no
 * per-draft override — DRAFT frontmatter never gained an `evidenceFloor`
 * field — so this reads only `config.gates.evidenceFloor`, falling back to
 * `'mention'`: the schema-level back-compat default from
 * `CadenceConfigZ.gates.evidenceFloor` (`packages/types/src/config.ts`),
 * which is deliberately the weakest rung so a config predating this gate
 * never starts newly refusing. The `checkEvidenceFloor` gate step in
 * `./ac-evidence.js` consumes this value.
 */
export declare function effectiveEvidenceFloor(config: Pick<CadenceConfig, 'gates'> | null): AcEvidence;
/**
 * Phase 214 (T3, AC-3): the specific, named reason `gates.evidenceFloor:
 * 'ai-verified'` is structurally unreachable while the active `--deep`
 * verifier provider is `mock`. `deriveAcEvidence`
 * (`./ac-evidence.js`) has always excluded a mock-provider deep-verify pass
 * from counting as `ai-verified` (Phase 140's "Mock Mirage" precedent:
 * `if (verdict?.pass === true && verdict.provider !== 'mock') return
 * 'ai-verified';`) — so under this exact combination `checkEvidenceFloor`
 * would refuse *every* settle attempt forever, with no evidence an operator
 * could produce to satisfy it short of a bypass. That is a permanent,
 * structural dead end, not an ordinary "strengthen the evidence" case, and
 * the generic below-floor message (`checkEvidenceFloor`'s `reason`) doesn't
 * say so.
 */
export declare const AI_VERIFIED_UNDER_MOCK_PROVIDER_REASON: string;
/**
 * Phase 214 (T3, AC-3): does effective `floor`/`provider` land on the
 * structural ai-verified/mock trap described above? Pure predicate — the
 * only two values that matter, already resolved by the caller.
 */
export declare function isEvidenceFloorStructurallyUnreachable(floor: AcEvidence, provider: ReturnType<typeof resolveEffectiveProvider>['provider']): boolean;
/**
 * Phase 214 (T3, AC-3): pick the evidence-floor refusal message. Swaps in
 * `AI_VERIFIED_UNDER_MOCK_PROVIDER_REASON` exactly when
 * `isEvidenceFloorStructurallyUnreachable` holds for the effective floor and
 * the resolved `--deep` verifier provider; otherwise returns `genericReason`
 * unchanged (the per-AC actual-vs-required text `checkEvidenceFloor`
 * already produces — see `./ac-evidence.js`). Provider resolution reuses
 * `resolveEffectiveProvider` (`../verify/verifier-factory.js`) rather than
 * re-deriving the `?? 'mock'` fallback here, so this stays in lockstep with
 * every other verifier-provider consumer in the codebase.
 */
export declare function evidenceFloorRefusalReason(floor: AcEvidence, config: Pick<CadenceConfig, 'verifier'> | null, genericReason: string): string;
/**
 * Compute the set of gates that should fire for a given (tier, profile)
 * combination. Pure function; no I/O. `softCap` is true only for the
 * `auto × complex` cell — gate implementations later phases refuse without
 * `--allow-auto-complex`.
 */
export declare function gatesFor(tier: Tier, profile: Profile): GateSet;
/**
 * Convenience: derive the effective gate set from state + config + draft.
 * State carries the active tier; draft (optional) provides the profile
 * override; config provides the project default.
 */
export declare function effectiveGateSet(state: Pick<CadenceState, 'tier'>, config: Pick<CadenceConfig, 'profile'> | null, draft: Pick<Draft, 'profile' | 'tier'> | null): GateSet;
//# sourceMappingURL=engine.d.ts.map