@skyramp/mcp 0.3.1 → 0.3.2-rc.pom-2

package/build/tools/submitReportTool.js

@@ -9,6 +9,23 @@ import { DriftAction } from "../types/TestAnalysis.js";
 import { TestExecutionStatus } from "../types/TestExecution.js";
 import { StateManager } from "../utils/AnalysisStateManager.js";
 import { toolError, testFileMatches } from "../utils/utils.js";
+import { matchesApprovedPlan } from "../utils/planMatchKeys.js";
+import { isTestbotEnabled } from "../utils/featureFlags.js";
+import { findUnbackedClaims, listChangedFiles } from "../utils/reportVerification.js";
+// SKYR-3879 Path B: which testTypes the register-plan checkpoint gates. Mirrors
+// the generation tools actually wired to planGuard (batch-scenario/integration,
+// contract) — UI and E2E are on a separate blueprint-grounded pipeline and are
+// NOT gated at generation time (see planGuard.ts wiring), so they are excluded
+// here too rather than surprising the agent with a report-time-only gate.
+const PLAN_GATED_TEST_TYPES = new Set([TestType.CONTRACT, TestType.INTEGRATION]);
+/** Split an `endpoint` field ("GET /api/v1/products") into method + path. */
+function parseEndpointField(endpoint) {
+    const trimmed = (endpoint ?? "").trim();
+    const spaceIdx = trimmed.indexOf(" ");
+    if (spaceIdx <= 0)
+        return { path: trimmed || undefined };
+    return { method: trimmed.slice(0, spaceIdx), path: trimmed.slice(spaceIdx + 1).trim() };
+}
 // Drift actions that actually modify a test file. VERIFY and IGNORE are
 // no-ops (the test was assessed but left unchanged), so they must not count
 // toward "tests maintained" telemetry.
@@ -430,6 +447,33 @@ export function registerSubmitReportTool(server) {
                 "Call skyramp_actions (with recommendations: [] if no existing tests needed action) before skyramp_submit_report.");
             return errorResult;
         }
+        // SKYR-3879 Path B: every gated newTestsCreated entry (contract/integration —
+        // the testTypes actually wired to planGuard) must be admissible under the
+        // approved plan from skyramp_register_test_plan — the same predicate the
+        // generation-tool gate uses (GENERATE, or ADDITIONAL backfill when GENERATE
+        // is non-empty), so a generation the gate permitted is never rejected at
+        // report time. Absent approvedPlan (register tool never ran / never
+        // pre-seeded anything) → no check, back-compat.
+        if (stateData.approvedPlan) {
+            const approvedPlan = stateData.approvedPlan;
+            const unapproved = dedupedNewTests.filter((t) => {
+                if (!PLAN_GATED_TEST_TYPES.has(t.testType))
+                    return false;
+                const { method, path } = parseEndpointField(t.endpoint);
+                return !matchesApprovedPlan(approvedPlan, { testType: t.testType, method, path });
+            });
+            if (unapproved.length > 0) {
+                const approvedList = approvedPlan.generate.length > 0
+                    ? approvedPlan.generate.map((item) => `[${item.testType}] ${item.scenarioName}`).join(", ")
+                    : "(none)";
+                errorResult = toolError(`${unapproved.length} newTestsCreated entr${unapproved.length === 1 ? "y" : "ies"} not in the approved plan from ` +
+                    `skyramp_register_test_plan (plan ${approvedPlan.planId}) — neither its GENERATE list nor its ADDITIONAL backfill pool: ` +
+                    `${unapproved.map((t) => `${t.testId} (${t.testType} ${t.endpoint})`).join(", ")}. ` +
+                    `Approved GENERATE items: ${approvedList}. Call skyramp_register_test_plan to register this test before reporting it, ` +
+                    `or remove it from newTestsCreated.`);
+                return errorResult;
+            }
+        }
         // TestbotReport.testMaintenance has no repository field, so a related repo's
         // reconciled verdicts have nowhere to go in this report. Fail loud instead of
         // silently omitting real maintenance work skyramp_actions already did and persisted.
@@ -493,6 +537,40 @@ export function registerSubmitReportTool(server) {
                 "Add a testMaintenanceDetails entry with the missing field(s), drafted from the execution output you already saw.");
             return errorResult;
         }
