@skyramp/mcp 0.2.8 → 0.2.9

package/build/services/TestDiscoveryService.test.js

@@ -308,13 +308,12 @@ describe("TestDiscoveryService", () => {
             writeFile("test_products_api.py", 'import requests\nrequests.get("/api/products")');
             const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
             const externalTests = result.tests.filter((t) => t.source === TestSource.External);
-            expect(externalTests.length).toBe(2);
+            // Only the relevant file (orders) is included — low-relevance files are excluded entirely.
+            expect(externalTests.length).toBe(1);
             const ordersTest = externalTests.find(t => t.testFile.includes("orders"));
-            const productsTest = externalTests.find(t => t.testFile.includes("products"));
-            // Relevant file gets endpoint extraction
             expect(ordersTest?.apiEndpoint).toContain("GET /api/orders");
-            // Low-relevance file gets name-only entry (no endpoint extraction)
-            expect(productsTest?.apiEndpoint).toBe("");
+            // Low-relevance products test is not in result.tests at all.
+            expect(externalTests.find(t => t.testFile.includes("products"))).toBeUndefined();
         });
         it("returns relevantExternalTestPaths including files where extraction may have failed", async () => {
             writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
@@ -380,27 +379,248 @@ describe("TestDiscoveryService", () => {
             // External tests suppressed in PR-mode-no-endpoints
             expect(externalTests.length).toBe(0);
         });
-        it("returns external tests as name-only with ['unknown'] sentinel (unresolvable resources)", async () => {
+        it("returns no external tests with ['unknown'] sentinel (unresolvable resources)", async () => {
             // When diff endpoints exist but all paths resolve to "unknown" (e.g. decorator-relative
-            // paths like "/{order_id}"), changedResources = ["unknown"]. External tests should be
-            // discovered (not skipped) but scored as low-relevance since "unknown" won't match filenames.
+            // paths like "/{order_id}"), changedResources = ["unknown"]. No external tests score > 0
+            // since "unknown" doesn't match any filename tokens — low-relevance files are excluded.
             writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
             writeFile("test_products_api.py", 'import requests\nrequests.get("/api/products")');
             const result = await service.discoverTests(tmpDir, { changedResources: ["unknown"] });
             const externalTests = result.tests.filter(t => t.source === TestSource.External);
-            // External tests discovered (not skipped like empty array)
-            expect(externalTests.length).toBe(2);
-            // But all are low-relevance (name-only) since "unknown" doesn't match any filename tokens
+            expect(externalTests.length).toBe(0);
             expect(result.relevantExternalTestPaths.length).toBe(0);
         });
-        it("low-relevance files have empty apiEndpoint and empty framework in PR mode", async () => {
+        it("low-relevance files are excluded from result.tests in PR mode", async () => {
             writeFile("test_orders_api.py", 'import requests\nrequests.get("/api/orders")');
             writeFile("test_products_api.py", 'import requests\nrequests.get("/api/products")');
             const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
+            // products scored 0 — excluded entirely, not even as name-only entry
             const productsTest = result.tests.find(t => t.testFile.includes("test_products_api"));
-            expect(productsTest?.source).toBe(TestSource.External);
-            expect(productsTest?.apiEndpoint).toBe("");
-            expect(productsTest?.framework).toBe("");
+            expect(productsTest).toBeUndefined();
         });
     });
 });
+// ---------------------------------------------------------------------------
+// Framework detection ordering — private method behaviour tested via discoverTests
+// ---------------------------------------------------------------------------
+describe("TestDiscoveryService — detectExternalFramework ordering", () => {
+    let service;
+    let tmpDir;
+    beforeEach(() => {
+        service = new TestDiscoveryService();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tds-fw-"));
+    });
+    afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+    function writeFile(rel, content) {
+        const fp = path.join(tmpDir, rel);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        fs.writeFileSync(fp, content, "utf-8");
+        return fp;
+    }
+    it("pytest-playwright file → playwright-ui (not pytest)", async () => {
+        writeFile("tests/test_login.py", "import pytest\nfrom playwright.sync_api import Page\ndef test_login(page: Page):\n  page.goto('http://localhost')");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["login"] });
+        const t = result.tests.find(f => f.testFile.includes("test_login.py"));
+        expect(t?.framework).toBe("playwright-ui");
+    });
+    it("Playwright API-only test (request, no page) → playwright (not playwright-ui)", async () => {
+        writeFile("tests/test_api.py", "from playwright.sync_api import APIRequestContext\ndef test_orders(request: APIRequestContext):\n  request.get('/api/orders')");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
+        const t = result.tests.find(f => f.testFile.includes("test_api.py"));
+        expect(t?.framework).toBe("playwright");
+    });
+    it("pure pytest file → pytest", async () => {
+        writeFile("tests/test_calc.py", "import pytest\ndef test_add():\n  assert 1 + 1 == 2");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["calc"] });
+        const t = result.tests.find(f => f.testFile.includes("test_calc.py"));
+        expect(t?.framework).toBe("pytest");
+    });
+    it("RTL file with it()/expect() → rtl (not jest)", async () => {
+        writeFile("src/Cart.test.tsx", "import { render } from '@testing-library/react';\nit('renders', () => { expect(true).toBe(true); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["cart"], hasFrontendChanges: true });
+        const t = result.tests.find(f => f.testFile.includes("Cart.test.tsx"));
+        expect(t?.framework).toBe("rtl");
+    });
+    it("vue-test-utils file → vue-test-utils (not jest)", async () => {
+        writeFile("src/Counter.test.ts", "import { mount } from '@testing-library/vue';\nit('works', () => { expect(true).toBe(true); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["counter"], hasFrontendChanges: true });
+        const t = result.tests.find(f => f.testFile.includes("Counter.test.ts"));
+        expect(t?.framework).toBe("vue-test-utils");
+    });
+    it("JS Playwright file using page.goto() → playwright-ui", async () => {
+        writeFile("e2e/login.spec.ts", "import { test } from '@playwright/test';\ntest('login', async ({ page }) => { await page.goto('/'); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["login"] });
+        const t = result.tests.find(f => f.testFile.includes("login.spec.ts"));
+        expect(t?.framework).toBe("playwright-ui");
+    });
+    it("JS Playwright using only request fixture → playwright", async () => {
+        writeFile("e2e/api.spec.ts", "import { test } from '@playwright/test';\ntest('api', async ({ request }) => { await request.get('/api'); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["api"] });
+        const t = result.tests.find(f => f.testFile.includes("api.spec.ts"));
+        expect(t?.framework).toBe("playwright");
+    });
+});
+// ---------------------------------------------------------------------------
+// detectExternalTestType path rules
+// ---------------------------------------------------------------------------
+describe("TestDiscoveryService — detectExternalTestType path rules", () => {
+    let service;
+    let tmpDir;
+    beforeEach(() => {
+        service = new TestDiscoveryService();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tds-type-"));
+    });
+    afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+    function writeFile(rel, content) {
+        const fp = path.join(tmpDir, rel);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        fs.writeFileSync(fp, content, "utf-8");
+        return fp;
+    }
+    it("file in playwright/ dir → testType=e2e", async () => {
+        writeFile("apps/web/playwright/login.spec.ts", "import { test } from '@playwright/test';\ntest('login', async ({ page }) => { await page.goto('/'); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["login"] });
+        const t = result.tests.find(f => f.testFile.includes("login.spec.ts"));
+        expect(t?.testType).toBe("e2e");
+    });
+    it("file with e2e in filename inside e2e/ dir → testType=e2e", async () => {
+        // .e2e.ts in an e2e/ dir is recognized both by dir pattern and filename
+        writeFile("apps/web/e2e/auth.e2e.ts", "import { test } from '@playwright/test';\ntest('auth', async ({ page }) => { await page.goto('/'); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["auth"] });
+        const t = result.tests.find(f => f.testFile.includes("auth.e2e.ts"));
+        expect(t?.testType).toBe("e2e");
+    });
+    it("file in api dir (no playwright in path) → NOT e2e", async () => {
+        writeFile("apps/api/v2/tests/login.spec.ts", "import { test } from '@jest/globals';\ntest('login', () => { expect(true).toBe(true); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["login"] });
+        const t = result.tests.find(f => f.testFile.includes("login.spec.ts"));
+        expect(t?.testType).not.toBe("e2e");
+    });
+    it("generic spec file (no e2e/playwright signal) → NOT e2e", async () => {
+        writeFile("modules/bookings/login.spec.ts", "import { test } from '@jest/globals';\ntest('login', () => {});");
+        const result = await service.discoverTests(tmpDir, { changedResources: ["login"] });
+        const t = result.tests.find(f => f.testFile.includes("login.spec.ts"));
+        expect(t?.testType).not.toBe("e2e");
+    });
+});
+// ---------------------------------------------------------------------------
+// isFrontendFile edge cases
+// ---------------------------------------------------------------------------
+const { isFrontendFile } = await import("../prompts/test-recommendation/scopeAssessment.js");
+describe("isFrontendFile edge cases", () => {
+    it("pages/api/orders.tsx → false (Next.js API route, /api/ blocks all)", () => {
+        expect(isFrontendFile("pages/api/orders.tsx")).toBe(false);
+    });
+    it("routes/product-card.tsx → true (.tsx in routes/ is page component)", () => {
+        expect(isFrontendFile("routes/product-card.tsx")).toBe(true);
+    });
+    it("routes/orders.ts → false (.ts in routes/ is route handler)", () => {
+        expect(isFrontendFile("routes/orders.ts")).toBe(false);
+    });
+    it("src/components/Cart.tsx → true", () => {
+        expect(isFrontendFile("src/components/Cart.tsx")).toBe(true);
+    });
+    it("src/utils/helpers.ts → false (ambiguous extension, not in frontend dir)", () => {
+        expect(isFrontendFile("src/utils/helpers.ts")).toBe(false);
+    });
+    it("app/modules/booking/BookingList.tsx → true", () => {
+        expect(isFrontendFile("app/modules/booking/BookingList.tsx")).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Content-based relevance cap (MAX_CONTENT_PROMOTED = 5)
+// ---------------------------------------------------------------------------
+describe("TestDiscoveryService — content-based relevance cap", () => {
+    let service;
+    let tmpDir;
+    beforeEach(() => {
+        service = new TestDiscoveryService();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tds-cap-"));
+    });
+    afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+    function writeFile(rel, content) {
+        const fp = path.join(tmpDir, rel);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        fs.writeFileSync(fp, content, "utf-8");
+        return fp;
+    }
+    it("promotes at most MAX_CONTENT_PROMOTED=5 files via content match", async () => {
+        // 10 test files that all reference /orders in their content
+        for (let i = 0; i < 10; i++) {
+            writeFile(`tests/test_feature_${i}.py`, `import requests\nrequests.get("/api/checkout_${i}")`);
+            // content-match: all contain "/orders"
+            fs.writeFileSync(path.join(tmpDir, `tests/test_feature_${i}.py`), `import requests\n# tests ordering\nrequests.get("/api/orders/item_${i}")`);
+        }
+        // changedResources=["unknown"] so all score 0 by filename; content scan fires
+        const result = await service.discoverTests(tmpDir, { changedResources: ["orders"] });
+        // At most 5 content-matched files should be in relevantExternalTestPaths
+        expect(result.relevantExternalTestPaths.length).toBeLessThanOrEqual(5);
+    });
+});
+// ---------------------------------------------------------------------------
+// scoreRelevanceByContent regex safety (dot/plus escaped)
+// ---------------------------------------------------------------------------
+describe("TestDiscoveryService — scoreRelevanceByContent regex safety", () => {
+    let service;
+    let tmpDir;
+    beforeEach(() => {
+        service = new TestDiscoveryService();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tds-regex-"));
+    });
+    afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+    function writeFile(rel, content) {
+        const fp = path.join(tmpDir, rel);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        fs.writeFileSync(fp, content, "utf-8");
+        return fp;
+    }
+    it("resource with dot (order.items) does not match orderXitems via unescaped dot", async () => {
+        writeFile("tests/test_order.py", `import requests\nrequests.get("/api/orderXitems")`);
+        // "order.items" in changedResources — dot must be escaped
+        const result = await service.discoverTests(tmpDir, { changedResources: ["order.items"] });
+        const t = result.tests.find(f => f.testFile.includes("test_order.py"));
+        // should NOT match (orderXitems ≠ order.items)
+        expect(result.relevantExternalTestPaths.some(p => p.includes("test_order.py"))).toBe(false);
+    });
+    it("resource with dot matches correctly when content has /order.items", async () => {
+        writeFile("tests/test_order_items.py", `import requests\nrequests.get("/api/order.items/list")`);
+        const result = await service.discoverTests(tmpDir, { changedResources: ["order.items"] });
+        expect(result.relevantExternalTestPaths.some(p => p.includes("test_order_items.py"))).toBe(true);
+    });
+    it("resource with plus does not throw SyntaxError", async () => {
+        writeFile("tests/test_v2.py", `import requests\nrequests.get("/api/v2/items")`);
+        // Should not throw
+        await expect(service.discoverTests(tmpDir, { changedResources: ["v2+api"] })).resolves.toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// hasFrontendChanges=false: no .e2e.ts promotion
+// ---------------------------------------------------------------------------
+describe("TestDiscoveryService — hasFrontendChanges=false guard", () => {
+    let service;
+    let tmpDir;
+    beforeEach(() => {
+        service = new TestDiscoveryService();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tds-nofe-"));
+    });
+    afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+    function writeFile(rel, content) {
+        const fp = path.join(tmpDir, rel);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        fs.writeFileSync(fp, content, "utf-8");
+        return fp;
+    }
+    it("does not promote .e2e.ts files when hasFrontendChanges=false", async () => {
+        writeFile("apps/web/playwright/onboarding.e2e.ts", "import { test } from '@playwright/test';\ntest('onboarding', async ({ page }) => { await page.goto('/onboarding'); });");
+        // changedResources=[] (no API endpoints) + hasFrontendChanges=false (config-only PR)
+        const result = await service.discoverTests(tmpDir, { changedResources: [], hasFrontendChanges: false });
+        expect(result.relevantExternalTestPaths.length).toBe(0);
+        expect(result.tests.length).toBe(0);
+    });
+    it("promotes .e2e.ts files when hasFrontendChanges=true", async () => {
+        writeFile("apps/web/playwright/onboarding.e2e.ts", "import { test } from '@playwright/test';\ntest('onboarding', async ({ page }) => { await page.goto('/onboarding'); });");
+        const result = await service.discoverTests(tmpDir, { changedResources: [], hasFrontendChanges: true });
+        // .e2e.ts should now be promoted (UI_TEST_EXT includes .e2e.ts)
+        expect(result.tests.some(t => t.testFile.includes("onboarding.e2e.ts"))).toBe(true);
+    });
+});

package/build/services/TestExecutionService.d.ts

@@ -1,5 +1,5 @@
 import { TestExecutionResult, BatchExecutionResult, TestExecutionOptions, ProgressCallback } from "../types/TestExecution.js";
-export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.29";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.30";
 export declare const PLAYWRIGHT_CONFIG_FILES: string[];
 export declare const EXCLUDED_MOUNT_ITEMS: string[];
 export declare const MOUNT_NULL_ITEMS: string[];

package/build/services/TestExecutionService.js

@@ -84,14 +84,14 @@ function setupVideoCapture(options, workspacePath, containerMountPath) {
     };
     if (!browserTest)
         return setup;
-    // Per-execution video output directory on host (cleared so a retry never
-    // reports a stale recording from a prior run).
-    const videoSubdir = getVideoSubdir(options.testFile);
+    // Each execution gets a unique video directory so there is nothing to clean up
+    // between runs. Avoids EACCES when the Docker executor (which runs as root) has
+    // left root-owned files in a previous run's directory. The timestamp keeps the
+    // name readable/ordered; the random suffix guarantees uniqueness even when two
+    // executions land in the same millisecond (retries, parallel runs).
+    const videoSubdir = `${getVideoSubdir(options.testFile)}-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
     setup.videoHostDir = path.join(workspacePath, ".skyramp", "videos", videoSubdir);
     setup.videoContainerDir = path.join(containerMountPath, ".skyramp", "videos", videoSubdir);
-    if (fs.existsSync(setup.videoHostDir)) {
-        fs.rmSync(setup.videoHostDir, { recursive: true, force: true });
-    }
     fs.mkdirSync(setup.videoHostDir, { recursive: true });
     // TypeScript/JavaScript: generate a per-execution Playwright config with video.
     if (options.language === "typescript" || options.language === "javascript") {
@@ -440,7 +440,7 @@ export class TestExecutionService {
         try {
             fs.accessSync(workspacePath, fs.constants.R_OK);
         }
-        catch (err) {
+        catch {
             throw new Error(`Workspace path does not exist or is not readable: ${workspacePath}`);
         }
         // Validate test file - use basename for safer filename extraction

package/build/services/TestExecutionService.test.js

@@ -521,7 +521,10 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
         });
         const dockerOptions = mockRun.mock.calls[0][3];
         const videoSubdir = getVideoSubdir("/workspace/tests/login.spec.ts");
-        const videoMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === `/home/user/.skyramp/videos/${videoSubdir}`);
+        // Each execution gets a unique per-run dir: `${videoSubdir}-<timestamp>`,
+        // so match by prefix rather than exact equality.
+        const videoMountPrefix = `/home/user/.skyramp/videos/${videoSubdir}`;
+        const videoMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target.startsWith(videoMountPrefix));
         expect(videoMount).toBeDefined();
         expect(videoMount.Type).toBe("bind");
         expect(videoMount.ReadOnly).toBe(false);

package/build/tools/submitReportTool.d.ts

@@ -42,7 +42,7 @@ export declare const newTestSchema: z.ZodEffects<z.ZodObject<{
     category: z.ZodEffects<z.ZodEnum<["business_rule", "security_boundary", "data_integrity", "breaking_change", "auth", "error_handling", "workflow", "data_validation", "crud"]>, "breaking_change" | "business_rule" | "security_boundary" | "data_integrity" | "auth" | "error_handling" | "workflow" | "data_validation" | "crud", unknown>;
     endpoint: z.ZodString;
     fileName: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
     scenarioFile: z.ZodOptional<z.ZodString>;
     traceFile: z.ZodOptional<z.ZodString>;
     frontendTrace: z.ZodOptional<z.ZodString>;
@@ -84,13 +84,13 @@ export declare const newTestSchema: z.ZodEffects<z.ZodObject<{
         pageHash?: string | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    description: string;
     testType: TestType;
     category: "breaking_change" | "business_rule" | "security_boundary" | "data_integrity" | "auth" | "error_handling" | "workflow" | "data_validation" | "crud";
     fileName: string;
     endpoint: string;
     testId: string;
     reasoning: string;
-    description?: string | undefined;
     repository?: string | undefined;
     traceFile?: string | undefined;
     scenarioFile?: string | undefined;
@@ -109,12 +109,12 @@ export declare const newTestSchema: z.ZodEffects<z.ZodObject<{
         pageHash?: string | undefined;
     } | undefined;
 }, {
+    description: string;
     testType: TestType;
     fileName: string;
     endpoint: string;
     testId: string;
     reasoning: string;
-    description?: string | undefined;
     repository?: string | undefined;
     category?: unknown;
     traceFile?: string | undefined;
@@ -134,13 +134,13 @@ export declare const newTestSchema: z.ZodEffects<z.ZodObject<{
         pageHash?: string | undefined;
     } | undefined;
 }>, {
+    description: string;
     testType: TestType;
     category: "breaking_change" | "business_rule" | "security_boundary" | "data_integrity" | "auth" | "error_handling" | "workflow" | "data_validation" | "crud";
     fileName: string;
     endpoint: string;
     testId: string;
     reasoning: string;
-    description?: string | undefined;
     repository?: string | undefined;
     traceFile?: string | undefined;
     scenarioFile?: string | undefined;
@@ -159,12 +159,12 @@ export declare const newTestSchema: z.ZodEffects<z.ZodObject<{
         pageHash?: string | undefined;
     } | undefined;
 }, {
+    description: string;
     testType: TestType;
     fileName: string;
     endpoint: string;
     testId: string;
     reasoning: string;
-    description?: string | undefined;
     repository?: string | undefined;
     category?: unknown;
     traceFile?: string | undefined;

package/build/tools/submitReportTool.js

@@ -77,7 +77,7 @@ export const newTestSchema = z.object({
     category: z.preprocess((val) => externalCategory(val), z.enum(TEST_CATEGORIES)).describe("Test category — critical categories (security_boundary, business_rule, data_integrity, breaking_change) get generation priority over workflow"),
     endpoint: z.string().describe("HTTP verb and path, e.g. 'GET /api/v1/products'"),
     fileName: z.string().describe("Name of the generated test file"),
-    description: z.string().optional().describe("What the test does — the steps and assertions, not the bugs it finds. e.g. 'Creates a collection, adds a link, then verifies the link exists'. Do NOT describe expected failures or bugs here — those belong in issuesFound."),
+    description: z.string().trim().min(1).describe("What the test does — the steps and assertions, not the bugs it finds. e.g. 'Creates a collection, adds a link, then verifies the link exists'. Do NOT describe expected failures or bugs here — those belong in issuesFound."),
     scenarioFile: z.string().optional().describe("Path to the scenario JSON file if one was generated (e.g. 'tests/scenario_collections-links.json')"),
     traceFile: z.string().optional().describe("Path to the backend trace file if used or created"),
     frontendTrace: z.string().optional().describe("Path to the Playwright/UI trace file if used or created"),
@@ -149,7 +149,7 @@ export const newTestSchema = z.object({
         }
     }
 });
-const descriptionSchema = z.object({
+const issueFoundSchema = z.object({
     description: z.string().describe("One-line description. Do NOT prefix with the severity level — severity is a separate field. Include code logic bugs from the diff, test generation/execution failures, and environment misconfiguration."),
     severity: z
         .enum(["critical", "high", "medium", "low"])
@@ -327,6 +327,12 @@ function deduplicateById(items) {
 }
 export function registerSubmitReportTool(server) {
     server.registerTool(TOOL_NAME, {
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true, // overwrites summaryOutputFile on disk
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: "Submit the final testbot report. Call this tool once after completing all test analysis, generation, and execution. " +
             "This is the ONLY way to submit the report — do NOT write the report to a file manually.",
         inputSchema: {
@@ -347,12 +353,12 @@ export function registerSubmitReportTool(server) {
             testMaintenance: z
                 .array(testMaintenanceLLMSchema)
                 .optional()
-                .describe("One entry per test assessed in the drift analysis step, including IGNORE and VERIFY entries — these provide triage transparency even when no edits were needed. Omit this field entirely when no existing tests were found."),
+                .describe("One entry per test that required action in the drift analysis step: UPDATE, REGENERATE, DELETE, and VERIFY. IGNORE entries are omitted — a clean test is not a maintenance action. Omit this field entirely when no existing tests were found."),
             testResults: z
                 .array(testResultSchema)
                 .describe("List of ALL test execution results. One entry per test executed."),
             issuesFound: z
-                .array(descriptionSchema)
+                .array(issueFoundSchema)
                 .describe("List of issues, failures, or bugs found. Use empty array [] if none."),
             nextSteps: z
                 .array(z.string())
@@ -360,6 +366,7 @@ export function registerSubmitReportTool(server) {
                 .default([])
                 .describe("Actionable follow-ups for the PR author. Each entry must be a single-line string (no embedded newlines). " +
                 "Include a next step for every critical/high severity issue in issuesFound. No next steps for low-severity issues. " +
+                "Also include a next step for every external test (Playwright, Cypress, RTL) assigned REGENERATE or DELETE in testMaintenance — the developer must act on these manually since they cannot be auto-applied (e.g. 'Regenerate frontend/tests/cart_pom.spec.ts — CartLine structure changed, all selectors need re-recording' or 'Delete frontend/tests/homepage.spec.ts — /cart route removed'). " +
                 "If multiple tests fail with 404 or connection refused: suggest checking targetSetupCommand/targetReadyCheckCommand. " +
                 "If 401/403 on auth endpoints: suggest authTokenCommand. " +
                 "When referencing code, use file name and relevant code pattern — no line numbers unless certain."),

package/build/tools/submitReportTool.test.js

@@ -483,6 +483,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 +499,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) {