import { type IntentCheckpoint } from "audit-tools/shared";
import type { ArtifactBundle } from "../io/artifacts.js";
import { type LaneSubmissionShortfall } from "./laneSubmissions.js";
export interface ConceptualReviewSettings {
    max_units?: number;
    conceptual_depth: "shallow" | "deep";
    perspectives?: number;
    /**
     * True when any confirmed charter is low-confidence (Phase A conceptual spine):
     * a review depending on a low-confidence charter must "flag for human intent
     * input, never opine" (`charterReviewDisposition`). Absent/false when no charters
     * are present or all are confident. The charter-aware prompt path consumes this
     * (Phase C); until then it records the disposition on the settings contract.
     */
    flag_for_human?: boolean;
    /**
     * Host-visible one-liner surfaced when the settings were REUSED from an existing
     * `intent_checkpoint.design_review` (rather than freshly confirmed this step).
     * Prepended to `ConceptualDispatch.instructionLines` so the host can see, in
     * `current-prompt.md`, which prior intent is being re-applied without re-running
     * `confirm_intent`. Present only on reuse; absent when the checkpoint carries no
     * `design_review`. Purely informational — it never alters the reuse DECISION
     * (the resolved depth/perspectives are byte-identical with or without it),
     * and the lens list it renders is content-sorted so the text never churns.
     */
    reuse_notice?: string;
}
/**
 * Render the host-visible reuse notice when a prior `intent_checkpoint.design_review`
 * drives this workload. Content-sorted lens list keeps the text stable (no churn),
 * and every field degrades cleanly on a partial checkpoint: a missing `confirmed_at`
 * renders `unknown`, an absent/empty lens selection renders `all lenses`, and a
 * missing depth falls back to the resolved default `shallow`.
 *
 * @internal Exported for testing purposes (TST-4c8bd93a-3).
 */
export declare function renderReuseNotice(checkpoint: NonNullable<IntentCheckpoint["design_review"]>, confirmedAt: string | undefined, lensSelection: IntentCheckpoint["lens_selection"], resolvedDepth: "shallow" | "deep"): string;
/**
 * Resolve the conceptual-review depth and perspective count from confirmed
 * intent. Absent an explicit choice, the default is a shallow review.
 */
export declare function resolveConceptualReviewSettings(bundle: ArtifactBundle): ConceptualReviewSettings;
export interface ConceptualDispatch {
    deep: boolean;
    /**
     * The single conceptual-review result file the orchestrator ingests — the
     * judge's merged output when deep, the lone reviewer's output when shallow.
     */
    conceptualResultsPath: string;
    /** Host-facing lines describing how to run the conceptual pass. */
    instructionLines: string[];
    /** Contributions to the step's `artifactPaths`. */
    artifactPaths: Record<string, string>;
    /** Prompt files the host's subagents read. */
    readPaths: string[];
    /** Result files the host's subagents write. */
    writePaths: string[];
    /** What a previous emission of this pass's lanes is still owed. */
    shortfall: LaneSubmissionShortfall;
}
/**
 * Write the conceptual-review prompt artifacts and return the host workload.
 *
 * Shallow: one conceptual prompt file for a single reviewer.
 * Deep: N independent perspective prompt files (real fan-out, one value system
 * each) plus an independent judge prompt that merges them — the judge writes the
 * single `conceptualResultsPath` the orchestrator ingests, so the state machine
 * is unchanged. The perspectives' intermediate result files are never ingested.
 */
export declare function prepareConceptualDispatch(opts: {
    artifactsDir: string;
    bundle: ArtifactBundle;
    settings: ConceptualReviewSettings;
    /**
     * Diff-based re-review section (B2 parity port). Present only when the
     * conceptual pass is being re-emitted after staleness. Appended to the single
     * reviewer's prompt when shallow, and to the JUDGE's prompt when deep — the
     * judge holds the prior merged verdict and produces the ingested result, so
     * the merge becomes diff-aware while the perspectives stay independent (each
     * still reviews fresh through its own lens, never seeing the prior verdict).
     */
    reReviewSection?: string;
}): Promise<ConceptualDispatch>;
//# sourceMappingURL=conceptualDispatch.d.ts.map