+        // SKYR-3883: in a testbot run, refuse to ship a report that claims file work
+        // the working tree doesn't reflect. The delivery step can only commit what the
+        // agent actually created/edited, so a report claiming otherwise erodes trust
+        // (a reviewer believes maintenance happened that never landed). Fail loudly so
+        // the agent makes the edit — or drops the claim — instead of hallucinating it.
+        // Only the working tree exists at report time (delivery commits later), so we
+        // verify against created/modified/untracked paths, not the eventual commit.
+        if (isTestbotEnabled()) {
+            const fullState = await stateManager.readFullState();
+            const repoRoot = fullState?.metadata?.repositoryPath;
+            if (repoRoot && repoRoot !== "unknown") {
+                try {
+                    const changedFiles = await listChangedFiles(repoRoot);
+                    const unbacked = findUnbackedClaims({
+                        repoRoot,
+                        changedFiles,
+                        newTests: dedupedNewTests,
+                        verdicts: stateData.maintenanceVerdicts ?? [],
+                        primaryRepository: fullState?.metadata?.repository,
+                    });
+                    if (unbacked.length > 0) {
+                        errorResult = toolError(`${unbacked.length} report claim(s) are not backed by any change in the working tree — ` +
+                            `Testbot will not report file work that hasn't actually been made. Make the edit (or remove the claim), then resubmit:\n` +
+                            unbacked.map((u) => `  - ${u}`).join("\n"));
+                        return errorResult;
+                    }
+                }
+                catch (err) {
+                    // Never block a valid report because verification itself failed (path not a
+                    // git repo, git unavailable) — degrade to a warning instead of false-rejecting.
+                    logger.warning(`Skipping report/working-tree verification (could not enumerate changes): ${err.message}`);
+                }
+            }
+        }
         // Strip generation-artifact fields from newTestsCreated before writing.
         // scenarioFile, traceFile, frontendTrace are internal paths used during
         // generation — downstream scoring scripts don't expect them and fail if

package/build/tools/submitReportTool.test.js

