@loopover/engine 1.0.0

package/dist/scoring/preview.js

@@ -0,0 +1,1108 @@
+import { DEFAULT_SCORING_CONSTANTS } from "./model.js";
+import { hasUnsafeWildcardCount } from "../signals/change-guardrail.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+const PROJECTED_SOLVED_BY_PULL_REQUEST_VALIDATION = Symbol("projectedSolvedByPullRequestValidation");
+export function buildScorePreview(args) {
+    const branchEligibility = normalizeBranchEligibility(args.input);
+    const current = computeScoreCore(args.input, args.repo, args.snapshot, args.contributorEvidence);
+    const scenarioPreviews = buildScenarioPreviews(args.input, args.repo, args.snapshot, args.contributorEvidence, current);
+    const blockedBy = blockedByFor(args.input, args.repo, current, branchEligibility);
+    const gateDeltas = buildGateDeltas(current, scenarioPreviews);
+    const effectiveEstimatedScore = current.scoreEstimate.estimatedMergedScore;
+    const underlyingPotentialScore = current.scoreEstimate.pendingSaturationScore;
+    const scoreabilityStatus = statusFor(args.repo, blockedBy, effectiveEstimatedScore, scenarioPreviews);
+    const warnings = [...args.snapshot.warnings, ...warningsFor(args.input, args.repo, current, branchEligibility)];
+    const actions = [
+        ...(!current.gates.baseTokenGatePassed ? ["Increase meaningful source change size or scope clarity before relying on this preview."] : []),
+        ...(current.scoreEstimate.openPrMultiplier === 0 ? ["Land or close existing open PRs before opening more concurrent work."] : []),
+        ...(current.scoreEstimate.openIssueMultiplier === 0 ? ["Close excess open issues to stay within the open-issue spam threshold."] : []),
+        ...(current.scoreEstimate.mergedHistoryMultiplier === 0 ? ["Build merged PR history on this repo before relying on this preview; upstream requires a minimum merged count."] : []),
+        ...(current.scoreEstimate.issueDiscoveryHistoryMultiplier === 0
+            ? ["Build valid solved-issue history and issue credibility before relying on issue-discovery scoring on this repo."]
+            : []),
+        ...(current.scoreEstimate.credibilityMultiplier < 1 ? ["Build or wait for contributor credibility evidence before relying on this preview."] : []),
+        ...(current.scoreEstimate.reviewPenaltyMultiplier < 1 ? ["Reduce review churn with tighter tests and clearer evidence."] : []),
+        ...(current.scoreEstimate.labelMultiplier <= 1 && Object.keys(args.repo?.registryConfig?.labelMultipliers ?? {}).length > 0
+            ? ["Check whether the change legitimately matches one of the repo's configured trusted labels."]
+            : []),
+        ...(branchEligibility.required && branchEligibility.status === "ineligible" ? ["Use an eligible branch or remove linked-issue assumptions before relying on this preview."] : []),
+        ...(branchEligibility.required && (branchEligibility.evidence === "missing" || branchEligibility.stale)
+            ? ["Refresh branch/base eligibility metadata before relying on linked-issue assumptions."]
+            : []),
+        ...(current.linkedIssueMultiplier.mode === "standard" && !current.linkedIssueMultiplier.eligible
+            ? ["Validate linked issue context with solved-by-PR evidence before relying on the standard issue multiplier."]
+            : []),
+    ];
+    return {
+        repoFullName: args.input.repoFullName,
+        generatedAt: nowIso(),
+        scoringModelSnapshotId: args.snapshot.id,
+        activeModel: args.snapshot.activeModel,
+        privateOnly: true,
+        laneMath: current.laneMath,
+        scoreEstimate: current.scoreEstimate,
+        linkedIssueMultiplier: current.linkedIssueMultiplier,
+        gates: current.gates,
+        branchEligibility,
+        effectiveEstimatedScore,
+        underlyingPotentialScore,
+        blockedBy,
+        gateDeltas,
+        scenarioPreviews,
+        scoreabilityStatus,
+        warnings,
+        assumptions: [
+            "Advisory preview only; tied to the recorded scoring model snapshot and cached Gittensory data.",
+            "No future outcome or exact payout is guaranteed.",
+            "Private API/MCP output only; public comments intentionally omit these details.",
+            `Linked issue multiplier status: ${current.linkedIssueMultiplier.status}; ${current.linkedIssueMultiplier.reason}`,
+            ...branchEligibility.warnings,
+            ...(args.input.scenarioNotes ?? []).map((note) => `User scenario note: ${note}`),
+        ],
+        recommendation: {
+            level: scoreabilityStatus === "hold" || warnings.some((warning) => /not registered|no active|exceeds/i.test(warning))
+                ? "hold"
+                : effectiveEstimatedScore >= 30 && warnings.length === 0
+                    ? "strong_fit"
+                    : effectiveEstimatedScore >= 15
+                        ? "reasonable_fit"
+                        : "needs_work",
+            actions: actions.length > 0 ? actions : ["Keep the PR focused, linked, tested, and easy for maintainers to review."],
+        },
+    };
+}
+export function makeScorePreviewRecord(input, snapshot, result) {
+    return {
+        id: crypto.randomUUID(),
+        scoringModelSnapshotId: snapshot.id,
+        repoFullName: input.repoFullName,
+        targetType: input.targetType ?? "planned_pr",
+        targetKey: input.targetKey ?? `${input.repoFullName}:${input.targetType ?? "planned_pr"}:${Date.now()}`,
+        contributorLogin: input.contributorLogin,
+        input: input,
+        result: result,
+        generatedAt: result.generatedAt,
+    };
+}
+function computeScoreCore(input, repo, snapshot, contributorEvidence) {
+    const constants = { ...snapshot.constants };
+    const config = repo?.registryConfig;
+    const emissionShare = clamp(config?.emissionShare ?? 0, 0, 1);
+    const issueDiscoveryShare = clamp(config?.issueDiscoveryShare ?? 0, 0, 1);
+    const ossEmissionShare = constant(constants, "OSS_EMISSION_SHARE");
+    const repoSlice = emissionShare * ossEmissionShare;
+    const directPrSlice = repoSlice * (1 - issueDiscoveryShare);
+    const issueDiscoverySlice = repoSlice * issueDiscoveryShare;
+    const sourceTokenScore = nonNegative(input.sourceTokenScore);
+    // TEST_FILE_CONTRIBUTION_WEIGHT (#808): upstream weights test-file tokens at 0.05× relative to source tokens.
+    // Applied only when totalTokenScore is not explicitly provided — an explicit caller total is honoured as-is.
+    const testFileWeight = constant(constants, "TEST_FILE_CONTRIBUTION_WEIGHT");
+    const cappedNonCodeTokenScore = applyNonCodeLineCap(input, constants);
+    const derivedTotalTokenScore = sourceTokenScore + testFileWeight * nonNegative(input.testTokenScore) + cappedNonCodeTokenScore;
+    const totalTokenScore = input.totalTokenScore === undefined ? nonNegative(derivedTotalTokenScore) : applyNonCodeCapToTotal(input.totalTokenScore, input, cappedNonCodeTokenScore);
+    const sourceLines = Math.max(1, nonNegative(input.sourceLines ?? sourceTokenScore));
+    const fixedBaseScore = clampFixedBaseScore(input.fixedBaseScore ?? config?.fixedBaseScore);
+    const rawDensity = sourceTokenScore / sourceLines;
+    // Density branch (#812): upstream is on the saturation model, but `current_density_model` is still a
+    // supported `activeModel` (types.ts union, the public OpenAPI schema, the DB parser, ~20 test fixtures, and
+    // src/services/score-breakdown.ts which keys off densityMultiplier). The issue's "if density is dead,
+    // remove the branch" condition is therefore FALSE — the branch is retained as the supported alternate /
+    // fetch-failure-`unknown` fallback model. Its fallback constants are now single-sourced from
+    // DEFAULT_SCORING_CONSTANTS (model.ts) instead of silent duplicated literals, closing the drift surface.
+    const densityMultiplier = clamp(rawDensity || 0, 0, constant(constants, "MAX_CODE_DENSITY_MULTIPLIER"));
+    const densityTokenGatePassed = sourceTokenScore >= constant(constants, "MIN_TOKEN_SCORE_FOR_BASE_SCORE");
+    const baseTokenGatePassed = snapshot.activeModel === "pending_saturation_model" ? sourceTokenScore > 0 : densityTokenGatePassed;
+    const densityContributionBonus = contributionBonusRamp(totalTokenScore, constants);
+    const saturationContributionBonusValue = saturationContributionBonus(totalTokenScore, constants);
+    const saturationBaseScore = saturationScore(sourceTokenScore, totalTokenScore, constants);
+    const densityBaseScore = (densityTokenGatePassed ? constant(constants, "MERGED_PR_BASE_SCORE") * densityMultiplier : 0) + densityContributionBonus;
+    const baseScore = fixedBaseScore !== undefined
+        ? fixedBaseScore
+        : snapshot.activeModel === "pending_saturation_model"
+            ? saturationBaseScore
+            : densityBaseScore;
+    const baseScoreCap = fixedBaseScore !== undefined
+        ? undefined
+        : snapshot.activeModel === "pending_saturation_model"
+            ? constant(constants, "MERGED_PR_BASE_SCORE") + constant(constants, "MAX_CONTRIBUTION_BONUS")
+            : constant(constants, "MERGED_PR_BASE_SCORE") * constant(constants, "MAX_CODE_DENSITY_MULTIPLIER") + constant(constants, "MAX_CONTRIBUTION_BONUS");
+    const activeContributionBonus = snapshot.activeModel === "pending_saturation_model" ? saturationContributionBonusValue : densityContributionBonus;
+    const labelMultiplier = selectLabelMultiplier(input.labels ?? [], config?.labelMultipliers ?? {}, config?.defaultLabelMultiplier ?? 1);
+    const branchEligibility = normalizeBranchEligibility(input);
+    const linkedIssueMultiplier = decideLinkedIssueMultiplier(input.linkedIssueMode ?? "none", input.linkedIssueContext, constants, branchEligibility);
+    const issueMultiplier = linkedIssueMultiplier.appliedMultiplier;
+    const credibilityObserved = clamp(input.credibility ?? inferCredibility(contributorEvidence), 0, 1);
+    const credibilityFloor = constant(constants, "MIN_CREDIBILITY");
+    const credibilityMultiplier = credibilityObserved >= credibilityFloor ? 1 : credibilityObserved / credibilityFloor;
+    const changesRequestedCount = nonNegative(input.changesRequestedCount);
+    const reviewPenaltyRate = constant(constants, "REVIEW_PENALTY_RATE");
+    const reviewPenaltyMultiplier = clamp(1 - changesRequestedCount * reviewPenaltyRate, 0, 1);
+    const reviewCollateralMultiplier = Math.min(constant(constants, "MAX_OPEN_PR_REVIEW_COLLATERAL_MULTIPLIER"), 1 + changesRequestedCount * reviewPenaltyRate);
+    const openPrCollateralPercent = constant(constants, "OPEN_PR_COLLATERAL_PERCENT");
+    const openPrCount = nonNegative(input.openPrCount);
+    // The concurrency allowance is earned from the contributor's established merged-history token
+    // score; the planned PR's own tokens (totalTokenScore) must not inflate its own open-PR threshold.
+    const openPrThreshold = Math.min(constant(constants, "MAX_OPEN_PR_THRESHOLD"), constant(constants, "EXCESSIVE_PR_PENALTY_BASE_THRESHOLD") +
+        Math.floor(nonNegative(input.existingContributorTokenScore) / constant(constants, "OPEN_PR_THRESHOLD_TOKEN_SCORE")));
+    const openPrMultiplier = openPrCount <= openPrThreshold ? 1 : 0;
+    // Open-issue spam gate (#808): mirrors the open-PR gate for the issue-discovery channel.
+    // A contributor earns extra open-issue slots from their existing merged-history token score.
+    const openIssueCount = nonNegative(input.openIssueCount);
+    const openIssueThreshold = Math.min(constant(constants, "MAX_OPEN_ISSUE_THRESHOLD"), constant(constants, "OPEN_ISSUE_SPAM_BASE_THRESHOLD") +
+        Math.floor(nonNegative(input.existingContributorTokenScore) / constant(constants, "OPEN_ISSUE_SPAM_TOKEN_SCORE_PER_SLOT")));
+    const openIssueMultiplier = openIssueCount <= openIssueThreshold ? 1 : 0;
+    const mergedPrFloor = constant(constants, "MIN_VALID_MERGED_PRS");
+    const mergedPullRequestsObserved = resolveMergedPullRequests(input, contributorEvidence);
+    const mergedHistoryMultiplier = mergedPullRequestsObserved === undefined ? 1 : mergedPullRequestsObserved >= mergedPrFloor ? 1 : 0;
+    const validSolvedIssuesFloor = constant(constants, "MIN_VALID_SOLVED_ISSUES");
+    const issueCredibilityFloor = constant(constants, "MIN_ISSUE_CREDIBILITY");
+    const validSolvedIssuesObserved = input.validSolvedIssues !== undefined ? nonNegative(input.validSolvedIssues) : undefined;
+    const issueCredibilityObserved = input.issueCredibility !== undefined ? clamp(input.issueCredibility, 0, 1) : undefined;
+    // Issue-discovery validity mirrors upstream's separate issue lane, which is the `standard` linked-issue
+    // lane only. The `maintainer` lane explicitly does not require solved-by-PR issue linkage (see
+    // decideLinkedIssueMultiplier), so it must not be gated by the solved-issue history floor — otherwise a
+    // maintainer preview with sparse issue history is wrongly zeroed and flagged issue_discovery_validity_floor.
+    const issueDiscoveryRelevant = (input.linkedIssueMode ?? "none") === "standard";
+    const issueDiscoveryHistoryKnown = validSolvedIssuesObserved !== undefined && issueCredibilityObserved !== undefined;
+    const issueDiscoveryHistoryMultiplier = !issueDiscoveryRelevant || !issueDiscoveryHistoryKnown
+        ? 1
+        : validSolvedIssuesObserved >= validSolvedIssuesFloor && issueCredibilityObserved >= issueCredibilityFloor
+            ? 1
+            : 0;
+    // Upstream time-decay (#703): mirrors upstream's `scored.time_decay_multiplier` applied to a PR's score.
+    // Opt-in + env-gated (default off). A fresh PR (prAgeHours below the grace period) yields 1.0, so a normal
+    // new-PR preview is unchanged even when enabled — only an aged-PR projection decays.
+    // Per-repo curve (#703): the repo's registry `scoring.time_decay` overrides overlay the snapshot defaults.
+    const timeDecayMultiplier = input.applyTimeDecay ? calculateTimeDecay(nonNegative(input.prAgeHours), constants, config?.timeDecay) : 1;
+    const estimatedMergedScore = roundScore(baseScore *
+        labelMultiplier *
+        issueMultiplier *
+        credibilityMultiplier *
+        reviewPenaltyMultiplier *
+        openPrMultiplier *
+        openIssueMultiplier *
+        mergedHistoryMultiplier *
+        issueDiscoveryHistoryMultiplier *
+        timeDecayMultiplier);
+    const pendingSaturationScore = roundScore(saturationBaseScore);
+    return {
+        laneMath: {
+            repoEmissionShare: emissionShare,
+            ossEmissionShare,
+            repoSlice: roundScore(repoSlice),
+            directPrSlice: roundScore(directPrSlice),
+            issueDiscoverySlice: roundScore(issueDiscoverySlice),
+            issueDiscoveryShare,
+        },
+        scoreEstimate: {
+            baseScore: roundScore(baseScore),
+            ...(baseScoreCap !== undefined ? { baseScoreCap: roundScore(baseScoreCap) } : {}),
+            densityMultiplier: roundScore(densityMultiplier),
+            contributionBonus: roundScore(activeContributionBonus),
+            labelMultiplier,
+            issueMultiplier,
+            credibilityMultiplier: roundScore(credibilityMultiplier),
+            reviewPenaltyMultiplier: roundScore(reviewPenaltyMultiplier),
+            openPrMultiplier,
+            openIssueMultiplier,
+            mergedHistoryMultiplier,
+            issueDiscoveryHistoryMultiplier,
+            timeDecayMultiplier: roundScore(timeDecayMultiplier),
+            estimatedMergedScore,
+            pendingSaturationScore,
+        },
+        linkedIssueMultiplier,
+        gates: {
+            baseTokenGatePassed,
+            openPrThreshold,
+            openPrCount,
+            reviewCollateralMultiplier: roundScore(reviewCollateralMultiplier),
+            collateralFraction: roundScore(openPrCollateralPercent * reviewCollateralMultiplier),
+            credibilityFloor,
+            credibilityObserved,
+            openIssueThreshold,
+            openIssueCount,
+            mergedPrFloor,
+            ...(mergedPullRequestsObserved !== undefined ? { mergedPullRequests: mergedPullRequestsObserved } : {}),
+            validSolvedIssuesFloor,
+            ...(validSolvedIssuesObserved !== undefined ? { validSolvedIssues: validSolvedIssuesObserved } : {}),
+            issueCredibilityFloor,
+            ...(issueCredibilityObserved !== undefined ? { issueCredibility: issueCredibilityObserved } : {}),
+            nonCodeLineCap: constant(constants, "MAX_LINES_SCORED_FOR_NON_CODE_EXT"),
+            ...(input.nonCodeLines !== undefined ? { nonCodeLinesObserved: nonNegative(input.nonCodeLines) } : {}),
+        },
+    };
+}
+function buildScenarioPreviews(input, repo, snapshot, contributorEvidence, current) {
+    // Count each pending open PR at most once. `approvedPrCount` and
+    // `pendingMergedPrCount` are the same merge-ready set — detectPendingPrScenario
+    // sets both to `mergeReady.length` — so they must be folded with `max`, not
+    // added, or the merge-ready PRs get double-subtracted from the open-PR
+    // projection. Closed/likely-close PRs are a disjoint set and add on top. This
+    // mirrors the canonical reduction in pending-pr-scenarios.ts
+    // (currentOpen - pendingMergedPrCount - pendingClosedPrCount).
+    const mergeReadyPending = Math.max(nonNegative(input.pendingMergedPrCount), nonNegative(input.approvedPrCount));
+    const userPendingCount = mergeReadyPending + nonNegative(input.pendingClosedPrCount);
+    const observedApprovedCount = nonNegative(input.observedApprovedPrCount);
+    const observedStaleCloseCount = nonNegative(input.observedStalePrCount);
+    const observedClosedCount = nonNegative(input.observedClosedPrCount);
+    const combinedPendingCount = userPendingCount + observedApprovedCount + observedStaleCloseCount;
+    const expectedOpenPrCountAfterMerge = input.expectedOpenPrCountAfterMerge !== undefined ? nonNegative(input.expectedOpenPrCountAfterMerge) : Math.max(0, current.gates.openPrCount - userPendingCount);
+    const projectedCredibility = input.projectedCredibility !== undefined
+        ? clamp(input.projectedCredibility, 0, 1)
+        : userPendingCount > 0
+            ? Math.max(current.gates.credibilityObserved, current.gates.credibilityFloor)
+            : current.gates.credibilityObserved;
+    const observedApprovalCredibility = observedApprovedCount > 0 ? Math.max(current.gates.credibilityObserved, current.gates.credibilityFloor) : current.gates.credibilityObserved;
+    const afterApprovedInput = {
+        ...input,
+        openPrCount: Math.max(0, current.gates.openPrCount - observedApprovedCount),
+        credibility: observedApprovalCredibility,
+    };
+    const afterStaleInput = {
+        ...input,
+        openPrCount: Math.max(0, current.gates.openPrCount - observedStaleCloseCount),
+        credibility: current.gates.credibilityObserved,
+    };
+    const cleanGatesInput = {
+        ...input,
+        openPrCount: Math.min(current.gates.openPrCount, current.gates.openPrThreshold),
+        openIssueCount: Math.min(current.gates.openIssueCount, current.gates.openIssueThreshold),
+        credibility: Math.max(current.gates.credibilityObserved, current.gates.credibilityFloor),
+        ...(current.gates.mergedPullRequests !== undefined
+            ? { mergedPullRequests: Math.max(current.gates.mergedPullRequests, current.gates.mergedPrFloor) }
+            : {}),
+        ...(current.gates.validSolvedIssues !== undefined
+            ? { validSolvedIssues: Math.max(current.gates.validSolvedIssues, current.gates.validSolvedIssuesFloor) }
+            : {}),
+        ...(current.gates.issueCredibility !== undefined
+            ? { issueCredibility: Math.max(current.gates.issueCredibility, current.gates.issueCredibilityFloor) }
+            : {}),
+    };
+    const afterPendingInput = {
+        ...input,
+        openPrCount: expectedOpenPrCountAfterMerge,
+        credibility: projectedCredibility,
+        ...(current.gates.mergedPullRequests !== undefined
+            ? { mergedPullRequests: nonNegative(current.gates.mergedPullRequests) + mergeReadyPending }
+            : {}),
+    };
+    const linkedIssueInput = withValidatedLinkedIssueScenario(input);
+    const bestReasonableInput = {
+        ...linkedIssueInput,
+        openPrCount: Math.min(input.expectedOpenPrCountAfterMerge !== undefined ? expectedOpenPrCountAfterMerge : Math.max(0, current.gates.openPrCount - combinedPendingCount), current.gates.openPrThreshold),
+        // Project open-issue spam cleanup (#808): mirror the open-PR projection so the
+        // "best reasonable case" can clear the open-issue gate just like it clears open-PR pressure.
+        openIssueCount: Math.min(current.gates.openIssueCount, current.gates.openIssueThreshold),
+        credibility: Math.max(projectedCredibility, observedApprovalCredibility, current.gates.credibilityFloor),
+        ...(current.gates.mergedPullRequests !== undefined
+            ? {
+                mergedPullRequests: Math.max(nonNegative(current.gates.mergedPullRequests) + mergeReadyPending, current.gates.mergedPrFloor),
+            }
+            : {}),
+        ...(current.gates.validSolvedIssues !== undefined
+            ? { validSolvedIssues: Math.max(current.gates.validSolvedIssues, current.gates.validSolvedIssuesFloor) }
+            : {}),
+        ...(current.gates.issueCredibility !== undefined
+            ? { issueCredibility: Math.max(current.gates.issueCredibility, current.gates.issueCredibilityFloor) }
+            : {}),
+    };
+    return [
+        scenario("current", "current_data", input, current, ["Current cached/account state and supplied local diff metadata."], repo),
+        scenario("cleanGates", "gittensory_projection", cleanGatesInput, computeScoreCore(cleanGatesInput, repo, snapshot, contributorEvidence), [
+            "Open PR, open-issue, credibility, and contributor-history gates are projected as cleared; branch metadata is otherwise unchanged.",
+        ], repo),
+        scenario("afterPendingMerges", input.pendingScenarioObserved
+            ? "github_observed"
+            : userPendingCount > 0 || input.expectedOpenPrCountAfterMerge !== undefined || input.projectedCredibility !== undefined
+                ? "user_supplied"
+                : "gittensory_projection", afterPendingInput, computeScoreCore(afterPendingInput, repo, snapshot, contributorEvidence), [
+            userPendingCount > 0
+                ? `${userPendingCount} pending merged/closed PR(s) are treated as no longer open for this scenario${input.pendingScenarioObserved ? "" : " (caller-supplied)"}.`
+                : "No pending merge/close count was supplied; this scenario preserves current open PR pressure.",
+            ...(input.projectedCredibility !== undefined
+                ? [`Projected credibility is user-supplied as ${roundScore(projectedCredibility)}.`]
+                : userPendingCount > 0
+                    ? [`Projected credibility is raised to the current floor ${current.gates.credibilityFloor} because pending merges are expected to land.`]
+                    : []),
+            ...(input.scenarioNotes ?? []),
+        ], repo),
+        scenario("afterApprovedPrsMerge", "github_observed", afterApprovedInput, computeScoreCore(afterApprovedInput, repo, snapshot, contributorEvidence), [
+            observedApprovedCount > 0
+                ? `${observedApprovedCount} GitHub-observed approved or mergeable open PR(s) are treated as no longer open if they merge.`
+                : "No GitHub-observed approved or mergeable open PRs were available for this scenario.",
+            ...(observedApprovedCount > 0 ? [`Projected credibility is raised to the current floor ${current.gates.credibilityFloor} after observed mergeable work lands.`] : []),
+            ...observedScenarioNotes(input),
+        ], repo),
+        scenario("afterStalePrsClose", "github_observed", afterStaleInput, computeScoreCore(afterStaleInput, repo, snapshot, contributorEvidence), [
+            observedStaleCloseCount > 0
+                ? `${observedStaleCloseCount} GitHub-observed stale open PR(s) are treated as no longer open if they close or withdraw.`
+                : "No GitHub-observed stale open PRs were available for this scenario.",
+            ...(observedClosedCount > 0 ? [`${observedClosedCount} GitHub-observed already-closed PR(s) are excluded because they no longer contribute to open PR pressure.`] : []),
+            "Credibility is not increased in this scenario because stale cleanup is not the same as merged work.",
+            ...observedScenarioNotes(input),
+        ], repo),
+        scenario("linkedIssueFixed", "gittensory_projection", linkedIssueInput, computeScoreCore(linkedIssueInput, repo, snapshot, contributorEvidence), [
+            input.linkedIssueMode === "none" || !input.linkedIssueMode
+                ? "A standard linked-issue/no-issue rationale multiplier is projected as solved-by-PR validated."
+                : "Linked issue mode was already supplied; this scenario projects solved-by-PR validation where needed.",
+        ], repo),
+        scenario("bestReasonableCase", "gittensory_projection", bestReasonableInput, computeScoreCore(bestReasonableInput, repo, snapshot, contributorEvidence), [
+            "Combines plausible near-term gate cleanup: open PR pressure at threshold or below, open-issue spam pressure at threshold or below, credibility at floor or above, contributor merged-history and issue-discovery validity at floor or above, and linked-issue context where applicable.",
+            ...(input.scenarioNotes ?? []),
+            ...observedScenarioNotes(input),
+        ], repo),
+    ];
+}
+function observedScenarioNotes(input) {
+    return [
+        ...(nonNegative(input.observedDraftPrCount) > 0 ? [`${nonNegative(input.observedDraftPrCount)} draft PR(s) were excluded from likely-to-land projections.`] : []),
+        ...(nonNegative(input.observedBlockedPrCount) > 0 ? [`${nonNegative(input.observedBlockedPrCount)} blocked PR(s) were excluded from likely-to-land projections.`] : []),
+        ...(nonNegative(input.observedMaintainerPrCount) > 0 ? [`${nonNegative(input.observedMaintainerPrCount)} maintainer-lane PR(s) were kept out of outside-contributor projections.`] : []),
+        ...(input.observedScenarioNotes ?? []),
+    ];
+}
+function scenario(name, source, input, core, assumptions, repo) {
+    const blockedBy = blockedByFor(input, repo, core);
+    return {
+        name,
+        source,
+        assumptions,
+        scoreEstimate: core.scoreEstimate,
+        linkedIssueMultiplier: core.linkedIssueMultiplier,
+        gates: core.gates,
+        effectiveEstimatedScore: core.scoreEstimate.estimatedMergedScore,
+        underlyingPotentialScore: core.scoreEstimate.pendingSaturationScore,
+        blockedBy,
+        deltaExplanation: deltaExplanationFor(core, blockedBy),
+    };
+}
+function blockedByFor(input, repo, core, branchEligibility = normalizeBranchEligibility(input)) {
+    return [
+        ...(!repo?.isRegistered
+            ? [{ code: "repo_not_registered", severity: "blocker", detail: "Repository is not registered in the local Gittensory cache." }]
+            : []),
+        ...(core.laneMath.repoEmissionShare <= 0
+            ? [{ code: "inactive_allocation", severity: "blocker", detail: "Repository has no active allocation in the current registry snapshot." }]
+            : []),
+        ...(input.metadataOnly
+            ? [{ code: "metadata_only", severity: "context", detail: "Preview used metadata-only inputs, so token and density estimates are rough." }]
+            : []),
+        ...(branchEligibility.required && branchEligibility.status === "ineligible"
+            ? [
+                {
+                    code: "branch_ineligible",
+                    severity: "reducer",
+                    detail: "Branch eligibility is confirmed ineligible; linked-issue multiplier assumptions are disabled.",
+                },
+            ]
+            : []),
+        ...(branchEligibility.required && branchEligibility.status === "unknown"
+            ? [
+                {
+                    code: "branch_eligibility_missing",
+                    severity: "context",
+                    detail: branchEligibility.evidence === "missing"
+                        ? "Branch eligibility evidence is missing; refresh branch/base metadata before relying on linked-issue assumptions."
+                        : "Branch eligibility is unknown; refresh branch/base metadata before relying on linked-issue assumptions.",
+                },
+            ]
+            : []),
+        ...(!core.gates.baseTokenGatePassed
+            ? [{ code: "base_token_gate", severity: "blocker", detail: "Source token score does not pass the current base-score token gate." }]
+            : []),
+        ...(core.scoreEstimate.openPrMultiplier === 0
+            ? [
+                {
+                    code: "open_pr_threshold",
+                    severity: "blocker",
+                    detail: `Open PR count ${core.gates.openPrCount} exceeds threshold ${core.gates.openPrThreshold}.`,
+                },
+            ]
+            : []),
+        ...(core.scoreEstimate.openIssueMultiplier === 0
+            ? [
+                {
+                    code: "open_issue_threshold",
+                    severity: "blocker",
+                    detail: `Open issue count ${core.gates.openIssueCount} exceeds spam threshold ${core.gates.openIssueThreshold}.`,
+                },
+            ]
+            : []),
+        ...(core.scoreEstimate.mergedHistoryMultiplier === 0
+            ? [
+                {
+                    code: "merged_pr_history_floor",
+                    severity: "blocker",
+                    detail: `Merged PR count ${core.gates.mergedPullRequests} is below upstream floor ${core.gates.mergedPrFloor}.`,
+                },
+            ]
+            : []),
+        ...(core.scoreEstimate.issueDiscoveryHistoryMultiplier === 0
+            ? [
+                {
+                    code: "issue_discovery_validity_floor",
+                    severity: "blocker",
+                    detail: `Issue-discovery history (${core.gates.validSolvedIssues} valid solved, credibility ${roundScore(core.gates.issueCredibility)}) is below upstream floors (${core.gates.validSolvedIssuesFloor} valid solved, ${core.gates.issueCredibilityFloor} credibility).`,
+                },
+            ]
+            : []),
+        ...(core.gates.credibilityObserved < core.gates.credibilityFloor
+            ? [
+                {
+                    code: "credibility_floor",
+                    severity: "reducer",
+                    detail: `Credibility ${roundScore(core.gates.credibilityObserved)} is below floor ${core.gates.credibilityFloor}.`,
+                },
+            ]
+            : []),
+        ...(core.scoreEstimate.reviewPenaltyMultiplier < 1
+            ? [{ code: "review_penalty", severity: "reducer", detail: "Change-request history reduces the estimate." }]
+            : []),
+        ...(core.linkedIssueMultiplier.mode === "standard" && core.linkedIssueMultiplier.status === "invalid"
+            ? [
+                {
+                    code: "linked_issue_invalid",
+                    severity: "reducer",
+                    detail: core.linkedIssueMultiplier.reason,
+                },
+            ]
+            : []),
+        ...(core.linkedIssueMultiplier.mode === "standard" && ["raw", "plausible", "unavailable"].includes(core.linkedIssueMultiplier.status)
+            ? [
+                {
+                    code: "linked_issue_unvalidated",
+                    severity: "context",
+                    detail: core.linkedIssueMultiplier.reason,
+                },
+            ]
+            : []),
+        ...(nonNegative(input.observedStalePrCount) > 0
+            ? [
+                {
+                    code: "stale_work",
+                    severity: "reducer",
+                    detail: `${nonNegative(input.observedStalePrCount)} stale open PR(s) detected; consider closing stale work before opening new contributions.`,
+                },
+            ]
+            : []),
+        ...(nonNegative(input.duplicateRiskCount) > 0
+            ? [
+                {
+                    code: "duplicate_risk",
+                    severity: "reducer",
+                    detail: `${nonNegative(input.duplicateRiskCount)} duplicate-risk issue(s) or PR(s) detected; verify there is no conflicting work before proceeding.`,
+                },
+            ]
+            : []),
+    ];
+}
+function buildGateDeltas(current, scenarios) {
+    const currentScenario = scenarios[0];
+    /* v8 ignore next -- buildScenarioPreviews always emits a current scenario; this protects malformed adapters. */
+    if (!currentScenario)
+        return [];
+    const bestMatch = scenarios.find((scenarioPreview) => scenarioPreview.name === "bestReasonableCase");
+    /* v8 ignore next -- buildScenarioPreviews always emits bestReasonableCase; current is the defensive fallback. */
+    const best = bestMatch ?? currentScenario;
+    const linkedMatch = scenarios.find((scenarioPreview) => scenarioPreview.name === "linkedIssueFixed");
+    /* v8 ignore next -- buildScenarioPreviews always emits linkedIssueFixed; best is the defensive fallback. */
+    const linked = linkedMatch ?? best;
+    return [
+        ...(current.scoreEstimate.openPrMultiplier !== best.scoreEstimate.openPrMultiplier || current.gates.openPrCount !== best.gates.openPrCount
+            ? [
+                {
+                    gate: "open_pr_threshold",
+                    current: `${current.gates.openPrCount}/${current.gates.openPrThreshold} open PRs, multiplier ${current.scoreEstimate.openPrMultiplier}`,
+                    projected: `${best.gates.openPrCount}/${best.gates.openPrThreshold} open PRs, multiplier ${best.scoreEstimate.openPrMultiplier}`,
+                    explanation: `Open PR pressure changes estimated score ${current.scoreEstimate.estimatedMergedScore} -> ${best.scoreEstimate.estimatedMergedScore}.`,
+                },
+            ]
+            : []),
+        ...(current.scoreEstimate.openIssueMultiplier !== best.scoreEstimate.openIssueMultiplier || current.gates.openIssueCount !== best.gates.openIssueCount
+            ? [
+                {
+                    gate: "open_issue_threshold",
+                    current: `${current.gates.openIssueCount}/${current.gates.openIssueThreshold} open issues, multiplier ${current.scoreEstimate.openIssueMultiplier}`,
+                    projected: `${best.gates.openIssueCount}/${best.gates.openIssueThreshold} open issues, multiplier ${best.scoreEstimate.openIssueMultiplier}`,
+                    explanation: `Open issue spam pressure changes estimated score ${current.scoreEstimate.estimatedMergedScore} -> ${best.scoreEstimate.estimatedMergedScore}.`,
+                },
+            ]
+            : []),
+        ...(current.scoreEstimate.mergedHistoryMultiplier !== best.scoreEstimate.mergedHistoryMultiplier
+            ? [
+                {
+                    gate: "merged_pr_history_floor",
+                    current: `${current.gates.mergedPullRequests}/${current.gates.mergedPrFloor} merged PRs, multiplier ${current.scoreEstimate.mergedHistoryMultiplier}`,
+                    projected: `${best.gates.mergedPullRequests}/${best.gates.mergedPrFloor} merged PRs, multiplier ${best.scoreEstimate.mergedHistoryMultiplier}`,
+                    explanation: `Merged PR history changes estimated score ${current.scoreEstimate.estimatedMergedScore} -> ${best.scoreEstimate.estimatedMergedScore}.`,
+                },
+            ]
+            : []),
+        ...(current.scoreEstimate.issueDiscoveryHistoryMultiplier !== best.scoreEstimate.issueDiscoveryHistoryMultiplier
+            ? [
+                {
+                    gate: "issue_discovery_validity_floor",
+                    current: `${current.gates.validSolvedIssues} valid solved / ${roundScore(current.gates.issueCredibility)} credibility, multiplier ${current.scoreEstimate.issueDiscoveryHistoryMultiplier}`,
+                    projected: `${best.gates.validSolvedIssues} valid solved / ${roundScore(best.gates.issueCredibility)} credibility, multiplier ${best.scoreEstimate.issueDiscoveryHistoryMultiplier}`,
+                    explanation: `Issue-discovery validity changes estimated score ${current.scoreEstimate.estimatedMergedScore} -> ${best.scoreEstimate.estimatedMergedScore}.`,
+                },
+            ]
+            : []),
+        ...(current.gates.credibilityObserved !== best.gates.credibilityObserved || current.scoreEstimate.credibilityMultiplier !== best.scoreEstimate.credibilityMultiplier
+            ? [
+                {
+                    gate: "credibility_floor",
+                    current: `${roundScore(current.gates.credibilityObserved)} observed, multiplier ${current.scoreEstimate.credibilityMultiplier}`,
+                    projected: `${roundScore(best.gates.credibilityObserved)} projected, multiplier ${best.scoreEstimate.credibilityMultiplier}`,
+                    explanation: `Credibility changes estimated score ${current.scoreEstimate.estimatedMergedScore} -> ${best.scoreEstimate.estimatedMergedScore}.`,
+                },
+            ]
+            : []),
+        ...(current.scoreEstimate.issueMultiplier !== linked.scoreEstimate.issueMultiplier
+            ? [
+                {
+                    gate: "linked_issue_multiplier",
+                    current: `${current.scoreEstimate.issueMultiplier}`,
+                    projected: `${linked.scoreEstimate.issueMultiplier}`,
+                    explanation: `Linked issue/no-issue context changes estimated score ${current.scoreEstimate.estimatedMergedScore} -> ${linked.scoreEstimate.estimatedMergedScore}.`,
+                },
+            ]
+            : []),
+    ];
+}
+function warningsFor(input, repo, core, branchEligibility = normalizeBranchEligibility(input)) {
+    return [...new Set([...blockedByFor(input, repo, core, branchEligibility).map((blocker) => blocker.detail), ...core.linkedIssueMultiplier.warnings])];
+}
+function statusFor(repo, blockedBy, effectiveEstimatedScore, scenarios) {
+    if (!repo?.isRegistered || blockedBy.some((blocker) => blocker.code === "inactive_allocation"))
+        return "hold";
+    if (effectiveEstimatedScore > 0 && !blockedBy.some((blocker) => blocker.severity === "blocker"))
+        return "scoreable";
+    if (scenarios.some((scenarioPreview) => scenarioPreview.name !== "current" && scenarioPreview.effectiveEstimatedScore > effectiveEstimatedScore)) {
+        return "conditionally_scoreable";
+    }
+    return "blocked";
+}
+function deltaExplanationFor(core, blockedBy) {
+    if (blockedBy.length === 0)
+        return `Currently scoreable at ${core.scoreEstimate.estimatedMergedScore}; underlying potential ${core.scoreEstimate.pendingSaturationScore}.`;
+    return `Effective score ${core.scoreEstimate.estimatedMergedScore}; underlying potential ${core.scoreEstimate.pendingSaturationScore}; blocked or reduced by ${blockedBy.map((blocker) => blocker.code).join(", ")}.`;
+}
+// A label multiplier must be a positive, finite number (mirrors the validity rule signals/engine.ts's own
+// config-quality check already documents and enforces for its ADVISORY health score: "0, negative, NaN, or
+// Infinity are config errors that would silently misweight scoring"). That check only ever adjusted a
+// repo's informational config-quality score -- it never stopped an invalid value from reaching the REAL
+// scoring formula here, where `labelMultiplier` multiplies directly into `estimatedMergedScore`. A
+// registry-sourced label multiplier of 0 or a negative number is valid JSON and passed neither `numberValue`
+// (only applied to the scalar overrides, not this map) nor any check in this function, so it would zero out
+// or invert any PR/issue score for a matching label. Filtering here closes the gap where it actually matters.
+function isValidLabelMultiplier(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function selectLabelMultiplier(labels, multipliers, fallback) {
+    const normalized = labels.map((label) => label.toLowerCase());
+    const matched = Object.entries(multipliers).flatMap(([pattern, multiplier]) => {
+        if (!isValidLabelMultiplier(multiplier))
+            return [];
+        const matcher = labelPatternToRegExp(pattern.toLowerCase());
+        return normalized.some((label) => matcher.test(label)) ? [multiplier] : [];
+    });
+    return matched.length > 0 ? Math.max(...matched) : isValidLabelMultiplier(fallback) ? fallback : 1;
+}
+/** True when `label` matches the configured multiplier `pattern` under the SAME case-insensitive fnmatch glob
+ *  semantics scoring uses to resolve label multipliers (see {@link labelPatternToRegExp}). Exported so the
+ *  signals surfaces that audit configured label keys (config-quality, label-audit) match them as the GLOBS they
+ *  are: a `type:*` key must count `type:bug-fix` as observed/configured, not silently report it missing because
+ *  the literal pattern never appears verbatim on a real issue/PR. A literal key (no glob metacharacter) still
+ *  matches only its exact label, so existing configs behave identically. */
+export function labelMatchesPattern(label, pattern) {
+    return labelPatternToRegExp(pattern.toLowerCase()).test(label.toLowerCase());
+}
+// Compiled fnmatch→RegExp matchers are memoized by pattern. The same small,
+// config-derived set of label keys is matched on every scored PR/issue, so the
+// per-call recompile inside the nested label loops in engine.ts is pure waste.
+// Keys come from a repo's registryConfig.labelMultipliers, sourced from the externally-fetched gittensor
+// registry (registry/sync.ts + registry/normalize.ts, not a value this repo's own maintainer directly controls
+// via .gittensory.yml) — so the pattern SET is small per repo, but individual pattern CONTENT is untrusted, not
+// literally attacker-supplied-per-request the way GitHub PR content is. The wildcard-count cap below (#2456)
+// bounds a single pattern's compile cost; this cache is additionally bounded to a fixed max entry count and
+// evicted LRU, so a long-running isolate that observes many distinct registry snapshots over its life still
+// can't grow the cache unboundedly. The compiled RegExp carries only the "i" flag (no global/sticky `lastIndex`
+// state), so sharing one instance across calls is safe and byte-identical to recompiling on every call.
+export const LABEL_PATTERN_REGEXP_CACHE_MAX_ENTRIES = 256;
+const labelPatternRegExpCache = new Map();
+// A RegExp that never matches any input — mirrors change-guardrail.ts's identical NEVER_MATCHES fallback for an
+// over-complex pattern, so a pathological registry entry degrades to "this label multiplier never applies"
+// instead of hanging the scoring path that evaluates it.
+const LABEL_PATTERN_NEVER_MATCHES = /^(?!)$/;
+// Upstream resolves label multipliers by matching each configured key as a Python `fnmatch` GLOB, not a
+// literal string: `fnmatch(label.lower(), pattern.lower())` in
+// gittensor/validator/oss_contributions/label_resolution.py, so a repo can configure `type:*`, `kind/*`, or
+// `priority:?` and have it match `type:bug-fix`, `kind/bug`, `priority:1` (#1244-class scoring parity). The
+// preview previously did exact equality, so it silently scored every wildcard-configured trusted label at the
+// neutral default — under-/over-estimating the score for any repo using glob keys. Translate one fnmatch
+// pattern to an anchored, case-insensitive RegExp. fnmatch semantics differ from the path-glob in
+// change-guardrail.ts (there `*` stops at `/` and `?` is literal): labels are flat strings, so `*` matches any
+// run, `?` any single character, and `[seq]`/`[!seq]` a character class. Literal keys are unaffected — for a
+// pattern with no glob metacharacter the RegExp is an exact match, so existing configs score identically.
+function labelPatternToRegExp(pattern) {
+    const cached = labelPatternRegExpCache.get(pattern);
+    if (cached !== undefined) {
+        // Refresh recency on hit so the cache behaves as an LRU: the most-recently-matched patterns
+        // survive eviction, not just the most-recently-inserted ones.
+        labelPatternRegExpCache.delete(pattern);
+        labelPatternRegExpCache.set(pattern, cached);
+        return cached;
+    }
+    // Reuses change-guardrail.ts's wildcard-GROUP counting (a `*` here matches the same "any run of chars"
+    // semantics as that glob compiler's `*`, so the same catastrophic-backtracking risk and the same empirically-
+    // safe threshold apply) — an over-complex registry-sourced label_multipliers key degrades to a safe never-match
+    // instead of hanging RegExp.test() on an adversarial near-miss label (#2456). Reachable via the public
+    // score-preview API, the MCP tool, and the per-PR label-audit signal, so one bad registry entry could otherwise
+    // hang scoring for every PR on that repo.
+    if (hasUnsafeWildcardCount(pattern)) {
+        setLabelPatternRegExpCacheEntry(pattern, LABEL_PATTERN_NEVER_MATCHES);
+        return LABEL_PATTERN_NEVER_MATCHES;
+    }
+    let regex = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern.charAt(i);
+        i += 1;
+        if (char === "*") {
+            regex += ".*";
+        }
+        else if (char === "?") {
+            regex += ".";
+        }
+        else if (char === "[") {
+            const close = pattern.indexOf("]", i);
+            if (close === -1) {
+                // No closing bracket: fnmatch treats the `[` as a literal character.
+                regex += "\\[";
+            }
+            else {
+                const rawBody = pattern.slice(i, close);
+                if (rawBody === "" || rawBody === "!") {
+                    // Empty classes and bare `[!]` stay literal in Python fnmatch instead of compiling as classes.
+                    regex += `\\[${escapeRegExpLiteral(rawBody)}\\]`;
+                }
+                else if (hasDescendingCharacterRange(rawBody)) {
+                    // Python fnmatch treats invalid ranges like `[z-a]` as a never-match pattern; RegExp throws.
+                    regex += "(?!)";
+                }
+                else {
+                    let body = rawBody.replace(/\\/g, "\\\\");
+                    // `[!seq]` is fnmatch's negated class; RegExp spells negation as `[^seq]`.
+                    if (body.startsWith("!"))
+                        body = `^${body.slice(1)}`;
+                    else if (body.startsWith("^"))
+                        body = `\\${body}`;
+                    regex += `[${body}]`;
+                }
+                i = close + 1;
+            }
+        }
+        else if (/[.+^${}()|\]\\]/.test(char)) {
+            regex += `\\${char}`;
+        }
+        else {
+            regex += char;
+        }
+    }
+    const compiled = new RegExp(`^${regex}$`, "i");
+    setLabelPatternRegExpCacheEntry(pattern, compiled);
+    return compiled;
+}
+// Inserts a new (never-before-cached) entry, evicting the least-recently-used entry first if the
+// cache is already at its bound. Callers must only use this for keys not already present — refreshing
+// an existing key's recency on a cache hit is handled inline above via delete+set.
+function setLabelPatternRegExpCacheEntry(pattern, compiled) {
+    if (labelPatternRegExpCache.size >= LABEL_PATTERN_REGEXP_CACHE_MAX_ENTRIES) {
+        // Map iteration order is insertion order, so the first key is always the least-recently-used
+        // one (recency is refreshed via delete+set on every hit/insert). The map is non-empty here
+        // because size >= LABEL_PATTERN_REGEXP_CACHE_MAX_ENTRIES (a positive constant), so the loop body
+        // always runs exactly once.
+        for (const oldestPattern of labelPatternRegExpCache.keys()) {
+            labelPatternRegExpCache.delete(oldestPattern);
+            break;
+        }
+    }
+    labelPatternRegExpCache.set(pattern, compiled);
+}
+export function clearLabelPatternRegExpCacheForTest() {
+    labelPatternRegExpCache.clear();
+}
+export function labelPatternRegExpCacheKeysForTest() {
+    return [...labelPatternRegExpCache.keys()];
+}
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasDescendingCharacterRange(body) {
+    const start = body.startsWith("!") ? 1 : 0;
+    // Walk the class left-to-right, consuming each `X-Y` range as a unit so a range endpoint can't be
+    // misread as the start of a spurious second range. Only a genuinely inverted range like `[z-a]` — the
+    // case JS `RegExp` actually throws on — must degrade the class to never-match; a literal `-` that
+    // follows a completed range (as in `[a-z-9]`, a valid class) must NOT be suppressed. The prior scan
+    // flagged any `-` whose left neighbor outranked its right neighbor, so it wrongly killed `[a-z-9]`.
+    let i = start;
+    while (i < body.length) {
+        if (i + 2 < body.length && body.charAt(i + 1) === "-") {
+            if (body.charCodeAt(i) > body.charCodeAt(i + 2))
+                return true;
+            i += 3;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return false;
+}
+function decideLinkedIssueMultiplier(mode, context, constants, branchEligibility) {
+    const baseMultiplier = selectIssueMultiplier(mode, constants);
+    const issueNumbers = uniquePositiveInts(context?.issueNumbers ?? []);
+    const solvedByPullRequests = uniquePositiveInts(context?.solvedByPullRequests ?? []);
+    if (mode === "none") {
+        return {
+            mode,
+            status: "not_required",
+            source: "none",
+            eligible: false,
+            issueNumbers,
+            solvedByPullRequests,
+            baseMultiplier,
+            appliedMultiplier: 1,
+            reason: "No linked-issue multiplier mode was requested.",
+            warnings: [],
+        };
+    }
+    if (mode === "maintainer") {
+        return {
+            mode,
+            status: "not_required",
+            source: context?.source ?? "none",
+            eligible: true,
+            issueNumbers,
+            solvedByPullRequests,
+            baseMultiplier,
+            appliedMultiplier: baseMultiplier,
+            reason: "Maintainer-lane multiplier does not require solved-by-PR issue linkage.",
+            warnings: context?.warnings ?? [],
+        };
+    }
+    const projectedSolvedByPullRequestValidation = context?.[PROJECTED_SOLVED_BY_PULL_REQUEST_VALIDATION] === true;
+    const requestedStatus = context?.status ?? (solvedByPullRequests.length > 0 ? "validated" : issueNumbers.length > 0 ? "raw" : "unavailable");
+    const hasSolvedByPullRequestEvidence = solvedByPullRequests.length > 0 || projectedSolvedByPullRequestValidation;
+    const status = requestedStatus === "validated" && !hasSolvedByPullRequestEvidence ? (issueNumbers.length > 0 ? "raw" : "unavailable") : requestedStatus;
+    const source = context?.source ?? (status === "unavailable" ? "missing" : "user_supplied");
+    const branchEligible = isConfirmedBranchEligible(branchEligibility);
+    const eligible = status === "validated" && hasSolvedByPullRequestEvidence && branchEligible;
+    const reason = branchEligible || status !== "validated"
+        ? status === requestedStatus
+            ? context?.reason ?? linkedIssueReason(status, source, issueNumbers, solvedByPullRequests)
+            : linkedIssueReason(status, source, issueNumbers, solvedByPullRequests)
+        : branchEligibilityFailureReason(branchEligibility);
+    return {
+        mode,
+        status,
+        source,
+        eligible,
+        issueNumbers,
+        solvedByPullRequests,
+        baseMultiplier,
+        appliedMultiplier: eligible ? baseMultiplier : 1,
+        reason,
+        warnings: [...new Set([...linkedIssueWarnings(status), ...branchEligibility.warnings, ...(context?.warnings ?? [])])],
+    };
+}
+function isConfirmedBranchEligible(branchEligibility) {
+    return !branchEligibility.required || (branchEligibility.status === "eligible" && branchEligibility.evidence === "provided" && !branchEligibility.stale);
+}
+function branchEligibilityFailureReason(branchEligibility) {
+    if (branchEligibility.status === "ineligible")
+        return "Branch eligibility is confirmed ineligible; standard issue multiplier is not applied.";
+    if (branchEligibility.evidence === "missing")
+        return "Branch eligibility evidence is missing; standard issue multiplier is not applied.";
+    if (branchEligibility.status === "unknown")
+        return "Branch eligibility is unknown; standard issue multiplier is not applied.";
+    if (branchEligibility.stale)
+        return "Branch eligibility evidence is stale; standard issue multiplier is not applied.";
+    if (branchEligibility.source === "user_supplied")
+        return "Branch eligibility evidence is user-supplied; standard issue multiplier is not applied until verified metadata is available.";
+    return "Branch eligibility is not confirmed; standard issue multiplier is not applied.";
+}
+function withValidatedLinkedIssueScenario(input) {
+    const mode = input.linkedIssueMode ?? "none";
+    if (mode === "maintainer")
+        return input;
+    const issueNumbers = uniquePositiveInts(input.linkedIssueContext?.issueNumbers ?? []);
+    const solvedByPullRequests = uniquePositiveInts(input.linkedIssueContext?.solvedByPullRequests ?? []);
+    const linkedIssueContext = {
+        ...input.linkedIssueContext,
+        status: "validated",
+        source: input.linkedIssueContext?.source ?? "user_supplied",
+        issueNumbers,
+        solvedByPullRequests,
+        warnings: [],
+        [PROJECTED_SOLVED_BY_PULL_REQUEST_VALIDATION]: true,
+    };
+    return {
+        ...input,
+        linkedIssueMode: "standard",
+        linkedIssueContext,
+    };
+}
+/**
+ * Project the standard linked-issue multiplier decision under the assumption that a planned PR
+ * becomes the merged solver of the given issue(s). Reuses {@link decideLinkedIssueMultiplier} — the
+ * same eligibility rule used by buildScorePreview — so standalone validators stay consistent with
+ * the scoring engine. The numeric multiplier on the returned decision is private; callers that are
+ * public-safe should surface only `eligible`/`status`/`reason`.
+ */
+export function projectLinkedIssueMultiplierForPlannedSolve(issueNumbers) {
+    const branchEligibility = {
+        required: true,
+        status: "eligible",
+        evidence: "provided",
+        source: "user_supplied",
+        stale: false,
+        warnings: [],
+    };
+    const context = {
+        status: "validated",
+        source: "user_supplied",
+        issueNumbers: uniquePositiveInts(issueNumbers),
+        solvedByPullRequests: [],
+        warnings: [],
+        [PROJECTED_SOLVED_BY_PULL_REQUEST_VALIDATION]: true,
+    };
+    return decideLinkedIssueMultiplier("standard", context, {}, branchEligibility);
+}
+function linkedIssueReason(status, source, issueNumbers, solvedByPullRequests) {
+    const issues = issueNumbers.length > 0 ? ` for issue(s) ${issueNumbers.map((number) => `#${number}`).join(", ")}` : "";
+    if (status === "validated") {
+        const solvers = solvedByPullRequests.length > 0 ? ` via solved-by-PR ${solvedByPullRequests.map((number) => `#${number}`).join(", ")}` : "";
+        return `Linked issue context is solved-by-PR validated${issues}${solvers}.`;
+    }
+    if (status === "invalid")
+        return `Linked issue context is invalid${issues}; standard issue multiplier is not applied.`;
+    if (status === "plausible")
+        return `Linked issue context is plausible${issues}, but solved-by-PR validation is not available yet.`;
+    if (status === "unavailable")
+        return `Linked issue mirror/cache data is unavailable${issues}; standard issue multiplier is not applied until validation is available.`;
+    return `Raw linked issue reference${issues} has no solved-by-PR validation from ${source}.`;
+}
+function linkedIssueWarnings(status) {
+    if (status === "validated")
+        return [];
+    if (status === "invalid")
+        return ["Linked issue context is invalid; standard issue multiplier is not applied."];
+    if (status === "unavailable")
+        return ["Linked issue mirror/cache data is unavailable; standard issue multiplier is not applied until validation is available."];
+    if (status === "plausible")
+        return ["Linked issue context is plausible but not solved-by-PR validated; standard issue multiplier is not applied."];
+    return ["Raw linked issue reference has no solved-by-PR evidence; standard issue multiplier is not applied."];
+}
+function uniquePositiveInts(values) {
+    return [...new Set(values.filter((value) => Number.isInteger(value) && value > 0))].sort((left, right) => left - right);
+}
+function selectIssueMultiplier(mode, constants) {
+    if (mode === "maintainer")
+        return constant(constants, "MAINTAINER_ISSUE_MULTIPLIER");
+    if (mode === "standard")
+        return constant(constants, "STANDARD_ISSUE_MULTIPLIER");
+    return 1;
+}
+function normalizeBranchEligibility(input) {
+    const required = input.linkedIssueMode === "standard";
+    const supplied = input.branchEligibility;
+    if (!required) {
+        return {
+            required: false,
+            status: "not_required",
+            evidence: supplied ? "provided" : "missing",
+            source: supplied ? supplied.source ?? "user_supplied" : "missing",
+            reason: supplied?.reason,
+            checkedAt: supplied?.checkedAt,
+            stale: Boolean(supplied?.stale),
+            warnings: [],
+        };
+    }
+    if (!supplied) {
+        return {
+            required: true,
+            status: "unknown",
+            evidence: "missing",
+            source: "missing",
+            stale: false,
+            warnings: ["Branch eligibility evidence is missing; refresh branch/base metadata before relying on linked-issue assumptions."],
+        };
+    }
+    const status = supplied.status ?? "unknown";
+    const stale = Boolean(supplied.stale);
+    const warnings = [
+        ...(status === "ineligible" ? ["Branch eligibility is confirmed ineligible; linked-issue multiplier assumptions are disabled."] : []),
+        ...(status === "unknown" ? ["Branch eligibility is unknown; refresh branch/base metadata before relying on linked-issue assumptions."] : []),
+        ...(stale ? ["Branch eligibility evidence is stale; refresh branch/base metadata before relying on linked-issue assumptions."] : []),
+    ];
+    return {
+        required: true,
+        status,
+        evidence: "provided",
+        source: supplied.source ?? "user_supplied",
+        reason: supplied.reason,
+        checkedAt: supplied.checkedAt,
+        stale,
+        warnings,
+    };
+}
+function resolveMergedPullRequests(input, contributorEvidence) {
+    if (input.mergedPullRequests !== undefined)
+        return nonNegative(input.mergedPullRequests);
+    const fromEvidence = Number(contributorEvidence?.payload?.mergedPullRequests);
+    return Number.isFinite(fromEvidence) ? nonNegative(fromEvidence) : undefined;
+}
+function inferCredibility(evidence) {
+    const payload = evidence?.payload;
+    const merged = Number(payload?.mergedPullRequests ?? 0);
+    const stale = Number(payload?.stalePullRequests ?? 0);
+    const unlinked = Number(payload?.unlinkedPullRequests ?? 0);
+    // The payload is a loosely-typed cache (`Record<string, JsonValue>`), so any count can arrive as a
+    // non-numeric value. A non-finite `stale`/`unlinked` propagates NaN through the arithmetic below —
+    // and `clamp` cannot rescue NaN — poisoning the whole credibility multiplier and score, so guard all
+    // three counts, not just `merged`, falling back to the neutral credibility.
+    if (!Number.isFinite(merged) || !Number.isFinite(stale) || !Number.isFinite(unlinked))
+        return 0.8;
+    return clamp(0.75 + merged * 0.04 - stale * 0.03 - unlinked * 0.02, 0.25, 1);
+}
+function applyNonCodeLineCap(input, constants) {
+    const score = nonNegative(input.nonCodeTokenScore);
+    const lines = nonNegative(input.nonCodeLines);
+    if (score <= 0 || lines <= 0)
+        return score;
+    const maxLines = constant(constants, "MAX_LINES_SCORED_FOR_NON_CODE_EXT");
+    return lines <= maxLines ? score : score * (maxLines / lines);
+}
+function applyNonCodeCapToTotal(totalTokenScore, input, cappedNonCodeTokenScore) {
+    const total = nonNegative(totalTokenScore);
+    const nonCodeTokenScore = nonNegative(input.nonCodeTokenScore);
+    if (nonCodeTokenScore <= 0 || cappedNonCodeTokenScore >= nonCodeTokenScore)
+        return total;
+    return Math.max(0, total - (nonCodeTokenScore - cappedNonCodeTokenScore));
+}
+// Single source of truth (#812): the fallback for any constant is ALWAYS DEFAULT_SCORING_CONSTANTS — never
+// a duplicated literal at the call site. The live `constants` (snapshot.constants, which already merges
+// DEFAULT_SCORING_CONSTANTS with parsed upstream values) wins when present; otherwise the declared default
+// is used. This removes the duplicate-source-of-truth drift surface without changing any value (every
+// former call-site literal already matched its DEFAULT_SCORING_CONSTANTS entry).
+function constant(constants, key) {
+    const value = constants[key];
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    const fallback = DEFAULT_SCORING_CONSTANTS[key];
+    /* v8 ignore next -- defensive: every recognized key is in DEFAULT_SCORING_CONSTANTS; this guards typos/forward-compat. */
+    return typeof fallback === "number" && Number.isFinite(fallback) ? fallback : 0;
+}
+/**
+ * Resolve a repo's time-decay curve: each parameter is the repo's per-repo override (from the registry's
+ * `scoring.time_decay`) when present, else the global default constant from the live scoring snapshot.
+ * Mirrors upstream's `resolve_time_decay` (RepoTimeDecayConfig overlaid on the module constants).
+ *
+ * Parity note (#1320): upstream coerces ONLY `grace_period_hours` to an integer
+ * (`grace_period_hours=int(pick(...))`) while the three curve params stay floats. A maintainer may legally
+ * configure a fractional grace (upstream validates `0 <= grace_period_hours <= 168`), so the resolved grace
+ * must be truncated toward zero to match the validator — otherwise a PR aged between `trunc(grace)` and
+ * `grace` is treated as fresh in the preview but already decaying upstream.
+ */
+export function resolveTimeDecay(constants, overrides) {
+    return {
+        gracePeriodHours: clampGracePeriodHours(Math.trunc(pickOverride(overrides?.gracePeriodHours, constant(constants, "TIME_DECAY_GRACE_PERIOD_HOURS")))),
+        sigmoidMidpointDays: pickOverride(overrides?.sigmoidMidpointDays, constant(constants, "TIME_DECAY_SIGMOID_MIDPOINT")),
+        sigmoidSteepness: pickOverride(overrides?.sigmoidSteepness, constant(constants, "TIME_DECAY_SIGMOID_STEEPNESS_SCALAR")),
+        minMultiplier: clampMinMultiplier(pickOverride(overrides?.minMultiplier, constant(constants, "TIME_DECAY_MIN_MULTIPLIER"))),
+    };
+}
+// Documented bound (see the parity note above): upstream validates 0 <= grace_period_hours <= 168. The
+// override reaches this resolver via a bare Number.isFinite check (registry/normalize.ts's parseTimeDecayOverrides),
+// so an out-of-band value (negative, or beyond a week) would otherwise apply verbatim.
+const GRACE_PERIOD_HOURS_MIN = 0;
+const GRACE_PERIOD_HOURS_MAX = 168;
+function clampGracePeriodHours(value) {
+    return clamp(value, GRACE_PERIOD_HOURS_MIN, GRACE_PERIOD_HOURS_MAX);
+}
+// minMultiplier is the sigmoid's floor (calculateTimeDecay: Math.max(sigmoid, minMultiplier)), and the
+// sigmoid itself is always in (0, 1). A per-repo override above 1 would floor every aged PR ABOVE a fresh
+// PR's multiplier -- inverting time decay into an age bonus -- and a negative override applied verbatim
+// today has no floor semantics at all. Bound to the sigmoid's own range so the floor invariant always holds.
+const MIN_MULTIPLIER_MIN = 0;
+const MIN_MULTIPLIER_MAX = 1;
+function clampMinMultiplier(value) {
+    return clamp(value, MIN_MULTIPLIER_MIN, MIN_MULTIPLIER_MAX);
+}
+function pickOverride(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+/**
+ * Upstream gittensor's sigmoid time-decay multiplier (#703), ported verbatim from the validator's
+ * `calculate_time_decay` (gittensor/validator/utils/datetime_utils.py): for the first grace-period hours the
+ * multiplier is exactly 1.0 (hard cutoff); after that it follows a logistic on days-since-merge centred at
+ * the sigmoid midpoint (50% at that point), floored at the minimum multiplier. The curve params are
+ * resolved PER-REPO (overrides ?? snapshot defaults), so each maintainer's registry hyperparameters apply.
+ * Pure + deterministic.
+ */
+export function calculateTimeDecay(prAgeHours, constants, overrides) {
+    const { gracePeriodHours, sigmoidMidpointDays, sigmoidSteepness, minMultiplier } = resolveTimeDecay(constants, overrides);
+    if (!Number.isFinite(prAgeHours) || prAgeHours < gracePeriodHours)
+        return 1;
+    const days = prAgeHours / 24;
+    const sigmoid = 1 / (1 + Math.exp(sigmoidSteepness * (days - sigmoidMidpointDays)));
+    return Math.max(sigmoid, minMultiplier);
+}
+function saturationScore(sourceTokenScore, totalTokenScore, constants) {
+    // SRC_TOK_SATURATION_SCALE is per-repo overridable only within [10, 500] upstream; a snapshot value outside
+    // that band (a bad override, a parse glitch) would otherwise distort the saturation curve — at scale 1 the
+    // component saturates almost immediately, well above the documented floor. Clamp to the documented range so
+    // the curve stays within upstream bounds (the prior Math.max(...,1) only guarded the divide-by-zero edge).
+    const scale = clampSaturationScale(constant(constants, "SRC_TOK_SATURATION_SCALE"));
+    return (constant(constants, "MERGED_PR_BASE_SCORE") * (1 - Math.exp(-sourceTokenScore / scale)) +
+        saturationContributionBonus(totalTokenScore, constants));
+}
+function saturationContributionBonus(totalTokenScore, constants) {
+    return contributionBonusRamp(totalTokenScore, constants);
+}
+// Shared contribution-bonus ramp used by both scoring models so the saturation
+// and density bonuses cannot drift: clamp(totalTokenScore / FULL_BONUS, 0, 1)
+// scaled by MAX_CONTRIBUTION_BONUS (upstream default 5; single-sourced in model.ts, see #807/#812).
+function contributionBonusRamp(totalTokenScore, constants) {
+    return (clamp(totalTokenScore / constant(constants, "CONTRIBUTION_SCORE_FOR_FULL_BONUS"), 0, 1) *
+        constant(constants, "MAX_CONTRIBUTION_BONUS"));
+}
+function nonNegative(value) {
+    /* v8 ignore next -- API schemas and local scorers normalize numeric preview inputs before this defensive fallback. */
+    return Number.isFinite(value) ? Math.max(0, value ?? 0) : 0;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+// Bounds documented by upstream for the two repo-configurable scoring inputs the preview consumes directly.
+const FIXED_BASE_SCORE_MIN = 0;
+const FIXED_BASE_SCORE_MAX = 100;
+const SRC_TOK_SATURATION_SCALE_MIN = 10;
+const SRC_TOK_SATURATION_SCALE_MAX = 500;
+// A repo's fixed_base_score override forces base_score to a constant within [0, 100]. The value reaches the
+// preview unbounded above — the API schema only enforces `.min(0)` and registry normalization accepts any
+// finite number — so a misconfigured 150 would otherwise mint a base score above the model ceiling. Clamp to
+// the documented range; a non-finite/absent value falls through to the token-derived base score.
+function clampFixedBaseScore(value) {
+    return Number.isFinite(value) ? clamp(value, FIXED_BASE_SCORE_MIN, FIXED_BASE_SCORE_MAX) : undefined;
+}
+function clampSaturationScale(value) {
+    return clamp(value, SRC_TOK_SATURATION_SCALE_MIN, SRC_TOK_SATURATION_SCALE_MAX);
+}
+function roundScore(value) {
+    return Math.round(value * 10000) / 10000;
+}