@skyramp/mcp 0.2.8 → 0.2.10-rc.1

package/build/tools/submitReportTool.test.js

@@ -6,6 +6,7 @@ import { TestExecutionStatus } from "../types/TestExecution.js";
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
+import { z } from "zod";
 jest.unstable_mockModule("../utils/logger.js", () => ({
     logger: { info: jest.fn(), error: jest.fn(), warning: jest.fn(), debug: jest.fn() },
 }));
@@ -18,17 +19,45 @@ const { AnalyticsService } = await import("../services/AnalyticsService.js");
 const pushMCPToolEventMock = AnalyticsService.pushMCPToolEvent;
 function captureToolHandler() {
     let handler;
+    let inputSchema;
     const fakeServer = {
-        registerTool: (_name, _opts, fn) => {
+        registerTool: (_name, opts, fn) => {
             handler = fn;
+            inputSchema = opts.inputSchema;
         },
     };
     registerSubmitReportTool(fakeServer);
-    return handler;
+    // 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");
-    await fs.writeFile(stateFile, JSON.stringify({ existingTests }), "utf-8");
+    // 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) {
@@ -37,9 +66,8 @@ function sampleReportParams(outputFile, stateFile) {
         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", reasoning: "Validates product search returns correct results for category filter" },
+            { 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" },
         ],
-        testMaintenance: [{ action: "UPDATE", testType: TestType.CONTRACT, endpoint: "GET /api/v1/products", fileName: "products_contract_test.py", description: "Updated auth flow in existing tests", beforeDetails: "", afterDetails: "" }],
         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" },
@@ -83,7 +111,7 @@ describe("registerSubmitReportTool", () => {
         expect(written.newTestsCreated).toHaveLength(1);
         expect(written.testResults).toHaveLength(2);
         expect(written.issuesFound).toHaveLength(1);
-        expect(written.testMaintenance).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-"));
@@ -373,12 +401,12 @@ describe("registerSubmitReportTool", () => {
             expect(result.success).toBe(true);
         });
         it("rejects targetElement missing accessibleName", () => {
-            const { accessibleName, ...withoutName } = validTarget;
+            const { accessibleName: _accessibleName, ...withoutName } = validTarget;
             const result = targetElementSchema.safeParse(withoutName);
             expect(result.success).toBe(false);
         });
         it("rejects targetElement missing role", () => {
-            const { role, ...withoutRole } = validTarget;
+            const { role: _role, ...withoutRole } = validTarget;
             const result = targetElementSchema.safeParse(withoutRole);
             expect(result.success).toBe(false);
         });
@@ -483,6 +511,7 @@ describe("registerSubmitReportTool", () => {
                 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) {
@@ -498,6 +527,7 @@ describe("registerSubmitReportTool", () => {
                 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) {
@@ -558,9 +588,11 @@ describe("registerSubmitReportTool", () => {
             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, 1 maintenance (no matching stateFile entry), 2 results
-            // (1 Pass + 1 Fail), 1 issue (no severity).
-            const stateFile = await writeStateFile(tmpDir, []);
+            // 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");
@@ -604,7 +636,6 @@ describe("registerSubmitReportTool", () => {
                 stateFile,
                 businessCaseAnalysis: "Config-only change.",
                 newTestsCreated: [],
-                testMaintenance: [],
                 testResults: [],
                 issuesFound: [],
             });
@@ -619,18 +650,15 @@ describe("registerSubmitReportTool", () => {
             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),
-                testMaintenance: [
-                    // Real change
-                    { action: "UPDATE", testType: TestType.CONTRACT, endpoint: "GET /api/v1/products", fileName: "products_contract_test.py", description: "Patched auth", beforeDetails: "", afterDetails: "" },
-                    { action: "REGENERATE", testType: TestType.SMOKE, endpoint: "GET /api/v1/orders", fileName: "orders_smoke_test.py", description: "Rewrote for new shape", beforeDetails: "", afterDetails: "" },
-                    // No-ops — assessed but not modified
-                    { action: "IGNORE", testType: TestType.SMOKE, endpoint: "GET /api/v1/reviews", fileName: "reviews_smoke_test.py", description: "No action required", beforeDetails: "", afterDetails: "" },
-                    { action: "VERIFY", testType: TestType.SMOKE, endpoint: "GET /api/v1/coupons", fileName: "coupons_smoke_test.py", description: "Verified still valid", beforeDetails: "", afterDetails: "" },
-                ],
-            });
+            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");
@@ -645,89 +673,106 @@ describe("registerSubmitReportTool", () => {
     // when toOutput or the stateFile enrichment path changes.
     // ─────────────────────────────────────────────────────────────────────────────
     describe("testMaintenance output shapes", () => {
-        const baseMaintenance = {
+        const baseVerdict = {
+            testFilePath: "/repo/backend/tests/orders_contract_test.py",
+            rationale: "Updated discount fields in assertions",
             testType: TestType.CONTRACT,
             endpoint: "GET /api/v1/orders",
-            fileName: "orders_contract_test.py",
-            description: "Updated discount fields in assertions",
-            beforeDetails: "",
-            afterDetails: "",
         };
-        async function writeAndRead(tmpDir, maintenance, extra) {
+        async function submitAndReadMaintenance(tmpDir, stateFile, testMaintenanceDetails = []) {
             const outputFile = path.join(tmpDir, "report.json");
-            await handler({
+            const result = await handler({
                 summaryOutputFile: outputFile,
+                stateFile,
                 businessCaseAnalysis: "Test",
                 newTestsCreated: [],
-                testMaintenance: maintenance,
+                testMaintenanceDetails,
                 testResults: [],
                 issuesFound: [],
-                ...extra,
             });
+            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 stateFile entry ───────────────────────────────────────────
-        it("UPDATE with no matching stateFile entry: beforeStatus=Unknown, afterStatus=Unknown", async () => {
+        // ── 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 writeStateFile(tmpDir, []);
-            const result = await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Update }], { stateFile });
+            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 stateFile entry: both Skipped", async () => {
+        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 writeStateFile(tmpDir, []);
-            const result = await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Ignore }], { stateFile });
+            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 stateFile entry: beforeStatus=Unknown, afterStatus=Skipped", async () => {
+        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 writeStateFile(tmpDir, []);
-            const result = await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Delete }], { stateFile });
+            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 stateFile entry ─────────────────────────────────────────
-        it("UPDATE with before=Pass after=Pass: status from stateFile, details from LLM", async () => {
+        // ── 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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/orders_contract_test.py",
+            const stateFile = await writeReconciledStateFile(tmpDir, [{
+                    testFile: baseVerdict.testFilePath,
                     executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 15090 },
                     executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 12880 },
-                }]);
-            const result = await writeAndRead(tmpDir, [{
-                    ...baseMaintenance, action: DriftAction.Update,
-                    beforeDetails: "4 passed in 15.09s",
-                    afterDetails: "5 passed in 12.88s",
-                }], { stateFile });
+                }], [{ ...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: status from stateFile, details from LLM", async () => {
+        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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/orders_contract_test.py",
+            const stateFile = await writeReconciledStateFile(tmpDir, [{
+                    testFile: baseVerdict.testFilePath,
                     executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 15090 },
-                    executionAfter: { status: TestExecutionStatus.Fail, errors: [], duration: 10940 },
-                }]);
-            const result = await writeAndRead(tmpDir, [{
-                    ...baseMaintenance, action: DriftAction.Update,
-                    beforeDetails: "4 passed in 15.09s",
-                    afterDetails: "FAILED test_orders_get — check_schema fails, test isolation bug",
-                }], { stateFile });
+                    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");
@@ -735,67 +780,135 @@ describe("registerSubmitReportTool", () => {
         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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/orders_contract_test.py",
+            const stateFile = await writeReconciledStateFile(tmpDir, [{
+                    testFile: baseVerdict.testFilePath,
                     executionBefore: { status: TestExecutionStatus.Error, errors: ["Connection refused"], duration: 500 },
                     executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
-                }]);
-            const result = await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Update }], { stateFile });
+                }], [{ ...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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/orders_contract_test.py",
+            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 },
-                }]);
-            await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Update }], { stateFile });
+                }], [{ ...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", async () => {
+        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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/orders_contract_test.py",
+            const stateFile = await writeReconciledStateFile(tmpDir, [{
+                    testFile: baseVerdict.testFilePath,
                     // executionBefore absent — agent skipped before-phase
                     executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
-                }]);
-            const result = await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Update }], { stateFile });
+                }], [{ ...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", async () => {
+        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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/orders_contract_test.py",
+            const stateFile = await writeReconciledStateFile(tmpDir, [{
+                    testFile: baseVerdict.testFilePath,
                     executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 2000 },
                     // executionAfter absent — file was deleted, nothing to run
-                }]);
-            const result = await writeAndRead(tmpDir, [{ ...baseMaintenance, action: DriftAction.Delete }], { stateFile });
+                }], [{ ...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("fileName matched by suffix: absolute stateFile path vs relative fileName", async () => {
+        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 writeStateFile(tmpDir, [{
-                    testFile: "/repo/backend/tests/python/orders_contract_test.py",
-                    executionBefore: { status: TestExecutionStatus.Pass, errors: [], duration: 15000 },
-                    executionAfter: { status: TestExecutionStatus.Pass, errors: [], duration: 12000 },
-                }]);
-            // fileName is relative — should still match via endsWith
-            const result = await writeAndRead(tmpDir, [{
-                    ...baseMaintenance,
-                    action: DriftAction.Update,
-                    fileName: "orders_contract_test.py",
-                }], { stateFile });
-            expect(result[0].beforeStatus).toBe("Pass");
+            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-"));
@@ -851,4 +964,210 @@ describe("registerSubmitReportTool", () => {
         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");
+        });
+    });
 });