@@ -6,6 +6,7 @@ import { TestExecutionStatus } from "../types/TestExecution.js";
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
+import { execFileSync } from "child_process";
 import { z } from "zod";
 jest.unstable_mockModule("../utils/logger.js", () => ({
     logger: { info: jest.fn(), error: jest.fn(), warning: jest.fn(), debug: jest.fn() },
@@ -16,6 +17,7 @@ jest.unstable_mockModule("../services/AnalyticsService.js", () => ({
 // @ts-ignore
 const { registerSubmitReportTool, additionalRecommendationSchema, newTestSchema, targetElementSchema, pageContextSchema } = await import("./submitReportTool.js");
 const { AnalyticsService } = await import("../services/AnalyticsService.js");
+const { CandidateSource } = await import("../types/Recommendation.js");
 const pushMCPToolEventMock = AnalyticsService.pushMCPToolEvent;
 function captureToolHandler() {
     let handler;
@@ -1170,4 +1172,257 @@ describe("registerSubmitReportTool", () => {
             expect(result.content[0].text).not.toContain("beforeDetails");
         });
     });
+    describe("approvedPlan cross-check (SKYR-3879 Path B)", () => {
+        async function writeStateFileWithPlan(dir, approvedPlan) {
+            const stateFile = path.join(dir, "analyze-changes-state.json");
+            await fs.writeFile(stateFile, JSON.stringify({
+                existingTests: [],
+                maintenanceVerdicts: [],
+                ...(approvedPlan ? { approvedPlan } : {}),
+                metadata: sampleMetadata(dir),
+            }), "utf-8");
+            return stateFile;
+        }
+        const APPROVED_PLAN = {
+            planId: "plan-42",
+            createdAt: "2026-01-01T00:00:00.000Z",
+            generate: [
+                {
+                    candidateId: "products-search-abcd1234",
+                    scenarioName: "products_search",
+                    testType: "contract",
+                    category: "business_rule",
+                    source: CandidateSource.AGENT,
+                    matchKeys: ["name:products-search", "ep:contract:GET:/api/v1/products/search"],
+                },
+            ],
+            additional: [],
+            demotions: [],
+        };
+        function contractNewTest(overrides = {}) {
+            return {
+                testId: "contract-get-products-search",
+                testType: TestType.CONTRACT,
+                category: "business_rule",
+                endpoint: "GET /api/v1/products/search",
+                fileName: "products_search_contract_test.py",
+                description: "Searches products and asserts the response schema.",
+                reasoning: "Validates the contract for the new search endpoint.",
+                ...overrides,
+            };
+        }
+        it("passes when every gated newTestsCreated entry matches an approved GENERATE item", async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+            tmpDirs.push(tmpDir);
+            const outputFile = path.join(tmpDir, "report.json");
+            const stateFile = await writeStateFileWithPlan(tmpDir, APPROVED_PLAN);
+            const result = await handler({
+                summaryOutputFile: outputFile,
+                stateFile,
+                businessCaseAnalysis: "Adds product search.",
+                newTestsCreated: [contractNewTest()],
+                testResults: [],
+                issuesFound: [],
+            });
+            expect(result.isError).toBeUndefined();
+        });
+        it("rejects an unapproved gated entry, naming the offending entry and the approved list", async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+            tmpDirs.push(tmpDir);
+            const outputFile = path.join(tmpDir, "report.json");
+            const stateFile = await writeStateFileWithPlan(tmpDir, APPROVED_PLAN);
+            const result = await handler({
+                summaryOutputFile: outputFile,
+                stateFile,
+                businessCaseAnalysis: "Adds an unregistered contract test.",
+                newTestsCreated: [
+                    contractNewTest({
+                        testId: "contract-get-products-unregistered",
+                        endpoint: "GET /api/v1/products/unregistered",
+                    }),
+                ],
+                testResults: [],
+                issuesFound: [],
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("plan-42");
+            expect(result.content[0].text).toContain("contract-get-products-unregistered");
+            expect(result.content[0].text).toContain("products_search");
+        });
+        it("accepts a gated entry matching an approved ADDITIONAL item — backfill parity with planGuard", async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+            tmpDirs.push(tmpDir);
+            const outputFile = path.join(tmpDir, "report.json");
+            const stateFile = await writeStateFileWithPlan(tmpDir, {
+                ...APPROVED_PLAN,
+                additional: [
+                    {
+                        candidateId: "products-backfill-efgh5678",
+                        scenarioName: "products_backfill",
+                        testType: "contract",
+                        category: "business_rule",
+                        source: CandidateSource.AGENT,
+                        matchKeys: ["name:products-backfill", "ep:contract:GET:/api/v1/products/backfill"],
+                    },
+                ],
+            });
+            const result = await handler({
+                summaryOutputFile: outputFile,
+                stateFile,
+                businessCaseAnalysis: "GENERATE item failed; backfilled from ADDITIONAL as the plan instructs.",
+                newTestsCreated: [
+                    contractNewTest({
+                        testId: "contract-get-products-backfill",
+                        endpoint: "GET /api/v1/products/backfill",
+                    }),
+                ],
+                testResults: [],
+                issuesFound: [],
+            });
+            expect(result.isError).toBeUndefined();
+        });
+        it("rejects an ADDITIONAL-matching entry when the GENERATE list is empty — zero-budget plans have nothing to backfill", async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+            tmpDirs.push(tmpDir);
+            const outputFile = path.join(tmpDir, "report.json");
+            const stateFile = await writeStateFileWithPlan(tmpDir, {
+                ...APPROVED_PLAN,
+                generate: [],
+                additional: APPROVED_PLAN.generate,
+            });
+            const result = await handler({
+                summaryOutputFile: outputFile,
+                stateFile,
+                businessCaseAnalysis: "Generated a test on a zero-budget plan.",
+                newTestsCreated: [contractNewTest()],
+                testResults: [],
+                issuesFound: [],
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("plan-42");
+        });
+        it("does not check newTestsCreated when approvedPlan is absent (back-compat)", async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+            tmpDirs.push(tmpDir);
+            const outputFile = path.join(tmpDir, "report.json");
+            const stateFile = await writeStateFileWithPlan(tmpDir, undefined);
+            const result = await handler({
+                summaryOutputFile: outputFile,
+                stateFile,
+                businessCaseAnalysis: "No plan was ever registered for this run.",
+                newTestsCreated: [contractNewTest({ endpoint: "GET /api/v1/products/anything" })],
+                testResults: [],
+                issuesFound: [],
+            });
+            expect(result.isError).toBeUndefined();
+        });
+        it("does not gate UI/E2E entries even when unmatched — those tools are outside planGuard's scope", async () => {
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
+            tmpDirs.push(tmpDir);
+            const outputFile = path.join(tmpDir, "report.json");
+            const stateFile = await writeStateFileWithPlan(tmpDir, APPROVED_PLAN);
+            const result = await handler({
+                summaryOutputFile: outputFile,
+                stateFile,
+                businessCaseAnalysis: "Adds a UI test not present in the approved plan.",
+                newTestsCreated: [
+                    {
+                        testId: "ui-checkout-flow",
+                        testType: TestType.UI,
+                        category: "workflow",
+                        endpoint: "N/A",
+                        fileName: "checkout_ui_test.spec.ts",
+                        description: "Walks through the checkout flow. [no-blueprint-data]",
+                        reasoning: "Covers the new checkout UI. [no-blueprint-data]",
+                        targetElements: null,
+                    },
+                ],
+                testResults: [],
+                issuesFound: [],
+            });
+            expect(result.isError).toBeUndefined();
+        });
+    });
+});
+// SKYR-3883: end-to-end coverage of the working-tree verification gate. The unit
+// behavior lives in reportVerification.test.ts; these exercise the wiring through
+// the real tool handler (feature-flag gating, git enumeration, error surfacing).
+describe("submit_report working-tree verification (SKYR-3883)", () => {
+    let handler;
+    let tmpDirs = [];
+    const prevFlag = process.env.SKYRAMP_FEATURE_TESTBOT;
+    beforeAll(() => {
+        handler = captureToolHandler();
+    });
+    beforeEach(() => {
+        process.env.SKYRAMP_FEATURE_TESTBOT = "1";
+    });
+    afterEach(async () => {
+        if (prevFlag === undefined)
+            delete process.env.SKYRAMP_FEATURE_TESTBOT;
+        else
+            process.env.SKYRAMP_FEATURE_TESTBOT = prevFlag;
+        for (const dir of tmpDirs)
+            await fs.rm(dir, { recursive: true, force: true });
+        tmpDirs = [];
+    });
+    async function initGitRepo() {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-wt-"));
+        tmpDirs.push(dir);
+        execFileSync("git", ["init", "-q"], { cwd: dir });
+        execFileSync("git", ["config", "user.email", "t@t.dev"], { cwd: dir });
+        execFileSync("git", ["config", "user.name", "t"], { cwd: dir });
+        return dir;
+    }
+    it("rejects a report whose newTestsCreated file was never written", async () => {
+        const dir = await initGitRepo();
+        const outputFile = path.join(dir, "report.json");
+        const stateFile = await writeStateFile(dir, []);
+        // search_smoke_test.py is claimed but never created → unbacked.
+        const result = await handler(sampleReportParams(outputFile, stateFile));
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("not backed");
+        expect(result.content[0].text).toContain("search_smoke_test.py");
+    });
+    it("accepts the report once the claimed file exists in the working tree", async () => {
+        const dir = await initGitRepo();
+        const outputFile = path.join(dir, "report.json");
+        const stateFile = await writeStateFile(dir, []);
+        await fs.writeFile(path.join(dir, "search_smoke_test.py"), "def test_search(): pass\n");
+        const result = await handler(sampleReportParams(outputFile, stateFile));
+        expect(result.isError).toBeUndefined();
+    });
+    it("rejects an UPDATE maintenance verdict with no working-tree change, exempting DELETE", async () => {
+        const dir = await initGitRepo();
+        const outputFile = path.join(dir, "report.json");
+        const stateFile = await writeReconciledStateFile(dir, [], [
+            { testFilePath: path.join(dir, "dcim/tests/test_filtersets.py"), action: DriftAction.Update, rationale: "physical_address filter", testType: TestType.INTEGRATION, endpoint: "GET /api/dcim/sites/" },
+            { testFilePath: path.join(dir, "dcim/tests/gone.py"), action: DriftAction.Delete, rationale: "obsolete", testType: TestType.INTEGRATION, endpoint: "GET /api/dcim/sites/" },
+        ]);
+        // Keep the newTestsCreated claim backed so the failure isolates to the verdict.
+        await fs.writeFile(path.join(dir, "search_smoke_test.py"), "x\n");
+        const result = await handler(sampleReportParams(outputFile, stateFile));
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("test_filtersets.py");
+        // DELETE is applied at delivery, never a working-tree claim — must not be flagged.
+        expect(result.content[0].text).not.toContain("gone.py");
+    });
+    it("skips verification entirely when the testbot feature flag is off", async () => {
+        delete process.env.SKYRAMP_FEATURE_TESTBOT;
+        const dir = await initGitRepo();
+        const outputFile = path.join(dir, "report.json");
+        const stateFile = await writeStateFile(dir, []);
+        // Claimed file absent, but the gate is off → report goes through.
+        const result = await handler(sampleReportParams(outputFile, stateFile));
+        expect(result.isError).toBeUndefined();
+    });
+    it("degrades to a pass when repositoryPath is not a git repo (verification can't run)", async () => {
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-nogit-"));
+        tmpDirs.push(dir);
+        const outputFile = path.join(dir, "report.json");
+        const stateFile = await writeStateFile(dir, []); // repositoryPath=dir, but no git init
+        const result = await handler(sampleReportParams(outputFile, stateFile));
+        // git status throws → caught → warning → report not falsely rejected.
+        expect(result.isError).toBeUndefined();
+    });
 });

package/build/tools/test-management/analyzeChangesTool.js

@@ -10,8 +10,12 @@ import { parseWorkspaceAuthType, getDefaultAuthHeader, WorkspaceAuthType, readWo
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { makeProgressReporter } from "../../utils/progress.js";
 import { StateManager, registerSession, storeSessionData, setTestsRepoDir, getActiveRunStatePath, setActiveRunStatePath, } from "../../utils/AnalysisStateManager.js";
-import { buildRecommendationPrompt } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
+import { buildRecommendationPrompt, computeScoredCandidates } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
 import { hasFlutterSdkDep, isFrontendFile, isTestFile } from "../../prompts/test-recommendation/scopeAssessment.js";
+import { buildExternalCoverageSet } from "../../prompts/test-recommendation/recommendationShared.js";
+import { CandidateSource, computeCandidateId } from "../../types/Recommendation.js";
+import { selectPlan } from "../../recommendation/planRanker.js";
+import { buildApprovedPlanItem } from "../../utils/planMatchKeys.js";
 import { enumerateCandidateUiPages } from "../../utils/uiPageEnumerator.js";
 import { checkFrontendFileIntegration } from "../../utils/frontendIntegration.js";
 import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-recommendation/recommendationSections.js";
@@ -1278,6 +1282,12 @@ export function registerAnalyzeChangesTool(server) {
                 diffFilePath = path.join(os.tmpdir(), `skyramp-diff-${sessionId}.diff`);
                 await fs.promises.writeFile(diffFilePath, diffData.diffContent, { encoding: "utf-8", mode: 0o600 });
             }
+            // SKYR-3879 Path B: size-capped raw diff text, persisted (not just the
+            // file path above) so skyramp_register_test_plan can verify a
+            // discriminator's changedCodeAnchor occurs verbatim in the diff without
+            // an extra file read of its own.
+            const DIFF_TEXT_CAP = 200_000;
+            const diffText = diffData?.diffContent ? diffData.diffContent.slice(0, DIFF_TEXT_CAP) : undefined;
             // Compute UI context from the diff's changed files using the shared
             // `isFrontendFile` classifier. Persisting this in the stateFile lets
             // skyramp_analyze_test_health and the recommendation prompt consume the
@@ -1326,11 +1336,54 @@ export function registerAnalyzeChangesTool(server) {
                         (unintegratedFrontendFiles.length > 0
                             ? `\n\n${buildUnintegratedInstructions(unintegratedFrontendFiles)}`
                             : "");
+            // ── SKYR-3879 Path B: budget context + pre-seeded approved plan ──
+            // Computed BEFORE the state write (not after, alongside the
+            // recommendation prompt) so both this pre-seed and buildRecommendationPrompt
+            // derive their GENERATE/ADDITIONAL split from the exact same numbers —
+            // computeScoredCandidates is the single source of truth for both.
+            const topN = params.topN ?? MAX_RECOMMENDATIONS;
+            const scoredResult = computeScoredCandidates(fullAnalysis, analysisScope, topN, params.maxGenerate);
+            const externalCoverage = buildExternalCoverageSet(testLocationsByType);
+            const planBudgetContext = {
+                maxGenerate: scoredResult.maxGen,
+                maxTotal: topN,
+                isUIOnlyPR: scoredResult.isUIOnlyPR,
+                hasFrontendChanges: scoredResult.hasFrontendChanges,
+                externalCoverageKeys: [...externalCoverage],
+            };
+            let approvedPlan;
+            if (scoredResult.scored.length > 0) {
+                const budgetCtx = {
+                    maxGenerate: planBudgetContext.maxGenerate,
+                    maxTotal: planBudgetContext.maxTotal,
+                    isUIOnlyPR: planBudgetContext.isUIOnlyPR,
+                    hasFrontendChanges: planBudgetContext.hasFrontendChanges,
+                    externalCoverage,
+                };
+                const serverCandidates = scoredResult.scored.map(({ scenario, priority, novelty }) => ({
+                    scenario,
+                    priority,
+                    novelty,
+                    source: CandidateSource.SERVER,
+                    candidateId: computeCandidateId(scenario),
+                }));
+                const plan = selectPlan(serverCandidates, budgetCtx);
+                approvedPlan = {
+                    planId: crypto.randomUUID(),
+                    createdAt: new Date().toISOString(),
+                    generate: plan.generate.map(buildApprovedPlanItem),
+                    additional: plan.additional.map(buildApprovedPlanItem),
+                    demotions: [],
+                };
+            }
             const unifiedState = {
                 existingTests,
                 newEndpoints: newEndpointsForDrafting,
                 analysisScope,
                 ...(uiContext ? { uiContext } : {}),
+                ...(diffText ? { diffText } : {}),
+                planBudgetContext,
+                ...(approvedPlan ? { approvedPlan } : {}),
                 repositoryAnalysis: {
                     skeletonEndpoints,
                     projectMeta,
@@ -1419,7 +1472,7 @@ export function registerAnalyzeChangesTool(server) {
             }
             await sendProgress(90, 100, "Generating ranked recommendations...");
             // ── Step 12: Generate ranked recommendations inline ──
-            const topN = params.topN ?? MAX_RECOMMENDATIONS;
+            // topN computed earlier (SKYR-3879 Path B pre-seed, before the state write).
             // ── Step 13: Fetch PR comment history for deduplication ──
             let prContext;
             if (params.prNumber) {

package/build/tools/test-management/analyzeChangesTool.test.js

@@ -9,6 +9,18 @@ jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
 }));
 jest.unstable_mockModule("../../prompts/test-recommendation/test-recommendation-prompt.js", () => ({
     buildRecommendationPrompt: jest.fn(),
+    // SKYR-3879 Path B pre-seed reads this before the state write — default to
+    // "nothing pre-ranked" so existing tests (which don't exercise the plan
+    // pre-seed) see byte-identical unifiedState/writeRepoData behavior.
+    computeScoredCandidates: jest.fn(() => ({
+        scored: [],
+        filteredChangedFiles: [],
+        isUIOnlyPR: false,
+        hasFrontendChanges: false,
+        hasApiChanges: false,
+        maxGen: 0,
+        seed: "",
+    })),
 }));
 jest.unstable_mockModule("../../prompts/test-recommendation/recommendationSections.js", () => ({
     MAX_RECOMMENDATIONS: 10,

package/build/tools/test-management/index.d.ts

@@ -1,3 +1,4 @@
 export { registerAnalyzeChangesTool } from "./analyzeChangesTool.js";
 export { registerAnalyzeTestHealthTool } from "./analyzeTestHealthTool.js";
 export { registerActionsTool } from "./actionsTool.js";
+export { registerRegisterTestPlanTool } from "./registerTestPlanTool.js";

package/build/tools/test-management/index.js

@@ -1,3 +1,4 @@
 export { registerAnalyzeChangesTool } from "./analyzeChangesTool.js";
 export { registerAnalyzeTestHealthTool } from "./analyzeTestHealthTool.js";
 export { registerActionsTool } from "./actionsTool.js";
+export { registerRegisterTestPlanTool } from "./registerTestPlanTool.js";

package/build/tools/test-management/registerTestPlanTool.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRegisterTestPlanTool(server: McpServer): void;