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

package/build/tools/submitReportTool.test.js

@@ -1,1428 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import { TestType } from "../types/TestTypes.js";
-import { DriftAction } from "../types/TestAnalysis.js";
-import { TestExecutionStatus } from "../types/TestExecution.js";
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-import { execFileSync } from "child_process";
-import { z } from "zod";
-jest.unstable_mockModule("../utils/logger.js", () => ({
-    logger: { info: jest.fn(), error: jest.fn(), warning: jest.fn(), debug: jest.fn() },
-}));
-jest.unstable_mockModule("../services/AnalyticsService.js", () => ({
-    AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) },
-}));
-// @ts-ignore
-const { registerSubmitReportTool, additionalRecommendationSchema, newTestSchema, targetElementSchema, pageContextSchema } = await import("./submitReportTool.js");
-const { AnalyticsService } = await import("../services/AnalyticsService.js");
-const { CandidateSource } = await import("../types/Recommendation.js");
-const pushMCPToolEventMock = AnalyticsService.pushMCPToolEvent;
-function captureToolHandler() {
-    let handler;
-    let inputSchema;
-    const fakeServer = {
-        registerTool: (_name, opts, fn) => {
-            handler = fn;
-            inputSchema = opts.inputSchema;
-        },
-    };
-    registerSubmitReportTool(fakeServer);
-    // Mirrors the real MCP SDK's registerTool: validates args against inputSchema via Zod
-    // before invoking the handler, so tests exercise the real tool contract (refinements
-    // included) instead of bypassing validation entirely.
-    return async (params) => {
-        const parsed = z.object(inputSchema).safeParse(params);
-        if (!parsed.success) {
-            return { isError: true, content: [{ type: "text", text: parsed.error.message }] };
-        }
-        return handler(parsed.data);
-    };
-}
-async function writeStateFile(dir, existingTests) {
-    const stateFile = path.join(dir, "analyze-changes-state.json");
-    // maintenanceVerdicts: [] simulates skyramp_actions having already run with nothing to
-    // do — the realistic state for tests not specifically exercising the maintenance flow.
-    await fs.writeFile(stateFile, JSON.stringify({ existingTests, maintenanceVerdicts: [], metadata: sampleMetadata(dir) }), "utf-8");
-    return stateFile;
-}
-function sampleMetadata(dir) {
-    return {
-        sessionId: "test-session",
-        stateType: "unified",
-        repositoryPath: dir,
-        createdAt: "2026-01-01T00:00:00.000Z",
-        updatedAt: "2026-01-01T00:00:00.000Z",
-    };
-}
-// SKYR-3906: state written by skyramp_actions after drift-analysis reconciliation.
-async function writeReconciledStateFile(dir, existingTests, maintenanceVerdicts, ignoredTestFiles = []) {
-    const stateFile = path.join(dir, "analyze-changes-state.json");
-    await fs.writeFile(stateFile, JSON.stringify({ existingTests, maintenanceVerdicts, ignoredTestFiles, metadata: sampleMetadata(dir) }), "utf-8");
-    return stateFile;
-}
-function sampleReportParams(outputFile, stateFile) {
-    return {
-        summaryOutputFile: outputFile,
-        stateFile,
-        businessCaseAnalysis: "This PR adds product search. Tests needed for filtering.",
-        newTestsCreated: [
-            { testId: "smoke-get-products-search", testType: TestType.SMOKE, category: "workflow", endpoint: "GET /api/v1/products/search", fileName: "search_smoke_test.py", description: "Searches products by category filter and asserts matching results are returned", reasoning: "Validates product search returns correct results for category filter" },
-        ],
-        testResults: [
-            { testType: TestType.SMOKE, endpoint: "GET /api/v1/products", status: "Pass", details: "2.1s, products_smoke_test.py" },
-            { testType: TestType.SMOKE, endpoint: "GET /api/v1/products/search", status: "Fail", details: "3.4s, search_smoke_test.py" },
-        ],
-        issuesFound: [{ description: "Search endpoint returns 500 with category filter" }],
-    };
-}
-describe("registerSubmitReportTool", () => {
-    let handler;
-    let tmpDirs = [];
-    beforeAll(() => {
-        handler = captureToolHandler();
-    });
-    afterEach(async () => {
-        for (const dir of tmpDirs) {
-            await fs.rm(dir, { recursive: true, force: true });
-        }
-        tmpDirs = [];
-    });
-    it("should register the tool on the server with nextSteps in schema", () => {
-        const registerToolMock = jest.fn();
-        const fakeServer = { registerTool: registerToolMock };
-        registerSubmitReportTool(fakeServer);
-        expect(registerToolMock).toHaveBeenCalledWith("skyramp_submit_report", expect.objectContaining({
-            description: expect.any(String),
-            inputSchema: expect.objectContaining({
-                nextSteps: expect.any(Object),
-            }),
-        }), expect.any(Function));
-    });
-    it("should write JSON report to the specified file", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBeUndefined();
-        expect(result.content[0].text).toContain("Report submitted successfully");
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.businessCaseAnalysis).toBe("This PR adds product search. Tests needed for filtering.");
-        expect(written.newTestsCreated).toHaveLength(1);
-        expect(written.testResults).toHaveLength(2);
-        expect(written.issuesFound).toHaveLength(1);
-        expect(written.testMaintenance).toBeUndefined();
-    });
-    it("accepts and persists the per-item `repository` field", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const params = sampleReportParams(outputFile, stateFile);
-        // Attribute one item to a related repo, leave others on the primary.
-        params.newTestsCreated[0] = { ...params.newTestsCreated[0], repository: "acme/backend" };
-        params.testResults[0] = { ...params.testResults[0], repository: "acme/backend" };
-        params.issuesFound[0] = { ...params.issuesFound[0], repository: "acme/backend" };
-        const result = await handler(params);
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.newTestsCreated[0].repository).toBe("acme/backend");
-        expect(written.testResults[0].repository).toBe("acme/backend");
-        expect(written.issuesFound[0].repository).toBe("acme/backend");
-        // Items without a repository stay primary (undefined → omitted from JSON).
-        expect(written.testResults[1].repository).toBeUndefined();
-    });
-    it("normalizes a blank/whitespace-only `repository` to undefined", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const params = sampleReportParams(outputFile, stateFile);
-        params.testResults[0] = { ...params.testResults[0], repository: "   " };
-        const result = await handler(params);
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        // Blank string must not serialize as a distinct empty repo.
-        expect(written.testResults[0].repository).toBeUndefined();
-    });
-    it("should create parent directories if they don't exist", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "nested", "dirs", "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.businessCaseAnalysis).toBeDefined();
-    });
-    it("should handle empty arrays for optional sections", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            summaryOutputFile: outputFile,
-            stateFile,
-            businessCaseAnalysis: "Simple config change.",
-            newTestsCreated: [],
-            testResults: [
-                { testType: TestType.SMOKE, endpoint: "GET /api/v1/products", status: "Pass", details: "1.0s, test.py" },
-            ],
-            issuesFound: [],
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.newTestsCreated).toEqual([]);
-        expect(written.testMaintenance).toBeUndefined();
-        expect(written.issuesFound).toEqual([]);
-        expect(written.testResults).toHaveLength(1);
-    });
-    it("should return error for invalid file path", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler(sampleReportParams("/nonexistent/readonly/path/report.json", stateFile));
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("Failed to write report");
-    });
-    it("should write commitMessage when provided", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            ...sampleReportParams(outputFile, stateFile),
-            commitMessage: "add contract tests for /products endpoint",
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.commitMessage).toBe("add contract tests for /products endpoint");
-    });
-    it("should use default commitMessage when omitted", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.commitMessage).toBe("Added recommendations by Skyramp Testbot.");
-    });
-    it("should sanitize commitMessage (collapse newlines, trim whitespace)", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            ...sampleReportParams(outputFile, stateFile),
-            commitMessage: "  line one\nline two\r\nline three  ",
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.commitMessage).toBe("line one line two line three");
-        // No length cap — truncation is the consumer's responsibility (SKYR-3757).
-    });
-    it("should preserve commitMessage longer than 72 chars without truncation", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const longMessage = "add contract and integration tests for the new PATCH /orders/{order_id} endpoint including discount recalculation and line-item edits";
-        const result = await handler({
-            ...sampleReportParams(outputFile, stateFile),
-            commitMessage: longMessage,
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.commitMessage).toBe(longMessage);
-        expect(written.commitMessage.length).toBeGreaterThan(72);
-    });
-    it("should use default commitMessage when whitespace-only", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            ...sampleReportParams(outputFile, stateFile),
-            commitMessage: "   \n\r\n   ",
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.commitMessage).toBe("Added recommendations by Skyramp Testbot.");
-    });
-    it("includes nextSteps array in written JSON", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            ...sampleReportParams(outputFile, stateFile),
-            nextSteps: ["Check your targetSetupCommand — endpoints returned 404"],
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.nextSteps).toEqual([
-            "Check your targetSetupCommand — endpoints returned 404",
-        ]);
-    });
-    it("defaults nextSteps to empty array when omitted", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.nextSteps).toEqual([]);
-    });
-    it("should produce valid JSON with pretty formatting", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        await handler(sampleReportParams(outputFile, stateFile));
-        const raw = await fs.readFile(outputFile, "utf-8");
-        // Pretty-printed JSON should have indentation
-        expect(raw).toContain("  ");
-        // Should not contain summaryOutputFile in the output
-        expect(raw).not.toContain("summaryOutputFile");
-    });
-    it("additionalRecommendations serialises primaryEndpoint into the report JSON", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const params = {
-            ...sampleReportParams(outputFile, stateFile),
-            additionalRecommendations: [
-                {
-                    testId: "integration-orders-patch-status",
-                    testType: TestType.INTEGRATION,
-                    category: "business_rule",
-                    primaryEndpoint: "PATCH /api/v1/orders/{order_id}",
-                    scenarioName: "orders-patch-status-transition",
-                    steps: [{ method: "PATCH", path: "/api/v1/orders/1", description: "Patch order status" }],
-                    description: "Verifies status transitions persist across PATCH calls",
-                    priority: "high",
-                    reasoning: "Catches broken state machine transitions on the new PATCH endpoint",
-                },
-            ],
-        };
-        const result = await handler(params);
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.additionalRecommendations[0].primaryEndpoint).toBe("PATCH /api/v1/orders/{order_id}");
-    });
-    it("additionalRecommendationSchema rejects a contract test missing primaryEndpoint", () => {
-        const result = additionalRecommendationSchema.safeParse({
-            testId: "contract-orders-patch-404",
-            testType: TestType.CONTRACT,
-            category: "error_handling",
-            // primaryEndpoint intentionally omitted — required for contract tests
-            scenarioName: "orders-patch-not-found",
-            steps: [{ method: "PATCH", path: "/api/v1/orders/99999", description: "Patch non-existent order" }],
-            description: "Verifies 404 for unknown order_id",
-            priority: "high",
-            reasoning: "Validates the 404 guard on the new PATCH endpoint",
-        });
-        expect(result.success).toBe(false);
-        const issue = result.error?.issues.find(i => i.path.includes("primaryEndpoint"));
-        expect(issue).toBeDefined();
-    });
-    it("additionalRecommendationSchema accepts a contract test with primaryEndpoint", () => {
-        const result = additionalRecommendationSchema.safeParse({
-            testId: "contract-orders-patch-404",
-            testType: TestType.CONTRACT,
-            category: "error_handling",
-            primaryEndpoint: "PATCH /api/v1/orders/{order_id}",
-            scenarioName: "orders-patch-not-found",
-            steps: [{ method: "PATCH", path: "/api/v1/orders/99999", description: "Patch non-existent order" }],
-            description: "Verifies 404 for unknown order_id",
-            priority: "high",
-            reasoning: "Validates the 404 guard on the new PATCH endpoint",
-        });
-        expect(result.success).toBe(true);
-    });
-    it("additionalRecommendationSchema accepts a multi-step integration test without primaryEndpoint", () => {
-        // For multi-step scenarios, primaryEndpoint is optional — steps is the authoritative source
-        const result = additionalRecommendationSchema.safeParse({
-            testId: "integration-orders-patch-mutation",
-            testType: TestType.INTEGRATION,
-            category: "business_rule",
-            // primaryEndpoint intentionally omitted for multi-step scenario
-            scenarioName: "orders-patch-mutation-verify",
-            steps: [
-                { method: "POST", path: "/api/v1/products", description: "Create product" },
-                { method: "POST", path: "/api/v1/orders", description: "Create order" },
-                { method: "PATCH", path: "/api/v1/orders/1", description: "Patch order" },
-            ],
-            description: "Verifies total_amount recalculates after PATCH",
-            priority: "high",
-            reasoning: "Catches item accumulation bug",
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.data.primaryEndpoint).toBeUndefined();
-        }
-    });
-    // Structured grounding fields for UI recommendations.
-    // ----------------------------------------------------------------------
-    // Sub-schemas — targetElement and pageContext — populated by the agent
-    // from a captured browser_blueprint element. UI-only via superRefine on
-    // the parent newTestSchema / additionalRecommendationSchema.
-    describe("targetElementSchema", () => {
-        const validTarget = {
-            role: "button",
-            accessibleName: "Save changes",
-            testId: "save-changes-btn",
-            stableId: null,
-            contextText: null,
-            mutability: "mutable",
-            widgetType: "native",
-        };
-        it("accepts a fully-populated targetElement", () => {
-            expect(targetElementSchema.safeParse(validTarget).success).toBe(true);
-        });
-        it("accepts a minimal targetElement (only required fields)", () => {
-            const result = targetElementSchema.safeParse({
-                role: "heading",
-                accessibleName: "Notifications",
-                testId: null,
-                stableId: null,
-                contextText: null,
-            });
-            expect(result.success).toBe(true);
-        });
-        it("accepts contextText as a string array (repeating-row case)", () => {
-            const result = targetElementSchema.safeParse({
-                ...validTarget,
-                contextText: ["customer@example.com", "$129.99", "Pending"],
-            });
-            expect(result.success).toBe(true);
-        });
-        it("rejects targetElement missing accessibleName", () => {
-            const { accessibleName: _accessibleName, ...withoutName } = validTarget;
-            const result = targetElementSchema.safeParse(withoutName);
-            expect(result.success).toBe(false);
-        });
-        it("rejects targetElement missing role", () => {
-            const { role: _role, ...withoutRole } = validTarget;
-            const result = targetElementSchema.safeParse(withoutRole);
-            expect(result.success).toBe(false);
-        });
-        it("rejects an invalid mutability enum value", () => {
-            const result = targetElementSchema.safeParse({ ...validTarget, mutability: "sometimes" });
-            expect(result.success).toBe(false);
-        });
-        it("rejects an invalid widgetType enum value", () => {
-            const result = targetElementSchema.safeParse({ ...validTarget, widgetType: "fancy" });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("pageContextSchema (UI recommendation grounding)", () => {
-        it("accepts pageContext with both url and pageHash", () => {
-            const result = pageContextSchema.safeParse({
-                url: "http://localhost:5173/orders/1",
-                pageHash: "10:434266447",
-            });
-            expect(result.success).toBe(true);
-        });
-        it("accepts pageContext without pageHash (optional)", () => {
-            const result = pageContextSchema.safeParse({ url: "http://localhost:5173/orders/1" });
-            expect(result.success).toBe(true);
-        });
-        it("rejects pageContext missing url", () => {
-            const result = pageContextSchema.safeParse({ pageHash: "10:abc" });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("newTestSchema with grounding fields (UI recommendation grounding)", () => {
-        const validTarget = {
-            role: "button",
-            accessibleName: "Save changes",
-            testId: "save-changes-btn",
-            stableId: null,
-            contextText: null,
-        };
-        const validPage = {
-            url: "http://localhost:5173/orders/1",
-            pageHash: "10:434266447",
-        };
-        const baseUITest = {
-            testId: "ui-edit-order-discount-validation",
-            testType: TestType.UI,
-            category: "business_rule",
-            endpoint: "PATCH /api/v1/orders/{id}",
-            fileName: "edit_order_discount.spec.ts",
-            description: "Navigates to the Edit Order form, enters a discount > 100, and asserts that the validation error appears and the Save button is disabled.",
-            reasoning: "Verifies the **Save changes** button (testid `save-changes-btn`) on the Edit Order form shows the validation error when discount > 100.",
-        };
-        it("accepts a UI test with single-element targetElements + pageContext", () => {
-            const result = newTestSchema.safeParse({
-                ...baseUITest,
-                targetElements: [validTarget],
-                pageContext: validPage,
-            });
-            expect(result.success).toBe(true);
-        });
-        it("accepts a UI test with multi-element targetElements (render-state test)", () => {
-            const result = newTestSchema.safeParse({
-                ...baseUITest,
-                targetElements: [
-                    {
-                        role: "heading",
-                        accessibleName: "Edit Order",
-                        testId: "edit-order-heading",
-                        stableId: null,
-                        contextText: null,
-                    },
-                    {
-                        role: "spinbutton",
-                        accessibleName: "Discount (%)",
-                        testId: "edit-order-input-discount",
-                        stableId: null,
-                        contextText: null,
-                    },
-                ],
-                pageContext: validPage,
-            });
-            expect(result.success).toBe(true);
-        });
-        it("rejects a UI test without targetElements (required for UI grounding)", () => {
-            const result = newTestSchema.safeParse(baseUITest);
-            expect(result.success).toBe(false);
-            expect(JSON.stringify(result.error?.issues)).toContain("targetElements is required for testType: 'ui'");
-        });
-        it("accepts a UI test with targetElements: null (fallback case)", () => {
-            const result = newTestSchema.safeParse({
-                ...baseUITest,
-                targetElements: null,
-                description: "[no-blueprint-data] Navigates to Edit Order form and checks discount validation error.",
-                reasoning: "[no-blueprint-data] Verifies the discount validation error appears on the Edit Order form when discount > 100.",
-            });
-            expect(result.success).toBe(true);
-        });
-        it("rejects a contract test that includes targetElements (UI-only)", () => {
-            const result = newTestSchema.safeParse({
-                testId: "contract-orders-patch",
-                testType: TestType.CONTRACT,
-                category: "business_rule",
-                endpoint: "PATCH /api/v1/orders/{id}",
-                fileName: "orders_patch_contract.py",
-                reasoning: "Validates request shape and 200/422 status codes",
-                targetElements: [validTarget],
-                description: "calls the PATCH /api/v1/orders/{id} API and validates it implements its contract.",
-            });
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues.some((i) => i.path.includes("targetElements"))).toBe(true);
-            }
-        });
-        it("rejects an integration test that includes pageContext (UI-only)", () => {
-            const result = newTestSchema.safeParse({
-                testId: "integration-orders",
-                testType: TestType.INTEGRATION,
-                category: "business_rule",
-                endpoint: "POST /api/v1/orders",
-                fileName: "orders_integration.py",
-                reasoning: "Multi-step order lifecycle",
-                pageContext: validPage,
-                description: "calls the POST /api/v1/orders API to create an order and then do stuff.",
-            });
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues.some((i) => i.path.includes("pageContext"))).toBe(true);
-            }
-        });
-    });
-    describe("additionalRecommendationSchema with grounding fields (UI recommendation grounding)", () => {
-        const validTarget = {
-            role: "button",
-            accessibleName: "Save changes",
-            testId: "save-changes-btn",
-            stableId: null,
-            contextText: null,
-        };
-        const validPage = { url: "http://localhost:5173/orders/1" };
-        it("accepts a UI rec with targetElements + pageContext", () => {
-            const result = additionalRecommendationSchema.safeParse({
-                testId: "ui-edit-order-discount-validation",
-                testType: TestType.UI,
-                category: "business_rule",
-                steps: [{ description: "Open Edit Order, type 150 in discount, click Save" }],
-                description: "Verify discount > 100 shows validation error",
-                priority: "medium",
-                reasoning: "Verify that the **Save changes** button (testid `save-changes-btn`) on the Edit Order form shows the validation error when discount > 100.",
-                targetElements: [validTarget],
-                pageContext: validPage,
-            });
-            expect(result.success).toBe(true);
-        });
-        it("rejects a non-UI rec that includes targetElements", () => {
-            const result = additionalRecommendationSchema.safeParse({
-                testId: "integration-orders-patch",
-                testType: TestType.INTEGRATION,
-                category: "business_rule",
-                steps: [{ method: "PATCH", path: "/api/v1/orders/1", description: "Patch order" }],
-                description: "Verifies PATCH workflow",
-                priority: "high",
-                reasoning: "Catches mutation bugs",
-                targetElements: [validTarget],
-            });
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues.some((i) => i.path.includes("targetElements"))).toBe(true);
-            }
-        });
-    });
-    describe("analytics metrics", () => {
-        beforeEach(() => {
-            pushMCPToolEventMock.mockClear();
-        });
-        function lastAnalyticsParams() {
-            expect(pushMCPToolEventMock).toHaveBeenCalled();
-            const calls = pushMCPToolEventMock.mock.calls;
-            return calls[calls.length - 1][2];
-        }
-        it("emits per-run count metrics derived from the report", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            // sampleReportParams: 1 new test, 2 results (1 Pass + 1 Fail), 1 issue (no severity).
-            // Plus 1 maintenance verdict (no matching existingTests entry) from state.
-            const stateFile = await writeReconciledStateFile(tmpDir, [], [
-                { testFilePath: "/repo/products_contract_test.py", action: DriftAction.Update, rationale: "Updated auth flow in existing tests", testType: TestType.CONTRACT, endpoint: "GET /api/v1/products" },
-            ]);
-            await handler(sampleReportParams(outputFile, stateFile));
-            const params = lastAnalyticsParams();
-            expect(params.testsGenerated).toBe("1");
-            expect(params.testsMaintained).toBe("1");
-            expect(params.recommendationsCount).toBe("0");
-            expect(params.maintenanceRecovered).toBe("0"); // no matching stateFile entry → no execution data
-            expect(params.testsPassed).toBe("1");
-            expect(params.testsFailed).toBe("1");
-            expect(params.testsSkipped).toBe("0");
-            expect(params.issuesFound).toBe("1");
-        });
-        it("breaks issues down by severity", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFile(tmpDir, []);
-            await handler({
-                ...sampleReportParams(outputFile, stateFile),
-                issuesFound: [
-                    { description: "Data corruption on checkout", severity: "critical" },
-                    { description: "Wrong total returned", severity: "high" },
-                    { description: "Another wrong total", severity: "high" },
-                    { description: "Minor gap", severity: "medium" },
-                    { description: "Unlabeled issue" },
-                ],
-            });
-            const params = lastAnalyticsParams();
-            expect(params.issuesFound).toBe("5");
-            expect(params.issuesCritical).toBe("1");
-            expect(params.issuesHigh).toBe("2");
-            expect(params.issuesMedium).toBe("1");
-            expect(params.issuesLow).toBe("0");
-        });
-        it("reports zero metrics for an empty report", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFile(tmpDir, []);
-            await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Config-only change.",
-                newTestsCreated: [],
-                testResults: [],
-                issuesFound: [],
-            });
-            const params = lastAnalyticsParams();
-            expect(params.testsGenerated).toBe("0");
-            expect(params.testsMaintained).toBe("0");
-            expect(params.maintenanceRecovered).toBe("0");
-            expect(params.testsPassed).toBe("0");
-            expect(params.issuesFound).toBe("0");
-        });
-        it("testsMaintained counts only change actions, not VERIFY/IGNORE no-ops", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeReconciledStateFile(tmpDir, [], [
-                // Real change
-                { testFilePath: "/repo/products_contract_test.py", action: DriftAction.Update, rationale: "Patched auth", testType: TestType.CONTRACT, endpoint: "GET /api/v1/products" },
-                { testFilePath: "/repo/orders_smoke_test.py", action: DriftAction.Regenerate, rationale: "Rewrote for new shape", testType: TestType.SMOKE, endpoint: "GET /api/v1/orders" },
-                // No-ops — assessed but not modified
-                { testFilePath: "/repo/reviews_smoke_test.py", action: DriftAction.Ignore, rationale: "No action required", testType: TestType.SMOKE, endpoint: "GET /api/v1/reviews" },
-                { testFilePath: "/repo/coupons_smoke_test.py", action: DriftAction.Verify, rationale: "Verified still valid", testType: TestType.SMOKE, endpoint: "GET /api/v1/coupons" },
-            ]);
-            await handler(sampleReportParams(outputFile, stateFile));
-            const params = lastAnalyticsParams();
-            // 2 change actions (UPDATE + REGENERATE), not 4
-            expect(params.testsMaintained).toBe("2");
-            // No matching stateFile entries — execution data unavailable
-            expect(params.maintenanceRecovered).toBe("0");
-        });
-    });
-    // ─────────────────────────────────────────────────────────────────────────────
-    // testMaintenance output shapes
-    // Each case documents exactly what the MCP writes to JSON, which is what the
-    // testbot renderer reads. Keeping these in sync prevents silent regressions
-    // when toOutput or the stateFile enrichment path changes.
-    // ─────────────────────────────────────────────────────────────────────────────
-    describe("testMaintenance output shapes", () => {
-        const baseVerdict = {
-            testFilePath: "/repo/backend/tests/orders_contract_test.py",
-            rationale: "Updated discount fields in assertions",
-            testType: TestType.CONTRACT,
-            endpoint: "GET /api/v1/orders",
-        };
-        async function submitAndReadMaintenance(tmpDir, stateFile, testMaintenanceDetails = []) {
-            const outputFile = path.join(tmpDir, "report.json");
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Test",
-                newTestsCreated: [],
-                testMaintenanceDetails,
-                testResults: [],
-                issuesFound: [],
-            });
-            if (result.isError)
-                throw new Error(`handler rejected: ${result.content?.[0]?.text}`);
-            const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-            return written.testMaintenance;
-        }
-        // ── No matching existingTests entry ───────────────────────────────────────
-        it("UPDATE with no matching existingTests entry: beforeStatus=Unknown, afterStatus=Unknown", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [], [{ ...baseVerdict, action: DriftAction.Update }]);
-            const result = await submitAndReadMaintenance(tmpDir, stateFile);
-            expect(result[0].beforeStatus).toBe("Unknown");
-            expect(result[0].afterStatus).toBe("Unknown");
-            expect(result[0].beforeDetails).toBe("");
-            expect(result[0].afterDetails).toBe("");
-        });
-        it("IGNORE with no matching existingTests entry: both Skipped", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [], [{ ...baseVerdict, action: DriftAction.Ignore }]);
-            const result = await submitAndReadMaintenance(tmpDir, stateFile);
-            expect(result[0].beforeStatus).toBe("Skipped");
-            expect(result[0].afterStatus).toBe("Skipped");
-            expect(result[0].beforeDetails).toBe("");
-            expect(result[0].afterDetails).toBe("");
-        });
-        it("DELETE with no matching existingTests entry: beforeStatus=Unknown, afterStatus=Skipped", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [], [{ ...baseVerdict, action: DriftAction.Delete }]);
-            const result = await submitAndReadMaintenance(tmpDir, stateFile);
-            expect(result[0].beforeStatus).toBe("Unknown");
-            expect(result[0].afterStatus).toBe("Skipped");
-        });
-        // ── With matching existingTests entry ─────────────────────────────────────
-        it("UPDATE with before=Pass after=Pass: status from stateFile, details from the LLM-drafted testMaintenanceDetails", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 15090 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 12880 },
-                }], [{ ...baseVerdict, action: DriftAction.Update }]);
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "4 passed in 15.09s", afterDetails: "5 passed in 12.88s" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Pass");
-            expect(result[0].beforeDetails).toBe("4 passed in 15.09s");
-            expect(result[0].afterStatus).toBe("Pass");
-            expect(result[0].afterDetails).toBe("5 passed in 12.88s");
-        });
-        it("UPDATE with before=Pass after=Fail: rejects when afterDetails is missing for a recorded execution", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 15090 },
-                    executionAfter: { status: TestExecutionStatus.Fail, errors: ["check_schema fails, test isolation bug"], duration: 10940 },
-                }], [{ ...baseVerdict, action: DriftAction.Update }]);
-            const outputFile = path.join(tmpDir, "report.json");
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Test",
-                newTestsCreated: [],
-                testMaintenanceDetails: [{ testFilePath: baseVerdict.testFilePath, beforeDetails: "4 passed in 15.09s", afterDetails: "" }], // afterDetails left blank
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("orders_contract_test.py (afterDetails)");
-        });
-        it("UPDATE with before=Pass after=Fail: afterDetails carries the LLM's drafted root cause when supplied", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 15090 },
-                    executionAfter: { status: TestExecutionStatus.Fail, errors: ["check_schema fails, test isolation bug"], duration: 10940 },
-                }], [{ ...baseVerdict, action: DriftAction.Update }]);
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "4 passed in 15.09s", afterDetails: "FAILED test_orders_get — check_schema fails, test isolation bug" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Pass");
-            expect(result[0].afterStatus).toBe("Fail");
-            expect(result[0].afterDetails).toBe("FAILED test_orders_get — check_schema fails, test isolation bug");
-        });
-        it("UPDATE with crashed execution: status is Error", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Error, errors: ["Connection refused"], duration: 500 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
-                }], [{ ...baseVerdict, action: DriftAction.Update }]);
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "Error — Connection refused", afterDetails: "5 passed in 2.00s" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Error");
-            expect(result[0].afterStatus).toBe("Pass");
-        });
-        it("UPDATE Fail→Pass: counted as maintenanceRecovered in analytics", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Fail, errors: ["FAILED test_foo - assert False"], duration: 5000 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 5000 },
-                }], [{ ...baseVerdict, action: DriftAction.Update }]);
-            await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "FAILED test_foo - assert False", afterDetails: "5 passed in 5.00s" },
-            ]);
-            expect(pushMCPToolEventMock.mock.calls.at(-1)?.[2].maintenanceRecovered).toBe("1");
-        });
-        it("UPDATE with no before-execution recorded: beforeStatus=Unknown, afterStatus=Pass, no beforeDetails required", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    // executionBefore absent — agent skipped before-phase
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
-                }], [{ ...baseVerdict, action: DriftAction.Update }]);
-            // Only afterDetails is meaningful — there's no recorded before-execution to summarize,
-            // so beforeDetails is the empty-string sentinel (the field is required, not omittable).
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "", afterDetails: "5 passed in 2.00s" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Unknown");
-            expect(result[0].afterStatus).toBe("Pass");
-        });
-        it("DELETE with before-execution, no after (file deleted): beforeStatus=Pass, afterStatus=Skipped, no afterDetails required", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
-                    // executionAfter absent — file was deleted, nothing to run
-                }], [{ ...baseVerdict, action: DriftAction.Delete }]);
-            // Only beforeDetails is meaningful — there's no recorded after-execution to summarize,
-            // so afterDetails is the empty-string sentinel (the field is required, not omittable).
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "4 passed in 2.00s", afterDetails: "" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Pass");
-            expect(result[0].afterStatus).toBe("Skipped");
-        });
-        it("REGENERATE with before=Fail after=Pass: requires both details, rejects when either is missing", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Fail, errors: ["schema drift"], duration: 4000 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 3000 },
-                }], [{ ...baseVerdict, action: DriftAction.Regenerate }]);
-            const outputFile = path.join(tmpDir, "report.json");
-            const rejected = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Test",
-                newTestsCreated: [],
-                testMaintenanceDetails: [{ testFilePath: baseVerdict.testFilePath, beforeDetails: "FAILED — schema drift", afterDetails: "" }], // afterDetails left blank
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(rejected.isError).toBe(true);
-            expect(rejected.content[0].text).toContain("orders_contract_test.py (afterDetails)");
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "FAILED — schema drift", afterDetails: "regenerated test now passes" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Fail");
-            expect(result[0].afterStatus).toBe("Pass");
-        });
-        it("VERIFY with a recorded execution: requires details even though VERIFY is not a change action", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 1500 },
-                }], [{ ...baseVerdict, action: DriftAction.Verify }]);
-            const outputFile = path.join(tmpDir, "report.json");
-            const rejected = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Test",
-                newTestsCreated: [],
-                testMaintenanceDetails: [],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(rejected.isError).toBe(true);
-            expect(rejected.content[0].text).toContain("orders_contract_test.py (beforeDetails)");
-            const result = await submitAndReadMaintenance(tmpDir, stateFile, [
-                { testFilePath: baseVerdict.testFilePath, beforeDetails: "confirmed still passes, no changes needed", afterDetails: "" },
-            ]);
-            expect(result[0].beforeStatus).toBe("Pass");
-        });
-        it("DELETE with a spurious executionAfter recorded: afterDetails is still required despite DELETE's default afterStatus being Skipped", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: baseVerdict.testFilePath,
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
-                    // executionAfter present even though the file should have been deleted — documents
-                    // that the required-details gate keys off recorded executions, not the action type.
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 1800 },
-                }], [{ ...baseVerdict, action: DriftAction.Delete }]);
-            const outputFile = path.join(tmpDir, "report.json");
-            const rejected = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Test",
-                newTestsCreated: [],
-                testMaintenanceDetails: [{ testFilePath: baseVerdict.testFilePath, beforeDetails: "4 passed in 2.00s", afterDetails: "" }], // afterDetails left blank
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(rejected.isError).toBe(true);
-            expect(rejected.content[0].text).toContain("orders_contract_test.py (afterDetails)");
-        });
-    });
-    it("testResult accepts videoPath field (optional)", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            summaryOutputFile: outputFile,
-            stateFile,
-            businessCaseAnalysis: "UI changes for login flow",
-            newTestsCreated: [],
-            testMaintenance: [],
-            testResults: [
-                {
-                    testType: TestType.UI,
-                    endpoint: "GET /login",
-                    status: "Pass",
-                    details: "5.2s, login_ui_test.spec.ts",
-                    videoPath: "/workspace/.skyramp/videos/login_ui_test-abc12345/video.webm",
-                },
-            ],
-            issuesFound: [],
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.testResults).toHaveLength(1);
-        expect(written.testResults[0].videoPath).toBe("/workspace/.skyramp/videos/login_ui_test-abc12345/video.webm");
-    });
-    it("testResult accepts entry without videoPath (optional field)", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-        tmpDirs.push(tmpDir);
-        const outputFile = path.join(tmpDir, "report.json");
-        const stateFile = await writeStateFile(tmpDir, []);
-        const result = await handler({
-            summaryOutputFile: outputFile,
-            stateFile,
-            businessCaseAnalysis: "API endpoint changes",
-            newTestsCreated: [],
-            testMaintenance: [],
-            testResults: [
-                {
-                    testType: TestType.CONTRACT,
-                    endpoint: "POST /api/v1/products",
-                    status: "Pass",
-                    details: "2.1s, products_contract_test.py",
-                    // videoPath intentionally omitted
-                },
-            ],
-            issuesFound: [],
-        });
-        expect(result.isError).toBeUndefined();
-        const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-        expect(written.testResults).toHaveLength(1);
-        expect(written.testResults[0].videoPath).toBeUndefined();
-    });
-    describe("testMaintenance derived from state (SKYR-3906)", () => {
-        it("derives testMaintenance from stateData.maintenanceVerdicts when testMaintenance is omitted", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeReconciledStateFile(tmpDir, [{ testFile: "/repo/tests/orders_contract_test.py" }], [{ testFilePath: "/repo/tests/orders_contract_test.py", action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }]);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a field to orders",
-                newTestsCreated: [],
-                // testMaintenance intentionally omitted — should be derived from state.
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-            const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-            expect(written.testMaintenance).toEqual([
-                expect.objectContaining({
-                    fileName: "orders_contract_test.py",
-                    testType: TestType.CONTRACT,
-                    endpoint: "GET /api/v1/orders",
-                    action: DriftAction.Update,
-                    description: "Field added",
-                }),
-            ]);
-        });
-        it("rejects when maintenanceVerdicts is undefined and existing tests were present — skyramp_actions was never called", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            // Plain writeStateFile with no maintenanceVerdicts override — undefined, distinct
-            // from skyramp_actions having run and recorded an empty array.
-            const stateFile = path.join(tmpDir, "analyze-changes-state.json");
-            await fs.writeFile(stateFile, JSON.stringify({
-                existingTests: [{ testFile: "/repo/tests/orders_contract_test.py" }],
-                metadata: { sessionId: "test-session", stateType: "unified", repositoryPath: tmpDir, createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" },
-            }), "utf-8");
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a field to orders",
-                newTestsCreated: [],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("skyramp_actions was not called");
-        });
-        it("allows maintenanceVerdicts to be undefined when there were no existing tests to assess", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            // No existing tests at all — nothing skyramp_actions could have lost, so skipping
-            // it entirely (never writing maintenanceVerdicts) is a valid, not an error, state.
-            const stateFile = path.join(tmpDir, "analyze-changes-state.json");
-            await fs.writeFile(stateFile, JSON.stringify({
-                existingTests: [],
-                metadata: { sessionId: "test-session", stateType: "unified", repositoryPath: tmpDir, createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" },
-            }), "utf-8");
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a new endpoint with no prior coverage",
-                newTestsCreated: [],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-            const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-            expect(written.testMaintenance).toBeUndefined();
-        });
-        it("rejects when a related repo has reconciled maintenanceVerdicts — testMaintenance has no repository field to carry them", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = path.join(tmpDir, "analyze-changes-state.json");
-            const now = "2026-01-01T00:00:00.000Z";
-            await fs.writeFile(stateFile, JSON.stringify({
-                existingTests: [],
-                maintenanceVerdicts: [],
-                metadata: { sessionId: "test-session", stateType: "unified", repositoryPath: tmpDir, createdAt: now, updatedAt: now },
-                relatedRepos: {
-                    "acme/backend": {
-                        repositoryPath: "/repo/backend",
-                        data: {
-                            existingTests: [],
-                            maintenanceVerdicts: [
-                                { testFilePath: "/repo/backend/tests/orders_test.py", action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" },
-                            ],
-                        },
-                    },
-                },
-            }), "utf-8");
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Test",
-                newTestsCreated: [],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("acme/backend");
-        });
-        it("rejects when a recorded execution has no matching testMaintenanceDetails entry at all", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: "/repo/tests/orders_contract_test.py",
-                    executionBefore: { status: TestExecutionStatus.Fail, errors: ["assert 403 got 200"], duration: 4200 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 5090 },
-                }], [{ testFilePath: "/repo/tests/orders_contract_test.py", action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }]);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a field to orders",
-                newTestsCreated: [],
-                // testMaintenanceDetails omitted entirely, despite both executions being recorded.
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("orders_contract_test.py (beforeDetails)");
-            expect(result.content[0].text).toContain("orders_contract_test.py (afterDetails)");
-        });
-        it("rejects a whitespace-only testMaintenanceDetails summary as if it were missing", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: "/repo/tests/orders_contract_test.py",
-                    executionBefore: { status: TestExecutionStatus.Fail, errors: ["assert 403 got 200"], duration: 4200 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 5090 },
-                }], [{ testFilePath: "/repo/tests/orders_contract_test.py", action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }]);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a field to orders",
-                newTestsCreated: [],
-                testMaintenanceDetails: [{
-                        testFilePath: "/repo/tests/orders_contract_test.py",
-                        beforeDetails: "   ",
-                        afterDetails: "5 passed in 5.09s",
-                    }],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("orders_contract_test.py (beforeDetails)");
-        });
-        it("prefers the LLM-drafted testMaintenanceDetails summary when supplied", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: "/repo/tests/orders_contract_test.py",
-                    executionBefore: { status: TestExecutionStatus.Fail, errors: ["assert 403 got 200"], duration: 4200 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 5090 },
-                }], [{ testFilePath: "/repo/tests/orders_contract_test.py", action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }]);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a field to orders",
-                newTestsCreated: [],
-                testMaintenanceDetails: [{
-                        testFilePath: "/repo/tests/orders_contract_test.py",
-                        beforeDetails: "FAILED test_orders_get — auth middleware not enforced for the new field",
-                        afterDetails: "5 passed in 5.09s",
-                    }],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-            const written = JSON.parse(await fs.readFile(outputFile, "utf-8"));
-            expect(written.testMaintenance[0].beforeDetails).toBe("FAILED test_orders_get — auth middleware not enforced for the new field");
-            expect(written.testMaintenance[0].afterDetails).toBe("5 passed in 5.09s");
-        });
-        it("rejects when only one of beforeDetails/afterDetails is supplied but both executions were recorded", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeReconciledStateFile(tmpDir, [{
-                    testFile: "/repo/tests/orders_contract_test.py",
-                    executionBefore: { status: TestExecutionStatus.Fail, errors: ["assert 403 got 200"], duration: 4200 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 5090 },
-                }], [{ testFilePath: "/repo/tests/orders_contract_test.py", action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }]);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a field to orders",
-                newTestsCreated: [],
-                testMaintenanceDetails: [{
-                        testFilePath: "/repo/tests/orders_contract_test.py",
-                        beforeDetails: "FAILED test_orders_get — auth middleware not enforced for the new field",
-                        afterDetails: "", // left blank, but an after-execution was recorded — must be rejected.
-                    }],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("orders_contract_test.py (afterDetails)");
-            expect(result.content[0].text).not.toContain("beforeDetails");
-        });
-    });
-    describe("approvedPlan cross-check (SKYR-3879 Path B)", () => {
-        async function writeStateFileWithPlan(dir, approvedPlan) {
-            const stateFile = path.join(dir, "analyze-changes-state.json");
-            await fs.writeFile(stateFile, JSON.stringify({
-                existingTests: [],
-                maintenanceVerdicts: [],
-                ...(approvedPlan ? { approvedPlan } : {}),
-                metadata: sampleMetadata(dir),
-            }), "utf-8");
-            return stateFile;
-        }
-        const APPROVED_PLAN = {
-            planId: "plan-42",
-            createdAt: "2026-01-01T00:00:00.000Z",
-            generate: [
-                {
-                    candidateId: "products-search-abcd1234",
-                    scenarioName: "products_search",
-                    testType: "contract",
-                    category: "business_rule",
-                    source: CandidateSource.AGENT,
-                    matchKeys: ["name:products-search", "ep:contract:GET:/api/v1/products/search"],
-                },
-            ],
-            additional: [],
-            demotions: [],
-        };
-        function contractNewTest(overrides = {}) {
-            return {
-                testId: "contract-get-products-search",
-                testType: TestType.CONTRACT,
-                category: "business_rule",
-                endpoint: "GET /api/v1/products/search",
-                fileName: "products_search_contract_test.py",
-                description: "Searches products and asserts the response schema.",
-                reasoning: "Validates the contract for the new search endpoint.",
-                ...overrides,
-            };
-        }
-        it("passes when every gated newTestsCreated entry matches an approved GENERATE item", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFileWithPlan(tmpDir, APPROVED_PLAN);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds product search.",
-                newTestsCreated: [contractNewTest()],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-        });
-        it("rejects an unapproved gated entry, naming the offending entry and the approved list", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFileWithPlan(tmpDir, APPROVED_PLAN);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds an unregistered contract test.",
-                newTestsCreated: [
-                    contractNewTest({
-                        testId: "contract-get-products-unregistered",
-                        endpoint: "GET /api/v1/products/unregistered",
-                    }),
-                ],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("plan-42");
-            expect(result.content[0].text).toContain("contract-get-products-unregistered");
-            expect(result.content[0].text).toContain("products_search");
-        });
-        it("accepts a gated entry matching an approved ADDITIONAL item — backfill parity with planGuard", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFileWithPlan(tmpDir, {
-                ...APPROVED_PLAN,
-                additional: [
-                    {
-                        candidateId: "products-backfill-efgh5678",
-                        scenarioName: "products_backfill",
-                        testType: "contract",
-                        category: "business_rule",
-                        source: CandidateSource.AGENT,
-                        matchKeys: ["name:products-backfill", "ep:contract:GET:/api/v1/products/backfill"],
-                    },
-                ],
-            });
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "GENERATE item failed; backfilled from ADDITIONAL as the plan instructs.",
-                newTestsCreated: [
-                    contractNewTest({
-                        testId: "contract-get-products-backfill",
-                        endpoint: "GET /api/v1/products/backfill",
-                    }),
-                ],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-        });
-        it("rejects an ADDITIONAL-matching entry when the GENERATE list is empty — zero-budget plans have nothing to backfill", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFileWithPlan(tmpDir, {
-                ...APPROVED_PLAN,
-                generate: [],
-                additional: APPROVED_PLAN.generate,
-            });
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Generated a test on a zero-budget plan.",
-                newTestsCreated: [contractNewTest()],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBe(true);
-            expect(result.content[0].text).toContain("plan-42");
-        });
-        it("does not check newTestsCreated when approvedPlan is absent (back-compat)", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFileWithPlan(tmpDir, undefined);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "No plan was ever registered for this run.",
-                newTestsCreated: [contractNewTest({ endpoint: "GET /api/v1/products/anything" })],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-        });
-        it("does not gate UI/E2E entries even when unmatched — those tools are outside planGuard's scope", async () => {
-            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-test-"));
-            tmpDirs.push(tmpDir);
-            const outputFile = path.join(tmpDir, "report.json");
-            const stateFile = await writeStateFileWithPlan(tmpDir, APPROVED_PLAN);
-            const result = await handler({
-                summaryOutputFile: outputFile,
-                stateFile,
-                businessCaseAnalysis: "Adds a UI test not present in the approved plan.",
-                newTestsCreated: [
-                    {
-                        testId: "ui-checkout-flow",
-                        testType: TestType.UI,
-                        category: "workflow",
-                        endpoint: "N/A",
-                        fileName: "checkout_ui_test.spec.ts",
-                        description: "Walks through the checkout flow. [no-blueprint-data]",
-                        reasoning: "Covers the new checkout UI. [no-blueprint-data]",
-                        targetElements: null,
-                    },
-                ],
-                testResults: [],
-                issuesFound: [],
-            });
-            expect(result.isError).toBeUndefined();
-        });
-    });
-});
-// SKYR-3883: end-to-end coverage of the working-tree verification gate. The unit
-// behavior lives in reportVerification.test.ts; these exercise the wiring through
-// the real tool handler (feature-flag gating, git enumeration, error surfacing).
-describe("submit_report working-tree verification (SKYR-3883)", () => {
-    let handler;
-    let tmpDirs = [];
-    const prevFlag = process.env.SKYRAMP_FEATURE_TESTBOT;
-    beforeAll(() => {
-        handler = captureToolHandler();
-    });
-    beforeEach(() => {
-        process.env.SKYRAMP_FEATURE_TESTBOT = "1";
-    });
-    afterEach(async () => {
-        if (prevFlag === undefined)
-            delete process.env.SKYRAMP_FEATURE_TESTBOT;
-        else
-            process.env.SKYRAMP_FEATURE_TESTBOT = prevFlag;
-        for (const dir of tmpDirs)
-            await fs.rm(dir, { recursive: true, force: true });
-        tmpDirs = [];
-    });
-    async function initGitRepo() {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-wt-"));
-        tmpDirs.push(dir);
-        execFileSync("git", ["init", "-q"], { cwd: dir });
-        execFileSync("git", ["config", "user.email", "t@t.dev"], { cwd: dir });
-        execFileSync("git", ["config", "user.name", "t"], { cwd: dir });
-        return dir;
-    }
-    it("rejects a report whose newTestsCreated file was never written", async () => {
-        const dir = await initGitRepo();
-        const outputFile = path.join(dir, "report.json");
-        const stateFile = await writeStateFile(dir, []);
-        // search_smoke_test.py is claimed but never created → unbacked.
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("not backed");
-        expect(result.content[0].text).toContain("search_smoke_test.py");
-    });
-    it("accepts the report once the claimed file exists in the working tree", async () => {
-        const dir = await initGitRepo();
-        const outputFile = path.join(dir, "report.json");
-        const stateFile = await writeStateFile(dir, []);
-        await fs.writeFile(path.join(dir, "search_smoke_test.py"), "def test_search(): pass\n");
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBeUndefined();
-    });
-    it("rejects an UPDATE maintenance verdict with no working-tree change, exempting DELETE", async () => {
-        const dir = await initGitRepo();
-        const outputFile = path.join(dir, "report.json");
-        const stateFile = await writeReconciledStateFile(dir, [], [
-            { testFilePath: path.join(dir, "dcim/tests/test_filtersets.py"), action: DriftAction.Update, rationale: "physical_address filter", testType: TestType.INTEGRATION, endpoint: "GET /api/dcim/sites/" },
-            { testFilePath: path.join(dir, "dcim/tests/gone.py"), action: DriftAction.Delete, rationale: "obsolete", testType: TestType.INTEGRATION, endpoint: "GET /api/dcim/sites/" },
-        ]);
-        // Keep the newTestsCreated claim backed so the failure isolates to the verdict.
-        await fs.writeFile(path.join(dir, "search_smoke_test.py"), "x\n");
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("test_filtersets.py");
-        // DELETE is applied at delivery, never a working-tree claim — must not be flagged.
-        expect(result.content[0].text).not.toContain("gone.py");
-    });
-    it("skips verification entirely when the testbot feature flag is off", async () => {
-        delete process.env.SKYRAMP_FEATURE_TESTBOT;
-        const dir = await initGitRepo();
-        const outputFile = path.join(dir, "report.json");
-        const stateFile = await writeStateFile(dir, []);
-        // Claimed file absent, but the gate is off → report goes through.
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        expect(result.isError).toBeUndefined();
-    });
-    it("degrades to a pass when repositoryPath is not a git repo (verification can't run)", async () => {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "submit-report-nogit-"));
-        tmpDirs.push(dir);
-        const outputFile = path.join(dir, "report.json");
-        const stateFile = await writeStateFile(dir, []); // repositoryPath=dir, but no git init
-        const result = await handler(sampleReportParams(outputFile, stateFile));
-        // git status throws → caught → warning → report not falsely rejected.
-        expect(result.isError).toBeUndefined();
-    });
-});