import type { VerificationEvidence } from "./verification-evidence.js";
export declare const VERIFICATION_STATE_KIND = "verification_state";
/**
 * True when the command looks like a test/typecheck/lint/build invocation:
 * compound segments considered independently, wrappers stripped, a known runner
 * leading, and a verification keyword among its operands. Deliberately strict —
 * `grep test x`, `git commit -m test` and `./run_tests.sh` all read as NOT
 * verification.
 */
export declare function isVerificationCommand(command: string): boolean;
/** True for paths that look like source code (not docs, config or assets). */
export declare function isCodeFilePath(filePath: string): boolean;
/**
 * Files that define what a check ASSERTS rather than what it tests: test files
 * and test directories, test-runner configs, and the type/lint configs whose
 * strictness the checks inherit. Editing one of these can turn a failing check
 * green without touching the behaviour under test.
 *
 * Deliberately matched on path shape only. Both error directions are cheap: a
 * miss leaves today's behavior, a false positive costs one disclosure sentence.
 */
export declare function isCheckOwnFile(filePath: string): boolean;
/**
 * Bookkeeping for "code was edited, nothing proved it since".
 * Callers record successful edit/write mutations on code files and
 * host-observed check results. Passive evidence only: run status and
 * autopilot read it; it never forces another model turn.
 */
export declare class VerificationGate {
    private seq;
    private lastMutationSeq;
    private lastVerificationSeq;
    private failedChecks;
    private passedChecks;
    private unknownVerification;
    /**
     * Did THIS run touch what the gate guards — a code mutation, or a check that
     * may have rewritten files? Inherited debt alone never re-arms the gate: a
     * run that edited nothing is a question or review turn, and hijacking it
     * with a verification demand answered the user's prompt with verification
     * status instead of an answer, on every prompt, forever.
     */
    private runTouched;
    /** Code files mutated since the last verification — the gate's file list. */
    private mutatedFiles;
    private evidenceRecords;
    private runEvidenceKeys;
    private runVerificationRequested;
    recordVerificationAttempt(): void;
    get checkedThisRun(): boolean;
    get changedThisRun(): boolean;
    private rememberEvidence;
    /** The same host-observed results used by the completion gate, not a second transcript verdict. */
    evidence(scope?: "workspace" | "run"): VerificationEvidence[];
    recordMutation(filePath: string): void;
    get revision(): number;
    recordVerification(revision?: number, command?: string): void;
    recordFailedVerification(command: string, revision?: number): void;
    requireFreshVerification(invalidateRevision?: boolean): void;
    /** Remember a check shape the evidence classifier refused. Command text is
     *  model-authored: capped, never executed. */
    recordRejectedCheck(command: string, reason: string): void;
    verificationProblem(): string | null;
    snapshot(): {
        version: 1;
        seq: number;
        mutation: number;
        verified: number;
        files: string[];
        failedChecks: [string, number][];
        unknown: boolean;
    };
    restore(value: unknown): void;
    beginRun(): void;
    isOwed(): boolean;
    reset(): void;
}