agentic-qe 3.11.4 → 3.12.0

package/dist/validation/anchor-set.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Frozen oracle-grade QE anchor set (ADR-117).
+ *
+ * A small, human-labeled, content-hash-pinned, constant-denominator eval set
+ * that promotion gates (ADR-118 accept(), ADR-120 re-executed gates) must
+ * evaluate and never regress against. The loader recomputes the content hash on
+ * load and THROWS on drift — a frozen anchor the optimizer can silently edit is
+ * not frozen. Mirrors ruflo `harness-frozen-eval` + retort's constant-denominator
+ * `REQUIREMENTS.json`.
+ *
+ * Each item is a test-generation task graded by the ADR-113 oracle
+ * (`evaluateOracle`): the policy produces a test for `referenceImpl`, and the
+ * mutation kill rate is the score. `requirements` is the pinned checklist (the
+ * constant denominator) the ADR-119 judge grades against.
+ */
+export interface AnchorItem {
+    /** Stable item id (e.g. "A1-inRange"). */
+    id: string;
+    /** Human-readable spec the test-gen policy is asked to produce a test for. */
+    inputUnderTest: string;
+    /** Base module name (no extension) for the reference impl. */
+    moduleName: string;
+    /** ESM source of the correct implementation. */
+    referenceImpl: string;
+    /** Pinned checklist of requirements — the CONSTANT denominator (frozen count). */
+    requirements: string[];
+    /** Ground-truth mutant count a correct test must kill (measured via the oracle at freeze time). */
+    expectedMutants: number;
+}
+export interface AnchorPassBar {
+    /** Minimum mutation kill rate for an item to pass (ADR-117 "High" bar = 0.8). */
+    mutationThreshold: number;
+    /** Required checklist coverage for the ADR-119 judge (pass only at 1.0). */
+    checklistCoverage: number;
+}
+export interface AnchorSet {
+    schemaVersion: number;
+    /** The frozen quality bar. */
+    passBar: AnchorPassBar;
+    /** No-regression tolerance: a promotion may not drop the anchor mean by more than this. */
+    anchorTol: number;
+    /** SHA-256 over the canonicalized items — recomputed and checked on load. */
+    contentHash: string;
+    items: AnchorItem[];
+}
+/**
+ * Deterministic canonical form of the items for hashing: items sorted by id,
+ * object keys sorted, no incidental whitespace. Independent of file formatting
+ * and key order so a semantically-identical file hashes identically.
+ */
+export declare function canonicalizeItems(items: AnchorItem[]): string;
+/** SHA-256 content hash over the canonicalized items. */
+export declare function computeContentHash(items: AnchorItem[]): string;
+/**
+ * Load a frozen anchor set, refusing to return if the recorded hash does not
+ * match the recomputed one (ADR-117 §2). No promotion path may read the anchor
+ * except through this loader.
+ */
+export declare function loadAnchorSet(path: string): AnchorSet;
+/** The score of one anchor item = its oracle mutation kill rate. */
+export declare function anchorItemScore(oracleResult: {
+    mutationScore: number;
+}): number;
+/**
+ * The anchor mean: Σ score / N with N constant (the constant-denominator
+ * property — comparable across runs and generations).
+ */
+export declare function anchorMean(scores: number[]): number;
+/**
+ * No-regression contract (ADR-117 §4, ADR-118 accept(), ADR-120 re-exec).
+ * A candidate policy may not drop the anchor mean below baseline − tol.
+ */
+export declare function meetsNoRegression(candidateMean: number, baselineMean: number, tol: number): boolean;
+//# sourceMappingURL=anchor-set.d.ts.map

package/dist/validation/anchor-set.js

