@skyramp/mcp 0.3.6 → 0.3.8

package/build/recommendation/budgeters/shared.js

@@ -1,28 +1,76 @@
 import { TestType } from "../../types/TestTypes.js";
 import { inferScenarioType, prioritizeAttackSurfaceBundles } from "../diversity.js";
 import { externalDedupKeys, scenarioCoverageKeys, isAttackSurfaceSecurityBoundary, } from "../../prompts/test-recommendation/recommendationShared.js";
+import { isFlawTargetingCategory } from "../../types/TestRecommendation.js";
 import { logger } from "../../utils/logger.js";
 /**
- * Backend GENERATE slot count:
- *  - UI-only PR: 0 (all slots are UI placeholders)
- *  - Mixed PR:   maxGenerate - 1 (last slot reserved for a UI placeholder)
- *  - Backend-only PR: maxGenerate
+ * What each PR class GUARANTEES in GENERATE (SKYR-4275). These are floors, not
+ * quotas: the slots above them are open to either kind, decided by `pick`.
+ * An open slot goes to whichever candidate `pick` chooses on rank, so a backend
+ * candidate takes one when it outranks the UI candidates, not merely because it
+ * exists. Measured against main on random mixed pools at `maxGenerate` 5 with no
+ * caught bugs: 35% get fewer backend tests than main did, average 3.53 to 3.24.
+ *
+ * Backend-only floors nothing on purpose: of 86 backend-only diffs in the eval
+ * corpus, ZERO generated a UI test, so a floor there would guarantee what
+ * already happens every time.
+ *
+ * At one slot there is no room for a floor plus an open slot, so each class
+ * keeps that slot for its own kind.
+ *
+ * The floors always sum to at most `maxGenerate`, which is what lets
+ * `applyFloors` satisfy both without one starving the other.
  */
