@skyramp/mcp 0.2.8-rc.1 → 0.2.9

package/build/prompts/test-maintenance/uiDriftAnalysisSections.js

@@ -0,0 +1,228 @@
+/**
+ * UI Drift Analysis prompt sections for Component 2.
+ *
+ * Mirrors the driftAnalysisSections.ts pattern but for UI-specific drift detection.
+ * These sections are included whenever `uiContext.changedFrontendFiles` is non-empty —
+ * both browser tests (Playwright/Cypress/Selenium) and component/widget tests
+ * (RTL/Flutter widget/vue-test-utils/angular-testbed) go through the same gate.
+ * Component tests always use source-only analysis regardless of blueprintCaptured.
+ */
+import { buildUiAssignAction } from "./driftAnalysisShared.js";
+/**
+ * Build the UI Action Decision Tree section.
+ * This is the main entry point for UI drift analysis.
+ */
+export function buildUiActionDecisionTree() {
+    return `<ui_decision_rules>
+For each UI test listed in the \`<ui_analysis_context>\` above, assess whether the test is still valid given the diff (and blueprint diff when blueprints were captured). The diff may have changed:
+- Element selectors (CSS class changes, component restructuring)
+- Page structure (new containers, removed sections)
+- Route paths (URL changes)
+- Component behavior (state changes, visibility conditions)
+
+**Scope gate:** Read each test file to determine its type, then apply the correct gate:
+- **Browser test** (has \`page.goto()\`, \`cy.visit()\`, \`driver.get()\`): check that the test navigates to a page the changed frontend file serves. Infer from the changed file's directory path (e.g. \`modules/bookings/\` → bookings page) or explicit route-path diff signals.
+- **Component/widget test** (has \`render(<…>)\`, \`mount()\`, \`shallowMount()\`): check if it directly renders/mounts a changed component. If none of the rendered components match a changed file, the test is unaffected.
+If neither condition applies, assign **IGNORE** and skip remaining checks.
+
+
+**Severity order (highest first): DELETE > REGENERATE > UPDATE > VERIFY > IGNORE**
+
+**Pre-scan the diff for UI-relevant changes:**
+- Component file changes: \`+ import { NewComponent }\`, \`- <OldComponent />\` / \`+ <NewComponent />\`
+- CSS/Tailwind changes: \`+ className="..."\`, \`+ tw="..."\`, \`+ styles.\`
+- Route changes: \`- path: "/old"\` / \`+ path: "/new"\`
+- Selector changes: \`+ data-testid="..."\`, \`- data-testid="..."\`, \`+ aria-label="..."\`
+- State/visibility changes: \`+ isOpen\`, \`+ isVisible\`, \`+ showModal\`
+
+Build a detection list first: for each matched diff line, write one line: \`{pattern type} — "{diff line}" — affects {route/component}\`.
+
+**Action definitions:**
+- **DELETE**: The test targets a page/route that no longer exists, or all selectors the test uses have been removed and there's no migration path.
+- **REGENERATE**: The interaction model changed so fundamentally that the test flow itself is broken — not just selector values, but the sequence of actions (e.g. a form replaced by a modal, buttons replaced by a dropdown, a multi-step flow collapsed into one). There is no rename mapping; re-recording from scratch is the only viable approach.
+- **UPDATE**: Specific selectors need updating, assertions need adjustment, or new elements were added to a page the test already exercises. Always an in-place edit to the existing file — do not generate a new spec to cover the same page or component.
+- **VERIFY**: The test may be impacted but you cannot confirm breakage without reading more context (e.g. selectors are hidden in a page object file you have not read, or the component is imported indirectly).
+- **IGNORE**: The changed code cannot reach this test's routes or rendered components — the test covers unchanged functionality. If you cannot point to a diff line that affects this test's routes, selectors, or rendered components, the action is IGNORE or VERIFY, not UPDATE.
+
+**Rules:**
+- DELETE when all routes the test covers were removed or all critical selectors are gone.
+- REGENERATE when the interaction model changed fundamentally — the test's sequence of actions is broken with no migration path (e.g. a click-to-update button replaced by an auto-updating stepper; a remove button moved into a dropdown). The number of broken selectors alone does not determine REGENERATE; what matters is whether the flow can still be expressed with targeted edits.
+- UPDATE when specific selectors changed (renamed classes, moved data-testid) but the test flow remains valid, or when new elements were added to a page the test already covers — append the assertion to the existing file.
+- VERIFY when a page object or indirect import hides the affected selectors — read the imported file before escalating to UPDATE.
+- IGNORE when the diff touches unrelated frontend code (different routes, different components).
+
+**Additional rule for component/widget tests** ([rtl], [flutter-widget], [vue-test-utils], [angular-testbed]):
+- Rule #7: Component deleted — source file removed with no re-export → **DELETE** (report-only for external tests). These tests have no navigation; the rendered component is their only target.
+- Skip the route-existence check (step 1.1) for component/widget tests — they have no \`page.goto()\` or equivalent navigation calls.
+- Primary matching signal: read the test to check if it directly renders a changed component — if so, it is impacted.
+</ui_decision_rules>`;
+}
+/**
+ * Pre-scan step: agent greps changed files' exported symbols across the test
+ * directory to catch tests that server-side discovery missed — aliased imports,
+ * indirect renders, or any test the blueprint diff doesn't directly reference.
+ */
+export function buildUiCheckExportedSymbols(changedFrontendFiles) {
+    const files = (changedFrontendFiles ?? []).join(", ") || "the changed frontend files";
+    return `The server pre-discovered the tests listed above using exported symbols and UI signals (testids, aria-labels, i18n keys, CSS classes) from the diff. Before assessing, do a quick complementary grep to catch any tests the server may have missed — aliased imports, indirect renders, or tests using symbols not present in the diff:
+
+1. For each changed frontend file (${files}):
+   a. Read the file and extract exported symbols — component names, function names, hook names, class names.
+   b. Grep the test directory for each symbol name (case-insensitive).
+   c. For any matching test file not already in the \`<ui_analysis_context>\` list — read it and apply the decision tree.
+
+This catches tests that import a changed symbol under an alias, exercise a shared hook, or render the changed component indirectly via a parent.`;
+}
+/**
+ * Check if routes targeted by the UI test still exist.
+ */
+export function buildUiCheckRouteExistence() {
+    return `Does the route/page this UI test navigates to still exist?
+
+**Skip this check for component/widget tests** ([rtl], [flutter-widget], [vue-test-utils], [angular-testbed]) — they render components directly with no navigation calls. Proceed to selector checks.
+
+Diff signals to look for (browser tests only):
+- Route removed: \`- path: "/old-path"\`, \`- @app.route("/old-path")\`, \`- router.get("/old-path")\`
+- Route renamed: paired \`-\` and \`+\` on route definitions with different paths
+- Redirect added: \`+ redirect: "/old-path" → "/new-path"\`, \`+ res.redirect(301, "/new-path")\`
+
+Actions:
+- ALL routes the test uses were removed → **DELETE**
+- SOME routes renamed with no redirect → **UPDATE** (update navigation calls to new URLs)
+- Routes renamed with redirect kept → **UPDATE** (verify redirect behavior, test should still work)
+- Routes unchanged → proceed to selector checks`;
+}
+/**
+ * Check if selectors used by the UI test still exist in the blueprints.
+ */
+export function buildUiCheckSelectors() {
+    return `Do the selectors/locators this UI test uses still match the current UI?
+
+Read the test (and any imported page object/fixture files) to extract the selectors/locators it uses — \`getByTestId(...)\`, \`locator(...)\`, \`.find('...')\`, \`data-testid\`, \`aria-label\`, CSS class names.
+
+Diff signals to look for:
+- CSS class changes: \`- className="old-class"\` / \`+ className="new-class"\`
+- Tailwind changes: \`- tw="p-4"\` / \`+ tw="p-6"\`
+- Test ID changes: \`- data-testid="old-id"\` / \`+ data-testid="new-id"\`
+- ARIA changes: \`- aria-label="Old"\` / \`+ aria-label="New"\`
+- Component restructuring: \`+ <NewWrapper>\` around existing content, \`- <OldWrapper>\`
+
+**When blueprints are available** (\`blueprintCaptured=true\`): compare extracted selectors against \`browser_blueprint_diff\` for the affected page — elements absent from the new blueprint signal breakage.
+
+**When blueprints are not available** (\`blueprintCaptured=false\`): use diff signals only. If a selector the test uses matches a value renamed or removed in the diff, assign UPDATE. If you cannot confirm breakage from the diff alone (e.g. selectors live in a page object you have not read), assign VERIFY rather than guessing.
+
+Actions:
+- Selectors confirmed unchanged (diff or blueprint) → **IGNORE** (no drift)
+- Selectors renamed (class, testid, aria-label changed) → **UPDATE** (patch selector values)
+- Selectors removed with no confirmed replacement → **UPDATE** (find replacement; use blueprint if available, diff otherwise)
+- Major restructuring (most selectors gone) → **REGENERATE** (page structure fundamentally changed)
+- All selectors gone, no replacement elements → **DELETE** (page no longer testable)
+- Cannot confirm without reading page object or additional files → **VERIFY**
+- Hardcoded visible string wrapped in a translation key (e.g. a literal moved to \`$t('...')\`) and the default-locale rendering is unchanged → **UPDATE**: the assertion now silently depends on the active locale. Add explicit locale context to the test fixture or assert via the translation key so the test tracks the translation rather than a hardcoded copy.`;
+}
+/**
+ * Check if page objects/fixtures referenced by the test still exist.
+ */
+export function buildUiCheckPageObjects() {
+    return `Do the page objects or fixture files imported by this UI test still exist, and are their underlying selectors still valid?
+
+**Always follow imports to find page objects — regardless of whether blueprints were captured.**
+Page objects can live anywhere in the repo (not just \`page-objects/\` or \`fixtures/\`). Do not assume a fixed directory. The only reliable way to find them is to follow the spec file's \`import\` statements.
+
+**Protocol for every browser test (Playwright/Cypress/Selenium):**
+1. Read the spec file and collect all local \`import\` statements (skip \`@playwright/test\`, \`vitest\`, etc. — only follow relative or repo-local paths).
+2. For each imported file, read it and extract the selectors it encapsulates — \`locator()\`, \`getByTestId()\`, \`getByRole()\`, \`getByLabel()\`, \`data-test-*\`, \`aria-label\`, CSS class strings.
+3. Compare those selectors against the diff: if a selector value the page object uses was renamed or removed in a \`-\` diff line → the page object needs **UPDATE**.
+4. **Update the page object file, not the spec file** — the page object is the selector source of truth. In the recommendation: set \`testFile\` to the **spec file** (so it shows correctly in the maintenance report) and set \`pomFile\` to the **page object path** (so \`skyramp_actions\` edits the right file). If the edit is rejected at action time, the agent or developer can address it separately.
+5. If the imported file is missing or unreadable → **VERIFY** (cannot confirm without the file).
+
+A clean spec with no raw selector calls is not a reason to assign VERIFY — it is expected when page objects are used. Assign the action based on the POM's selectors.
+
+Diff signals to look for in the spec's imports:
+- Import deleted: \`- import { OldPage } from './pages/OldPage'\` → page object removed
+- Import path changed: paired \`-\`/\`+\` on the same import → page object moved or renamed
+- New import added: \`+ import { NewFixture } from '../fixtures/new'\` → new dependency
+
+Actions:
+- Page object's selectors match a renamed/removed diff value → **UPDATE** (patch the page object)
+- Page object import path changed in the diff → **UPDATE** (fix the import in the spec)
+- Page object file deleted, no replacement found → **UPDATE** (inline selectors or find alternative)
+- Selectors in page object unchanged and diff does not affect them → **IGNORE**
+- **All POM selectors are gone with no migration path in the diff** (the component's interaction model changed fundamentally — no ` + ` lines showing replacement selectors) → **REGENERATE**. Do not stay at VERIFY after reading the POM and confirming this — escalate once you have confirmed the failure.`;
+}
+/**
+ * Check for component behavior changes that affect assertions.
+ */
+export function buildUiCheckBehavioralChanges() {
+    return `Have component behaviors changed in ways that would break test assertions?
+
+Diff signals to look for:
+- State changes: \`+ isLoading\`, \`+ isOpen\`, \`+ showModal\`, \`+ disabled\`
+- Visibility conditions: \`+ if (condition) return null\`, \`+ {condition && <Component />}\`
+- Interaction changes: \`+ onClick={() => setOpen(true)}\`, \`+ require('auth')\`
+- Async behavior: \`+ setTimeout\`, \`+ debounce\`, \`+ async/await\` in handlers
+
+Actions:
+- New loading states → **UPDATE** (add waitFor or assertion for loading state)
+- New conditional rendering → **UPDATE** (update assertions to match new conditions)
+- Auth behavior changed → **UPDATE** (adjust login flow in test)
+- Async delays added → **UPDATE** (add appropriate waits/timeouts)
+- Shared component changed (used across multiple pages, dialogs, or layouts): if the test covers only one consumer and you have not read all other consumers, assign **VERIFY** — the blast radius across other consumers is indeterminate. Only assign UPDATE if you have confirmed the change is isolated to this test's consumer.`;
+}
+/**
+ * Assign the final UI drift action.
+ */
+export function buildUiCheckAssignAction() {
+    return buildUiAssignAction(`**Component/widget test matching (source-only):**
+- Read the test to check if it directly renders a changed component — if so, it is impacted.
+- If the test only imports but does not directly render the component, assign VERIFY (component-import signal — cannot confirm impact without reading the parent).
+- If neither signal fires, assign **IGNORE**.`);
+}
+/**
+ * Build the UI drift output checklist.
+ */
+export function buildUiDriftOutputChecklist(stateFile, tests) {
+    const finalStep = `Call \`skyramp_actions\` with \`stateFile: "${stateFile ?? "<stateFile>"}"\`.`;
+    const hasTests = (tests?.length ?? 0) > 0;
+    const testList = hasTests
+        ? tests.map(t => `- ${t.testFile}${t.source === "external" ? " [external]" : ""}`).join("\n")
+        : "- (none)";
+    const noTestsNote = !hasTests
+        ? `\nNo existing tests were found. Call \`skyramp_actions\` with \`recommendations: []\`.\n`
+        : "";
+    const existingTestSection = `**Tests (${tests?.length ?? 0} total) — assess ALL of the following:**
+${testList}
+${noTestsNote}
+
+**Execution policy:**
+- Skyramp-generated tests: UPDATE/REGENERATE/DELETE applied automatically by \`skyramp_actions\`. Run via \`skyramp_execute_test\`.
+- External tests (Playwright, Cypress, RTL, etc.): \`skyramp_actions\` applies UPDATE edits to \`testFile\` — which can be the test itself, a snapshot file, a page object, or a fixture. Application source files are automatically rejected. After a successful UPDATE, call \`skyramp_execute_test\` to confirm the patched test passes (the test environment is already running). Record the result as the after-state in the report. For DELETE and REGENERATE on external tests, see the execution policy in the decision rules above.
+
+For each UI test above, output one structured entry in \`recommendations[]\`:
+- **IGNORE**: \`{testFile} — IGNORE: {specific reason the diff cannot reach this test — name the route or component that differs}\` — do not pass to \`skyramp_actions\`
+- **VERIFY**: \`{testFile} — VERIFY: {uncertain element, e.g. "selectors hidden in page object not yet read"}\`
+\`\`\`
+Test: {testFile}
+Action: UPDATE
+Rationale: UPDATE because {quoted diff line}; {selector/route/behavior change}
+UpdateInstructions: {what must change — specific selectors to update, routes to patch, assertions to add}
+\`\`\`
+\`\`\`
+Test: {testFile}
+Action: REGENERATE
+Rationale: REGENERATE because {quoted diff line}; page structure fundamentally changed
+\`\`\`
+\`\`\`
+Test: {testFile}
+Action: DELETE
+Rationale: DELETE because {quoted diff line}; all routes removed or no valid selectors remain
+\`\`\`
+
+Be concise — one line per VERIFY/IGNORE entry.`;
+    const sections = [existingTestSection, finalStep];
+    return `<ui_output_format>
+Complete ALL of the following:
+
+${sections.join("\n\n")}
+</ui_output_format>`;
+}

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

