@loopover/engine 1.0.0

package/dist/opportunity-freshness.js

@@ -0,0 +1,55 @@
+function round4(value) {
+    return Math.round(value * 10000) / 10000;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function isParseableTimestamp(value) {
+    return Number.isFinite(Date.parse(value));
+}
+function pickTimestamp(issue) {
+    const updated = typeof issue.updatedAt === "string" ? issue.updatedAt.trim() : "";
+    if (updated && isParseableTimestamp(updated))
+        return updated;
+    const created = typeof issue.createdAt === "string" ? issue.createdAt.trim() : "";
+    if (created && isParseableTimestamp(created))
+        return created;
+    return null;
+}
+function issueAgeDays(value, nowMs) {
+    if (!value)
+        return Number.POSITIVE_INFINITY;
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        return Number.POSITIVE_INFINITY;
+    return Math.floor((nowMs - parsed) / 86_400_000);
+}
+function isOpenIssue(issue) {
+    return typeof issue?.state === "string" && issue.state.trim().toLowerCase() === "open";
+}
+/* v8 ignore start -- Test-only export surface for branch coverage. */
+export const opportunityFreshnessInternals = {
+    pickTimestamp,
+    issueAgeDays,
+};
+/* v8 ignore stop */
+/**
+ * Compute a [0.05, 1] freshness factor from open issue timestamps, mirroring
+ * `opportunityFreshnessFactor` in `src/signals/reward-risk.ts` with an injected clock so the miner engine
+ * stays pure and testable.
+ */
+export function computeOpportunityFreshness(issues, nowMs) {
+    /* v8 ignore next -- Caller supplies a finite epoch; non-finite clocks degrade to zero freshness. */
+    if (!Number.isFinite(nowMs))
+        return 0;
+    const openIssues = issues.filter(isOpenIssue);
+    if (openIssues.length === 0)
+        return 0;
+    let mostRecentAgeDays = Number.POSITIVE_INFINITY;
+    for (const issue of openIssues) {
+        const ageDays = issueAgeDays(pickTimestamp(issue), nowMs);
+        if (ageDays < mostRecentAgeDays)
+            mostRecentAgeDays = ageDays;
+    }
+    return round4(clamp(Math.exp(-mostRecentAgeDays / 20), 0.05, 1));
+}

package/dist/opportunity-metadata.d.ts

@@ -0,0 +1,53 @@
+import { type MinerGoalSpec } from "./miner-goal-spec.js";
+import { type OpportunityRankInput } from "./opportunity-ranker.js";
+/** Metadata-only candidate issue shape produced by `@loopover/miner` fan-out helpers. */
+export type MetadataCandidateIssue = {
+    repoFullName: string;
+    issueNumber: number;
+    title: string;
+    labels: readonly string[];
+    /** When present, lane fit uses path+label goal matching instead of labels alone. */
+    candidatePaths?: readonly string[] | undefined;
+    commentsCount: number;
+    createdAt?: string | null | undefined;
+    updatedAt?: string | null | undefined;
+};
+export type MetadataRankContext = {
+    nowMs: number;
+    highRiskDuplicateClusters?: number | undefined;
+    openPullRequests?: number | undefined;
+    goalSpecsByRepo?: Readonly<Record<string, MinerGoalSpec>> | undefined;
+};
+declare function normalizeLabels(labels: readonly string[]): string[];
+declare function resolveGoalSpec(repoFullName: string, context: MetadataRankContext): MinerGoalSpec;
+declare function pickMetadataTimestamp(issue: MetadataCandidateIssue): string;
+/**
+ * Estimate reward potential from issue labels alone. Explicitly negative labels collapse the score; common
+ * contribution labels raise it; everything else keeps a neutral baseline.
+ */
+export declare function computeMetadataPotential(issue: {
+    labels: readonly string[];
+}): number;
+/**
+ * Estimate achievability from metadata-only cues: lower discussion load and fresher issues score higher.
+ */
+export declare function computeMetadataFeasibility(issue: MetadataCandidateIssue, nowMs: number): number;
+declare function titlesOverlap(left: string, right: string): boolean;
+export declare const opportunityMetadataInternals: {
+    titlesOverlap: typeof titlesOverlap;
+    normalizeLabels: typeof normalizeLabels;
+    resolveGoalSpec: typeof resolveGoalSpec;
+    pickMetadataTimestamp: typeof pickMetadataTimestamp;
+};
+/**
+ * Estimate duplicate-work risk inside a metadata-only candidate batch by looking for overlapping titles in the
+ * same repository. This is intentionally conservative: any strong overlap raises dupRisk toward 1.
+ */
+export declare function computeMetadataDupRisk(issue: MetadataCandidateIssue, peers: readonly MetadataCandidateIssue[]): number;
+/** Build the five ranker inputs for one metadata candidate. Pure. */
+export declare function buildMetadataRankInput(issue: MetadataCandidateIssue, peers: readonly MetadataCandidateIssue[], context: MetadataRankContext): OpportunityRankInput;
+/** Rank metadata-only candidates with the shared opportunity ranker. Pure. */
+export declare function rankMetadataOpportunities<T extends MetadataCandidateIssue>(candidates: readonly T[], context: MetadataRankContext): Array<T & OpportunityRankInput & {
+    rankScore: number;
+}>;
+export {};

package/dist/opportunity-metadata.js

@@ -0,0 +1,204 @@
+import { computeMetadataLaneFit, isMinerRepoTargetable } from "./miner-goal-lane-fit.js";
+import { DEFAULT_MINER_GOAL_SPEC } from "./miner-goal-spec.js";
+import { computeOpportunityCompetition } from "./opportunity-competition.js";
+import { computeOpportunityFreshness } from "./opportunity-freshness.js";
+import { rankOpportunities, } from "./opportunity-ranker.js";
+const POSITIVE_LABELS = Object.freeze([
+    "good first issue",
+    "help wanted",
+    "enhancement",
+    "feature",
+    "documentation",
+]);
+const NEGATIVE_LABELS = Object.freeze([
+    "blocked",
+    "wontfix",
+    "duplicate",
+    "invalid",
+    "question",
+]);
+function clamp01(value) {
+    /* v8 ignore next -- Defensive guard for malformed adapter input; scores are always finite in practice. */
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+function finiteNonNegativeInt(value) {
+    /* v8 ignore next -- Defensive guard for malformed adapter input; counts are normalized before scoring. */
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.trunc(value));
+}
+/* v8 ignore start -- Label/title normalization helpers are covered through exported ranker entrypoints. */
+function normalizeLabels(labels) {
+    return labels
+        .filter((label) => typeof label === "string")
+        .map((label) => label.trim().toLowerCase())
+        .filter(Boolean);
+}
+function normalizeTitle(title) {
+    return title.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function resolveGoalSpec(repoFullName, context) {
+    const target = repoFullName.trim().toLowerCase();
+    const entries = context.goalSpecsByRepo ? Object.entries(context.goalSpecsByRepo) : [];
+    for (const [repo, spec] of entries) {
+        if (repo.trim().toLowerCase() === target)
+            return spec;
+    }
+    return DEFAULT_MINER_GOAL_SPEC;
+}
+/* v8 ignore stop */
+const STALE_AGE_DAYS = 9999;
+/* v8 ignore start -- Internal timestamp helpers mirror freshness semantics; exercised via exported ranker paths. */
+function pickMetadataTimestamp(issue) {
+    // Mirror freshness semantics (opportunity-freshness's pickTimestamp): only commit to a timestamp that actually
+    // parses. Without the guard, a present-but-unparseable updatedAt shadows a valid createdAt, so issueAgeDays
+    // hits the STALE_AGE_DAYS sentinel and a genuinely fresh issue is scored as maximally stale.
+    if (typeof issue.updatedAt === "string") {
+        const updated = issue.updatedAt.trim();
+        if (updated && Number.isFinite(Date.parse(updated)))
+            return updated;
+    }
+    if (typeof issue.createdAt === "string") {
+        const created = issue.createdAt.trim();
+        if (created && Number.isFinite(Date.parse(created)))
+            return created;
+    }
+    return "";
+}
+function issueAgeDays(issue, nowMs) {
+    const stamp = pickMetadataTimestamp(issue);
+    if (!stamp)
+        return STALE_AGE_DAYS;
+    const parsed = Date.parse(stamp);
+    if (!Number.isFinite(parsed))
+        return STALE_AGE_DAYS;
+    return Math.max(0, Math.floor((nowMs - parsed) / 86_400_000));
+}
+/* v8 ignore stop */
+/**
+ * Estimate reward potential from issue labels alone. Explicitly negative labels collapse the score; common
+ * contribution labels raise it; everything else keeps a neutral baseline.
+ */
+/* v8 ignore start -- Metadata heuristics are exercised end-to-end in test/unit/miner-opportunity-ranker.test.ts. */
+export function computeMetadataPotential(issue) {
+    const labels = normalizeLabels(issue.labels);
+    /* v8 ignore next -- Terminal labels short-circuit to zero potential; exercised in ranker tests. */
+    if (labels.some((label) => NEGATIVE_LABELS.includes(label)))
+        return 0;
+    let score = 0.45;
+    /* v8 ignore next -- Neutral metadata keeps the baseline when no contribution labels are present. */
+    if (labels.some((label) => POSITIVE_LABELS.includes(label)))
+        score += 0.35;
+    /* v8 ignore next -- Bug/refactor bonuses are additive; neutral-only labels keep the baseline score. */
+    if (labels.includes("bug"))
+        score += 0.1;
+    /* v8 ignore next */
+    if (labels.includes("refactor"))
+        score += 0.05;
+    return clamp01(score);
+}
+/**
+ * Estimate achievability from metadata-only cues: lower discussion load and fresher issues score higher.
+ */
+export function computeMetadataFeasibility(issue, nowMs) {
+    /* v8 ignore next -- Ranker callers inject a finite epoch; malformed clocks degrade to zero feasibility. */
+    if (!Number.isFinite(nowMs))
+        return 0;
+    const comments = finiteNonNegativeInt(issue.commentsCount);
+    const commentScore = clamp01(1 - comments / 25);
+    const ageDays = issueAgeDays(issue, nowMs);
+    const ageScore = clamp01(Math.exp(-ageDays / 45));
+    const titleLength = normalizeTitle(issue.title).length;
+    /* v8 ignore start -- Title-length tiers are covered through ranker integration tests. */
+    let titleScore = 0.4;
+    if (titleLength >= 8) {
+        titleScore = 1;
+    }
+    else if (titleLength >= 4) {
+        titleScore = 0.7;
+    }
+    /* v8 ignore stop */
+    return clamp01(commentScore * 0.45 + ageScore * 0.35 + titleScore * 0.2);
+}
+/* v8 ignore start -- Title overlap helper is exercised through computeMetadataDupRisk. */
+function titlesOverlap(left, right) {
+    if (!left || !right)
+        return false;
+    if (left === right)
+        return true;
+    let shorter = left;
+    let longer = right;
+    if (left.length > right.length) {
+        shorter = right;
+        longer = left;
+    }
+    return longer.includes(shorter) && shorter.length >= 12;
+}
+/* v8 ignore stop */
+/* v8 ignore start -- Test-only export surface for branch coverage. */
+export const opportunityMetadataInternals = {
+    titlesOverlap,
+    normalizeLabels,
+    resolveGoalSpec,
+    pickMetadataTimestamp,
+};
+/* v8 ignore stop */
+/**
+ * Estimate duplicate-work risk inside a metadata-only candidate batch by looking for overlapping titles in the
+ * same repository. This is intentionally conservative: any strong overlap raises dupRisk toward 1.
+ */
+export function computeMetadataDupRisk(issue, peers) {
+    const normalized = normalizeTitle(issue.title);
+    /* v8 ignore next -- Blank titles are treated as maximum dup risk. */
+    if (!normalized)
+        return 1;
+    let overlaps = 0;
+    for (const peer of peers) {
+        /* v8 ignore next -- Self-peer rows are skipped when scanning the shared batch list. */
+        if (peer.issueNumber === issue.issueNumber && peer.repoFullName === issue.repoFullName)
+            continue;
+        /* v8 ignore next -- Cross-repo peers are ignored when scanning for overlap inside a batch. */
+        if (peer.repoFullName.trim().toLowerCase() !== issue.repoFullName.trim().toLowerCase())
+            continue;
+        /* v8 ignore next -- Overlap hits are counted only for same-repo peers with shared title segments. */
+        if (titlesOverlap(normalized, normalizeTitle(peer.title)))
+            overlaps += 1;
+    }
+    /* v8 ignore next -- No overlaps keeps dup risk at zero for unique titles. */
+    if (overlaps === 0)
+        return 0;
+    return clamp01(overlaps / (overlaps + 1));
+}
+/** Build the five ranker inputs for one metadata candidate. Pure. */
+export function buildMetadataRankInput(issue, peers, context) {
+    const goalSpec = resolveGoalSpec(issue.repoFullName, context);
+    const repoCompetition = computeOpportunityCompetition(
+    /* v8 ignore next */
+    context.highRiskDuplicateClusters ?? 0, 
+    /* v8 ignore next */
+    context.openPullRequests ?? 0);
+    const batchDupRisk = computeMetadataDupRisk(issue, peers);
+    return {
+        potential: computeMetadataPotential(issue),
+        feasibility: computeMetadataFeasibility(issue, context.nowMs),
+        laneFit: computeMetadataLaneFit(issue, goalSpec),
+        freshness: computeOpportunityFreshness(
+        /* v8 ignore next */
+        [{ state: "open", updatedAt: issue.updatedAt ?? null, createdAt: issue.createdAt ?? null }], context.nowMs),
+        /* v8 ignore next */
+        dupRisk: clamp01(Math.max(batchDupRisk, repoCompetition)),
+    };
+}
+/** Rank metadata-only candidates with the shared opportunity ranker. Pure. */
+export function rankMetadataOpportunities(candidates, context) {
+    const targetableCandidates = candidates.filter((candidate) => isMinerRepoTargetable(resolveGoalSpec(candidate.repoFullName, context)));
+    const annotated = targetableCandidates.map((candidate) => ({
+        ...candidate,
+        ...buildMetadataRankInput(candidate, targetableCandidates, context),
+    }));
+    /* v8 ignore next */
+    return rankOpportunities(annotated);
+}
+/* v8 ignore stop */

package/dist/opportunity-ranker.d.ts

@@ -0,0 +1,46 @@
+/** The five 0-1 normalized signals for one candidate opportunity. */
+export type OpportunityRankInput = {
+    /** Expected reward if the work is won (score / label-multiplier potential). */
+    potential: number;
+    /** How achievable the issue is for the miner. */
+    feasibility: number;
+    /** Fit with the miner's preferred lanes. */
+    laneFit: number;
+    /** How recently actionable the opportunity is (decays as it ages). */
+    freshness: number;
+    /** Risk the work is already claimed / contested; higher means more likely a wasted attempt. */
+    dupRisk: number;
+};
+/**
+ * The ordinal opportunity score: `potential * feasibility * laneFit * freshness * (1 - dupRisk)`, with every field
+ * clamped to [0, 1] first. Because it is a product, ANY single factor at 0 — or a `dupRisk` of exactly 1 — collapses
+ * the whole score to 0: a candidate that fails any one dimension is not an opportunity. Malformed input never passes
+ * through raw and always degrades the score toward 0: the four positive factors clamp a non-finite value to 0, and a
+ * non-finite `dupRisk` fails closed to 1 (max risk). So a bad signal can neither invert the sign nor overflow the
+ * product. Pure.
+ *
+ * Signal-source map for the composing caller (a later issue): `feasibility` ← the per-repo report in
+ * `src/services/issue-quality.ts`; `laneFit` ← `MinerGoalSpec.preferredLanes` (the goal-model issue); `freshness`
+ * ← `src/signals/reward-risk.ts`'s `freshnessFactor`; `dupRisk` ← `src/signals/reward-risk.ts`'s
+ * `competitionFactor` combined with `src/signals/duplicate-winner.ts`'s claim adjudication.
+ */
+export declare function rankOpportunityScore(input: OpportunityRankInput): number;
+/**
+ * Rank a candidate list by descending {@link rankOpportunityScore}, annotating each candidate with its `rankScore`.
+ * Equal scores keep their input order: the tie-break is made EXPLICIT via a carried index (`rankScore` desc, then
+ * `index` asc) rather than relying on `Array.prototype.sort` stability, so the contract holds on any engine and is
+ * enforced by this function. Mirrors the tie-break intent of `isDuplicateClusterWinnerByClaim` in
+ * src/signals/duplicate-winner.ts, where an earlier entry wins a tie. Pure — returns a new array; the input array
+ * and its elements are not mutated. The computed `rankScore` REPLACES any `rankScore` already on an input element
+ * (`Omit<T, "rankScore">` in the result), so a caller carrying its own field can't collide with the annotation.
+ */
+export declare function rankOpportunities<T>(candidates: Array<T & OpportunityRankInput>): Array<Omit<T, "rankScore"> & OpportunityRankInput & {
+    rankScore: number;
+}>;
+/**
+ * Rank candidates and return the top `limit` entries. Non-finite or negative limits return an empty list.
+ * Pure — delegates to {@link rankOpportunities} for ordering and tie-breaking.
+ */
+export declare function pickTopRankedOpportunities<T>(candidates: Array<T & OpportunityRankInput>, limit: number): Array<Omit<T, "rankScore"> & OpportunityRankInput & {
+    rankScore: number;
+}>;

package/dist/opportunity-ranker.js

@@ -0,0 +1,74 @@
+// Opportunity ranker (#2302). The core Phase-1 miner-discovery ranker: it composes five already-normalized,
+// deterministic signals into a single ordinal score used to sort a cross-repo candidate-issue list, so a later
+// `gittensory_find_opportunities` tool has something deterministic to sort by.
+//
+// This module is PURE — no IO, no Date, no random — so identical inputs always produce identical order, matching
+// the house convention in src/signals/duplicate-winner.ts. Every input is clamped to [0, 1] before use; the sole
+// exception is a NON-finite `dupRisk` (NaN/±Infinity), which can't be clamped and fails closed to max risk so a
+// broken contention signal never looks safe. Either way a malformed signal degrades the score toward 0 rather than
+// inverting or blowing up the product.
+/** Clamp a positive factor to [0, 1]; a non-finite value (NaN/±Infinity from a broken upstream) degrades to 0. */
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+/**
+ * Normalize the contention/risk signal to [0, 1]. A FINITE value is clamped like every other field — below-range
+ * → 0, above-range → 1 — so `dupRisk = -0.1` reads as no contention and `dupRisk = 1.4` as full contention. A
+ * NON-finite value (`NaN`/`±Infinity`) cannot be clamped and signals a broken upstream, so it FAILS CLOSED to
+ * maximum risk (1), never 0: a broken contention signal must not masquerade as a safe, uncontested opportunity
+ * (mirroring the fail-closed convention in `src/signals/duplicate-winner.ts`, where sparse rows fail closed).
+ */
+function clampRisk(value) {
+    if (!Number.isFinite(value))
+        return 1;
+    return Math.min(1, Math.max(0, value));
+}
+/**
+ * The ordinal opportunity score: `potential * feasibility * laneFit * freshness * (1 - dupRisk)`, with every field
+ * clamped to [0, 1] first. Because it is a product, ANY single factor at 0 — or a `dupRisk` of exactly 1 — collapses
+ * the whole score to 0: a candidate that fails any one dimension is not an opportunity. Malformed input never passes
+ * through raw and always degrades the score toward 0: the four positive factors clamp a non-finite value to 0, and a
+ * non-finite `dupRisk` fails closed to 1 (max risk). So a bad signal can neither invert the sign nor overflow the
+ * product. Pure.
+ *
+ * Signal-source map for the composing caller (a later issue): `feasibility` ← the per-repo report in
+ * `src/services/issue-quality.ts`; `laneFit` ← `MinerGoalSpec.preferredLanes` (the goal-model issue); `freshness`
+ * ← `src/signals/reward-risk.ts`'s `freshnessFactor`; `dupRisk` ← `src/signals/reward-risk.ts`'s
+ * `competitionFactor` combined with `src/signals/duplicate-winner.ts`'s claim adjudication.
+ */
+export function rankOpportunityScore(input) {
+    return (clamp01(input.potential) *
+        clamp01(input.feasibility) *
+        clamp01(input.laneFit) *
+        clamp01(input.freshness) *
+        (1 - clampRisk(input.dupRisk)));
+}
+/**
+ * Rank a candidate list by descending {@link rankOpportunityScore}, annotating each candidate with its `rankScore`.
+ * Equal scores keep their input order: the tie-break is made EXPLICIT via a carried index (`rankScore` desc, then
+ * `index` asc) rather than relying on `Array.prototype.sort` stability, so the contract holds on any engine and is
+ * enforced by this function. Mirrors the tie-break intent of `isDuplicateClusterWinnerByClaim` in
+ * src/signals/duplicate-winner.ts, where an earlier entry wins a tie. Pure — returns a new array; the input array
+ * and its elements are not mutated. The computed `rankScore` REPLACES any `rankScore` already on an input element
+ * (`Omit<T, "rankScore">` in the result), so a caller carrying its own field can't collide with the annotation.
+ */
+export function rankOpportunities(candidates) {
+    return candidates
+        .map((candidate, index) => ({ candidate, rankScore: rankOpportunityScore(candidate), index }))
+        .sort((a, b) => b.rankScore - a.rankScore || a.index - b.index)
+        .map(({ candidate, rankScore }) => ({ ...candidate, rankScore }));
+}
+/**
+ * Rank candidates and return the top `limit` entries. Non-finite or negative limits return an empty list.
+ * Pure — delegates to {@link rankOpportunities} for ordering and tie-breaking.
+ */
+export function pickTopRankedOpportunities(candidates, limit) {
+    if (!Number.isFinite(limit))
+        return [];
+    const safeLimit = Math.max(0, Math.trunc(limit));
+    if (safeLimit === 0 || candidates.length === 0)
+        return [];
+    return rankOpportunities(candidates).slice(0, safeLimit);
+}

package/dist/pairwise-calibration.d.ts

@@ -0,0 +1,49 @@
+import type { ObjectiveAnchorScore } from "./objective-anchor.js";
+export type PairwiseCalibrationVerdict = "replay_better" | "revealed_better" | "tie" | "incomparable";
+export type PairwiseCalibrationAttempt = {
+    /** Judge result when replayed output is shown first and revealed history second. */
+    replayFirst: PairwiseCalibrationVerdict;
+    /** Judge result when revealed history is shown first and replayed output second. */
+    revealedFirst: PairwiseCalibrationVerdict;
+};
+export type PairwiseCalibrationWeights = {
+    objectiveAnchor?: number | undefined;
+    pairwiseJudge?: number | undefined;
+};
+export type PairwiseCalibrationResolvedSample = {
+    stable: boolean;
+    exhausted: boolean;
+    attemptsUsed: number;
+    maxAttempts: number;
+    verdict: PairwiseCalibrationVerdict | "unstable";
+    pairwiseScore: number | null;
+};
+export type PairwiseCalibrationScore = {
+    compositeScore: number;
+    objectiveAnchorScore: number;
+    pairwiseJudgeScore: number | null;
+    weights: {
+        objectiveAnchor: number;
+        pairwiseJudge: number;
+    };
+    samples: PairwiseCalibrationResolvedSample[];
+    metrics: {
+        totalSamples: number;
+        stableSamples: number;
+        unstableSamples: number;
+        exhaustedSamples: number;
+        orderInstabilityRate: number;
+    };
+};
+export declare function resolvePairwiseCalibrationSample(input: {
+    attempts: readonly PairwiseCalibrationAttempt[];
+    maxAttempts?: number | undefined;
+}): PairwiseCalibrationResolvedSample;
+export declare function computePairwiseCalibrationScore(input: {
+    objectiveAnchor: number | ObjectiveAnchorScore;
+    samples: readonly {
+        attempts: readonly PairwiseCalibrationAttempt[];
+        maxAttempts?: number | undefined;
+    }[];
+    weights?: PairwiseCalibrationWeights | undefined;
+}): PairwiseCalibrationScore;

package/dist/pairwise-calibration.js

@@ -0,0 +1,106 @@
+// Deterministic pairwise-judge calibration combiner (#3013).
+//
+// The model invocation itself belongs to the miner runtime. This engine module owns the pure part: interpret the
+// two order-swapped judge outputs, discard unstable pairs, cap retries, expose instability metrics, and combine the
+// surviving judge score with the objective-anchor score.
+const DEFAULT_PAIRWISE_WEIGHTS = {
+    objectiveAnchor: 0.5,
+    pairwiseJudge: 0.5,
+};
+function finiteNonNegative(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isFinite(value) || value < 0)
+        return 0;
+    return value;
+}
+function normalizePairwiseWeights(weights) {
+    const raw = {
+        objectiveAnchor: finiteNonNegative(weights?.objectiveAnchor, DEFAULT_PAIRWISE_WEIGHTS.objectiveAnchor),
+        pairwiseJudge: finiteNonNegative(weights?.pairwiseJudge, DEFAULT_PAIRWISE_WEIGHTS.pairwiseJudge),
+    };
+    const total = raw.objectiveAnchor + raw.pairwiseJudge;
+    if (total <= 0)
+        return DEFAULT_PAIRWISE_WEIGHTS;
+    return {
+        objectiveAnchor: raw.objectiveAnchor / total,
+        pairwiseJudge: raw.pairwiseJudge / total,
+    };
+}
+function invertedVerdict(verdict) {
+    if (verdict === "replay_better")
+        return "revealed_better";
+    if (verdict === "revealed_better")
+        return "replay_better";
+    return verdict;
+}
+function verdictScore(verdict) {
+    if (verdict === "replay_better")
+        return 1;
+    if (verdict === "tie")
+        return 0.5;
+    if (verdict === "revealed_better")
+        return 0;
+    return null;
+}
+function roundScore(value) {
+    return Math.round(Math.min(1, Math.max(0, value)) * 1_000_000) / 1_000_000;
+}
+export function resolvePairwiseCalibrationSample(input) {
+    const requestedMaxAttempts = input.maxAttempts ?? input.attempts.length;
+    const maxAttempts = Math.max(1, Math.floor(requestedMaxAttempts || 1));
+    const attempts = input.attempts.slice(0, maxAttempts);
+    for (let index = 0; index < attempts.length; index += 1) {
+        const attempt = attempts[index];
+        const stable = attempt.replayFirst === invertedVerdict(attempt.revealedFirst);
+        if (stable) {
+            const score = verdictScore(attempt.replayFirst);
+            if (score !== null) {
+                return {
+                    stable: true,
+                    exhausted: false,
+                    attemptsUsed: index + 1,
+                    maxAttempts,
+                    verdict: attempt.replayFirst,
+                    pairwiseScore: score,
+                };
+            }
+        }
+    }
+    return {
+        stable: false,
+        exhausted: attempts.length >= maxAttempts,
+        attemptsUsed: attempts.length,
+        maxAttempts,
+        verdict: "unstable",
+        pairwiseScore: null,
+    };
+}
+export function computePairwiseCalibrationScore(input) {
+    const objectiveAnchorScore = typeof input.objectiveAnchor === "number" ? roundScore(input.objectiveAnchor) : input.objectiveAnchor.score;
+    const samples = input.samples.map(resolvePairwiseCalibrationSample);
+    const stableScores = samples
+        .map((sample) => sample.pairwiseScore)
+        .filter((score) => score !== null);
+    const pairwiseJudgeScore = stableScores.length === 0 ? null : roundScore(stableScores.reduce((sum, score) => sum + score, 0) / stableScores.length);
+    const weights = normalizePairwiseWeights(input.weights);
+    const compositeScore = pairwiseJudgeScore === null
+        ? objectiveAnchorScore
+        : roundScore(objectiveAnchorScore * weights.objectiveAnchor + pairwiseJudgeScore * weights.pairwiseJudge);
+    const unstableSamples = samples.filter((sample) => !sample.stable).length;
+    const exhaustedSamples = samples.filter((sample) => sample.exhausted).length;
+    return {
+        compositeScore,
+        objectiveAnchorScore,
+        pairwiseJudgeScore,
+        weights,
+        samples,
+        metrics: {
+            totalSamples: samples.length,
+            stableSamples: stableScores.length,
+            unstableSamples,
+            exhaustedSamples,
+            orderInstabilityRate: samples.length === 0 ? 0 : roundScore(unstableSamples / samples.length),
+        },
+    };
+}