@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/prompts/test-recommendation/test-recommendation-prompt.test.js

@@ -1,1925 +0,0 @@
-import { jest } from "@jest/globals";
-import { Novelty, PriorityTier } from "../../types/TestRecommendation.js";
-import { TestType } from "../../types/TestTypes.js";
-jest.unstable_mockModule("@skyramp/skyramp", () => ({
-    WorkspaceConfigManager: { create: jest.fn() },
-}));
-const { buildRecommendationPrompt, buildExternalCoverageSet, externalDedupKey } = await import("./test-recommendation-prompt.js");
-const { buildExecutionPlan, EXEC_STEP_REGISTER } = await import("./diffExecutionPlan.js");
-const { PATH_PARAM_UUID_GUIDANCE, MAX_TESTS_TO_GENERATE, buildTestQualityCriteria, buildArchitectPreamble, buildContextFetchingGuidance, buildReasoningProtocol, buildFewShotExamples, buildVerificationChecklist, } = await import("./recommendationSections.js");
-import { AnalysisScope } from "../../types/RepositoryAnalysis.js";
-// ---------------------------------------------------------------------------
-// Minimal fixtures
-// ---------------------------------------------------------------------------
-function minimalAnalysis(overrides = {}) {
-    return {
-        metadata: { repositoryName: "test-repo", analysisDate: "2026-01-01", scanDepth: "quick" },
-        projectClassification: {
-            projectType: "rest-api",
-            primaryLanguage: "TypeScript",
-            primaryFramework: "Express",
-            deploymentPattern: "traditional",
-        },
-        technologyStack: { languages: ["TypeScript"], frameworks: ["Express"], runtime: "node", keyDependencies: [] },
-        businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-        artifacts: { openApiSpecs: [], playwrightRecordings: [], traceFiles: [], notFound: [] },
-        apiEndpoints: {
-            totalCount: 1,
-            baseUrl: "http://localhost:3000",
-            endpoints: [{
-                    path: "/api/items",
-                    resourceGroup: "items",
-                    pathParams: [],
-                    methods: [{
-                            method: "GET",
-                            description: "List items",
-                            queryParams: [],
-                            authRequired: false,
-                            sourceFile: "routes/items.ts",
-                            interactions: [{ description: "success", type: "success", request: {}, response: { statusCode: 200, description: "OK" } }],
-                        }],
-                }],
-        },
-        authentication: { method: "bearer", configLocation: "middleware/auth.ts", envVarsRequired: [], setupExample: "" },
-        infrastructure: { isContainerized: false, hasDockerCompose: false, hasKubernetes: false, hasCiCd: false },
-        existingTests: { frameworks: ["jest"], coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 }, testLocations: {}, hasCoverageReports: false },
-        ...overrides,
-    };
-}
-function makePRContext(overrides = {}) {
-    return {
-        prNumber: 42,
-        previousRecommendations: [],
-        implementedTestFiles: [],
-        executionResults: [],
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// Tests — PR History & Stability in prompt output
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — PR History section", () => {
-    it("omits PR History section when no prContext is provided", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).not.toContain("PR History");
-        expect(prompt).not.toContain("Stability rule");
-    });
-    it("omits PR History section when prContext has no recommendations", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, makePRContext());
-        expect(prompt).not.toContain("PR History");
-    });
-    it("includes PR History section with prNumber when recommendations exist", () => {
-        const ctx = makePRContext({
-            prNumber: 99,
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/items", status: "implemented", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("PR History (PR #99)");
-    });
-    it("renders Previously Generated Tests for implemented recommendations", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "implemented", commentId: "1" },
-            ],
-            implementedTestFiles: ["test_items_contract.py"],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Previously Generated Tests");
-        expect(prompt).toContain("contract — GET /api/items");
-        expect(prompt).toContain("test_items_contract.py");
-    });
-    it("does NOT include stability rule when only implemented tests exist (no recommended)", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "implemented", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).not.toContain("Stability rule");
-        expect(prompt).not.toContain("Previously Recommended");
-    });
-    it("includes stability rule when recommended-but-not-generated tests exist", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/orders", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Previously Recommended (not generated)");
-        expect(prompt).toContain("Stability rule");
-        expect(prompt).toContain("integration — POST /api/orders (scenario: order-lifecycle)");
-    });
-    it("stability rule uses scenarioName for multi-step and endpoint for single-endpoint matching", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/orders", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        const stabilityBlock = prompt.slice(prompt.indexOf("**Stability rule**"), prompt.indexOf("Only add NEW recommendations"));
-        expect(stabilityBlock).toContain("scenarioName");
-        expect(stabilityBlock).toContain("endpoint");
-        expect(stabilityBlock).toContain("Re-derive category and priority");
-        expect(stabilityBlock).not.toMatch(/same.*category/);
-        expect(stabilityBlock).not.toMatch(/same.*priority/);
-    });
-    it("includes top-level stability guidance about not churning recommendations", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/orders", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Do not churn recommendations without cause");
-        expect(prompt).toContain("Carry forward");
-    });
-    it("includes both implemented and recommended sections when both exist", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "implemented", commentId: "1" },
-                { testType: "integration", endpoint: "POST /api/orders", scenarioName: "order-flow", status: "recommended", commentId: "1" },
-            ],
-            implementedTestFiles: ["test_items_contract.py"],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Previously Generated Tests");
-        expect(prompt).toContain("Previously Recommended (not generated)");
-        expect(prompt).toContain("Stability rule");
-    });
-    it("includes execution results when present", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "implemented", commentId: "1" },
-            ],
-            executionResults: [
-                { testFile: "test_items_contract.py", status: "fail", timestamp: "2026-01-01T00:00:00Z" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Execution Results from Prior Run");
-        expect(prompt).toContain("test_items_contract.py");
-        expect(prompt).toContain("fail");
-    });
-    it("does not render scenarioName parenthetical when scenarioName is undefined", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("contract — GET /api/items");
-        expect(prompt).not.toContain("(scenario:");
-    });
-    it("lists ALL recommended scenarios when multiple exist", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/orders", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-                { testType: "contract", endpoint: "GET /api/items/{id}", scenarioName: "item-schema-check", status: "recommended", commentId: "1" },
-                { testType: "integration", endpoint: "DELETE /api/users/{id}", scenarioName: "cascade-delete-user", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("order-lifecycle");
-        expect(prompt).toContain("item-schema-check");
-        expect(prompt).toContain("cascade-delete-user");
-        expect(prompt).toContain("Stability rule");
-    });
-    it("excludes dismissed recommendations from Previously Generated and Previously Recommended", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/orders", scenarioName: "order-lifecycle", status: "dismissed", commentId: "1" },
-                { testType: "contract", endpoint: "GET /api/items", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).not.toContain("order-lifecycle");
-        expect(prompt).toContain("contract — GET /api/items");
-    });
-    it("shows promotion instruction alongside carry-forward when recommended tests exist", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/orders", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Promote the highest-priority ones");
-        expect(prompt).toContain("into generation slots if capacity allows");
-    });
-    it("includes do-not-re-recommend instruction for implemented tests", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "implemented", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("Do NOT re-recommend");
-        expect(prompt).toContain("Previously Generated Tests");
-    });
-    it("de-duplicates multi-step scenario entries to one line per scenario", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/items", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-                { testType: "integration", endpoint: "POST /api/orders", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-                { testType: "integration", endpoint: "GET /api/orders/{id}", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        const recSection = prompt.slice(prompt.indexOf("Previously Recommended"), prompt.indexOf("**Stability rule**"));
-        const scenarioOccurrences = (recSection.match(/order-lifecycle/g) || []).length;
-        expect(scenarioOccurrences).toBe(1);
-        expect(recSection).toContain("integration — POST /api/items (scenario: order-lifecycle)");
-        expect(recSection).not.toContain("POST /api/orders");
-        expect(recSection).not.toContain("GET /api/orders/{id}");
-    });
-    it("keeps entries with no scenarioName as separate lines (de-dup by testType+endpoint)", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "recommended", commentId: "1" },
-                { testType: "contract", endpoint: "GET /api/items", status: "recommended", commentId: "1" },
-                { testType: "contract", endpoint: "POST /api/items", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        const recSection = prompt.slice(prompt.indexOf("Previously Recommended"), prompt.indexOf("**Stability rule**"));
-        const getOccurrences = (recSection.match(/contract — GET \/api\/items/g) || []).length;
-        expect(getOccurrences).toBe(1);
-        expect(recSection).toContain("contract — POST /api/items");
-    });
-    // Ensure de-duplicates across different scenarios independently
-    it("de-duplicates across different scenarios independently", () => {
-        const ctx = makePRContext({
-            previousRecommendations: [
-                { testType: "integration", endpoint: "POST /api/items", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-                { testType: "integration", endpoint: "POST /api/orders", scenarioName: "order-lifecycle", status: "recommended", commentId: "1" },
-                { testType: "integration", endpoint: "POST /api/items", scenarioName: "cascade-delete", status: "recommended", commentId: "1" },
-                { testType: "integration", endpoint: "DELETE /api/items/{id}", scenarioName: "cascade-delete", status: "recommended", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        const recSection = prompt.slice(prompt.indexOf("Previously Recommended"), prompt.indexOf("**Stability rule**"));
-        const orderOccurrences = (recSection.match(/order-lifecycle/g) || []).length;
-        const cascadeOccurrences = (recSection.match(/cascade-delete/g) || []).length;
-        expect(orderOccurrences).toBe(1);
-        expect(cascadeOccurrences).toBe(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Stability and supplement in buildRecommendationPrompt
-// ---------------------------------------------------------------------------
-function minimalScenario(overrides = {}) {
-    return {
-        scenarioName: "item-create-delete",
-        description: "Create and delete an item to verify cascade",
-        category: "data_integrity",
-        priority: "high",
-        steps: [
-            { order: 1, method: "POST", path: "/api/items", description: "Create item", interactionType: "success", expectedStatusCode: 201 },
-            { order: 2, method: "DELETE", path: "/api/items/{id}", description: "Delete item", interactionType: "success", expectedStatusCode: 204 },
-        ],
-        chainingKeys: ["id"],
-        requiresAuth: false,
-        estimatedComplexity: "simple",
-        testType: TestType.INTEGRATION,
-        ...overrides,
-    };
-}
-describe("buildRecommendationPrompt — Stability and supplement section", () => {
-    it("includes Recommendation Stability section in output when scenarios exist (PR mode)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [minimalScenario()] },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("## Recommendation Stability");
-    });
-    it("stability section uses scenarioName/endpoint matching strategy (PR mode)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [minimalScenario()] },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        const stabilityStart = prompt.indexOf("## Recommendation Stability");
-        const stabilityBlock = prompt.slice(stabilityStart, stabilityStart + 500);
-        expect(stabilityBlock).toContain("scenarioName");
-        expect(stabilityBlock).toContain("endpoint");
-        expect(stabilityBlock).toContain("Re-derive category and priority");
-    });
-    it("stability section specifies when to drop a recommendation (PR mode)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [minimalScenario()] },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("target endpoint was removed");
-        expect(prompt).toContain("business logic changed");
-        expect(prompt).toContain("covered by a generated test");
-    });
-    it("instructs to supplement beyond pre-ranked list to reach topN", () => {
-        // 1 scenario, topN=10 → supplementCount=9 → supplement note should appear
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [minimalScenario()] },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.FullRepo, 10);
-        expect(prompt).toContain("<supplement_guidance>");
-        expect(prompt).toContain("5-dimension rubric");
-    });
-    // Verify MAX_TESTS_TO_GENERATE is still exported and equals 3
-    it("MAX_TESTS_TO_GENERATE is 3", () => {
-        expect(MAX_TESTS_TO_GENERATE).toBe(3);
-    });
-    it("uses MAX_CRITICAL_TESTS in category-aware selection rules (PR mode)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [minimalScenario()] },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        // MAX_CRITICAL_TESTS applies to PR mode (GENERATE items) — full_repo mode only presents, does not execute
-        expect(prompt).toContain("GENERATE items should be from HIGH-priority categories");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — PATH_PARAM_UUID_GUIDANCE (no hardcoded UUID anchor)
-// ---------------------------------------------------------------------------
-const UUID_V4_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i;
-describe("PATH_PARAM_UUID_GUIDANCE — no hardcoded UUID anchor", () => {
-    it("contains no hardcoded UUID that the LLM could anchor to", () => {
-        expect(PATH_PARAM_UUID_GUIDANCE).not.toMatch(UUID_V4_REGEX);
-    });
-    it("uses <random-uuid-v4> as the placeholder in the pathParams example", () => {
-        expect(PATH_PARAM_UUID_GUIDANCE).toContain("<random-uuid-v4>");
-    });
-    it("instructs the LLM to generate a fresh UUID v4", () => {
-        expect(PATH_PARAM_UUID_GUIDANCE).toContain("generate a fresh random UUID v4");
-    });
-    it("is included in the recommendation prompt for an endpoint with a UUID path param", () => {
-        const analysis = minimalAnalysis({
-            apiEndpoints: {
-                totalCount: 1,
-                baseUrl: "http://localhost:3000",
-                endpoints: [{
-                        path: "/api/items/{item_id}",
-                        resourceGroup: "items",
-                        pathParams: [{ name: "item_id", type: "string", required: true }],
-                        methods: [{
-                                method: "GET",
-                                description: "Get item by ID",
-                                queryParams: [],
-                                authRequired: false,
-                                sourceFile: "routes/items.ts",
-                                interactions: [{ description: "success", type: "success", request: {}, response: { statusCode: 200, description: "OK" } }],
-                            }],
-                    }],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("<random-uuid-v4>");
-        expect(prompt).not.toMatch(UUID_V4_REGEX);
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — maxGenerateOverride parameter in buildRecommendationPrompt
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — maxGenerateOverride", () => {
-    const scenariosForOverride = [
-        // One single-step scenario (auto-classified as contract in full_repo mode) to verify contract tool calls
-        minimalScenario({
-            scenarioName: "scenario-0",
-            description: "Test scenario 0",
-            category: "security_boundary",
-            priority: "high",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "GET", path: "/api/items", description: "Get items", interactionType: "success", expectedStatusCode: 200 }],
-        }),
-        // Five multi-step integration scenarios
-        ...Array.from({ length: 5 }, (_, i) => minimalScenario({
-            scenarioName: `scenario-${i + 1}`,
-            description: `Test scenario ${i + 1}`,
-            category: i < 1 ? "security_boundary" : "crud",
-            priority: i < 1 ? "high" : "low",
-        })),
-    ];
-    const analysisWithScenarios = minimalAnalysis({
-        businessContext: {
-            mainPurpose: "Test API",
-            userFlows: [],
-            dataFlows: [],
-            integrationPatterns: [],
-            draftedScenarios: scenariosForOverride,
-        },
-    });
-    it("uses MAX_TESTS_TO_GENERATE as default when maxGenerateOverride is undefined", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.CurrentBranchDiff, 10);
-        // buildExecutionPlan seed line: "Max: N generate + up to M additional"
-        expect(prompt).toContain(`Max: ${MAX_TESTS_TO_GENERATE} generate`);
-    });
-    it("respects maxGenerateOverride when provided", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 5);
-        expect(prompt).toContain("Max: 5 generate");
-        expect(prompt).toContain("up to 5 additional");
-    });
-    it("clamps maxGenerateOverride to topN when override exceeds topN", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.CurrentBranchDiff, 4, undefined, undefined, undefined, undefined, 10);
-        expect(prompt).toContain("Max: 4 generate");
-    });
-    it("clamps maxGenerateOverride to 0 when negative", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, -5);
-        expect(prompt).toContain("Max: 0 generate");
-    });
-    it("allows maxGenerateOverride of 0 to produce no generate items", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 0);
-        expect(prompt).toContain("Max: 0 generate");
-        // The few-shot examples section contains "#1 — GENERATE" as an illustration,
-        // so check the execution plan's GENERATE section is empty instead.
-        expect(prompt).toContain("(no pre-ranked generate items");
-    });
-    it("uses topN as default maxGen in full_repo scope — Repo mode output format", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.FullRepo, 6);
-        expect(prompt).toContain("Test Recommendations — 6 total (grouped by test type)");
-        expect(prompt).toContain("Repo mode");
-        expect(prompt).not.toContain("Budget:");
-        // Full-repo mode: no execution, just presentation
-        expect(prompt).toContain("no tests are executed");
-        expect(prompt).toContain("Present up to 6 recommendations.");
-        // Full-repo items must include tool calls for on-demand generation
-        expect(prompt).toContain("skyramp_contract_test_generation");
-    });
-    it("full_repo mode ignores maxGenerateOverride — always presents all", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.FullRepo, 6, undefined, undefined, undefined, undefined, 2);
-        expect(prompt).toContain("Test Recommendations — 6 total (grouped by test type)");
-        expect(prompt).toContain("Repo mode");
-        expect(prompt).not.toContain("Budget:");
-        expect(prompt).toContain("no tests are executed");
-    });
-    it("full_repo mode includes tool calls in each recommendation item", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.FullRepo, 6);
-        // Contract items should have tool calls
-        expect(prompt).toContain("skyramp_contract_test_generation");
-        // Integration items should use the batch tool
-        expect(prompt).toContain("skyramp_batch_scenario_test_generation");
-        // MANDATORY language for test type mix and item counts
-        expect(prompt).toContain("Test type mix");
-    });
-    it("full_repo mode uses MANDATORY language for item count and test type mix", () => {
-        const prompt = buildRecommendationPrompt(analysisWithScenarios, AnalysisScope.FullRepo, 6);
-        expect(prompt).toContain("Test type mix — MANDATORY");
-        expect(prompt).toContain("Present up to 6 recommendations.");
-    });
-    it("full_repo mode pre-allocates E2E and UI sections for full-stack repos", () => {
-        const fullStackAnalysis = minimalAnalysis({
-            projectClassification: {
-                projectType: "full-stack",
-                primaryLanguage: "TypeScript",
-                primaryFramework: "Express",
-                deploymentPattern: "traditional",
-            },
-            businessContext: {
-                mainPurpose: "Test API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: scenariosForOverride,
-            },
-        });
-        const prompt = buildRecommendationPrompt(fullStackAnalysis, AnalysisScope.FullRepo, 10);
-        // E2E and UI sections must be present even though scenarioDrafting only produces backend types
-        expect(prompt).toContain("### E2E");
-        expect(prompt).toContain("### UI");
-        expect(prompt).toContain("skyramp_e2e_test_generation");
-        expect(prompt).toContain("skyramp_ui_test_generation");
-        // Backend sections should still be present
-        expect(prompt).toContain("### Integration");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Additional recommendation dedup (Fix 1) and E2E slot guard (Fix 2)
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — additional recommendation dedup", () => {
-    function patchOrdersScenario(name, overrides = {}) {
-        return {
-            scenarioName: name,
-            description: `Test ${name}`,
-            category: "new_endpoint",
-            priority: "high",
-            steps: [
-                { order: 1, method: "POST", path: "/api/v1/products", description: "Create product", interactionType: "success", expectedStatusCode: 201 },
-                { order: 2, method: "POST", path: "/api/v1/orders", description: "Create order", interactionType: "success", expectedStatusCode: 201 },
-                { order: 3, method: "PATCH", path: "/api/v1/orders/{order_id}", description: "Patch order", interactionType: "success", expectedStatusCode: 200 },
-            ],
-            chainingKeys: ["id"],
-            requiresAuth: false,
-            estimatedComplexity: "complex",
-            testType: TestType.INTEGRATION,
-            ...overrides,
-        };
-    }
-    function analysisWithPatchScenarios(scenarios) {
-        return minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Order API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: scenarios,
-            },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/patch-orders",
-                changedFiles: ["backend/src/api/orders.py", "src/frontend/components/OrderDetail.tsx"],
-                newEndpoints: [{ path: "/api/v1/orders/{order_id}", methods: [{ method: "PATCH", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-            apiEndpoints: {
-                totalCount: 3,
-                baseUrl: "http://localhost:8000",
-                endpoints: [
-                    { path: "/api/v1/products", resourceGroup: "products", pathParams: [], methods: [{ method: "POST", description: "Create product", queryParams: [], authRequired: false, sourceFile: "routes.py", interactions: [] }] },
-                    { path: "/api/v1/orders", resourceGroup: "orders", pathParams: [], methods: [{ method: "POST", description: "Create order", queryParams: [], authRequired: false, sourceFile: "routes.py", interactions: [] }] },
-                    { path: "/api/v1/orders/{order_id}", resourceGroup: "orders", pathParams: [{ name: "order_id", type: "string", required: true }], methods: [{ method: "PATCH", description: "Update order", queryParams: [], authRequired: false, sourceFile: "routes.py", interactions: [] }] },
-                ],
-            },
-        });
-    }
-    it("filters additional items that share resource and test type with GENERATE items", () => {
-        const scenarios = [
-            patchOrdersScenario("orders-patch-add-items-recalculate"),
-            patchOrdersScenario("orders-patch-new-endpoint-happy-path"),
-            patchOrdersScenario("orders-patch-items-cleanup-verification"),
-            patchOrdersScenario("orders-patch-discount-fixed"),
-            patchOrdersScenario("orders-patch-another-variant"),
-        ];
-        const analysis = analysisWithPatchScenarios(scenarios);
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 2);
-        // First 2 become GENERATE, the remaining share orders::integration → should be filtered
-        const ordersPatchAdditional = (prompt.match(/\[ADDITIONAL\].*orders-patch/g) || []);
-        // Same-resource same-type scenarios should NOT appear in ADDITIONAL
-        expect(ordersPatchAdditional.length).toBe(0);
-    });
-    it("preserves additional items with different test type for same endpoint", () => {
-        const scenarios = [
-            patchOrdersScenario("orders-patch-add-items-recalculate"),
-            patchOrdersScenario("orders-patch-new-endpoint-happy-path"),
-            // Contract test for same endpoint — different test type, should survive dedup
-            {
-                ...patchOrdersScenario("orders-patch-contract"),
-                testType: TestType.CONTRACT,
-                steps: [{ order: 1, method: "PATCH", path: "/api/v1/orders/{order_id}", description: "Contract test", interactionType: "success", expectedStatusCode: 200 }],
-            },
-        ];
-        const analysis = analysisWithPatchScenarios(scenarios);
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 2);
-        // Contract test targets orders but is a different type → should be in ADDITIONAL
-        expect(prompt).toContain("orders-patch-contract");
-    });
-    it("preserves additional items targeting a different resource", () => {
-        const scenarios = [
-            patchOrdersScenario("orders-patch-add-items-recalculate"),
-            patchOrdersScenario("orders-patch-new-endpoint-happy-path"),
-            // Different resource entirely
-            {
-                ...patchOrdersScenario("products-unique-constraint"),
-                steps: [
-                    { order: 1, method: "POST", path: "/api/v1/products", description: "Create product", interactionType: "success", expectedStatusCode: 201 },
-                    { order: 2, method: "POST", path: "/api/v1/products", description: "Create duplicate", interactionType: "error", expectedStatusCode: 409 },
-                ],
-            },
-        ];
-        const analysis = analysisWithPatchScenarios(scenarios);
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 2);
-        expect(prompt).toContain("products-unique-constraint");
-    });
-});
-describe("buildRecommendationPrompt — LLM scope assessment for UI/E2E split", () => {
-    it("embeds scope assessment section in diff-scope prompt for mixed PR", () => {
-        // The LLM now determines UI vs backend split via the scope assessment — verify it's present.
-        const scenarios = [
-            minimalScenario({ scenarioName: "integration-test-1", category: "new_endpoint" }),
-        ];
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: scenarios },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["backend/routes.py", "src/frontend/components/App.tsx"],
-                newEndpoints: [{ path: "/api/items/{id}", methods: [{ method: "PATCH", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 3);
-        expect(prompt).toContain("PR Scope Assessment");
-        expect(prompt).toContain("Budget Plan:");
-        expect(prompt).toContain("UI/E2E tests (add per your Budget Plan)");
-        expect(prompt).toContain("Honor your Budget Plan");
-    });
-    it("includes UI/E2E tool guidance in the ADDITIONAL section for mixed PRs", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["backend/routes.py", "src/frontend/components/App.tsx"],
-                newEndpoints: [{ path: "/api/items", methods: [{ method: "POST", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 1);
-        expect(prompt).toContain("skyramp_e2e_test_generation");
-        expect(prompt).toContain("skyramp_ui_test_generation");
-    });
-    it("omits UI/E2E guidance for backend-only PRs (no frontend files)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["backend/routes.py", "services/order_service.py"],
-                newEndpoints: [{ path: "/api/items", methods: [{ method: "POST", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10, undefined, undefined, undefined, undefined, 3);
-        // No UI guidance injected for backend-only PR — scope assessment covers it
-        expect(prompt).not.toContain("UI/E2E tests (add per your Budget Plan)");
-    });
-    it("embeds scope assessment in UI-only PR (frontend files, no API changes)", () => {
-        // Previously the UI-only path used a hard-coded Budget: N total mandate.
-        // Now it goes through scope assessment so the LLM can scale down for CSS tweaks.
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["src/components/Button.tsx", "styles/global.css"],
-                newEndpoints: [],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("PR Scope Assessment");
-        expect(prompt).toContain("Budget Plan:");
-        expect(prompt).toContain("100% UI/E2E");
-        expect(prompt).toContain("Honor your Budget Plan");
-        // Hard-coded exact mandate should be gone — LLM decides the count
-        expect(prompt).not.toContain("You MUST produce EXACTLY");
-    });
-    it("embeds scope assessment in no-scenarios path (backend PR, no drafted scenarios)", () => {
-        // Previously the no-scenarios path used a hard-coded Budget mandate.
-        // Now it uses scope assessment so a trivial PR doesn't get told to produce 20 tests.
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["backend/routes.py"],
-                newEndpoints: [{ path: "/api/items", methods: [{ method: "POST", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("PR Scope Assessment");
-        expect(prompt).toContain("Budget Plan:");
-        expect(prompt).toContain("Honor your Budget Plan");
-        expect(prompt).not.toContain("You MUST produce EXACTLY");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — zero-classified diff: budget defaults to 0 (SKYR-3820)
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — zero-classified diff (SKYR-3820)", () => {
-    function zeroClassifiedAnalysis(changedFiles) {
-        return minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "skyramp/testbot-setup",
-                changedFiles,
-                newEndpoints: [],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-    }
-    it("config-only PR (netbox shape): Budget Plan defaults to 0 total, fixed budget mandate absent", () => {
-        const prompt = buildRecommendationPrompt(zeroClassifiedAnalysis([
-            ".github/workflows/skyramp-testbot.yml",
-            "deployment-testbot/Dockerfile",
-            "deployment-testbot/configuration.py",
-            "deployment-testbot/setup.sh",
-        ]), AnalysisScope.CurrentBranchDiff, 20, undefined, undefined, undefined, undefined, 3);
-        expect(prompt).toContain("Budget Plan: 0 total");
-        expect(prompt).not.toContain("Budget Plan: 20 total (3 generate + 17 additional)");
-        expect(prompt).not.toContain("Use these exact numbers throughout the rest of the prompt.");
-        // The "draft your own" pressure valves must not fire on a zero-classified diff
-        expect(prompt).not.toContain("draft your own based on endpoint analysis");
-        expect(prompt).not.toContain("If your Budget Plan total exceeds the pre-ranked items listed above");
-    });
-    it("backend source change with 0 classified endpoints keeps the conditional ceiling (SKYR-3855 guard)", () => {
-        // immich user.dto.ts shape — classification blind to a real behavior change.
-        // The agent must still be able to claim the budget from its own code review.
-        const prompt = buildRecommendationPrompt(zeroClassifiedAnalysis(["server/src/dtos/user.dto.ts"]), AnalysisScope.CurrentBranchDiff, 20, undefined, undefined, undefined, undefined, 3);
-        expect(prompt).toContain("Budget Plan: 0 total");
-        expect(prompt).toContain("up to 20 total (3 generate + 17 additional)");
-    });
-    it("classified backend PR is unchanged: fixed budget line still rendered", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["backend/routes.py"],
-                newEndpoints: [{ path: "/api/items", methods: [{ method: "POST", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 20, undefined, undefined, undefined, undefined, 3);
-        expect(prompt).toContain("Budget Plan: 20 total (3 generate + 17 additional), 0% UI/E2E");
-        expect(prompt).toContain("Use these exact numbers throughout the rest of the prompt.");
-        expect(prompt).not.toContain("Budget Plan: 0 total");
-    });
-    it("buildExecutionPlan omitting hasApiChanges renders the fixed budget (back-compat)", () => {
-        const plan = buildExecutionPlan([], 3, 20, "http://localhost:3000", "", "", "", "seed", 100, false, false);
-        expect(plan).toContain("Budget Plan: 20 total (3 generate + 17 additional), 0% UI/E2E");
-        expect(plan).not.toContain("Budget Plan: 0 total");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — REGISTER step (SKYR-3879 Path B checkpoint)
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — REGISTER step (SKYR-3879 Path B)", () => {
-    it("diff-scope execution plan includes the REGISTER step and its skyramp_register_test_plan instruction", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 5);
-        expect(prompt).toContain(`Step ${EXEC_STEP_REGISTER} — Register your test plan`);
-        expect(prompt).toContain("skyramp_register_test_plan");
-    });
-    it("diff-scope execution plan's GENERATE header references the REGISTER step", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 5);
-        expect(prompt).toContain(`registering via Step ${EXEC_STEP_REGISTER}`);
-    });
-    it("full-repo mode (no execution plan) never mentions skyramp_register_test_plan", () => {
-        const scenariosForFullRepo = [
-            minimalScenario({
-                scenarioName: "scenario-0",
-                category: "crud",
-                priority: "low",
-                testType: TestType.CONTRACT,
-                steps: [{ order: 1, method: "GET", path: "/api/items", description: "Get items", interactionType: "success", expectedStatusCode: 200 }],
-            }),
-        ];
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test API", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: scenariosForFullRepo },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.FullRepo, 6);
-        expect(prompt).not.toContain("skyramp_register_test_plan");
-    });
-    it("diff-scope 'draft your own' fallback (no pre-drafted scenarios) still includes the REGISTER step — the execution plan is always used in diff scope", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 5);
-        // minimalAnalysis() has no draftedScenarios and no branchDiffContext, so scored=[]
-        // but buildExecutionPlan still renders (see buildRecommendationPrompt's isDiffScope branch).
-        expect(prompt).toContain("skyramp_register_test_plan");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — GENERATE slot allocation (UI vs backend slots)
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — GENERATE slot allocation", () => {
-    function makeScenario(name) {
-        return minimalScenario({ scenarioName: name, category: "new_endpoint" });
-    }
-    it("UI-only PR: all GENERATE slots are UI placeholders (no backend)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: [] },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/ui",
-                changedFiles: ["src/components/OrderForm.tsx", "src/pages/Checkout.tsx"],
-                newEndpoints: [],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        // The GENERATE slots are the UI placeholder blocks — check their specific scenario names
-        expect(prompt).toContain("#1 — GENERATE** | ui | workflow | new");
-        expect(prompt).toContain("ui-test-for-changed-component-1");
-        expect(prompt).toContain("ui_test_1_trace.zip");
-        expect(prompt).toContain("skyramp_ui_test_generation");
-        // Each slot targets a distinct changed component/flow
-        expect(prompt).toContain("distinct changed component or user flow");
-    });
-    it("mixed PR: last GENERATE slot is UI, preceding slots are backend scenarios", () => {
-        const scenarios = [
-            makeScenario("orders-create"),
-            makeScenario("orders-update"),
-            makeScenario("orders-delete"),
-        ];
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: scenarios },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/mixed",
-                changedFiles: ["src/routes/orders.ts", "src/components/OrderForm.tsx"],
-                newEndpoints: [{ path: "/api/orders", methods: [{ method: "POST", sourceFile: "orders.ts", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        // Last GENERATE slot is UI (not E2E)
-        expect(prompt).toContain("— GENERATE** | ui");
-        expect(prompt).toContain("skyramp_ui_test_generation");
-        expect(prompt).not.toContain("— GENERATE** | e2e");
-        // At least one backend scenario in GENERATE (#1 or #2)
-        expect(prompt).toContain("#1 — GENERATE** | integration");
-        // Scenario name from the pre-ranked list (orders-create or orders-update)
-        expect(prompt).toContain("orders-create");
-    });
-    it("backend-only PR: all GENERATE slots are backend scenarios (no E2E injection)", () => {
-        const scenarios = [makeScenario("items-create"), makeScenario("items-get"), makeScenario("items-delete")];
-        const analysis = minimalAnalysis({
-            businessContext: { mainPurpose: "Test", userFlows: [], dataFlows: [], integrationPatterns: [], draftedScenarios: scenarios },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/backend",
-                changedFiles: ["backend/routes.py"],
-                newEndpoints: [{ path: "/api/items", methods: [{ method: "POST", sourceFile: "routes.py", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        // All 3 GENERATE slots are backend
-        expect(prompt).toContain("#1 — GENERATE** | integration");
-        // No UI placeholder injected for backend-only PR
-        expect(prompt).not.toContain("ui-test-for-changed-components");
-        expect(prompt).not.toContain("ui_mixed_pr_trace.zip");
-    });
-    it("promotes attack-surface security boundaries into generated slots", () => {
-        const attackSurface = minimalScenario({
-            scenarioName: "flows-bulk-delete-post-auth-boundary",
-            description: "Attack-surface auth boundary: /api/flows/bulk_delete is a destructive sibling of changed DELETE /api/flows/{id}; verify it rejects missing authentication",
-            category: "security_boundary",
-            priority: "high",
-            testType: TestType.CONTRACT,
-            steps: [{
-                    order: 1,
-                    method: "POST",
-                    path: "/api/flows/bulk_delete",
-                    description: "POST /api/flows/bulk_delete without auth",
-                    interactionType: "error",
-                    expectedStatusCode: 401,
-                }],
-        });
-        const directDelete = minimalScenario({
-            scenarioName: "flows-delete-auth-boundary",
-            description: "Auth boundary: DELETE /api/flows/{id} rejects missing authentication",
-            category: "security_boundary",
-            priority: "high",
-            testType: TestType.CONTRACT,
-            steps: [{
-                    order: 1,
-                    method: "DELETE",
-                    path: "/api/flows/{id}",
-                    description: "DELETE /api/flows/{id} without auth",
-                    interactionType: "error",
-                    expectedStatusCode: 401,
-                }],
-        });
-        const validation = minimalScenario({
-            scenarioName: "flows-delete-invalid-id",
-            description: "Validate malformed IDs",
-            category: "data_validation",
-            priority: "medium",
-            testType: TestType.CONTRACT,
-            steps: [{
-                    order: 1,
-                    method: "DELETE",
-                    path: "/api/flows/not-a-uuid",
-                    description: "DELETE /api/flows/not-a-uuid",
-                    interactionType: "error",
-                    expectedStatusCode: 422,
-                }],
-        });
-        const analysis = minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Test",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: [directDelete, validation, attackSurface],
-            },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/admin-key",
-                changedFiles: ["src/prefect/server/api/flows.py"],
-                newEndpoints: [],
-                modifiedEndpoints: [{
-                        path: "/api/flows/{id}",
-                        methods: [{ method: "DELETE", sourceFile: "flows.py", changeType: "modified" }],
-                    }],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 5, undefined, undefined, undefined, undefined, 2);
-        const attackIdx = prompt.indexOf("POST /api/flows/bulk_delete → 401");
-        const directIdx = prompt.indexOf("DELETE /api/flows/{id} → 401");
-        expect(attackIdx).toBeGreaterThanOrEqual(0);
-        expect(directIdx).toBeGreaterThanOrEqual(0);
-        expect(attackIdx).toBeLessThan(directIdx);
-        expect(prompt).toContain("#1 — GENERATE** | contract | security_boundary");
-        expect(prompt).toContain("preserve attack-surface `security_boundary` items");
-    });
-    it("does not external-dedup protected bug-catching or attack-surface scenarios", () => {
-        const attackSurface = minimalScenario({
-            scenarioName: "flows-bulk-delete-post-auth-boundary",
-            description: "Verify destructive sibling rejects missing authentication",
-            category: "security_boundary",
-            isAttackSurfaceSecurityBoundary: true,
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "POST", path: "/api/flows/bulk_delete", description: "POST /api/flows/bulk_delete without auth", interactionType: "error", expectedStatusCode: 401 }],
-        });
-        const bugCaught = minimalScenario({
-            scenarioName: "orders-discount-bug-caught",
-            description: "Bug-catching test: discount should subtract from total",
-            category: "bug_caught",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "POST", path: "/api/orders", description: "POST /api/orders exposes discount bug", interactionType: "success", expectedStatusCode: 201 }],
-        });
-        const ordinary = minimalScenario({
-            scenarioName: "customers-create-contract",
-            description: "Create customer contract",
-            category: "crud",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "POST", path: "/api/customers", description: "POST /api/customers", interactionType: "success", expectedStatusCode: 201 }],
-        });
-        const prompt = buildExecutionPlan([attackSurface, bugCaught, ordinary].map((scenario) => ({
-            scenario,
-            priority: scenario.category === "crud" ? PriorityTier.LOW : PriorityTier.CRITICAL,
-            novelty: Novelty.MODIFIED,
-        })), 3, 3, "http://localhost:3000", "Authorization", ", authScheme: \"Bearer\"", "", "seed", 3, false, false, false, new Set(["POST::flows::contract", "POST::orders::contract", "POST::customers::contract"]));
-        expect(prompt).toContain("POST /api/flows/bulk_delete → 401");
-        expect(prompt).toContain("POST /api/orders → 201");
-        expect(prompt).not.toContain("POST /api/customers → 201");
-        expect(prompt).toContain("`bug_caught` and attack-surface `security_boundary` items get the strictest reading");
-    });
-    it("keeps symmetric attack-surface siblings together before ordinary auth boundaries", () => {
-        const directWidgets = minimalScenario({
-            scenarioName: "widgets-delete-auth-boundary",
-            description: "Auth boundary: DELETE /api/widgets/{id} rejects missing authentication",
-            category: "security_boundary",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "DELETE", path: "/api/widgets/{id}", description: "DELETE /api/widgets/{id} without auth", interactionType: "error", expectedStatusCode: 401 }],
-        });
-        const directGadgets = minimalScenario({
-            scenarioName: "gadgets-delete-auth-boundary",
-            description: "Auth boundary: DELETE /api/gadgets/{id} rejects missing authentication",
-            category: "security_boundary",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "DELETE", path: "/api/gadgets/{id}", description: "DELETE /api/gadgets/{id} without auth", interactionType: "error", expectedStatusCode: 401 }],
-        });
-        const widgetsBulk = minimalScenario({
-            scenarioName: "widgets-bulk-delete-auth-boundary",
-            description: "Attack-surface auth boundary: /api/widgets/bulk_delete is a destructive sibling of changed DELETE /api/widgets/{id}; verify it rejects missing authentication",
-            category: "security_boundary",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "POST", path: "/api/widgets/bulk_delete", description: "POST /api/widgets/bulk_delete without auth", interactionType: "error", expectedStatusCode: 401 }],
-        });
-        const gadgetsBulk = minimalScenario({
-            scenarioName: "gadgets-bulk-delete-auth-boundary",
-            description: "Attack-surface auth boundary: /api/gadgets/bulk_delete is a destructive sibling of changed DELETE /api/gadgets/{id}; verify it rejects missing authentication",
-            category: "security_boundary",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "POST", path: "/api/gadgets/bulk_delete", description: "POST /api/gadgets/bulk_delete without auth", interactionType: "error", expectedStatusCode: 401 }],
-        });
-        const prompt = buildExecutionPlan([directWidgets, directGadgets, widgetsBulk, gadgetsBulk].map((scenario) => ({
-            scenario,
-            priority: PriorityTier.CRITICAL,
-            novelty: Novelty.MODIFIED,
-        })), 3, 4, "http://localhost:3000", "Authorization", ", authScheme: \"Bearer\"", "", "seed", 4, false);
-        const generatedBlock = prompt.slice(0, prompt.indexOf("#4 [ADDITIONAL]"));
-        const additionalBlock = prompt.slice(prompt.indexOf("#4 [ADDITIONAL]"));
-        expect(generatedBlock).toContain("POST /api/widgets/bulk_delete → 401");
-        expect(generatedBlock).toContain("POST /api/gadgets/bulk_delete → 401");
-        expect(additionalBlock).not.toContain("POST /api/widgets/bulk_delete → 401");
-        expect(additionalBlock).not.toContain("POST /api/gadgets/bulk_delete → 401");
-        expect(additionalBlock).toContain("DELETE /api/gadgets/{id} → 401");
-    });
-});
-describe("buildExecutionPlan — even-with-spillover test-type distribution", () => {
-    // Backend-only PR (hasFrontendChanges=false) so every GENERATE slot is a backend
-    // scenario drawn from `scored` — this is where contract-vs-integration distribution
-    // applies. baseUrl/auth args mirror the existing buildExecutionPlan tests above.
-    const contract = (name, path, priority = PriorityTier.HIGH) => ({
-        scenario: minimalScenario({
-            scenarioName: name,
-            category: "crud",
-            testType: TestType.CONTRACT,
-            steps: [{ order: 1, method: "POST", path, description: `POST ${path}`, interactionType: "success", expectedStatusCode: 201 }],
-        }),
-        priority: priority,
-        novelty: Novelty.NEW,
-    });
-    const integration = (name, p1, p2, priority = PriorityTier.HIGH) => ({
-        scenario: minimalScenario({
-            scenarioName: name,
-            category: "data_integrity",
-            testType: TestType.INTEGRATION,
-            steps: [
-                { order: 1, method: "POST", path: p1, description: `POST ${p1}`, interactionType: "success", expectedStatusCode: 201 },
-                { order: 2, method: "PATCH", path: p2, description: `PATCH ${p2}`, interactionType: "success", expectedStatusCode: 200 },
-            ],
-        }),
-        priority: priority,
-        novelty: Novelty.NEW,
-    });
-    const plan = (items, maxGen, topN) => buildExecutionPlan(items, maxGen, topN, "http://localhost:3000", "Authorization", ", authScheme: \"Bearer\"", "", "seed", items.length, false);
-    it("distributes GENERATE slots across contract AND integration when budget < candidates", () => {
-        // 4 contract out-rank 4 integration; pure top-3 rank slice would be all contract.
-        const items = [
-            contract("c1", "/api/a"), contract("c2", "/api/b"), contract("c3", "/api/c"), contract("c4", "/api/d"),
-            integration("i1", "/api/x", "/api/x/{id}"), integration("i2", "/api/y", "/api/y/{id}"),
-        ];
-        const prompt = plan(items, 3, 6);
-        const generated = prompt.slice(0, prompt.indexOf("[ADDITIONAL]") >= 0 ? prompt.indexOf("[ADDITIONAL]") : prompt.length);
-        expect(generated).toMatch(/GENERATE\*\* \| contract/);
-        expect(generated).toMatch(/GENERATE\*\* \| integration/);
-    });
-    it("single backend type → unchanged top-N rank slice (no regression)", () => {
-        const items = [contract("c1", "/api/a"), contract("c2", "/api/b"), contract("c3", "/api/c"), contract("c4", "/api/d")];
-        const prompt = plan(items, 3, 6);
-        const generated = prompt.slice(0, prompt.indexOf("[ADDITIONAL]") >= 0 ? prompt.indexOf("[ADDITIONAL]") : prompt.length);
-        // Top 3 contract by rank are generated; the 4th is not.
-        expect(generated).toContain("POST /api/a → 201");
-        expect(generated).toContain("POST /api/b → 201");
-        expect(generated).toContain("POST /api/c → 201");
-        expect(generated).not.toContain("POST /api/d → 201");
-        expect(generated).not.toMatch(/GENERATE\*\* \| integration/);
-    });
-    it("keeps a CRITICAL item in GENERATE even when lower-ranked than other-type candidates", () => {
-        // A CRITICAL integration sits after several HIGH contracts in rank order.
-        const items = [
-            contract("c1", "/api/a"), contract("c2", "/api/b"), contract("c3", "/api/c"),
-            integration("crit", "/api/orders", "/api/orders/{id}", PriorityTier.CRITICAL),
-        ];
-        const prompt = plan(items, 3, 6);
-        const generated = prompt.slice(0, prompt.indexOf("[ADDITIONAL]") >= 0 ? prompt.indexOf("[ADDITIONAL]") : prompt.length);
-        // The CRITICAL integration must occupy a GENERATE slot (protected-first).
-        expect(generated).toContain("PATCH /api/orders/{id}");
-    });
-    it("spills freed slots to the remaining type when one type runs dry", () => {
-        // 1 integration + 4 contract, budget 3: round 1 = 1 integration + 1 contract,
-        // integration bucket now empty → remaining 1 slot spills to contract → 2 contract total.
-        const items = [
-            integration("i1", "/api/x", "/api/x/{id}"),
-            contract("c1", "/api/a"), contract("c2", "/api/b"), contract("c3", "/api/c"), contract("c4", "/api/d"),
-        ];
-        const prompt = plan(items, 3, 6);
-        const generated = prompt.slice(0, prompt.indexOf("[ADDITIONAL]") >= 0 ? prompt.indexOf("[ADDITIONAL]") : prompt.length);
-        const contractSlots = (generated.match(/GENERATE\*\* \| contract/g) || []).length;
-        const integrationSlots = (generated.match(/GENERATE\*\* \| integration/g) || []).length;
-        expect(integrationSlots).toBe(1);
-        expect(contractSlots).toBe(2);
-    });
-    it("never lists a GENERATE item again under ADDITIONAL (set-difference recompute)", () => {
-        const items = [
-            contract("c1", "/api/a"), contract("c2", "/api/b"), contract("c3", "/api/c"), contract("c4", "/api/d"),
-            integration("i1", "/api/x", "/api/x/{id}"), integration("i2", "/api/y", "/api/y/{id}"),
-        ];
-        const prompt = plan(items, 3, 6);
-        const splitIdx = prompt.indexOf("[ADDITIONAL]");
-        expect(splitIdx).toBeGreaterThan(0);
-        const generated = prompt.slice(0, splitIdx);
-        const additional = prompt.slice(splitIdx);
-        // Each generated endpoint must not reappear in the ADDITIONAL section.
-        for (const m of generated.matchAll(/(POST|PATCH) (\/api\/[^\s]+)/g)) {
-            expect(additional).not.toContain(`${m[1]} ${m[2]}`);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — buildTestQualityCriteria contract-test guidance (regression guard)
-// ---------------------------------------------------------------------------
-describe("buildTestQualityCriteria — contract test guidance for error-handling", () => {
-    it("includes guidance to use contract tests for single-endpoint error-handling scenarios", () => {
-        const criteria = buildTestQualityCriteria();
-        expect(criteria).toContain("Contract tests");
-        expect(criteria).toContain("error-handling scenarios on a single");
-        expect(criteria).toContain("Do NOT add setup steps just to avoid hardcoding an ID");
-    });
-    it("instructs to use a hardcoded nonexistent ID to keep it a single-step test", () => {
-        const criteria = buildTestQualityCriteria();
-        expect(criteria).toContain("99999");
-        expect(criteria).toContain("single-step contract test");
-    });
-    it("is included in the recommendation prompt when scored scenarios exist", () => {
-        const analysis = minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Test API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: [minimalScenario()],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.FullRepo, 10);
-        expect(prompt).toContain("Do NOT add setup steps just to avoid hardcoding an ID");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Architect Persona Preamble
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — Architect Persona Preamble", () => {
-    it("includes Skyramp Integration Architect persona at the beginning of the prompt", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).toContain("Skyramp Integration Architect");
-    });
-    it("persona appears before the mode preamble", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        const architectIdx = prompt.indexOf("Skyramp Integration Architect");
-        const modeIdx = prompt.indexOf("Repo mode");
-        expect(architectIdx).toBeLessThan(modeIdx);
-        expect(architectIdx).toBeGreaterThan(-1);
-    });
-    it("persona instructs not to guess or fabricate values", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).toContain("No guessing");
-        expect(prompt).toContain("derive all parameters");
-    });
-    it("buildArchitectPreamble(diff) returns the diff persona", () => {
-        const preamble = buildArchitectPreamble(true);
-        expect(preamble).toContain("Skyramp Integration Architect");
-        expect(preamble).toContain("generate tests for this PR");
-        expect(preamble).toContain("duplicate coverage");
-    });
-    it("buildArchitectPreamble(full_repo) returns the full-repo persona", () => {
-        const preamble = buildArchitectPreamble(false);
-        expect(preamble).toContain("Skyramp Integration Architect");
-        expect(preamble).toContain("comprehensive test recommendation catalog");
-        expect(preamble).toContain("Do not call any generation tools");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Mandatory Reasoning Protocol
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — Mandatory Reasoning Protocol", () => {
-    it("includes reasoning protocol section in the prompt", () => {
-        const analysis = minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Test API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: [minimalScenario()],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.FullRepo, 10);
-        expect(prompt).toContain("Parameter Grounding Rule");
-    });
-    it("reasoning protocol covers the key parameter sources", () => {
-        const protocol = buildReasoningProtocol();
-        expect(protocol).toContain("requestBody");
-        expect(protocol).toContain("endpointURL");
-        expect(protocol).toContain("authHeader");
-        expect(protocol).toContain("Foreign-key path params");
-    });
-    it("reasoning protocol instructs to read source file when value cannot be sourced", () => {
-        const protocol = buildReasoningProtocol();
-        expect(protocol).toContain("read the relevant source file");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Context Fetching Guidance
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — Context Fetching Guidance", () => {
-    it("includes execution plan context when sessionId is provided", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.FullRepo, 10, undefined, undefined, undefined, undefined, undefined, "test-session-123");
-        expect(prompt).toContain("Execution Plan Context");
-        expect(prompt).toContain("relevant source file");
-    });
-    it("omits execution plan context when sessionId is not provided", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).not.toContain("Execution Plan Context");
-    });
-    it("buildContextFetchingGuidance returns empty string when no sessionId", () => {
-        expect(buildContextFetchingGuidance()).toBe("");
-        expect(buildContextFetchingGuidance(undefined)).toBe("");
-    });
-    it("buildContextFetchingGuidance references enriched scenarios and source files", () => {
-        const guidance = buildContextFetchingGuidance("session-1");
-        expect(guidance).toContain("placeholder");
-        expect(guidance).toContain("relevant source file");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Tool Contract Framing
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — Tool Contract Framing", () => {
-    it("includes contract language in tool workflows section (PR mode only)", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff);
-        expect(prompt).toContain("strict technical contracts");
-    });
-    it("includes parameter grounding reminder in tool workflows (PR mode only)", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff);
-        expect(prompt).toContain("Confirm WHERE each key value comes from");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Multi-method endpoint partitioning
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — multi-method endpoint partitioning", () => {
-    it("classifies all methods of a changed endpoint as changed", () => {
-        // When classifyEndpointsByChangedFiles identifies a file as changed,
-        // all methods from that endpoint's scanned catalog entry are included
-        // with concrete methods (no MULTI sentinels).
-        const analysis = minimalAnalysis({
-            apiEndpoints: {
-                totalCount: 2,
-                baseUrl: "http://localhost:3000",
-                endpoints: [
-                    {
-                        path: "/api/products",
-                        resourceGroup: "products",
-                        pathParams: [],
-                        methods: [
-                            { method: "GET", description: "List products", queryParams: [], authRequired: false, sourceFile: "app/api/products/route.ts", interactions: [] },
-                            { method: "POST", description: "Create product", queryParams: [], authRequired: false, sourceFile: "app/api/products/route.ts", interactions: [] },
-                        ],
-                    },
-                    {
-                        path: "/api/items",
-                        resourceGroup: "items",
-                        pathParams: [],
-                        methods: [
-                            { method: "GET", description: "List items", queryParams: [], authRequired: false, sourceFile: "routes/items.ts", interactions: [] },
-                        ],
-                    },
-                ],
-            },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/products",
-                changedFiles: ["app/api/products/route.ts"],
-                newEndpoints: [{
-                        path: "/api/products",
-                        methods: [
-                            { method: "GET", sourceFile: "app/api/products/route.ts", interactionCount: 0 },
-                            { method: "POST", sourceFile: "app/api/products/route.ts", interactionCount: 0 },
-                        ],
-                    }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        // Both GET and POST for /api/products should be in "Changed in this PR"
-        expect(prompt).toContain("Likely changed in this PR");
-        expect(prompt).toMatch(/Likely changed in this PR[\s\S]*GET \/api\/products/);
-        expect(prompt).toMatch(/Likely changed in this PR[\s\S]*POST \/api\/products/);
-        // /api/items should NOT be in changed section
-        expect(prompt).toMatch(/Other endpoints[\s\S]*GET \/api\/items/);
-    });
-    it("handles mix of new and modified endpoints with concrete methods", () => {
-        const analysis = minimalAnalysis({
-            apiEndpoints: {
-                totalCount: 2,
-                baseUrl: "http://localhost:3000",
-                endpoints: [
-                    {
-                        path: "/api/products",
-                        resourceGroup: "products",
-                        pathParams: [],
-                        methods: [
-                            { method: "GET", description: "List", queryParams: [], authRequired: false, sourceFile: "routes.ts", interactions: [] },
-                            { method: "POST", description: "Create", queryParams: [], authRequired: false, sourceFile: "routes.ts", interactions: [] },
-                        ],
-                    },
-                    {
-                        path: "/api/orders",
-                        resourceGroup: "orders",
-                        pathParams: [],
-                        methods: [
-                            { method: "POST", description: "Create order", queryParams: [], authRequired: false, sourceFile: "routes.ts", interactions: [] },
-                        ],
-                    },
-                ],
-            },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/mix",
-                changedFiles: ["routes.ts"],
-                newEndpoints: [
-                    { path: "/api/products", methods: [
-                            { method: "GET", sourceFile: "routes.ts", interactionCount: 0 },
-                            { method: "POST", sourceFile: "routes.ts", interactionCount: 0 },
-                        ] },
-                ],
-                modifiedEndpoints: [
-                    { path: "/api/orders", methods: [{ method: "POST", sourceFile: "routes.ts", changeType: "modified" }] },
-                ],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        // Both products and orders should be in changed section
-        expect(prompt).toMatch(/Likely changed in this PR[\s\S]*GET \/api\/products/);
-        expect(prompt).toMatch(/Likely changed in this PR[\s\S]*POST \/api\/orders/);
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Removed endpoint [removed] marker in prompt (Fix 3 verification)
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — removed endpoint listing", () => {
-    it("appends [removed] marker for removed endpoints not in current catalog", () => {
-        const analysis = minimalAnalysis({
-            apiEndpoints: {
-                totalCount: 1,
-                baseUrl: "http://localhost:3000",
-                endpoints: [{
-                        path: "/api/items",
-                        resourceGroup: "items",
-                        pathParams: [],
-                        methods: [{
-                                method: "GET", description: "List items", queryParams: [],
-                                authRequired: false, sourceFile: "routes.ts", interactions: [],
-                            }],
-                    }],
-            },
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/remove",
-                changedFiles: ["routes.ts"],
-                newEndpoints: [],
-                modifiedEndpoints: [],
-                removedEndpoints: [{
-                        path: "/api/legacy",
-                        methods: [{ method: "DELETE", sourceFile: "routes.ts", changeType: "removed" }],
-                    }],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("DELETE /api/legacy [removed]");
-        expect(prompt).toContain("Likely changed in this PR");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Long-context best practices: XML tags structure
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — XML tag structure (long-context best practice)", () => {
-    it("wraps repository context in <repository_context> tags", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).toContain("<repository_context>");
-        expect(prompt).toContain("</repository_context>");
-    });
-    it("wraps endpoint interactions in <endpoint_interactions> tags", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).toContain("<endpoint_interactions>");
-        expect(prompt).toContain("</endpoint_interactions>");
-    });
-    it("wraps existing tests in <existing_tests> tags", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).toContain("<existing_tests>");
-        expect(prompt).toContain("</existing_tests>");
-    });
-    it("wraps instructions in <instructions> tags", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).toContain("<instructions>");
-        expect(prompt).toContain("</instructions>");
-    });
-    it("wraps branch diff in <branch_diff> tags when diff context is present", () => {
-        const analysis = minimalAnalysis({
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["src/routes.ts"],
-                newEndpoints: [{ path: "/api/new", methods: [{ method: "POST", sourceFile: "routes.ts", interactionCount: 0 }] }],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("<branch_diff>");
-        expect(prompt).toContain("</branch_diff>");
-    });
-    it("wraps PR history in <pr_history> tags when present", () => {
-        const ctx = makePRContext({
-            prNumber: 42,
-            previousRecommendations: [
-                { testType: "contract", endpoint: "GET /api/items", status: "implemented", commentId: "1" },
-            ],
-        });
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff, 10, ctx);
-        expect(prompt).toContain("<pr_history>");
-        expect(prompt).toContain("</pr_history>");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Long-context best practice: data before instructions
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — data-before-instructions ordering", () => {
-    it("places repository_context before instructions", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        const dataIdx = prompt.indexOf("<repository_context>");
-        const instructionsIdx = prompt.indexOf("<instructions>");
-        expect(dataIdx).toBeLessThan(instructionsIdx);
-    });
-    it("places existing_tests before instructions", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        const testsIdx = prompt.indexOf("<existing_tests>");
-        const instructionsIdx = prompt.indexOf("<instructions>");
-        expect(testsIdx).toBeLessThan(instructionsIdx);
-    });
-    it("places endpoint_interactions before instructions", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        const interactionsIdx = prompt.indexOf("<endpoint_interactions>");
-        const instructionsIdx = prompt.indexOf("<instructions>");
-        expect(interactionsIdx).toBeLessThan(instructionsIdx);
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Few-shot examples
-// ---------------------------------------------------------------------------
-describe("buildFewShotExamples — concrete few-shot examples with thinking", () => {
-    it("returns examples wrapped in <examples> tags", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("<examples>");
-        expect(examples).toContain("</examples>");
-    });
-    it("contains at least 2 example blocks", () => {
-        const examples = buildFewShotExamples();
-        const count = (examples.match(/<example /g) || []).length;
-        expect(count).toBeGreaterThanOrEqual(2);
-    });
-    it("includes <thinking> blocks inside examples to demonstrate reasoning", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("<thinking>");
-        expect(examples).toContain("</thinking>");
-    });
-    it("includes an integration test example with tool calls", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("skyramp_batch_scenario_test_generation");
-        expect(examples).toContain("skyramp_integration_test_generation");
-    });
-    it("includes a contract test example", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("skyramp_contract_test_generation");
-    });
-    it("includes an ADDITIONAL example", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("[ADDITIONAL]");
-    });
-    it("thinking blocks demonstrate parameter grounding", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("**Parameter grounding**:");
-        expect(examples).toContain("workspace");
-        expect(examples).toContain("chained from");
-    });
-    it("integration example uses filePath from batch response, not a guessed filename", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("<filePath returned by skyramp_batch_scenario_test_generation");
-        expect(examples).not.toContain('scenarioFile: "scenario_');
-    });
-    it("integration example includes bugCatchingTarget", () => {
-        const examples = buildFewShotExamples();
-        expect(examples).toContain("bugCatchingTarget:");
-    });
-    it("is included in the recommendation prompt (PR mode only)", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff);
-        expect(prompt).toContain("<examples>");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Verification checklist
-// ---------------------------------------------------------------------------
-describe("buildVerificationChecklist — self-check at end of prompt", () => {
-    it("returns checklist wrapped in <verification> tags", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("<verification>");
-        expect(checklist).toContain("</verification>");
-    });
-    it("includes total count check aligned with Budget Plan range", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        // minTotal = min(3+1, 10) = 4 — range is 4–10
-        expect(checklist).toContain("between 4 and 10");
-        expect(checklist).toContain("Budget Plan");
-        expect(checklist).not.toContain("equals exactly 10");
-    });
-    it("includes scenarioFile source check", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("filePath");
-        expect(checklist).toContain("skyramp_batch_scenario_test_generation");
-    });
-    it("includes bugCatchingTarget check", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("bugCatchingTarget");
-    });
-    it("includes issue coverage check with promotion cap", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("Issue coverage");
-        expect(checklist).toContain("highest-severity flaw");
-        expect(checklist).toContain("At most one promotion per run");
-    });
-    it("includes distinct code path check", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("distinct code path");
-    });
-    it("includes auth consistency check", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("Auth parameters are consistent");
-    });
-    it("includes endpointURL format check", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("base URL and the path");
-    });
-    it("includes placeholder removal check", () => {
-        const checklist = buildVerificationChecklist(10, 3);
-        expect(checklist).toContain("from source");
-    });
-    it("is included in the recommendation prompt (PR mode only)", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis(), AnalysisScope.CurrentBranchDiff);
-        expect(prompt).toContain("<verification>");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Source evidence grounding
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — source evidence grounding", () => {
-    it("includes source_evidence instruction in repo-mode enrichment", () => {
-        const analysis = minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Test API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: [minimalScenario()],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.FullRepo, 10);
-        expect(prompt).toContain("Test Recommendations");
-    });
-    it("includes source_evidence instruction in PR-mode enrichment", () => {
-        const analysis = minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Test API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: [minimalScenario()],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).toContain("Execution Plan");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — Over-prompting reduction
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — reduced over-prompting", () => {
-    it("uses softer language for step labels (no MANDATORY)", () => {
-        const analysis = minimalAnalysis({
-            businessContext: {
-                mainPurpose: "Test API",
-                userFlows: [],
-                dataFlows: [],
-                integrationPatterns: [],
-                draftedScenarios: [minimalScenario()],
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis, AnalysisScope.CurrentBranchDiff, 10);
-        expect(prompt).not.toContain("(MANDATORY before executing anything)");
-        expect(prompt).toContain("(before anything else)");
-    });
-    it("uses XML tags in context fetching guidance", () => {
-        const guidance = buildContextFetchingGuidance("session-1");
-        expect(guidance).toContain("<context_fetching_protocol>");
-        expect(guidance).toContain("</context_fetching_protocol>");
-    });
-    it("uses XML tags in reasoning protocol", () => {
-        const protocol = buildReasoningProtocol();
-        expect(protocol).toContain("<reasoning_protocol>");
-        expect(protocol).toContain("</reasoning_protocol>");
-    });
-});
-// ---------------------------------------------------------------------------
-// testFingerprint — compact existing-test summary in repoContext
-// ---------------------------------------------------------------------------
-describe("buildRecommendationPrompt — testFingerprint", () => {
-    it("omits fingerprint when no existing test locations", () => {
-        const prompt = buildRecommendationPrompt(minimalAnalysis());
-        expect(prompt).not.toContain("Tests already covering endpoints in this repo");
-    });
-    it("includes fingerprint with file count and endpoints when testLocations present", () => {
-        const analysis = minimalAnalysis({
-            existingTests: {
-                frameworks: ["pytest"],
-                coverage: { unit: 0, integration: 1, e2e: 0, ui: 0, load: 0, contract: 1, smoke: 0 },
-                testLocations: {
-                    contract: "test_items_contract.py (covers: GET /api/items, POST /api/items)",
-                    integration: "test_orders_integration.py (covers: POST /api/orders)",
-                },
-                hasCoverageReports: false,
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toContain("Tests already covering endpoints in this repo (2 files)");
-        expect(prompt).toContain("contract: GET /api/items, POST /api/items");
-        expect(prompt).toContain("integration: POST /api/orders");
-    });
-    it("counts files without covers: clause correctly (e.g. UI tests)", () => {
-        const analysis = minimalAnalysis({
-            existingTests: {
-                frameworks: ["playwright"],
-                coverage: { unit: 0, integration: 0, e2e: 0, ui: 2, load: 0, contract: 0, smoke: 0 },
-                testLocations: {
-                    ui: "test_ui_login.py, test_ui_dashboard.py",
-                },
-                hasCoverageReports: false,
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis);
-        // File count should be 2, not 1
-        expect(prompt).toContain("Tests already covering endpoints in this repo (2 files)");
-    });
-    it("omits types with no endpoint coverage from fingerprint lines (no trailing 'ui: ' line)", () => {
-        const analysis = minimalAnalysis({
-            existingTests: {
-                frameworks: ["pytest", "playwright"],
-                coverage: { unit: 0, integration: 1, e2e: 0, ui: 1, load: 0, contract: 0, smoke: 0 },
-                testLocations: {
-                    integration: "test_orders.py (covers: POST /api/orders)",
-                    ui: "test_ui_login.py", // no covers: clause
-                },
-                hasCoverageReports: false,
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toContain("Tests already covering endpoints in this repo (2 files)");
-        expect(prompt).toContain("integration: POST /api/orders");
-        // UI type has no endpoints — must not emit a blank "ui: " line
-        expect(prompt).not.toMatch(/^\s*ui:\s*$/m);
-    });
-    it("distinguishes external tests from Skyramp tests in fingerprint", () => {
-        const analysis = minimalAnalysis({
-            existingTests: {
-                frameworks: ["pytest"],
-                coverage: { unit: 0, integration: 1, e2e: 0, ui: 0, load: 0, contract: 1, smoke: 0 },
-                testLocations: {
-                    contract: "test_items_contract.py (covers: GET /api/items)",
-                    integration: "tests/test_api.py [external] (covers: POST /api/orders)",
-                },
-                hasCoverageReports: false,
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toContain("1 Skyramp + 1 external");
-        expect(prompt).toContain("cannot be updated");
-    });
-    it("uses inclusive header for test coverage table", () => {
-        const analysis = minimalAnalysis({
-            existingTests: {
-                frameworks: ["pytest"],
-                coverage: { unit: 0, integration: 0, e2e: 0, ui: 0, load: 0, contract: 1, smoke: 0 },
-                testLocations: {
-                    contract: "test_items_contract.py (covers: GET /api/items)",
-                },
-                hasCoverageReports: false,
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toContain("Existing test coverage (Skyramp + external)");
-        expect(prompt).not.toContain("Existing Skyramp test coverage");
-    });
-    it("includes external test dedup rule that blocks CREATE", () => {
-        const analysis = minimalAnalysis({
-            existingTests: {
-                frameworks: ["pytest"],
-                coverage: { unit: 0, integration: 1, e2e: 0, ui: 0, load: 0, contract: 0, smoke: 0 },
-                testLocations: {
-                    integration: "tests/test_api.py [external] (covers: POST /api/orders)",
-                },
-                hasCoverageReports: false,
-            },
-        });
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toContain("[external]");
-        expect(prompt).toContain("do NOT create a new parallel test");
-        expect(prompt).toContain("Task 1 maintenance applies to them the same as Skyramp tests");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — External test dedup primitives
-// ---------------------------------------------------------------------------
-describe("buildExternalCoverageSet", () => {
-    it("parses single external test with one endpoint", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external] (covers: GET /api/v1/orders)',
-        });
-        expect(set.has("GET::orders::integration")).toBe(true);
-        expect(set.size).toBe(1);
-    });
-    it("parses multiple endpoints in one covers clause", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external] (covers: GET /api/v1/orders, POST /api/v1/orders, DELETE /api/v1/orders/{id})',
-        });
-        expect(set.has("GET::orders::integration")).toBe(true);
-        expect(set.has("POST::orders::integration")).toBe(true);
-        expect(set.has("DELETE::orders::integration")).toBe(true);
-        expect(set.size).toBe(3);
-    });
-    it("parses multiple external files in one test type", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_orders.py [external] (covers: GET /api/orders), tests/test_products.py [external] (covers: POST /api/products)',
-        });
-        expect(set.has("GET::orders::integration")).toBe(true);
-        expect(set.has("POST::products::integration")).toBe(true);
-        expect(set.size).toBe(2);
-    });
-    it("handles multiple test types", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external] (covers: GET /api/orders)',
-            contract: 'tests/test_contract.py [external] (covers: GET /api/orders)',
-        });
-        expect(set.has("GET::orders::integration")).toBe(true);
-        expect(set.has("GET::orders::contract")).toBe(true);
-        expect(set.size).toBe(2);
-    });
-    it("emits both integration and contract keys for unknown test type", () => {
-        const set = buildExternalCoverageSet({
-            unknown: 'tests/test_misc.py [external] (covers: GET /api/items)',
-        });
-        expect(set.has("GET::items::integration")).toBe(true);
-        expect(set.has("GET::items::contract")).toBe(true);
-        expect(set.size).toBe(2);
-    });
-    it("ignores Skyramp tests (no [external] tag)", () => {
-        const set = buildExternalCoverageSet({
-            contract: 'test_items_contract.py (covers: GET /api/items)',
-        });
-        expect(set.size).toBe(0);
-    });
-    it("ignores external tests without covers clause", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external]',
-        });
-        expect(set.size).toBe(0);
-    });
-    it("returns empty set for empty testLocations", () => {
-        const set = buildExternalCoverageSet({});
-        expect(set.size).toBe(0);
-    });
-    it("skips endpoints with unparseable paths", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external] (covers: GET )',
-        });
-        // "GET " → method="GET", path="" → resource="unknown" → skipped
-        expect(set.size).toBe(0);
-    });
-    it("strips path parameters from resource extraction", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external] (covers: PUT /api/v1/orders/{order_id})',
-        });
-        // {order_id} is a path param → skipped, resource is "orders"
-        expect(set.has("PUT::orders::integration")).toBe(true);
-        expect(set.size).toBe(1);
-    });
-    it("normalizes method to uppercase", () => {
-        const set = buildExternalCoverageSet({
-            integration: 'tests/test_api.py [external] (covers: get /api/orders)',
-        });
-        expect(set.has("GET::orders::integration")).toBe(true);
-    });
-});
-describe("externalDedupKey", () => {
-    it("builds key from single-step contract scenario", () => {
-        const scenario = {
-            scenarioName: "get_orders",
-            description: "Get orders",
-            category: "crud",
-            priority: "high",
-            steps: [{ order: 1, method: "GET", path: "/api/v1/orders", description: "list orders", interactionType: "success", expectedStatusCode: 200 }],
-            chainingKeys: [],
-            requiresAuth: false,
-            estimatedComplexity: "simple",
-        };
-        expect(externalDedupKey(scenario)).toBe("GET::orders::contract");
-    });
-    it("builds key from multi-step integration scenario using last mutating step", () => {
-        const scenario = {
-            scenarioName: "create_and_update_order",
-            description: "Create then update order",
-            category: "workflow",
-            priority: "high",
-            steps: [
-                { order: 1, method: "POST", path: "/api/v1/orders", description: "create order", interactionType: "success", expectedStatusCode: 201 },
-                { order: 2, method: "PUT", path: "/api/v1/orders/{order_id}", description: "update order", interactionType: "success", expectedStatusCode: 200 },
-                { order: 3, method: "GET", path: "/api/v1/orders/{order_id}", description: "verify", interactionType: "success", expectedStatusCode: 200 },
-            ],
-            chainingKeys: [],
-            requiresAuth: false,
-            estimatedComplexity: "moderate",
-        };
-        // Last mutating step is PUT /orders/{order_id} → resource "orders"
-        expect(externalDedupKey(scenario)).toBe("PUT::orders::integration");
-    });
-    it("falls back to last step when no mutating methods present", () => {
-        const scenario = {
-            scenarioName: "get_items",
-            description: "List and get items",
-            category: "crud",
-            priority: "medium",
-            steps: [
-                { order: 1, method: "GET", path: "/api/v1/items", description: "list items", interactionType: "success", expectedStatusCode: 200 },
-                { order: 2, method: "GET", path: "/api/v1/items/{id}", description: "get item", interactionType: "success", expectedStatusCode: 200 },
-            ],
-            chainingKeys: [],
-            requiresAuth: false,
-            estimatedComplexity: "simple",
-        };
-        // No mutating steps → falls back to last step → GET /items/{id} → resource "items"
-        expect(externalDedupKey(scenario)).toBe("GET::items::integration");
-    });
-    it("uses explicit testType when provided", () => {
-        const scenario = {
-            scenarioName: "get_orders_contract",
-            description: "Contract test for orders",
-            category: "crud",
-            priority: "high",
-            steps: [
-                { order: 1, method: "GET", path: "/api/v1/orders", description: "list orders", interactionType: "success", expectedStatusCode: 200 },
-                { order: 1, method: "POST", path: "/api/v1/orders", description: "create order", interactionType: "success", expectedStatusCode: 201 },
-            ],
-            chainingKeys: [],
-            requiresAuth: false,
-            estimatedComplexity: "simple",
-            testType: "contract",
-        };
-        expect(externalDedupKey(scenario)).toBe("POST::orders::contract");
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests — UI recommendation authoring rules
-// ---------------------------------------------------------------------------
-//
-// The recommendation prompt always emits a "UI Recommendation Authoring Rules"
-// section that anchors UI rec reasoning. Earlier iterations of this code
-// accepted a `capturedBlueprints` parameter and rendered the captures inline,
-// but that was redundant: the agent has the captures in its own tool-result
-// history. The prompt now ships the rules; the agent supplies the vocabulary.
-describe("buildRecommendationPrompt UI authoring rules", () => {
-    function minimalDiffAnalysis() {
-        return minimalAnalysis({
-            branchDiffContext: {
-                baseBranch: "main",
-                currentBranch: "feature/test",
-                changedFiles: ["src/components/OrderForm.tsx"],
-                newEndpoints: [],
-                modifiedEndpoints: [],
-                affectedServices: [],
-            },
-        });
-    }
-    it("emits UI authoring rules wrapped in an XML tag, unconditionally", () => {
-        const analysis = minimalDiffAnalysis();
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toContain("<ui_recommendation_authoring_rules>");
-        expect(prompt).toContain("</ui_recommendation_authoring_rules>");
-        expect(prompt).toMatch(/do NOT mention "blueprint"/i);
-        expect(prompt).toMatch(/do not invent element names/i);
-    });
-    it("does not render a 'Captured Blueprints' data section (param removed)", () => {
-        // Regression on the previous design: capturedBlueprints used to be
-        // threaded through the call and rendered as a "## Captured Blueprints"
-        // data section. That path is gone — the agent's own browser_blueprint
-        // tool-result history is the source of truth for element vocabulary.
-        const analysis = minimalDiffAnalysis();
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).not.toContain("## Captured Blueprints");
-    });
-    it("instructs the LLM to ground UI recommendations in elements observed via earlier browser_blueprint calls", () => {
-        const analysis = minimalDiffAnalysis();
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toMatch(/ground the [`]?reasoning[`]?\s*field in elements you have actually observed/i);
-        expect(prompt).toMatch(/inform.*how.*describe.*not.*which/i);
-    });
-    it("instructs the LLM not to leak internal MCP terminology into reasoning", () => {
-        const analysis = minimalDiffAnalysis();
-        const prompt = buildRecommendationPrompt(analysis);
-        expect(prompt).toMatch(/do NOT mention "blueprint"/i);
-        expect(prompt).toMatch(/leak builder internals/i);
-    });
-    it("does not abbreviate 'recommendation' to 'rec' in the rules section", () => {
-        // Per PR review: shortform 'rec' invites the LLM to hallucinate the term.
-        // Spell it out to keep the language consistent with the rest of the prompt.
-        const analysis = minimalDiffAnalysis();
-        const prompt = buildRecommendationPrompt(analysis);
-        const rulesStart = prompt.indexOf("<ui_recommendation_authoring_rules>");
-        const rulesEnd = prompt.indexOf("</ui_recommendation_authoring_rules>");
-        const rulesBlock = prompt.slice(rulesStart, rulesEnd);
-        // Allow "recs" as a substring within "recommendations" — match only the
-        // standalone word.
-        expect(rulesBlock).not.toMatch(/\b(rec|recs)\b/);
-    });
-});