@@ -11,7 +11,12 @@ const FLUTTER_DART_EXT = /\.dart$/i;
 const LIKELY_FRONTEND_EXT = /\.(tsx|jsx)$/i;
 // Ambiguous extensions need directory context to distinguish frontend from backend.
 const AMBIGUOUS_FRONTEND_PATTERN = /\.(tsx?|jsx?|css|scss|less|html?|erb|jsp|asp|jinja2?|twig)$/i;
-const API_DIR_PATTERN = /\/(api|routes?|controllers?|routers?|handlers?|endpoints?|server)\//;
+// /api/ always signals backend — even .tsx files (e.g. Next.js pages/api/*.tsx handlers).
+const STRICT_API_DIR_PATTERN = /\/(api)\//i;
+// Framework route dirs that contain React page components in modern full-stack apps
+// (Medusa Admin, Remix, React Router v6). These only block non-.tsx/.jsx files —
+// a .tsx file in routes/ is a page component, not a route handler.
+const FRAMEWORK_ROUTE_DIR_PATTERN = /\/(routes?|controllers?|routers?|handlers?|endpoints?|server)\//i;
 const FRONTEND_DIR_PATTERN = /(^|\/)(components?|pages?|views?|layouts?|app|src\/app|frontend|client|public|styles?|templates?)\//i;
 /**
  * Returns true if the repository root's `pubspec.yaml` declares a Flutter
@@ -120,7 +125,12 @@ export function isFrontendFile(filePath, { hasFlutterSdkDep = false } = {}) {
         return true;
     if (hasFlutterSdkDep && FLUTTER_DART_EXT.test(filePath))
         return true;
-    if (API_DIR_PATTERN.test(filePath))
+    // /api/ always means backend regardless of extension (Next.js API routes use .tsx).
+    if (STRICT_API_DIR_PATTERN.test(filePath))
+        return false;
+    // routes/, controllers/ etc. block .ts/.js but not .tsx/.jsx — Medusa Admin and
+    // React Router place page components under routes/, not API handlers.
+    if (!LIKELY_FRONTEND_EXT.test(filePath) && FRAMEWORK_ROUTE_DIR_PATTERN.test(filePath))
         return false;
     if (LIKELY_FRONTEND_EXT.test(filePath))
         return true;

package/build/prompts/testbot/testbot-prompts.js

@@ -126,7 +126,7 @@ ${hasRelatedRepos ? `
 
 2. **Maintain existing tests:**
 
-   a. Call \`skyramp_analyze_test_health\` with \`stateFile\` (from \`skyramp_analyze_changes\` output). **Do NOT read application source files** (routes, models, controllers) — all change information you need is in the \`skyramp_analyze_changes\` output and the diff.
+   a. Call \`skyramp_analyze_test_health\` with \`stateFile\` (from \`skyramp_analyze_changes\` output). Pass \`blueprintCaptured: true\` when \`browser_blueprint\` was called successfully earlier in this session — see the parameter description for when this applies. **Do NOT read application source files** (routes, models, controllers) — all change information you need is in the \`skyramp_analyze_changes\` output and the diff. Exception: the UI drift pre-scan (\`UI_SYMBOL_PRESCAN\`) may instruct you to read changed frontend files to extract exported symbols — follow those instructions when present.
 
    b. Write \`updateInstructions\` for each UPDATE or REGENERATE test before calling \`skyramp_actions\` — articulating the change first prevents file content from overriding diff-based reasoning.
 
@@ -572,13 +572,14 @@ In these cases:
 Otherwise: in \`newTestsCreated\`, you must have exactly ${maxGenerate} budget-counting new tests for the planned GENERATE items. Only new files (ADD) created for those planned GENERATE items count toward this ${maxGenerate} target — GENERATE items converted to UPDATE do not. You may also include at most one additional discovered-scenario file in \`newTestsCreated\` (the bug-catching test generated after all planned items); that extra test does **not** count against the ${maxGenerate} budget. If you have fewer than ${maxGenerate} budget-counting new tests, backfill from the remaining ADDITIONAL candidates before proceeding. Only proceed with fewer than ${maxGenerate} budget-counting new tests if all candidates failed after retry AND the fallback single-contract test also failed.
 
 Call \`skyramp_submit_report\` with \`summaryOutputFile\`: "${summaryOutputFile}" and \`stateFile\` (from \`skyramp_analyze_changes\` output) — the stateFile is required for execution outcome tracking. Field names, types, and formats are defined in the tool's parameter schema — follow them exactly.
+
 ${hasRelatedRepos ? `
 - **MULTI-REPO attribution**: Set the \`repository\` field (\`owner/repo\`) on EVERY \`newTestsCreated\`, \`testResults\`, \`issuesFound\`, and \`additionalRecommendations\` item — including items about the PRIMARY repo — so each finding is unambiguously attributed. The primary repo's \`repository\` is \`${primaryRepo || "<the primary repo's owner/repo>"}\`; items derived from a related repo's diff (from the \`<related_repositories>\` analysis) carry that repo's \`repository\` value. In \`businessCaseAnalysis\`, include a short per-repo subsection and call out any cross-repo correlations you found.
 ` : ""}
 - **additionalRecommendations**: AT MOST ${maxRecommendations - maxGenerate} items.
   - For \`testType: "contract"\` entries: **\`primaryEndpoint\` is required** (e.g. \`"GET /api/v1/users/{user_id}"\`). The tool will reject the submission without it — do not omit it or you will be forced to resubmit.
   - For \`testType: "integration"\` or \`"e2e"\` entries: omit \`primaryEndpoint\` — use \`description\` to list the endpoints involved instead.
-- **testMaintenance**: Use \`[]\` **only** if no existing Skyramp tests were found in the repository. If existing tests were found (any score), include one entry per test. Set \`action\` to the exact drift action you chose from the Action Decision Matrix (\`UPDATE\`, \`REGENERATE\`, \`DELETE\`, \`VERIFY\`, or \`IGNORE\`). For UPDATE/REGENERATE/DELETE tests that were modified and executed, populate \`beforeDetails\` and \`afterDetails\` from what you observed in \`skyramp_execute_test\` output — one line each, no newlines. For passing runs write the count and timing (e.g. \`"4 passed in 15.09s"\`). For failing runs write the test name and failure reason (e.g. \`"1 failed: test_foo - assert X == Y — shared-state pollution"\`). For VERIFY/IGNORE tests (not modified), omit \`beforeDetails\` and \`afterDetails\`. Do **not** add entries for tests that were not returned by the health analysis.
+- **\`testMaintenance\`**: include one entry per test that received UPDATE, REGENERATE, DELETE, or VERIFY. Do NOT include IGNORE — a test assessed and confirmed clean is not a maintenance action and adds noise to the report.
 - **testResults**: For UI/E2E test entries, include the \`videoPath\` field if \`skyramp_execute_test\` returned one.
 
 ---

package/build/services/TestDiscoveryService.d.ts

@@ -9,14 +9,16 @@ export interface TestDiscoveryOptions {
      * Resource names derived from endpoints in changed files (e.g. ["orders", "products"]).
      * - Non-empty array: external files partitioned by relevance; only relevant files
      *   get full endpoint extraction. May be the sentinel `["unknown"]` when endpoints
-     *   exist but resource names are unresolvable — treated as "endpoints present" to
-     *   avoid skipping external coverage. Also used for "add field" PRs where the changed
-     *   files have no endpoint definitions but the scanner found related endpoints nearby.
-     * - Empty array `[]`: PR mode with no endpoints from diff or scanner — external
-     *   tests are skipped entirely to avoid flooding context.
+     *   exist but resource names are unresolvable — most files score 0 (low-relevance)
+     *   and are excluded; only the few that happen to match the sentinel are kept.
+     * - Empty array `[]`: PR mode with no endpoints from diff or scanner — API/integration
+     *   external tests are excluded entirely; UI tests may still be promoted via hasFrontendChanges.
      * - `undefined`: full-repo mode — external tests capped at MAX_EXTERNAL_FULL_REPO.
      */
     changedResources?: string[];
