import { z } from "zod";
import { type CharterDelta, type CharterClarificationRequest, type GoalGraph } from "../types/charter.js";
import type { Finding } from "../types/finding.js";
/**
 * The host answers submission (what the host writes to
 * the `charter_clarification` lane): one symmetric answer per interactive
 * question. A question with no answer in the submission defaults to `leave_open`
 * (the interruptible-loop rule — a user who taps out leaves the rest open), which
 * guarantees the queue drains and the loop terminates in one round-trip.
 */
export declare const ClarificationAnswersSubmissionSchema: z.ZodObject<{
    answers: z.ZodDefault<z.ZodArray<z.ZodObject<{
        request_id: z.ZodString;
        answer: z.ZodEnum<["this_side_wins", "that_side_wins", "rewrite_both", "leave_open"]>;
    }, "strict", z.ZodTypeAny, {
        request_id: string;
        answer: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open";
    }, {
        request_id: string;
        answer: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open";
    }>, "many">>;
}, "strict", z.ZodTypeAny, {
    answers: {
        request_id: string;
        answer: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open";
    }[];
}, {
    answers?: {
        request_id: string;
        answer: "this_side_wins" | "that_side_wins" | "rewrite_both" | "leave_open";
    }[] | undefined;
}>;
export type ClarificationAnswersSubmission = z.infer<typeof ClarificationAnswersSubmissionSchema>;
/**
 * A routed delta joined to its subsystem + (optional) goal node — the loop input.
 *
 * `node_id` is the delta's OWN node identity as Phase C stamped it, supplied by the
 * caller that performed the join: `delta.delta_id` is an OPAQUE identity here and is
 * never split to recover a node. Phase C mints it with a content-derived
 * discriminator when one subsystem carries two deltas on the same channel pair, so
 * its segment structure carries no recoverable node id — anything keyed on parsing
 * it silently misjoins the delta to the wrong subsystem's `members`. Both joins this
 * module performs (`members` here, and the goal graph via `goal_node_id`) stay keyed
 * on that same node_id space.
 */
export interface ClarificationDeltaInput {
    delta: CharterDelta;
    node_id: string;
    members: string[];
    goal_node_id?: string;
}
/** The attention appetite — see the D2 dial. `0` = autonomous (bank everything). */
export type ClarificationAttention = number | "all";
/**
 * The pure D1/D2 primitives injected from the audit side (src/audit/clarification/*)
 * so this shared assembler never imports audit code. phase-e injects the same set.
 */
export interface ClarificationLoopDeps {
    partitionDeltasToQuestions: (deltas: Array<{
        delta: CharterDelta;
        node_id: string;
        goal_node_id?: string;
    }>, goalGraph: GoalGraph) => CharterClarificationRequest[];
    applyRiskGate: (requests: CharterClarificationRequest[]) => CharterClarificationRequest[];
    splitByAttention: (requests: CharterClarificationRequest[], appetite: ClarificationAttention) => {
        asked: CharterClarificationRequest[];
        banked: CharterClarificationRequest[];
    };
}
/** The assembled loop product (the gated + split questions + surfaced leads). */
export interface AssembledClarifications {
    asked: CharterClarificationRequest[];
    banked: CharterClarificationRequest[];
    findings: Finding[];
    validation_issues: string[];
}
/**
 * Assemble the charter-clarification loop from the Phase-C routed deltas.
 *
 * 1. PARTITION the clarification/human-routed deltas into symmetric questions with
 *    their VOI axes (blast radius + cascade count) — remediator-routed spec-drift
 *    deltas are NOT questions and are recorded as a validation note.
 * 2. RISK-GATE the questions (high-blast → higher adversarial bar → `finding_only`).
 * 3. SPLIT by the attention appetite into `asked` (the VOI-ranked interactive
 *    queue) vs `banked` (written as findings; everything under appetite 0).
 * 4. SURFACE the banked questions as Finding leads for synthesis.
 *
 * Deterministic: same deltas + same graph + same appetite → same register.
 */
export declare function assembleClarificationRegister(deltas: ClarificationDeltaInput[], goalGraph: GoalGraph, attention: ClarificationAttention, deps: ClarificationLoopDeps, priorAnswers?: Map<string, CharterClarificationRequest["answer"]>): AssembledClarifications;
//# sourceMappingURL=charterClarification.d.ts.map