agentic-qe 3.11.5 → 3.12.0

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

package/dist/validation/gate-reexecute.js

@@ -0,0 +1,255 @@
+/**
+ * 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).
+ */
+import { createHash } from 'node:crypto';
+import { meetsNoRegression } from './anchor-set.js';
+import { tierAllowsPromotion } from '../learning/provenance-tier.js';
+/** Tag domain-separating the rule fingerprint hash. */
+const RULE_TAG = 'aqe:accept-rule:v1+sig';
+/**
+ * accept/v1 — the conjunctive frozen gate. Promotes only when ALL hold:
+ *   1. provenance tier is strong enough (ADR-121),
+ *   2. held-out strictly beats baseline (ADR-118),
+ *   3. the anchor mean does not regress (ADR-117).
+ */
+const acceptV1 = (s) => {
+    if (!tierAllowsPromotion(s.provenanceTier, { allowJudgeTier: s.allowJudgeTier })) {
+        return { promote: false, reason: `provenance tier '${s.provenanceTier}' not allowed to promote` };
+    }
+    if (!(s.candidateHeldOut > s.baselineHeldOut)) {
+        return { promote: false, reason: `held-out ${s.candidateHeldOut} did not beat baseline ${s.baselineHeldOut}` };
+    }
+    if (!meetsNoRegression(s.candidateAnchorMean, s.baselineAnchorMean, s.anchorTol)) {
+        return { promote: false, reason: `anchor regression: ${s.candidateAnchorMean} < ${s.baselineAnchorMean} - ${s.anchorTol}` };
+    }
+    return { promote: true, reason: 'held-out gain, no anchor regression, oracle-tier evidence' };
+};
+/** Registry of versioned frozen rules. Add a NEW key to change a rule; never edit in place. */
+export const ACCEPTANCE_RULES = Object.freeze({
+    'accept/v1': acceptV1,
+});
+/**
+ * Canonical (sorted-key) JSON — same discipline as ADR-116 proof-gate. Keys
+ * whose value is `undefined` are OMITTED, matching JSON.stringify, so a sealed
+ * input's hash is stable across a JSON serialize/parse roundtrip (e.g. persisting
+ * a receipt to the DB and reloading it — an optional field like `allowJudgeTier`
+ * that is undefined must not change the hash).
+ */
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const rec = value;
+    const keys = Object.keys(rec).filter((k) => rec[k] !== undefined).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(rec[k])}`).join(',')}}`;
+}
+/** SHA-256 content hash of the sealed inputs (ADR-116 canonical form). */
+export function sealedHash(sealed) {
+    return createHash('sha256').update(canonicalJson(sealed)).digest('hex');
+}
+/**
+ * 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 function gateFingerprint(ruleVersion) {
+    if (!(ruleVersion in ACCEPTANCE_RULES)) {
+        throw new Error(`Unknown acceptance rule version '${ruleVersion}' — cannot fingerprint an unregistered rule.`);
+    }
+    return createHash('sha256').update(RULE_TAG).update('\0').update(ruleVersion).digest('hex');
+}
+/** Re-execute a frozen rule on sealed inputs. Throws for an unknown version. */
+export function reExecuteGate(ruleVersion, sealed) {
+    const rule = ACCEPTANCE_RULES[ruleVersion];
+    if (!rule) {
+        throw new Error(`Unknown acceptance rule version '${ruleVersion}' — refusing to re-execute an unregistered rule.`);
+    }
+    return rule(sealed);
+}
+/**
+ * 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 function verifyPromotion(receipt, opts = {}) {
+    const failures = [];
+    // sealIntact — recompute the sealed content hash (ADR-116).
+    const sealIntact = sealedHash(receipt.sealed) === receipt.sealedHash;
+    if (!sealIntact)
+        failures.push('sealIntact');
+    // gateUnchanged — recorded fingerprint matches the current rule version, and
+    // the pinned fingerprint if one was supplied. Unknown version ⇒ not unchanged.
+    let gateUnchanged = false;
+    try {
+        const currentFp = gateFingerprint(receipt.ruleVersion);
+        gateUnchanged =
+            receipt.ruleFingerprint === currentFp &&
+                (opts.pinnedRuleFingerprint === undefined || receipt.ruleFingerprint === opts.pinnedRuleFingerprint);
+    }
+    catch {
+        gateUnchanged = false; // unregistered rule version
+    }
+    if (!gateUnchanged)
+        failures.push('gateUnchanged');
+    // gateReExecutes — only meaningful if the inputs are intact and the rule is
+    // the same one. Re-run must reproduce the recorded verdict; a logged PROMOTE
+    // the frozen rule would reject (the A8-EXT forgery class) fails here.
+    let gateReExecutes = false;
+    if (sealIntact && gateUnchanged) {
+        const rerun = reExecuteGate(receipt.ruleVersion, receipt.sealed);
+        const rerunVerdict = rerun.promote ? 'promote' : 'reject';
+        gateReExecutes = rerunVerdict === receipt.recordedVerdict;
+    }
+    if (!gateReExecutes)
+        failures.push('gateReExecutes');
+    const valid = failures.length === 0;
+    return {
+        valid,
+        checks: { sealIntact, gateUnchanged, gateReExecutes },
+        failures,
+        reason: valid
+            ? 'promotion verified: sealed inputs intact, rule unchanged, frozen rule re-execution reproduces the recorded verdict'
+            : `promotion INVALID (failed: ${failures.join(', ')}) — the recorded verdict is not reproducible under the frozen rule`,
+    };
+}
+/** Tag domain-separating the path-rule fingerprint (distinct from the accept tag). */
+const PATH_RULE_TAG = 'aqe:promotion-path-rule:v1+sig';
+/**
+ * pattern-promote/v1 — the P1 conjunctive gate (short-term → long-term).
+ * Promotes only when ALL hold: evidence tier allows promotion (ADR-121),
+ * reward / occurrences / success-rate clear their sealed thresholds, and the
+ * pattern was active within the promotion window (anti-stale).
+ */
+const patternPromoteV1 = (s) => {
+    if (!tierAllowsPromotion(s.provenanceTier, { allowJudgeTier: s.allowJudgeTier })) {
+        return { promote: false, reason: `provenance tier '${s.provenanceTier}' not allowed to promote` };
+    }
+    if (s.reward === undefined || s.rewardThreshold === undefined || !(s.reward >= s.rewardThreshold)) {
+        return { promote: false, reason: `reward ${s.reward} below threshold ${s.rewardThreshold}` };
+    }
+    if (s.occurrences === undefined || s.occurrenceThreshold === undefined || !(s.occurrences >= s.occurrenceThreshold)) {
+        return { promote: false, reason: `occurrences ${s.occurrences} below threshold ${s.occurrenceThreshold}` };
+    }
+    if (s.successRate === undefined || s.successRateThreshold === undefined || !(s.successRate >= s.successRateThreshold)) {
+        return { promote: false, reason: `success rate ${s.successRate} below threshold ${s.successRateThreshold}` };
+    }
+    if (s.withinActivityWindow !== true) {
+        return { promote: false, reason: 'pattern outside promotion activity window (stale)' };
+    }
+    return { promote: true, reason: 'tier allowed; reward/occurrence/success-rate thresholds met; within activity window' };
+};
+/**
+ * dream-apply/v1 — the P2 gate (the A8-EXT fake-`applied`-counter home).
+ * An insight is countable as applied only when: its evidence tier allows a
+ * fleet-changing apply (ADR-121), its confidence clears the sealed threshold,
+ * and it produced a real reorganization action (not `no_action`).
+ */
+const dreamApplyV1 = (s) => {
+    if (!tierAllowsPromotion(s.provenanceTier, { allowJudgeTier: s.allowJudgeTier })) {
+        return { promote: false, reason: `provenance tier '${s.provenanceTier}' not allowed to apply` };
+    }
+    if (s.insightConfidence === undefined ||
+        s.insightConfidenceThreshold === undefined ||
+        !(s.insightConfidence >= s.insightConfidenceThreshold)) {
+        return { promote: false, reason: `insight confidence ${s.insightConfidence} below threshold ${s.insightConfidenceThreshold}` };
+    }
+    if (s.insightActionable !== true) {
+        return { promote: false, reason: 'insight produced no actionable reorganization' };
+    }
+    return { promote: true, reason: 'tier allowed; insight confidence meets threshold; actionable' };
+};
+/**
+ * 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 const PROMOTION_PATH_RULES = Object.freeze({
+    'pattern-promote/v1': patternPromoteV1,
+    'dream-apply/v1': dreamApplyV1,
+});
+/** SHA-256 content hash of path sealed inputs (ADR-116 canonical form). */
+export function pathSealedHash(sealed) {
+    return createHash('sha256').update(canonicalJson(sealed)).digest('hex');
+}
+/** Fingerprint of a path-rule VERSION. Throws for an unregistered rule. */
+export function pathGateFingerprint(ruleVersion) {
+    if (!(ruleVersion in PROMOTION_PATH_RULES)) {
+        throw new Error(`Unknown promotion-path rule version '${ruleVersion}' — cannot fingerprint an unregistered rule.`);
+    }
+    return createHash('sha256').update(PATH_RULE_TAG).update('\0').update(ruleVersion).digest('hex');
+}
+/** Re-execute a frozen path rule on sealed inputs. Throws for an unknown version. */
+export function reExecutePathGate(ruleVersion, sealed) {
+    const rule = PROMOTION_PATH_RULES[ruleVersion];
+    if (!rule) {
+        throw new Error(`Unknown promotion-path rule version '${ruleVersion}' — refusing to re-execute an unregistered rule.`);
+    }
+    return rule(sealed);
+}
+/**
+ * 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 function verifyPathPromotion(receipt, opts = {}) {
+    const failures = [];
+    const sealIntact = pathSealedHash(receipt.sealed) === receipt.sealedHash;
+    if (!sealIntact)
+        failures.push('sealIntact');
+    let gateUnchanged = false;
+    try {
+        const currentFp = pathGateFingerprint(receipt.ruleVersion);
+        gateUnchanged =
+            receipt.ruleFingerprint === currentFp &&
+                (opts.pinnedRuleFingerprint === undefined || receipt.ruleFingerprint === opts.pinnedRuleFingerprint);
+    }
+    catch {
+        gateUnchanged = false; // unregistered rule version
+    }
+    if (!gateUnchanged)
+        failures.push('gateUnchanged');
+    let gateReExecutes = false;
+    if (sealIntact && gateUnchanged) {
+        const rerun = reExecutePathGate(receipt.ruleVersion, receipt.sealed);
+        const rerunVerdict = rerun.promote ? 'promote' : 'reject';
+        gateReExecutes = rerunVerdict === receipt.recordedVerdict;
+    }
+    if (!gateReExecutes)
+        failures.push('gateReExecutes');
+    const valid = failures.length === 0;
+    return {
+        valid,
+        checks: { sealIntact, gateUnchanged, gateReExecutes },
+        failures,
+        reason: valid
+            ? 'promotion verified: sealed inputs intact, rule unchanged, frozen rule re-execution reproduces the recorded verdict'
+            : `promotion INVALID (failed: ${failures.join(', ')}) — the recorded verdict is not reproducible under the frozen rule`,
+    };
+}
+//# sourceMappingURL=gate-reexecute.js.map