@@ -0,0 +1,78 @@
+/**
+ * Frozen oracle-grade QE anchor set (ADR-117).
+ *
+ * A small, human-labeled, content-hash-pinned, constant-denominator eval set
+ * that promotion gates (ADR-118 accept(), ADR-120 re-executed gates) must
+ * evaluate and never regress against. The loader recomputes the content hash on
+ * load and THROWS on drift — a frozen anchor the optimizer can silently edit is
+ * not frozen. Mirrors ruflo `harness-frozen-eval` + retort's constant-denominator
+ * `REQUIREMENTS.json`.
+ *
+ * Each item is a test-generation task graded by the ADR-113 oracle
+ * (`evaluateOracle`): the policy produces a test for `referenceImpl`, and the
+ * mutation kill rate is the score. `requirements` is the pinned checklist (the
+ * constant denominator) the ADR-119 judge grades against.
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+/**
+ * Deterministic canonical form of the items for hashing: items sorted by id,
+ * object keys sorted, no incidental whitespace. Independent of file formatting
+ * and key order so a semantically-identical file hashes identically.
+ */
+export function canonicalizeItems(items) {
+    const norm = [...items]
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map((it) => ({
+        id: it.id,
+        inputUnderTest: it.inputUnderTest,
+        moduleName: it.moduleName,
+        referenceImpl: it.referenceImpl,
+        requirements: it.requirements,
+        expectedMutants: it.expectedMutants,
+    }));
+    return JSON.stringify(norm);
+}
+/** SHA-256 content hash over the canonicalized items. */
+export function computeContentHash(items) {
+    return createHash('sha256').update(canonicalizeItems(items)).digest('hex');
+}
+/**
+ * Load a frozen anchor set, refusing to return if the recorded hash does not
+ * match the recomputed one (ADR-117 §2). No promotion path may read the anchor
+ * except through this loader.
+ */
+export function loadAnchorSet(path) {
+    const raw = JSON.parse(fs.readFileSync(path, 'utf8'));
+    const recomputed = computeContentHash(raw.items);
+    if (recomputed !== raw.contentHash) {
+        throw new Error(`Anchor set hash drift at ${path}: recorded ${raw.contentHash}, `
+            + `recomputed ${recomputed}. Refusing to load a mutated frozen anchor (ADR-117). `
+            + `A legitimate change must be a versioned re-freeze (qe-anchor-v2), never an in-place edit.`);
+    }
+    if (raw.items.length === 0) {
+        throw new Error(`Anchor set at ${path} has no items — a frozen anchor must be non-empty.`);
+    }
+    return raw;
+}
+/** The score of one anchor item = its oracle mutation kill rate. */
+export function anchorItemScore(oracleResult) {
+    return oracleResult.mutationScore;
+}
+/**
+ * The anchor mean: Σ score / N with N constant (the constant-denominator
+ * property — comparable across runs and generations).
+ */
+export function anchorMean(scores) {
+    if (scores.length === 0)
+        return 0;
+    return scores.reduce((a, b) => a + b, 0) / scores.length;
+}
+/**
+ * No-regression contract (ADR-117 §4, ADR-118 accept(), ADR-120 re-exec).
+ * A candidate policy may not drop the anchor mean below baseline − tol.
+ */
+export function meetsNoRegression(candidateMean, baselineMean, tol) {
+    return candidateMean >= baselineMean - tol;
+}
+//# sourceMappingURL=anchor-set.js.map

