import { z } from "zod";
/**
 * The accepted scope and intent for a run, confirmed by the host before
 * planning. Single-sourced so both orchestrators share one shape: audit-code
 * uses `excluded_scope`/`must_not_touch`/`free_form_intent`; remediate-code
 * additionally uses `filters` to narrow findings. `scope_summary`/
 * `intent_summary` are human renders; the structured fields are what downstream
 * planning, worker prompts, and reports actually consume.
 */
export declare const IntentCheckpointSchema: z.ZodObject<{
    schema_version: z.ZodLiteral<"intent-checkpoint/v1">;
    confirmed_at: z.ZodString;
    /**
     * `"host"` — checkpoint has been reviewed and confirmed by the host agent.
     * `"draft"` — preliminary checkpoint pre-populated by synthesize_intake worker;
     *   not yet confirmed; planning must not begin and filtering must not apply.
     */
    confirmed_by: z.ZodEnum<["host", "draft"]>;
    /** Human-readable description of the confirmed scope. */
    scope_summary: z.ZodString;
    /** Human-readable description of the goal (e.g. full-audit / delta). */
    intent_summary: z.ZodString;
    /**
     * Free-form intent; interpreted into priority/lens/scope signals at planning
     * time via freeFormIntentInterpreter. Never threaded verbatim into worker or
     * dispatch prompts (see freeFormIntentInterpreter, INV-S04).
     */
    free_form_intent: z.ZodOptional<z.ZodString>;
    /** Paths intentionally excluded from the run, each with a reason. */
    excluded_scope: z.ZodOptional<z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        reason: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        path: string;
        reason: string;
    }, {
        path: string;
        reason: string;
    }>, "many">>;
    /** Path globs that must never be written to. */
    must_not_touch: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    /** Remediate-only finding filters; audit-code ignores these. */
    filters: z.ZodOptional<z.ZodObject<{
        severity: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        lenses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        packages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        themes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strict", z.ZodTypeAny, {
        lenses?: string[] | undefined;
        severity?: string[] | undefined;
        themes?: string[] | undefined;
        packages?: string[] | undefined;
    }, {
        lenses?: string[] | undefined;
        severity?: string[] | undefined;
        themes?: string[] | undefined;
        packages?: string[] | undefined;
    }>>;
    /**
     * Clauses from free_form_intent that could not be encoded as lens-weight,
     * priority, or scope signals. Each entry carries the original clause text,
     * the blocking checkpoint question raised for it, and the optional host
     * answer once resolved. These survive as explicit machine-checkable
     * contract constraints threaded into planning and worker prompts.
     */
    constraint_clauses: z.ZodOptional<z.ZodArray<z.ZodObject<{
        /**
         * Stable clause identity — the RESOLUTION KEY (CE-004). An entry
         * resolves the clause whose identity equals this id, regardless of
         * how the question renders. Keyed off the clause text by
         * `clauseIdentity`; optional for back-compat (a legacy entry without
         * it falls back to matching on `checkpoint_question`), but every
         * fresh entry carries it so two distinct clauses that render to the
         * same question are answered individually.
         */
        clause_id: z.ZodOptional<z.ZodString>;
        /** The original unencodable clause text. */
        text: z.ZodString;
        /** The blocking checkpoint question generated for this clause. */
        checkpoint_question: z.ZodString;
        /** The host's answer to the checkpoint question once resolved. */
        host_answer: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        text: string;
        checkpoint_question: string;
        clause_id?: string | undefined;
        host_answer?: string | undefined;
    }, {
        text: string;
        checkpoint_question: string;
        clause_id?: string | undefined;
        host_answer?: string | undefined;
    }>, "many">>;
    /**
     * Per-file or per-prefix status corrections accepted by the host. Applied
     * before coverage initialization so overridden files never become audit
     * tasks. Typically sourced from `disposition_override_proposals` in the
     * scope pre-digest shown during the `confirm_intent` step.
     */
    disposition_overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        status: z.ZodEnum<["included", "excluded", "generated", "vendor", "binary", "doc_only"]>;
        reason: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        path: string;
        status: "included" | "excluded" | "generated" | "vendor" | "binary" | "doc_only";
        reason: string;
    }, {
        path: string;
        status: "included" | "excluded" | "generated" | "vendor" | "binary" | "doc_only";
        reason: string;
    }>, "many">>;
    /**
     * Accepted or modified lens set from the host, derived from the
     * lens proposition table in the scope pre-digest. `include` is additive (always
     * merged with mandatory lenses); `exclude` removes non-mandatory lenses.
     */
    lens_selection: z.ZodOptional<z.ZodObject<{
        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strict", z.ZodTypeAny, {
        include?: string[] | undefined;
        exclude?: string[] | undefined;
    }, {
        include?: string[] | undefined;
        exclude?: string[] | undefined;
    }>>;
    /**
     * Conceptual design-review depth, confirmed by the host during
     * `confirm_intent`. It records *how much* conceptual review to do, never how
     * the host chooses to execute that work.
     * - `conceptual_depth: "shallow"` (default when omitted) — a single conceptual
     *   reviewer.
     * - `conceptual_depth: "deep"` — fan out `perspectives` independent reviewers
     *   with maximally dissimilar perspectives, then compile via an independent
     *   judge.
     * `perspectives` bounds the deep fan-out count; ignored when shallow.
     */
    design_review: z.ZodOptional<z.ZodObject<{
        conceptual_depth: z.ZodOptional<z.ZodEnum<["shallow", "deep"]>>;
        perspectives: z.ZodOptional<z.ZodNumber>;
        /**
         * The premise-height consent dial (how far up a finding may reach),
         * captured at `confirm_intent`. Optional and additive — a legacy
         * checkpoint carrying only `conceptual_depth`/`perspectives` stays
         * valid. NOTE: the checkpoint deliberately carries the ceiling as
         * INPUT only — charters/teleologies/goal graph live on
         * `charter_register.json` (the OUTPUT artifact), never here; embedding
         * them would create a staleness cycle with the checkpoint the register
         * depends on. (Never-written `charters`/`goal_graph` embeds were
         * deleted 2026-08-06, design resolution 4.)
         */
        ceiling: z.ZodOptional<z.ZodObject<{
            rung: z.ZodEnum<["shallow", "deep", "deepest"]>;
            explicit_opt_in: z.ZodOptional<z.ZodBoolean>;
        }, "strict", z.ZodTypeAny, {
            rung: "shallow" | "deep" | "deepest";
            explicit_opt_in?: boolean | undefined;
        }, {
            rung: "shallow" | "deep" | "deepest";
            explicit_opt_in?: boolean | undefined;
        }>>;
        /**
         * The ATTENTION dial (Phase D control surface, currency #3) — how much the
         * user will converse to align the charters: how many VOI-ranked
         * charter-clarification questions they answer this round. `0` is the
         * autonomous mode (every charter-delta becomes a written finding, nothing
         * interactive); a finite N takes the top-N of the VOI queue; `"all"` takes
         * every interactive question. Attended and unattended are two settings of
         * ONE dial, not a forked path. Optional + additive; defaults to `0`
         * (conversation-first: no human loop unless the user opts in).
         */
        attention: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"all">]>>;
    }, "strict", z.ZodTypeAny, {
        conceptual_depth?: "shallow" | "deep" | undefined;
        perspectives?: number | undefined;
        ceiling?: {
            rung: "shallow" | "deep" | "deepest";
            explicit_opt_in?: boolean | undefined;
        } | undefined;
        attention?: number | "all" | undefined;
    }, {
        conceptual_depth?: "shallow" | "deep" | undefined;
        perspectives?: number | undefined;
        ceiling?: {
            rung: "shallow" | "deep" | "deepest";
            explicit_opt_in?: boolean | undefined;
        } | undefined;
        attention?: number | "all" | undefined;
    }>>;
}, "strict", z.ZodTypeAny, {
    schema_version: "intent-checkpoint/v1";
    confirmed_at: string;
    confirmed_by: "host" | "draft";
    scope_summary: string;
    intent_summary: string;
    excluded_scope?: {
        path: string;
        reason: string;
    }[] | undefined;
    free_form_intent?: string | undefined;
    must_not_touch?: string[] | undefined;
    filters?: {
        lenses?: string[] | undefined;
        severity?: string[] | undefined;
        themes?: string[] | undefined;
        packages?: string[] | undefined;
    } | undefined;
    constraint_clauses?: {
        text: string;
        checkpoint_question: string;
        clause_id?: string | undefined;
        host_answer?: string | undefined;
    }[] | undefined;
    disposition_overrides?: {
        path: string;
        status: "included" | "excluded" | "generated" | "vendor" | "binary" | "doc_only";
        reason: string;
    }[] | undefined;
    lens_selection?: {
        include?: string[] | undefined;
        exclude?: string[] | undefined;
    } | undefined;
    design_review?: {
        conceptual_depth?: "shallow" | "deep" | undefined;
        perspectives?: number | undefined;
        ceiling?: {
            rung: "shallow" | "deep" | "deepest";
            explicit_opt_in?: boolean | undefined;
        } | undefined;
        attention?: number | "all" | undefined;
    } | undefined;
}, {
    schema_version: "intent-checkpoint/v1";
    confirmed_at: string;
    confirmed_by: "host" | "draft";
    scope_summary: string;
    intent_summary: string;
    excluded_scope?: {
        path: string;
        reason: string;
    }[] | undefined;
    free_form_intent?: string | undefined;
    must_not_touch?: string[] | undefined;
    filters?: {
        lenses?: string[] | undefined;
        severity?: string[] | undefined;
        themes?: string[] | undefined;
        packages?: string[] | undefined;
    } | undefined;
    constraint_clauses?: {
        text: string;
        checkpoint_question: string;
        clause_id?: string | undefined;
        host_answer?: string | undefined;
    }[] | undefined;
    disposition_overrides?: {
        path: string;
        status: "included" | "excluded" | "generated" | "vendor" | "binary" | "doc_only";
        reason: string;
    }[] | undefined;
    lens_selection?: {
        include?: string[] | undefined;
        exclude?: string[] | undefined;
    } | undefined;
    design_review?: {
        conceptual_depth?: "shallow" | "deep" | undefined;
        perspectives?: number | undefined;
        ceiling?: {
            rung: "shallow" | "deep" | "deepest";
            explicit_opt_in?: boolean | undefined;
        } | undefined;
        attention?: number | "all" | undefined;
    } | undefined;
}>;
export type IntentCheckpoint = z.infer<typeof IntentCheckpointSchema>;
//# sourceMappingURL=intentCheckpoint.d.ts.map