import type { Finding } from "../types.js";
import type { GoalGraph } from "audit-tools/shared";
/** How a systemic challenge round folds into the running register. */
export interface SystemicRoundResult {
    /** Every distinct finding across all rounds so far, blast-ranked, true-lens. */
    findings: Finding[];
    /** The ids this round added that no prior round had (empty ⇒ dry/converged). */
    new_finding_ids: string[];
    /** True when this round surfaced nothing new — the loop-until-dry terminator. */
    dry: boolean;
    /** Assembly notes (e.g. a finding was dropped as ungrounded), surfaced. */
    validation_issues: string[];
}
/**
 * Fold one challenge round's submitted improvement findings into the prior set. The
 * enforcement pass:
 *   1. GROUND each new finding against the repo manifest (reusing the shared design
 *      grounding — an improvement pointing at no real component is dropped).
 *   2. Mark `systemic:true` and (re)derive `blast_radius` from the goal DAG, while
 *      PRESERVING the adversary-tagged TRUE lens.
 *   3. DEDUPE against prior rounds by finding identity (lens+category+title); a
 *      re-emission of a prior finding is NOT new.
 *   4. Determine convergence: a round that adds zero new findings is `dry` (the loop
 *      terminates); an empty submission is trivially dry.
 * Deterministic: the returned `findings` are ordered by descending blast radius, ties
 * broken by finding id, so the register never churns on submission order.
 */
export declare function foldChallengeRound(params: {
    prior: Finding[];
    submitted: Finding[];
    goalGraph?: GoalGraph;
    repoManifest?: {
        files?: Array<{
            path: string;
        }>;
    };
    /** Map a finding to a goal-graph node id, when the linkage is known. */
    goalNodeOf?: (finding: Finding) => string | undefined;
}): SystemicRoundResult;
//# sourceMappingURL=systemicChallengeLoop.d.ts.map