package/dist/validation/frontier-judge.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Frontier-tier spec judge for the ADR-119 two-gate quality verdict.
+ *
+ * This is the real spec-gate `Judge` consumed by `computeQualityVerdict`
+ * (quality-verdict.ts). It grades an artifact against a pinned,
+ * constant-denominator ADR-117 checklist using a FRONTIER model — never the
+ * cheap local writer lane (ADR-111: the oracle is the one place you never
+ * economize). Two design guarantees flow from the verdict logic:
+ *
+ *   - `preflight()` does a cheap live round-trip to prove the provider and
+ *     credentials actually respond. On any failure it returns `false`, which the
+ *     verdict maps to `inconclusive` — a dead provider can never masquerade as a
+ *     silent pass.
+ *   - `grade()` returns `ran: false` on ANY tooling failure (timeout,
+ *     usage-limit, unparseable response). A non-real opinion can never
+ *     contribute to a `fail`; too few real opinions ⇒ `inconclusive`.
+ *
+ * The single provider call is isolated behind an injectable `complete(prompt)`
+ * seam so the judge is unit-testable with a fake and zero network. Wire the real
+ * frontier model with `routerComplete()` / `createRouterFrontierJudge()`.
+ */
+import type { Judge, RequirementChecklist } from './quality-verdict.js';
+import type { HybridRouter } from '../shared/llm/router/hybrid-router.js';
+import type { ExtendedProviderType } from '../shared/llm/router/types.js';
+/** The model call seam. Returns the raw model text for one prompt. */
+export type CompleteFn = (prompt: string) => Promise<string>;
+export interface FrontierJudgeOptions {
+    /**
+     * Injectable frontier-model call. In production this is `routerComplete()`
+     * bound to a frontier model; in tests it is a fake — NO network either way.
+     */
+    complete: CompleteFn;
+    /**
+     * Cheap liveness ping used by `preflight()`. Defaults to a minimal
+     * `complete()` round-trip. Should resolve truthy only when the provider and
+     * credentials actually respond.
+     */
+    ping?: () => Promise<boolean>;
+    /** Frontier model id, for reporting/telemetry only (the seam owns the call). */
+    model?: string;
+    /** Per-call timeout in ms (grade + default ping). Default 60s. */
+    timeoutMs?: number;
+    /** Optional diagnostic logger. */
+    logger?: (message: string) => void;
+}
+/**
+ * Create the ADR-119 frontier spec judge.
+ *
+ * The returned object satisfies the `Judge` contract consumed by
+ * `computeQualityVerdict`. All provider interaction is behind `opts.complete`.
+ */
+export declare function createFrontierJudge(opts: FrontierJudgeOptions): Judge;
+/**
+ * Build a `complete()` seam backed by the shared HybridRouter, pinned to a
+ * frontier model. This is where the ADR-111 "never economize the oracle" rule is
+ * enforced: `model` defaults to a frontier Opus and `preferredProvider` lets the
+ * caller route to a frontier provider explicitly.
+ */
+export declare function routerComplete(router: HybridRouter, opts?: {
+    model?: string;
+    preferredProvider?: ExtendedProviderType;
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+}): CompleteFn;
+/**
+ * Convenience: a frontier judge wired to the shared HybridRouter. The judge is
+ * ALWAYS frontier-tier — `model` defaults to a frontier Opus.
+ */
+export declare function createRouterFrontierJudge(router: HybridRouter, opts?: {
+    model?: string;
+    preferredProvider?: ExtendedProviderType;
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    logger?: (message: string) => void;
+}): Judge;
+/**
+ * A judge for when no frontier provider is available (no LLM router / no
+ * credentials). `preflight()` returns false so the verdict is `inconclusive` —
+ * NEVER a silent pass. Both CLI and MCP use this fallback so they stay in parity.
+ */
+export declare function createUnavailableJudge(_reason: string): Judge;
+/**
+ * Build the grading prompt. Requirements are numbered 1..N and the model is
+ * asked for the numbers of the UNMET ones as strict JSON. Reporting unmet (not
+ * satisfied) keeps the denominator constant and the contract unambiguous.
+ */
+export declare function buildGradePrompt(artifact: string, checklist: RequirementChecklist): string;
+/**
+ * Parse the model response into a set of 0-based unmet requirement indices.
+ * Returns `null` when the response cannot be parsed into the strict contract
+ * (so the caller treats it as a non-real opinion). Out-of-range and duplicate
+ * numbers are ignored — a garbled index list never inflates the unmet count.
+ */
+export declare function parseUnmetIndices(raw: string, total: number): Set<number> | null;
+/** Reject with a timeout error if `p` does not settle within `ms`. */
+export declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
+//# sourceMappingURL=frontier-judge.d.ts.map

package/dist/validation/frontier-judge.js