+    /** True when the diff contains frontend files — promotes UI test files for framework
+     *  detection regardless of changedResources. Orthogonal to API relevance scoring. */
+    hasFrontendChanges?: boolean;
 }
 export declare class TestDiscoveryService {
     private readonly EXCLUDED_DIRS;
@@ -45,9 +47,13 @@ export declare class TestDiscoveryService {
      * Example: "test_orders_api.py" vs ["orders"] → score 1.
      */
     private scoreRelevance;
+    private readonly MAX_CONTENT_PROMOTED;
     /**
      * Partition external test files into relevant (score > 0) and low-relevance (score = 0).
-     * Signal: path/name token overlap with changedResources.
+     * Two-pass: filename token overlap first (primary); content-based endpoint path scan
+     * as a capped fallback for tests misnamed relative to the endpoint they exercise
+     * (e.g. test_checkout_flow.py testing /api/orders scores 0 by name but matches in content).
+     * Content matches are capped at MAX_CONTENT_PROMOTED to bound token impact.
      */
     private partitionByRelevance;
     /**
@@ -101,9 +107,6 @@ export declare class TestDiscoveryService {
      * Falls back to directory/filename heuristics since external tests lack Skyramp command lines.
      */
     private detectExternalTestType;
-    /**
-     * Detect test framework from external test file content by checking imports.
-     */
     private detectExternalFramework;
     /**
      * Detect programming language from file extension

package/build/services/TestDiscoveryService.js

@@ -23,7 +23,8 @@ export class TestDiscoveryService {
     SUPPORTED_EXTENSIONS = [
         ".py", ".js", ".ts", ".tsx", ".jsx", ".java",
         ".go", ".rb", ".kt", ".kts", ".cs", ".rs",
-        ".php", ".scala", ".swift", ".m",
+        ".php", ".scala", ".swift", ".m", ".dart",
+        ".snap", // Jest/Vitest snapshot files — may need updating when UI changes break them
     ];
     // Concurrency control for parallel operations
     MAX_CONCURRENT_OPERATIONS = 10;
@@ -47,11 +48,20 @@ export class TestDiscoveryService {
         // Skyramp-generated test suffixes — must be matched even outside test dirs
         /.*_(?:smoke|contract|fuzz|integration|load|e2e|ui)\.(py|ts|js|java|rb|go|cs|kt|kts|scala|swift|php|rs)$/i,
     ];
-    // Directory patterns that signal test directories — works with both / and \ separators
+    // Directory patterns that signal test-owned files — works with both / and \ separators.
+    // Includes standard test dirs, snapshot dirs, and common helper/fixture dirs used by
+    // Playwright, Cypress, and other frameworks for page objects and support code.
     TEST_DIR_PATTERNS = [
         /[\\/]tests?[\\/]/,
         /[\\/]__tests__[\\/]/,
+        /[\\/]__snapshots__[\\/]/, // Jest/Vitest snapshot directories
         /[\\/]spec[\\/]/,
+        /[\\/]e2e[\\/]/,
+        /[\\/]cypress[\\/]/, // Cypress support, fixtures, plugins
+        /[\\/]playwright[\\/]/, // Playwright fixtures and helpers
+        /[\\/]page-?objects?[\\/]/, // page-objects/, page-object/, pageObjects/
+        /[\\/]fixtures[\\/](?!db[\\/]|seed[\\/]|migrations[\\/])/, // test fixture files (not db/seed/migration fixtures)
+        /[\\/]cypress[\\/]support[\\/]/, // Cypress support directory (scoped to avoid matching app support/ dirs)
     ];
     /**
      * Discover all tests under testDir — both Skyramp-generated and external (user-written).
@@ -93,48 +103,57 @@ export class TestDiscoveryService {
         // Full-repo mode (changedResources is undefined):
         //   No diff context — all external files treated as potentially relevant.
         //   Cap at MAX_EXTERNAL_FULL_REPO to avoid reading hundreds of files.
-        const { changedResources } = options;
+        const { changedResources, hasFrontendChanges } = options;
         let relevantExternal;
-        let otherExternal;
+        // Includes .e2e.ts — Playwright/Cypress tests that navigate pages. These get
+        // testType="e2e" from path detection but are never named *.test.ts or *.spec.ts
+        // so without explicit promotion they'd be excluded from stateData.existingTests,
+        // making the server-side symbol grep unable to find them.
+        const UI_TEST_EXT = /\.(test|spec|e2e)\.(tsx|jsx|ts|js)$/;
+        const SEC_EXT = /\.(snap|ambr|txt|yml|yaml)$/;
+        // Step 1 — API relevance partitioning (driven by changedResources).
+        // Two-pass: filename token overlap first, then content-based endpoint path scan
+        // for tests that are misnamed relative to the endpoint they exercise.
         if (changedResources?.length) {
-            // PR mode with detected endpoints — partition by relevance
-            ({ relevant: relevantExternal, other: otherExternal } =
-                this.partitionByRelevance(classified.external, changedResources));
+            ({ relevant: relevantExternal } =
+                this.partitionByRelevance(classified.external, changedResources, classified.contentCache));
         }
         else if (changedResources !== undefined) {
-            // PR mode with no path-resolvable endpoints — no path-based scoring available.
             relevantExternal = [];
-            otherExternal = [];
         }
         else {
-            // Full-repo mode (no diff context): cap full-extraction set, remaining become name-only
             relevantExternal = classified.external.slice(0, this.MAX_EXTERNAL_FULL_REPO);
-            otherExternal = classified.external.slice(this.MAX_EXTERNAL_FULL_REPO);
         }
-        logger.info(`External tests: ${relevantExternal.length} relevant (full extraction), ${otherExternal.length} low-relevance (name-only)`);
-        // Free cached content for files we will not extract — their content is not needed.
-        for (const f of otherExternal) {
-            classified.contentCache.delete(f);
+        // Step 2 — UI test promotion (driven by hasFrontendChanges, independent of Step 1).
+        if (hasFrontendChanges) {
+            const alreadyRelevant = new Set(relevantExternal);
+            const promoted = classified.external.filter(f => UI_TEST_EXT.test(f) && !alreadyRelevant.has(f));
+            const promotedSet = new Set(promoted);
+            // Promote snapshot/fixture siblings of scored AND newly promoted UI tests.
+            // Include promoted files so siblings are found on UI-only PRs where
+            // relevantExternal started empty before Step 2.
+            const relevantTestBasenames = new Set([...relevantExternal, ...promoted].filter(f => UI_TEST_EXT.test(f)).map(f => path.basename(f)));
+            const promotedSecondary = classified.external.filter(f => !alreadyRelevant.has(f) &&
+                !promotedSet.has(f) &&
+                relevantTestBasenames.has(path.basename(f).replace(SEC_EXT, '')));
+            const allPromoted = [...promoted, ...promotedSecondary];
+            if (allPromoted.length > 0) {
+                logger.info(`Promoting ${promoted.length} UI test + ${promotedSecondary.length} secondary file(s) for content reading`);
+                relevantExternal = [...relevantExternal, ...allPromoted];
+            }
+        }
+        // Free content cache for external files not selected for full extraction.
+        const relevantSet = new Set(relevantExternal);
+        for (const f of classified.external) {
+            if (!relevantSet.has(f))
+                classified.contentCache.delete(f);
         }
-        // Full metadata + endpoint extraction only for relevant external files
+        logger.info(`External tests: ${relevantExternal.length} relevant (full extraction)`);
         const relevantExternalTests = await this.processFilesInBatches(relevantExternal, true, classified.contentCache);
-        // Minimal entries for low-relevance files — no content reads, no endpoint extraction
-        const otherExternalTests = otherExternal.map(filePath => ({
-            testFile: filePath,
-            testType: this.detectExternalTestType(filePath, ""),
-            language: this.detectLanguage(filePath),
-            framework: "",
-            apiEndpoint: "",
-            source: TestSource.External,
-        }));
-        const externalTests = [...relevantExternalTests, ...otherExternalTests];
+        const externalTests = relevantExternalTests;
         logger.info(`Discovered ${skyrampTests.length} Skyramp tests, ${externalTests.length} external tests`);
         return {
             tests: [...skyrampTests, ...externalTests],
-            // Expose the relevant file paths so callers can build read instructions for the LLM.
-            // These are the files the agent should read in Step 0 for definitive coverage
-            // verification — includes files where regex extraction may have failed (e.g. helper
-            // abstractions) since those most need semantic inspection.
             relevantExternalTestPaths: relevantExternal,
         };
     }
@@ -168,22 +187,46 @@ export class TestDiscoveryService {
             return parts.length > 1 && parts.every(p => p.length >= 3 && expanded.has(p));
         }).length;
     }
+    // Max additional tests promoted via content-based scoring on top of filename matches.
+    // Content matches are lower-confidence than filename matches — cap to avoid token bloat.
+    MAX_CONTENT_PROMOTED = 5;
     /**
      * Partition external test files into relevant (score > 0) and low-relevance (score = 0).
-     * Signal: path/name token overlap with changedResources.
+     * Two-pass: filename token overlap first (primary); content-based endpoint path scan
+     * as a capped fallback for tests misnamed relative to the endpoint they exercise
+     * (e.g. test_checkout_flow.py testing /api/orders scores 0 by name but matches in content).
+     * Content matches are capped at MAX_CONTENT_PROMOTED to bound token impact.
      */
-    partitionByRelevance(files, changedResources) {
-        const relevant = [];
-        const other = [];
+    partitionByRelevance(files, changedResources, contentCache) {
+        const nameMatched = [];
+        const contentCandidates = [];
+        // Precompile content patterns once — avoids 20 resources × 150 files = 3K compilations.
+        const contentPatterns = contentCache
+            ? changedResources.map(r => {
+                // Escape all regex metacharacters, then restore [-/] as a character class
+                // for hyphens and slashes that appear in resource names like "order-items".
+                const escaped = r.toLowerCase()
+                    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // escape regex metacharacters
+                    .replace(/-|\//g, "[-/]"); // treat hyphens/slashes interchangeably
+                return new RegExp(`["'\`][^"'\`]*/${escaped}`, "i");
+            })
+            : [];
         for (const f of files) {
             if (this.scoreRelevance(f, changedResources) > 0) {
-                relevant.push(f);
+                nameMatched.push(f);
             }
-            else {
-                other.push(f);
+            else if (contentPatterns.length > 0) {
+                const content = contentCache.get(f) ?? "";
+                if (content && contentPatterns.some(p => p.test(content))) {
+                    contentCandidates.push(f);
+                }
             }
         }
-        return { relevant, other };
+        const contentMatched = contentCandidates.slice(0, this.MAX_CONTENT_PROMOTED);
+        if (contentMatched.length > 0) {
+            logger.info(`Content-based relevance: promoting ${contentMatched.length} test(s) (capped at ${this.MAX_CONTENT_PROMOTED})`);
+        }
+        return { relevant: [...nameMatched, ...contentMatched] };
     }
     /**
      * Process test files in parallel batches with concurrency control
@@ -458,6 +501,10 @@ export class TestDiscoveryService {
             return "integration";
         if (/e2e|end[_-]to[_-]end/.test(lowerPath))
             return "e2e";
+        // Playwright/Cypress directory paths → e2e even without "e2e" in the filename.
+        // Ensures correct testType for tests where content wasn't read (framework stays "").
+        if (/[\\/]playwright[\\/]|[\\/]cypress[\\/]/.test(lowerPath))
+            return "e2e";
         if (/contract/.test(lowerPath))
             return "contract";
         if (/smoke/.test(lowerPath))
@@ -466,35 +513,57 @@ export class TestDiscoveryService {
             return "load";
         if (/[\\/]unit[\\/]|_unit/.test(lowerPath))
             return "unit";
-        // Heuristic: files making HTTP calls are likely integration/API tests
         if (/(?:requests|fetch|axios|supertest|RestAssured)/i.test(content))
             return "integration";
         return "unknown";
     }
-    /**
-     * Detect test framework from external test file content by checking imports.
-     */
     detectExternalFramework(content) {
-        // Python
+        if (/from selenium\b|import selenium\b|from appium\b|import appium\b/.test(content))
+            return "selenium";
+        // pytest-playwright: check before the generic pytest return.
+        if (/from playwright\.(?:sync|async)_api\b|import playwright\./.test(content)) {
+            const usesPage = /\bpage\.(?:goto|click|locator|get_by|fill|type|press|wait_for)\b/.test(content);
+            const usesRequestOnly = !usesPage && /\brequest\.(?:get|post|put|patch|delete)\b/.test(content);
+            return usesRequestOnly ? "playwright" : "playwright-ui";
+        }
         if (/import pytest|from pytest/.test(content))
             return "pytest";
         if (/import unittest|from unittest/.test(content))
             return "unittest";
-        // JavaScript/TypeScript
         if (/from ['"]vitest['"]|import.*vitest|require\(['"]vitest['"]\)|\bvi\./.test(content))
             return "vitest";
-        if (/from ['"]@jest\/globals['"]|from ['"]jest['"]|import.*jest|require\(['"]jest['"]\)|jest\./.test(content) ||
-            (/\b(?:test|it)\s*\(/.test(content) && /\bexpect\s*\(/.test(content))) {
-            return "jest";
-        }
+        // Component/UI test frameworks — checked BEFORE the broad jest heuristic below,
+        // because RTL and similar frameworks use it()/expect() which would otherwise
+        // match the jest fallback and hide the more specific framework signal.
+        if (/from ['"]@testing-library\/react['"]|from ['"]@testing-library\/react-native['"]/.test(content))
+            return "rtl";
+        if (/from ['"]@testing-library\/vue['"]|from ['"]@vue\/test-utils['"]/.test(content))
+            return "vue-test-utils";
+        if (/from ['"]@testing-library\/angular['"]/.test(content))
+            return "angular-testbed";
+        if (/from ['"]@testing-library\/svelte['"]/.test(content))
+            return "svelte-testing-library";
+        if (/from ['"]enzyme['"]|require\(['"]enzyme['"]\)/.test(content))
+            return "enzyme";
         if (/from ['"]mocha['"]|require\(['"]mocha['"]\)/.test(content))
             return "mocha";
         if (/supertest/.test(content))
             return "supertest";
-        if (/from ['"]@playwright/.test(content))
-            return "playwright";
+        if (/from ['"]@playwright/.test(content)) {
+            // Distinguish browser UI usage (page fixture) from REST API usage (request fixture only).
+            // Using Playwright for API testing is an edge case — the default classification is UI.
+            const usesPage = /\bpage\.(goto|click|locator|getBy|fill|type|press|waitFor)\b/.test(content);
+            const usesRequestOnly = !usesPage && /\brequest\.(get|post|put|patch|delete)\b/.test(content);
+            return usesRequestOnly ? "playwright" : "playwright-ui";
+        }
         if (/from ['"]cypress/.test(content))
-            return "cypress";
+            return "cypress-ui";
+        if (/package:flutter_test\/flutter_test\.dart/.test(content))
+            return "flutter-widget";
+        if (/from ['"]@jest\/globals['"]|from ['"]jest['"]|import.*jest|require\(['"]jest['"]\)|jest\./.test(content) ||
+            (/\b(?:test|it)\s*\(/.test(content) && /\bexpect\s*\(/.test(content))) {
+            return "jest";
+        }
         // Java / Kotlin — check TestNG before @Test since TestNG also uses @Test
         if (/import org\.testng/.test(content))
             return "testng";
@@ -502,6 +571,10 @@ export class TestDiscoveryService {
             return "junit";
         if (/RestAssured/.test(content))
             return "rest-assured";
+        if (/import androidx\.test\b|import com\.android\.support\.test\b|EspressoIdlingResource|onView\(/.test(content))
+            return "espresso";
+        if (/import io\.appium\./.test(content))
+            return "appium";
         // Go
         if (/import.*"testing"|func\s+Test\w+\(t\s+\*testing\.T\)/.test(content))
             return "go-testing";
@@ -555,6 +628,7 @@ export class TestDiscoveryService {
             ".scala": "scala",
             ".swift": "swift",
             ".m": "objective-c",
+            ".dart": "dart",
         };
         return languageMap[ext] || "unknown";
     }