/**
 * DD-9 — the intent-equivalence obligation's executor.
 *
 * Decides whether the live `intent_checkpoint.json` is semantically equivalent
 * to the baseline downstreams last derived against, and COMMITS the resolution
 * into `artifact_metadata.intent_baseline` — the revision authority the
 * metadata stamper mirrors (see `artifactMetadata.ts`): a committed `changed`
 * advances `baseline.revision` (downstreams re-stale exactly once); an
 * `equivalent` advances only the normal forms (downstreams never notice).
 *
 * Arms (see `deriveIntentEquivalenceStatus`):
 *  - `satisfied` — no checkpoint, or forms match the gate-current baseline.
 *  - `stamp_baseline` — no baseline yet: stamp from the current checkpoint
 *    (deterministic, drainable). First-contact on legacy run dirs.
 *  - `gate_version_stale` — the persisted baseline predates the current
 *    normalize-config / judge / prompt-template trio: resolve as CHANGED
 *    (over-stale, the safe direction; the old normal forms are not comparable).
 *  - `structured_changed` — the STRUCTURED normal form moved: deterministically
 *    CHANGED, no judge (an LLM must never arbitrate a numeric/list delta).
 *  - `prose_judgment_pending` — structured equal, prose moved: the bounded host
 *    judge owns the verdict and the obligation remains pending until it arrives.
 *
 * A judge submission names the pair it judged (`judged_pair` normal-form
 * hashes); consumption re-derives the live pair and DISCARDS a stale verdict
 * (the checkpoint moved again mid-judgment) so the obligation re-fires on the
 * new pair — the O2 interleave property realized by the step round-trip itself.
 */
import { z } from "zod";
import type { ArtifactBundle } from "../io/artifacts.js";
import type { ExecutorRunResult } from "./executorResult.js";
export declare const IntentEquivalenceVerdictSchema: z.ZodObject<{
    verdict: z.ZodEnum<["equivalent", "changed"]>;
    judged_pair: z.ZodObject<{
        prior_hash: z.ZodString;
        new_hash: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        prior_hash: string;
        new_hash: string;
    }, {
        prior_hash: string;
        new_hash: string;
    }>;
}, "strict", z.ZodTypeAny, {
    verdict: "changed" | "equivalent";
    judged_pair: {
        prior_hash: string;
        new_hash: string;
    };
}, {
    verdict: "changed" | "equivalent";
    judged_pair: {
        prior_hash: string;
        new_hash: string;
    };
}>;
export type IntentEquivalenceVerdictSubmission = z.infer<typeof IntentEquivalenceVerdictSchema>;
export type IntentEquivalenceStatus = {
    kind: "satisfied";
} | {
    kind: "stamp_baseline";
} | {
    kind: "gate_version_stale";
} | {
    kind: "structured_changed";
} | {
    kind: "prose_judgment_pending";
    prior_prose: string;
    current_prose: string;
    prior_hash: string;
    new_hash: string;
};
/** Pure derivation of the obligation's state from the live bundle. */
export declare function deriveIntentEquivalenceStatus(bundle: ArtifactBundle): IntentEquivalenceStatus;
/**
 * Resolve the obligation. `verdict` is the consumed judge submission when one
 * arrived this step. Prose-only changes require that bound host judgment;
 * deterministic arms never fabricate one.
 */
export declare function runIntentEquivalenceResolve(bundle: ArtifactBundle, verdict?: IntentEquivalenceVerdictSubmission): ExecutorRunResult;
//# sourceMappingURL=intentEquivalenceExecutor.d.ts.map