@@ -0,0 +1,234 @@
+/**
+ * Frontier-tier spec judge for the ADR-119 two-gate quality verdict.
+ *
+ * This is the real spec-gate `Judge` consumed by `computeQualityVerdict`
+ * (quality-verdict.ts). It grades an artifact against a pinned,
+ * constant-denominator ADR-117 checklist using a FRONTIER model — never the
+ * cheap local writer lane (ADR-111: the oracle is the one place you never
+ * economize). Two design guarantees flow from the verdict logic:
+ *
+ *   - `preflight()` does a cheap live round-trip to prove the provider and
+ *     credentials actually respond. On any failure it returns `false`, which the
+ *     verdict maps to `inconclusive` — a dead provider can never masquerade as a
+ *     silent pass.
+ *   - `grade()` returns `ran: false` on ANY tooling failure (timeout,
+ *     usage-limit, unparseable response). A non-real opinion can never
+ *     contribute to a `fail`; too few real opinions ⇒ `inconclusive`.
+ *
+ * The single provider call is isolated behind an injectable `complete(prompt)`
+ * seam so the judge is unit-testable with a fake and zero network. Wire the real
+ * frontier model with `routerComplete()` / `createRouterFrontierJudge()`.
+ */
+import { DEFAULT_OPUS_MODEL } from '../shared/llm/model-registry.js';
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_PING_TIMEOUT_MS = 15_000;
+/**
+ * Create the ADR-119 frontier spec judge.
+ *
+ * The returned object satisfies the `Judge` contract consumed by
+ * `computeQualityVerdict`. All provider interaction is behind `opts.complete`.
+ */
+export function createFrontierJudge(opts) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const log = opts.logger ?? (() => { });
+    const model = opts.model ?? 'frontier';
+    const ping = opts.ping ??
+        (async () => {
+            const text = await withTimeout(opts.complete('Reply with exactly: OK'), Math.min(DEFAULT_PING_TIMEOUT_MS, timeoutMs), 'judge preflight ping');
+            return typeof text === 'string' && text.trim().length > 0;
+        });
+    return {
+        async preflight() {
+            try {
+                const ok = await ping();
+                if (!ok)
+                    log(`frontier-judge preflight: provider (${model}) returned empty — not ready`);
+                return ok;
+            }
+            catch (err) {
+                // A dead/unauthenticated provider MUST NOT read as "ready" — that is
+                // exactly how an infra hiccup would masquerade as a silent pass.
+                log(`frontier-judge preflight failed (${model}): ${errText(err)}`);
+                return false;
+            }
+        },
+        async grade(artifact, checklist) {
+            const total = checklist.requirements.length;
+            try {
+                const prompt = buildGradePrompt(artifact, checklist);
+                const raw = await withTimeout(opts.complete(prompt), timeoutMs, 'judge grade');
+                const unmetIdx = parseUnmetIndices(raw, total);
+                if (unmetIdx == null) {
+                    // Unparseable — a real model ran but we cannot trust the grade, so it
+                    // is NOT a real opinion (cannot contribute to a fail).
+                    log(`frontier-judge grade: could not parse response for ${checklist.id}`);
+                    return { ran: false, coverage: 0, unmet: [] };
+                }
+                const unmet = [...unmetIdx].sort((a, b) => a - b).map((i) => checklist.requirements[i]);
+                // Coverage over the CONSTANT denominator (ADR-117) — comparable across runs.
+                const coverage = (total - unmet.length) / total;
+                return { ran: true, coverage, unmet };
+            }
+            catch (err) {
+                // Timeout / usage-limit / network — not a real opinion.
+                log(`frontier-judge grade failed for ${checklist.id} (${model}): ${errText(err)}`);
+                return { ran: false, coverage: 0, unmet: [] };
+            }
+        },
+    };
+}
+/**
+ * Build a `complete()` seam backed by the shared HybridRouter, pinned to a
+ * frontier model. This is where the ADR-111 "never economize the oracle" rule is
+ * enforced: `model` defaults to a frontier Opus and `preferredProvider` lets the
+ * caller route to a frontier provider explicitly.
+ */
+export function routerComplete(router, opts = {}) {
+    const model = opts.model ?? DEFAULT_OPUS_MODEL;
+    return async (prompt) => {
+        const res = await router.chat({
+            messages: [{ role: 'user', content: prompt }],
+            model,
+            preferredProvider: opts.preferredProvider,
+            temperature: opts.temperature ?? 0,
+            maxTokens: opts.maxTokens ?? 1024,
+            timeoutMs: opts.timeoutMs,
+            skipCache: true,
+        });
+        return res.content ?? '';
+    };
+}
+/**
+ * Convenience: a frontier judge wired to the shared HybridRouter. The judge is
+ * ALWAYS frontier-tier — `model` defaults to a frontier Opus.
+ */
+export function createRouterFrontierJudge(router, opts = {}) {
+    const model = opts.model ?? DEFAULT_OPUS_MODEL;
+    return createFrontierJudge({
+        complete: routerComplete(router, { ...opts, model }),
+        model,
+        timeoutMs: opts.timeoutMs,
+        logger: opts.logger,
+    });
+}
+/**
+ * A judge for when no frontier provider is available (no LLM router / no
+ * credentials). `preflight()` returns false so the verdict is `inconclusive` —
+ * NEVER a silent pass. Both CLI and MCP use this fallback so they stay in parity.
+ */
+export function createUnavailableJudge(_reason) {
+    return {
+        preflight: () => false,
+        grade: () => ({ ran: false, coverage: 0, unmet: [] }),
+    };
+}
+// ============================================================================
+// Prompt + parsing
+// ============================================================================
+/**
+ * Build the grading prompt. Requirements are numbered 1..N and the model is
+ * asked for the numbers of the UNMET ones as strict JSON. Reporting unmet (not
+ * satisfied) keeps the denominator constant and the contract unambiguous.
+ */
+export function buildGradePrompt(artifact, checklist) {
+    const numbered = checklist.requirements.map((r, i) => `${i + 1}. ${r}`).join('\n');
+    return [
+        'You are a rigorous, frontier-tier quality oracle grading a software artifact',
+        'against a FIXED requirement checklist. Judge only what the artifact actually',
+        'verifies — do not give credit for requirements it merely mentions or leaves',
+        'implicit. A requirement is "met" only if the artifact demonstrably covers it.',
+        '',
+        `Checklist id: ${checklist.id}`,
+        'Requirements (the denominator is fixed — grade ALL of them):',
+        numbered,
+        '',
+        '--- ARTIFACT UNDER JUDGEMENT ---',
+        artifact,
+        '--- END ARTIFACT ---',
+        '',
+        'Return ONLY a single JSON object, no prose, no markdown fences, of the form:',
+        '{"unmet": [<numbers of requirements NOT met>]}',
+        'Use the requirement numbers above. If every requirement is met, return {"unmet": []}.',
+    ].join('\n');
+}
+/**
+ * Parse the model response into a set of 0-based unmet requirement indices.
+ * Returns `null` when the response cannot be parsed into the strict contract
+ * (so the caller treats it as a non-real opinion). Out-of-range and duplicate
+ * numbers are ignored — a garbled index list never inflates the unmet count.
+ */
+export function parseUnmetIndices(raw, total) {
+    const obj = extractJsonObject(raw);
+    if (obj == null || !Array.isArray(obj.unmet)) {
+        return null;
+    }
+    const out = new Set();
+    for (const v of obj.unmet) {
+        const n = typeof v === 'number' ? v : typeof v === 'string' ? Number(v.trim()) : NaN;
+        if (!Number.isInteger(n))
+            continue;
+        const idx = n - 1; // 1-based prompt -> 0-based index
+        if (idx >= 0 && idx < total)
+            out.add(idx);
+    }
+    return out;
+}
+/** Extract the first balanced top-level JSON object from arbitrary model text. */
+function extractJsonObject(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const start = raw.indexOf('{');
+    if (start === -1)
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < raw.length; i++) {
+        const ch = raw[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === '\\')
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0) {
+                try {
+                    return JSON.parse(raw.slice(start, i + 1));
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+    }
+    return null;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/** Reject with a timeout error if `p` does not settle within `ms`. */
+export function withTimeout(p, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        p.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=frontier-judge.js.map

package/dist/validation/gate-reexecute.d.ts

@@ -0,0 +1,165 @@
+/**
+ * gateReExecutes — re-execute a frozen acceptance rule from sealed inputs
+ * on every promotion path (ADR-120).
+ *
+ * The July 2026 remediation exposed the A8-EXT fake-`applied`-counter: a
+ * promotion path that logged success without doing the work — a logged verdict
+ * that lied. The fix (from MetaHarness `verifyReplayBundle`): trust the re-run,
+ * not the log. At verification time, re-execute a VERSIONED FROZEN acceptance
+ * rule against the decision's SEALED inputs; a recorded PROMOTE the frozen rule
+ * would not grant is a forgery.
+ *
+ * Two checks, both required (mirrors MetaHarness `replay.ts:66-90`):
+ *   - gateUnchanged   — the recorded rule fingerprint matches the current rule
+ *                       version's fingerprint (a swapped rule is caught).
+ *   - gateReExecutes  — re-running the frozen rule on the sealed inputs
+ *                       reproduces the recorded verdict.
+ * Plus sealIntact (ADR-116 composition) — the sealed inputs were not mutated
+ * after the decision. Re-execution on tampered inputs is meaningless.
+ *
+ * The acceptance rule is a PURE function of sealed inputs. `accept/v1` composes
+ * the cluster: ADR-121 provenance tier gate + ADR-118 held-out-beats-baseline +
+ * ADR-117 anchor no-regression. Changing a rule is a new VERSION, never an
+ * in-place edit (which gateUnchanged flags).
+ */
+/** The inputs a promotion decision was made on — sealed at decision time. */
+export interface SealedInputs {
+    /** Candidate policy's held-out score (ADR-118). */
+    candidateHeldOut: number;
+    /** Baseline (current champion) held-out score. */
+    baselineHeldOut: number;
+    /** Candidate anchor mean (ADR-117). */
+    candidateAnchorMean: number;
+    /** Baseline anchor mean. */
+    baselineAnchorMean: number;
+    /** Content hash of the ADR-117 anchor used (which frozen anchor this was graded on). */
+    anchorHash: string;
+    /** No-regression tolerance the anchor was gated at. */
+    anchorTol: number;
+    /** ADR-121 evidence tier of the candidate. */
+    provenanceTier: string;
+    /** Whether judge-tier promotion was explicitly budgeted (ADR-121). */
+    allowJudgeTier?: boolean;
+}
+export interface RuleResult {
+    promote: boolean;
+    reason: string;
+}
+/** A versioned, frozen acceptance rule — a pure function of sealed inputs. */
+export type AcceptanceRule = (sealed: SealedInputs) => RuleResult;
+/** Registry of versioned frozen rules. Add a NEW key to change a rule; never edit in place. */
+export declare const ACCEPTANCE_RULES: Readonly<Record<string, AcceptanceRule>>;
+/** SHA-256 content hash of the sealed inputs (ADR-116 canonical form). */
+export declare function sealedHash(sealed: SealedInputs): string;
+/**
+ * Fingerprint of a rule VERSION. Because a rule change is a version bump
+ * (ADR-120 §5), fingerprinting the version string is the contract — an edited
+ * rule ships under a new version and thus a new fingerprint. Throws for an
+ * unknown version so a missing rule can never silently pass verification.
+ */
+export declare function gateFingerprint(ruleVersion: string): string;
+/** Re-execute a frozen rule on sealed inputs. Throws for an unknown version. */
+export declare function reExecuteGate(ruleVersion: string, sealed: SealedInputs): RuleResult;
+/** A recorded promotion decision. The logged verdict is advisory; the re-run is authoritative. */
+export interface PromotionReceipt {
+    ruleVersion: string;
+    /** Fingerprint recorded at decision time. */
+    ruleFingerprint: string;
+    /** Content hash of the sealed inputs recorded at decision time. */
+    sealedHash: string;
+    sealed: SealedInputs;
+    /** What was logged. NOT trusted — re-execution decides. */
+    recordedVerdict: 'promote' | 'reject';
+}
+export interface ReplayChecks {
+    /** Sealed inputs were not mutated after the decision (ADR-116). */
+    sealIntact: boolean;
+    /** Recorded rule fingerprint matches the current (and pinned) rule version. */
+    gateUnchanged: boolean;
+    /** Re-running the frozen rule on the sealed inputs reproduces the recorded verdict. */
+    gateReExecutes: boolean;
+}
+export interface ReplayVerdict {
+    /** All three checks passed — the promotion is valid. */
+    valid: boolean;
+    checks: ReplayChecks;
+    failures: string[];
+    reason: string;
+}
+/**
+ * Verify a promotion by re-executing its frozen rule on its sealed inputs.
+ * The logged verdict is trusted only insofar as the re-run reproduces it.
+ *
+ * @param opts.pinnedRuleFingerprint - if supplied, the receipt's fingerprint
+ *   must also equal this pinned value (an externally-anchored rule identity).
+ */
+export declare function verifyPromotion(receipt: PromotionReceipt, opts?: {
+    pinnedRuleFingerprint?: string;
+}): ReplayVerdict;
+/**
+ * Superset sealed inputs for the retrofit promotion paths. Every field is
+ * optional; each frozen path rule reads only the fields it needs and rejects
+ * (never throws) when a field it requires is absent — a missing input can
+ * never silently promote.
+ */
+export interface PathSealedInputs {
+    /** ADR-121 evidence tier of the artifact being promoted/applied. */
+    provenanceTier: string;
+    /** Whether judge-tier evidence was explicitly budgeted (ADR-121 / ADR-119). */
+    allowJudgeTier?: boolean;
+    /** Pattern average reward (quality score). */
+    reward?: number;
+    /** Reward promotion threshold the decision was gated at. */
+    rewardThreshold?: number;
+    /** Pattern usage/occurrence count. */
+    occurrences?: number;
+    /** Minimum occurrence threshold. */
+    occurrenceThreshold?: number;
+    /** Pattern success rate. */
+    successRate?: number;
+    /** Minimum success-rate threshold. */
+    successRateThreshold?: number;
+    /** Whether the pattern was active within the promotion window (anti-stale). */
+    withinActivityWindow?: boolean;
+    /** Dream insight confidence score. */
+    insightConfidence?: number;
+    /** Confidence threshold the apply was gated at. */
+    insightConfidenceThreshold?: number;
+    /** Whether the insight produced a real (non-`no_action`) reorganization. */
+    insightActionable?: boolean;
+}
+/** A versioned, frozen promotion-path rule — a pure function of sealed inputs. */
+export type PathRule = (sealed: PathSealedInputs) => RuleResult;
+/**
+ * Registry of versioned frozen promotion-path rules. Add a NEW key to change a
+ * rule; never edit in place (a rule change is a version bump — ADR-120 §5).
+ * Kept separate from `ACCEPTANCE_RULES` so the flywheel accept gate and its
+ * locked test are untouched.
+ */
+export declare const PROMOTION_PATH_RULES: Readonly<Record<string, PathRule>>;
+/** SHA-256 content hash of path sealed inputs (ADR-116 canonical form). */
+export declare function pathSealedHash(sealed: PathSealedInputs): string;
+/** Fingerprint of a path-rule VERSION. Throws for an unregistered rule. */
+export declare function pathGateFingerprint(ruleVersion: string): string;
+/** Re-execute a frozen path rule on sealed inputs. Throws for an unknown version. */
+export declare function reExecutePathGate(ruleVersion: string, sealed: PathSealedInputs): RuleResult;
+/** A recorded promotion/apply decision on a retrofit path. */
+export interface PathPromotionReceipt {
+    ruleVersion: string;
+    /** Fingerprint recorded at decision time. */
+    ruleFingerprint: string;
+    /** Content hash of the sealed inputs recorded at decision time. */
+    sealedHash: string;
+    sealed: PathSealedInputs;
+    /** What was logged. NOT trusted — re-execution decides. */
+    recordedVerdict: 'promote' | 'reject';
+}
+/**
+ * Verify a promotion-path decision by re-executing its frozen rule on its
+ * sealed inputs. Identical semantics to {@link verifyPromotion}: the logged
+ * verdict is trusted only insofar as the re-run reproduces it on intact inputs.
+ */
+export declare function verifyPathPromotion(receipt: PathPromotionReceipt, opts?: {
+    pinnedRuleFingerprint?: string;
+}): ReplayVerdict;
+//# sourceMappingURL=gate-reexecute.d.ts.map