-export function backendGenerateCount(ctx) {
+export function generateFloors(ctx) {
+    // Number.isFinite, not Math.max: `Math.max(0, NaN)` is NaN, which compares
+    // false against 0 and would fall through to the class branches below.
+    const max = Number.isFinite(ctx.maxGenerate) ? Math.max(0, Math.floor(ctx.maxGenerate)) : 0;
+    if (max === 0)
+        return { ui: 0, backend: 0 };
     if (ctx.isUIOnlyPR)
-        return 0;
-    return ctx.hasFrontendChanges ? Math.max(0, ctx.maxGenerate - 1) : ctx.maxGenerate;
+        return { ui: max === 1 ? 1 : max - 1, backend: 0 };
+    if (ctx.hasFrontendChanges)
+        return max === 1 ? { ui: 1, backend: 0 } : { ui: 1, backend: 1 };
+    return { ui: 0, backend: 0 };
 }
-/** UI placeholder slots the render layer fills (UI-only → all; mixed → one). */
-export function reservedUISlots(ctx) {
-    if (ctx.isUIOnlyPR)
-        return ctx.maxGenerate;
-    return ctx.hasFrontendChanges && ctx.maxGenerate > 0 ? 1 : 0;
+/**
+ * Raise a chosen GENERATE set to meet the floors, by swapping rather than
+ * re-picking. `pick` runs ONCE over the whole pool, so its protected-first
+ * ordering, its one-slot-per-test-type coverage and attack-surface bundle
+ * adjacency are all settled before this runs. Picking each floor from its own
+ * slice instead would compute those guarantees per slice and collapse them —
+ * measured at 25% of mixed-PR inputs losing a test type, 8.3% losing contract
+ * coverage outright.
+ *
+ * A floor is raised only as far as the pool allows. Satisfying one floor cannot
+ * starve the other, because `generateFloors` never returns two that sum above
+ * the budget — `generateFloors.test.ts` pins that invariant.
+ */
+function applyFloors(generate, slotOrdered, floors, isUI) {
+    const isBackend = (item) => !isUI(item);
+    const result = [...generate];
+    for (const [want, wanted] of [
+        [floors.ui, isUI],
+        [floors.backend, isBackend],
+    ]) {
+        const spare = slotOrdered.filter((item) => wanted(item) && !result.includes(item));
+        let shortfall = Math.min(want, result.filter(wanted).length + spare.length) - result.filter(wanted).length;
+        // Swap from the END: `pick` returns its slots in preference order, so the
+        // last one it chose is the one this PR class needs least.
+        for (let i = result.length - 1; i >= 0 && shortfall > 0; i--) {
+            if (wanted(result[i]))
+                continue;
+            result[i] = spare.shift();
+            shortfall--;
+        }
+    }
+    return result;
 }
 /**
  * Split candidates by whether an external test already covers them. Protected
- * `bug_caught` / attack-surface scenarios always count as uncovered — they
- * require semantic flaw coverage the external test may not provide.
+ * `bug_caught` / `requirement_conflict` / attack-surface scenarios always count
+ * as uncovered — they require semantic flaw coverage the external test may not
+ * provide.
  *
  * A candidate is covered only when the set holds EVERY one of its keys. One
  * match is not coverage: a scenario exercising two changed endpoints would lose
@@ -44,8 +92,8 @@ function partitionByExternalCoverage(ranked, externalCoverage) {
             uncovered.push(item);
             continue;
         }
-        if (item.scenario.category === "bug_caught" || isAttackSurfaceSecurityBoundary(item.scenario)) {
-            logger.info(`External dedup: preserving "${item.scenario.scenarioName}" (${keys.join(", ")}) — protected bug/attack-surface scenario requires semantic flaw coverage`);
+        if (isFlawTargetingCategory(item.scenario.category) || isAttackSurfaceSecurityBoundary(item.scenario)) {
+            logger.info(`External dedup: preserving "${item.scenario.scenarioName}" (${keys.join(", ")}) — protected bug/requirement-conflict/attack-surface scenario requires semantic flaw coverage`);
             uncovered.push(item);
             continue;
         }
@@ -62,36 +110,27 @@ function partitionByExternalCoverage(ranked, externalCoverage) {
  * With `pick = roundRobinByType` this reproduces the pre-refactor selection in
  * diffExecutionPlan.ts exactly.
  */
-export function runBudget(ranked, ctx, pick) {
+export function runBudget(ranked, rawCtx, pick) {
+    // SKYR-4292: maxTotal is the budget; maxGenerate is how much of it to generate.
+    // Every producer clamps upstream (getTestbotPrompt, computeScoredCandidates,
+    // buildScopeAssessmentSection), but a state file is the tool boundary and can
+    // carry maxGenerate > maxTotal — the UI-only branch then reserved maxGenerate
+    // slots and planned more items than the total. Clamp once here so every
+    // budgeter agrees with the prompt. It must stay ABOVE generateFloors(ctx):
+    // the floors are computed from the clamped budget, and moving the clamp
+    // below them would let the floors sum past maxTotal again (review on #835).
+    const ctx = { ...rawCtx, maxGenerate: Math.min(rawCtx.maxGenerate, rawCtx.maxTotal) };
     const dropped = [];
-    const backend = backendGenerateCount(ctx);
-    const uiSlots = reservedUISlots(ctx);
+    const floors = generateFloors(ctx);
     const { uncovered, covered } = partitionByExternalCoverage(ranked, ctx.externalCoverage);
     const slotOrdered = prioritizeAttackSurfaceBundles(uncovered);
-    // When UI slots are reserved, keep UI candidates out of the backend pick so the
-    // reserved slot can always be filled below. Otherwise a high-ranked (e.g.
-    // CRITICAL) UI candidate could be consumed by the backend pick on a mixed PR,
-    // leaving the UI-promotion loop with nothing to promote and GENERATE short.
-    const backendSource = uiSlots > 0
-        ? slotOrdered.filter((item) => inferScenarioType(item.scenario) !== TestType.UI)
-        : slotOrdered;
-    const backendGenerate = pick(backendSource, Math.min(backend, backendSource.length));
-    // Fill the reserved UI slots the `pick` step leaves empty: the backend count
-    // is 0 on a UI-only PR (and maxGenerate-1 on a mixed PR), so UI candidates are
-    // never chosen above even though reservedUISlots budgets for them. Promote the
-    // top-ranked UI candidates not already chosen, up to the reserved count, so
-    // GENERATE is complete instead of an empty list plus a dropped count.
-    const chosen = new Set(backendGenerate);
-    const uiGenerate = [];
-    for (const item of slotOrdered) {
-        if (uiGenerate.length >= uiSlots)
-            break;
-        if (chosen.has(item) || inferScenarioType(item.scenario) !== TestType.UI)
-            continue;
-        uiGenerate.push(item);
-        chosen.add(item);
-    }
-    const generate = [...backendGenerate, ...uiGenerate];
+    const isUICandidate = (item) => inferScenarioType(item.scenario) === TestType.UI;
+    // ONE pick over the whole pool — the shape the backend pick always had — so
+    // `pick` decides protected-first order, per-type coverage and bundle adjacency
+    // exactly once. `applyFloors` then corrects only the UI/backend mix.
+    const budget = Number.isFinite(ctx.maxGenerate) ? Math.max(0, Math.floor(ctx.maxGenerate)) : 0;
+    const picked = pick(slotOrdered, Math.min(budget, slotOrdered.length));
+    const generate = applyFloors(picked, slotOrdered, floors, isUICandidate);
     // SKYR-4024. A covered candidate is one an existing test already reaches, so
     // generating a second test for it is wrong — maintenance updates the existing
     // one. But dropping it outright removed it from the RECOMMENDATIONS too, and an
@@ -100,24 +139,50 @@ export function runBudget(ranked, ctx, pick) {
     // one UI candidate fills the reserved slot while every covered backend
     // candidate would otherwise vanish.
     //
-    // Two conditions keep the reserve shut where recommending nothing is right.
-    // Backend slots must exist, so a UI-only PR is left alone. And the PR must not
-    // touch a test file of its own: coverage is read from the working tree, and a
-    // test file without the Skyramp marker counts as external, so a PR that adds
-    // its own tests would have that coverage used as grounds to recommend
-    // duplicates of it.
-    const spendReserve = backendGenerate.length === 0 && backend > 0 && covered.length > 0 && !ctx.diffChangesTestFiles;
+    // Three conditions keep the reserve shut where recommending nothing is right.
+    // A UI-only PR is left alone. A zero budget is an explicit abstention, so it
+    // must not be talked out of recommending nothing. And the PR must not touch a
+    // test file of its own: coverage is read from the working tree, and a test
+    // file without the Skyramp marker counts as external, so a PR that adds its
+    // own tests would have that coverage used as grounds to recommend duplicates
+    // of it.
+    //
+    // One pick over the whole pool leaves no "backend half" to count, so the
+    // emptiness test reproduces what that half used to mean per class. On a mixed
+    // PR the UI slot must not read as backend coverage, or a covered backend
+    // candidate vanishes behind it. On a backend-only PR the pick always drew from
+    // the whole pool, so a non-empty GENERATE closed the reserve even when every
+    // item was UI — keep that, or an all-UI pool opens a reserve it never opened.
+    const backendChosen = generate.filter((item) => !isUICandidate(item));
+    const backendHalfEmpty = ctx.hasFrontendChanges
+        ? backendChosen.length === 0
+        : generate.length === 0;
+    // One per-class behaviour DID change here, deliberately. On a mixed PR at a
+    // budget of 1 the old gate also required `backendGenerateCount > 0`, which is
+    // 0 for that class, so a covered backend candidate was dropped outright. The
+    // reserve exists because dropping removes a candidate from the
+    // RECOMMENDATIONS too (SKYR-4024), and a budget of 1 is the case where that
+    // costs most — there is no second slot to find it later. It is now
+    // recommended instead of dropped. `reserveOpensForMixedPRAtBudgetOne` in
+    // shared.test.ts pins it, so a future change has to mean it.
+    const spendReserve = backendHalfEmpty &&
+        !ctx.isUIOnlyPR &&
+        budget > 0 &&
+        covered.length > 0 &&
+        !ctx.diffChangesTestFiles;
     if (spendReserve) {
         logger.info(`External dedup: GENERATE empty after dedup — recommending ${covered.length} held-back candidate(s) as ADDITIONAL rather than approving an empty plan`);
     }
     else if (covered.length > 0) {
         // SKYR-4214. The reserve stayed shut, so these really are dropped — say so,
         // with the reason, instead of leaving the agent an unexplained short list.
-        const reason = backendGenerate.length > 0
-            ? `the backend half of GENERATE is filled (${backendGenerate.length})`
-            : backend === 0
-                ? "no backend slots (UI-only PR)"
-                : "the PR changes test files of its own";
+        const reason = !backendHalfEmpty
+            ? `the backend half of GENERATE is filled (${backendChosen.length || generate.length})`
+            : ctx.isUIOnlyPR
+                ? "a UI-only PR keeps its slots for UI"
+                : budget === 0
+                    ? "the budget is zero"
+                    : "the PR changes test files of its own";
         logger.info(`External dedup: dropping ${covered.length} covered candidate(s) — reserve shut because ${reason}`);
         for (const { item, keys } of covered) {
             dropped.push({
@@ -142,6 +207,7 @@ export function runBudget(ranked, ctx, pick) {
     const additionalSource = spendReserve
         ? [...slotOrdered, ...prioritizeAttackSurfaceBundles(covered.map((c) => c.item))]
         : slotOrdered;
+    const chosen = new Set(generate);
     const notChosen = additionalSource.filter((it) => !chosen.has(it));
     const remainingBudget = Math.max(0, ctx.maxTotal - generate.length);
     const generatedCoverage = new Set(generate.flatMap((item) => scenarioCoverageKeys(item.scenario)));
@@ -149,6 +215,18 @@ export function runBudget(ranked, ctx, pick) {
         const keys = scenarioCoverageKeys(item.scenario);
         if (keys.length === 0 || !keys.every((key) => generatedCoverage.has(key)))
             return true;
+        // Same exemption the EXTERNAL dedup above already makes, for the same
+        // reason: a flaw-targeting scenario (a caught bug, or a requirement the code
+        // contradicts) or an attack-surface boundary asserts a specific defect, and
+        // sharing an endpoint with a GENERATE item is not evidence that the defect is
+        // covered. Without it a PR with two defects in one handler had its second one
+        // deleted here — the first took a GENERATE slot, and the key is method +
+        // resource + test type + interaction + status, which two tests on one
+        // endpoint share.
+        if (isFlawTargetingCategory(item.scenario.category) || isAttackSurfaceSecurityBoundary(item.scenario)) {
+            logger.info(`GENERATE dedup: preserving "${item.scenario.scenarioName}" (${keys.join(", ")}) — protected bug/requirement-conflict/attack-surface scenario requires semantic flaw coverage`);
+            return true;
+        }
         dropped.push({
             candidateId: item.candidateId,
             reason: `covered by GENERATE (${keys.join(", ")})`,
@@ -164,5 +242,5 @@ export function runBudget(ranked, ctx, pick) {
     }
     // Budgeting itself produces no demotions; the register-plan selection stage
     // (planRanker.selectPlan) fills this channel from discriminator verification.
-    return { generate, additional, reservedUISlots: uiSlots, demotions: [], dropped };
+    return { generate, additional, reservedUISlots: floors.ui, demotions: [], dropped };
 }

package/build/recommendation/planRanker.d.ts

@@ -4,8 +4,10 @@ import { ScenarioCategory } from "../types/TestRecommendation.js";
 export interface RankOptions {
     /**
      * Categories that take the top carve-out tier ahead of everything else.
-     * Defaults to the `CATEGORY_PRIORITY === "CRITICAL"` categories (bug_caught only —
-     * new_endpoint is MEDIUM, not carved out). Exposed so phase 2 can tune the carve-out
+     * Defaults to the `CATEGORY_PRIORITY === "CRITICAL"` categories (bug_caught and
+     * requirement_conflict — new_endpoint is MEDIUM, not carved out). The two CRITICAL
+     * categories are carved out independently, so a requirement conflict never competes
+     * with a code-review bug for one slot. Exposed so phase 2 can tune the carve-out
      * WITHOUT reintroducing the agent's priority tag as a ranking input.
      */
     carveOutCategories?: ScenarioCategory[];
@@ -32,7 +34,7 @@ export interface SelectPlanContext extends BudgetContext {
  * independent of input order (the final tiebreak is the stable `candidateId`).
  *
  * Ordering (highest first):
- *   1. Carve-out — CRITICAL-category scenarios (bug_caught), preserving the
+ *   1. Carve-out — CRITICAL-category scenarios (bug_caught, requirement_conflict), preserving the
  *      protected-first convention of `roundRobinByType` /
  *      `prioritizeAttackSurfaceBundles`.
  *   2. Verified discriminators — candidates whose declared discriminator survived

package/build/recommendation/planRanker.js

@@ -14,7 +14,7 @@ const DEFAULT_CARVE_OUT_CATEGORIES = Object.keys(CATEGORY_PRIORITY).filter((cate
  * independent of input order (the final tiebreak is the stable `candidateId`).
  *
  * Ordering (highest first):
- *   1. Carve-out — CRITICAL-category scenarios (bug_caught), preserving the
+ *   1. Carve-out — CRITICAL-category scenarios (bug_caught, requirement_conflict), preserving the
  *      protected-first convention of `roundRobinByType` /
  *      `prioritizeAttackSurfaceBundles`.
  *   2. Verified discriminators — candidates whose declared discriminator survived

package/build/services/TestGenerationService.js

@@ -7,13 +7,14 @@ import { extractPathname, resolveQueryParamsForPath, contributesNothing, } from
 import { getPathParameterValidationError, OUTPUT_DIR_FIELD_NAME, PATH_PARAMS_FIELD_NAME, QUERY_PARAMS_FIELD_NAME, FORM_PARAMS_FIELD_NAME, validateParams, validatePath, validateRequestData, } from "../utils/utils.js";
 import { getEntryPoint } from "../utils/telemetry.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
-import { TestType } from "../types/TestTypes.js";
+import { ASSERTION_ENHANCEABLE_TEST_TYPES, TestType, MOCK_TYPE, } from "../types/TestTypes.js";
 import { logger } from "../utils/logger.js";
 import { normalizeLanguageParams } from "../utils/normalizeParams.js";
 import { stageGeneratedPaths, resolveOutputDir } from "../utils/gitStaging.js";
 import { isInsideExecutorWorkDir, executorWorkDirRefusal, generationTargets, } from "../utils/executorWorkDir.js";
 import { getTestsRepoDir } from "../utils/AnalysisStateManager.js";
 import { recordReuseHandOff } from "../tools/code-refactor/reuse-state.js";
+import { recordAssertionBaseline } from "../tools/code-refactor/assertion-state.js";
 import { isModularizeFirstTarget } from "../utils/reuseRouting.js";
 /**
  * Derive the framework actually used for generation from the (normalized)
@@ -106,7 +107,20 @@ export class TestGenerationService {
             // The files this call wrote, as codegen reports them — the reuse hand-off is
             // recorded per FILE (SKYR-4220).
             const written = generatedFilesFrom(result);
+            // Seed the assertion-enhancement baseline SERVER-SIDE at generation time
+            // (same pattern as recordReuseHandOff below): the execute-time
+            // verification gate arms even if the agent never calls
+            // skyramp_enhance_assertions at all — the last prompt-mediated entry
+            // point. Best-effort; no run state means the gate stays open as before.
             const testType = this.getTestType();
+            if (params.enhanceAssertions &&
+                testType !== MOCK_TYPE &&
+                ASSERTION_ENHANCEABLE_TEST_TYPES.includes(testType) &&
+                (testType !== TestType.CONTRACT || params.providerMode !== false)) {
+                for (const file of written) {
+                    await recordAssertionBaseline(file, testType, "generation");
+                }
+            }
             const languageSteps = getLanguageSteps({
                 language: params.language || "",
                 testType: testType,

package/build/tools/code-refactor/assertion-state.d.ts

@@ -0,0 +1,91 @@
+import { type AssertionBaseline, type AssertionEnhanceType, type AssertionVerifyResult } from "../../utils/assertion-verify/index.js";
+import type { AssertionOutcome, AssertionRecord } from "../../types/AssertionOutcome.js";
+import type { TestType } from "../../types/TestTypes.js";
+import type { RepoCheckout } from "../../utils/reportVerification.js";
+/**
+ * Persistence for the assertion-enhancement verification loop, keyed by the
+ * spec's CANONICAL absolute path in `UnifiedAnalysisState.assertionOutcomes`.
+ * Path keying (not basename, unlike reuseOutcomes — nothing here needs to
+ * match report rows) removes the multi-repo basename-collision class outright,
+ * and canonicalization closes the alias bypass: `dir//x.spec.ts` and
+ * `dir/./x.spec.ts` must hit the same record as `dir/x.spec.ts`.
+ *
+ * Every write is best-effort: verification must never be able to fail an
+ * enhancement that otherwise succeeded, so a missing/unreadable state file
+ * degrades to stateless checks and open gates — always with a warning.
+ */
+/** Canonical identity of a test file — all keying and ownership comparisons
+ *  go through this so a non-normalized agent-supplied path cannot fork or
+ *  bypass a record. realpath also collapses symlinked directories; a path
+ *  that does not (yet) exist falls back to plain resolution. */
+export declare function canonicalTestPath(testFile: string): string;
+/** A record only counts for `testFile` when its stored path canonicalizes to
+ *  the same spec — the single home for the ownership invariant (previously
+ *  copied in baselineFrom, recordAssertionVerdict, and the enhance tool). */
+export declare function trustedRecord(record: AssertionRecord | undefined, testFile: string): AssertionRecord | undefined;
+/** One spec's record, or undefined when there is no run state / no record. */
+export declare function readAssertionRecord(testFile: string, explicitStateFile?: string): Promise<AssertionRecord | undefined>;
+/**
+ * Snapshot the file at instruction hand-out time — the baseline verify measures
+ * against. Keep-first rule: while no Passed verdict exists for the same file and
+ * enhanceType, a repeat hand-out does NOT re-baseline (re-calling the tool after
+ * half-editing must not shrink the required delta). A hand-out after a Passed
+ * verdict, or with a different enhanceType, starts a new enhancement round.
+ */
+export declare function recordAssertionBaseline(testFile: string, testType: TestType, enhanceType: AssertionEnhanceType, explicitStateFile?: string): Promise<void>;
+/** The baseline verify measures against, from a record; undefined when the
+ *  record carries no snapshot or belongs to a different canonical path. */
+export declare function baselineFrom(record: AssertionRecord | undefined, testFile: string): AssertionBaseline | undefined;
+/** Record what one verify pass established. The verdict is written to the
+ *  state file the record actually LIVES in (not blindly to the explicit path —
+ *  a mismatched `stateFile` would otherwise split verdict from baseline).
+ *  Never writes onto a record owned by a different canonical path, and never
+ *  fails silently. */
+export declare function recordAssertionVerdict(testFile: string, result: AssertionVerifyResult, explicitStateFile?: string): Promise<void>;
+/**
+ * Deterministic execute-time verification: skyramp_execute_test calls this
+ * itself, so the check runs whether or not the agent ever called `verify: true`
+ * — a prose instruction can be ignored, a server-side call cannot. Returns the
+ * feedback text when the assertions are insufficient (the caller returns it
+ * instead of executing), or undefined to proceed.
+ *
+ * Self-clearing: the checks run on the file's CURRENT content, so fixing the
+ * assertions and re-executing passes — no separate verify call is required.
+ * Skipped once a verdict has PASSED: sanctioned later rewrites (a `.raw.bak`
+ * restore during execution fix-up) would otherwise false-fail the differential
+ * gates. Modularization needs no special handling: the shared-helper policy
+ * keeps every value assertion in the test body, so the baseline comparison
+ * stays valid across it. Fails open on no baseline and unreadable state/file.
+ */
+export declare function assertionFeedbackForExecution(testFile: string, explicitStateFile?: string): Promise<string | undefined>;
+/**
+ * Count one execution of this spec (called by skyramp_execute_test after its
+ * gates pass, best-effort). Creates a minimal record when none exists so an
+ * executed-but-never-enhanced spec is still visible to the report cross-check.
+ */
+export declare function recordAssertionExecution(testFile: string, testType: TestType, explicitStateFile?: string): Promise<void>;
+/** A repo checkout as listRepoCheckouts returns it — the canonical type from
+ *  reportVerification, re-exported (a local re-declaration had drifted:
+ *  `root` weakened to optional, forcing a redundant guard at each use). */
+export type RepoCheckoutRef = RepoCheckout;
+/** The record for a report row, matched by the canonical-path keys' basenames
+ *  and then GUARDED: the record's testType must match the row's, and when the
+ *  run's checkouts are known, the record's path must live in the row's repo
+ *  (primary when the row names none). Without the guards, a basename shared
+ *  across repos published one spec's proof-of-work under another's name — and
+ *  the victim was exactly the never-enhanced spec the field exists to expose.
+ *  Ambiguity after filtering still fails open: wrong attribution is worse
+ *  than omission. */
+export declare function findAssertionRecordByFileName(outcomes: Record<string, AssertionRecord>, row: {
+    fileName: string;
+    testType?: string;
+    repository?: string;
+}, checkouts: RepoCheckoutRef[]): AssertionRecord | undefined;
+/**
+ * Report-facing proof-of-work summary re-derived from the spec as delivered
+ * NOW — final metrics come from the file, not from verify-time state, so
+ * post-verify edits cannot publish stale counts. Always returns the status
+ * fields (verification, declinedReason, executionCount — they come from the
+ * record); the metric fields are omitted when the file cannot supply them.
+ */
+export declare function rederiveAssertionOutcome(record: AssertionRecord): Promise<AssertionOutcome>;