import { type RunOutcome, type SuiteStepSummary } from '@opensip-cli/contracts';
import { type ToolCliContext, type EvidenceSnapshotContribution } from '@opensip-cli/core';
import type { SuiteStepReviewInput } from './review-brief.js';
import type { ValidatedSuite } from './validate-suite.js';
import type { RunActionHooks } from '../../bootstrap/run-plane.js';
/** A step's lifecycle transition, emitted so a live view can drive the checklist. */
export type SuiteStepEvent = {
    readonly phase: 'start';
    readonly index: number;
} | {
    readonly phase: 'done';
    readonly index: number;
    readonly summary: SuiteStepSummary;
};
export declare function runStepsSerially(args: {
    readonly suite: ValidatedSuite;
    readonly suiteRunId: string;
    readonly ctx: ToolCliContext;
    readonly runActionHooks: RunActionHooks;
    readonly suiteOpts: Readonly<Record<string, unknown>>;
    readonly defaultChanged?: boolean;
    readonly fullScopeFiles?: readonly string[];
    /** Optional lifecycle sink (the suite live view wires this to progress events). */
    readonly onStepEvent?: (event: SuiteStepEvent) => void;
}): Promise<SuiteStepReviewInput[]>;
/**
 * Derive a suite step's authoritative 3-way {@link RunOutcome} from the two
 * runtime signals the runner observes — the host-caught `errorMessage` (a thrown
 * step OR a reportFailure) and the emitted envelope's verdict.
 *
 * The emitted envelope's verdict is AUTHORITATIVE when present: it already
 * carries `faulted` for a UNIT-level fault (a check that threw), and a
 * report-DELIVERY failure on a run that DID produce results is orthogonal to the
 * analysis outcome (it rides the exit code, ADR-0008) — so it does not override a
 * passing/failing verdict into `faulted`. A host-caught error decides the outcome
 * ONLY when the step produced NO envelope at all (a thrown command,
 * ConfigurationError, or ToolError before results, ADR-0060) — that reads
 * `faulted`. With neither an envelope nor an error, the exit code is the fallback.
 *
 * This distinction is load-bearing for the suite exit: an envelope-backed fault
 * (a check crashed, `verdict` present) is a NON-blocking "result unknown", while
 * a no-envelope fault (the tool/step itself crashed) keeps its ADR-0020 exit
 * taxonomy and blocks — see the `isNonBlockingFault` gate in `orchestrator.ts`.
 */
export declare function deriveStepOutcome(input: {
    readonly errorMessage: string | undefined;
    readonly envelopeVerdict: {
        readonly passed: boolean;
        readonly faulted?: boolean;
    } | undefined;
    readonly exitCode: number;
}): RunOutcome;
/** Closed readiness projection for a generic evidence-producing suite step. */
export declare function evidenceStepReadiness(snapshots: readonly EvidenceSnapshotContribution[]): NonNullable<SuiteStepSummary['readiness']>;
//# sourceMappingURL=suite-step-runner.d.ts.map