@skyramp/mcp 0.2.9 → 0.2.10-rc.1

package/build/tools/test-management/actionsTool.test.js

@@ -0,0 +1,297 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
+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() },
+}));
+jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) },
+}));
+const { registerActionsTool } = await import("./actionsTool.js");
+const { DriftAction, TestSource } = await import("../../types/TestAnalysis.js");
+const { TestType } = await import("../../types/TestTypes.js");
+function captureToolHandler() {
+    let handler;
+    let inputSchema;
+    const fakeServer = {
+        registerTool: (_name, opts, fn) => {
+            handler = fn;
+            inputSchema = opts.inputSchema;
+        },
+    };
+    registerActionsTool(fakeServer);
+    // Mirrors the real MCP SDK's registerTool: validates args against inputSchema via Zod
+    // before invoking the handler, so tests exercise the real tool contract (refinements
+    // included) instead of bypassing validation entirely.
+    return async (params) => {
+        const parsed = z.object(inputSchema).safeParse(params);
+        if (!parsed.success) {
+            return { isError: true, content: [{ type: "text", text: parsed.error.message }] };
+        }
+        return handler(parsed.data);
+    };
+}
+async function writeStateFile(dir, existingTests, repositoryAnalysis) {
+    const stateFile = path.join(dir, "analyze-changes-state.json");
+    await fs.writeFile(stateFile, JSON.stringify({
+        existingTests,
+        repositoryAnalysis,
+        analysisScope: {},
+        newEndpoints: [],
+        metadata: {
+            sessionId: "test-session",
+            stateType: "unified",
+            repositoryPath: dir,
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-01T00:00:00.000Z",
+        },
+    }), "utf-8");
+    return stateFile;
+}
+describe("registerActionsTool — completeness check (SKYR-3906)", () => {
+    let handler;
+    let tmpDirs = [];
+    beforeAll(() => {
+        handler = captureToolHandler();
+    });
+    afterEach(async () => {
+        for (const dir of tmpDirs) {
+            await fs.rm(dir, { recursive: true, force: true });
+        }
+        tmpDirs = [];
+    });
+    it("succeeds when every existing test is covered by recommendations", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "orders_contract_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            recommendations: [
+                {
+                    testFilePath: testFile,
+                    action: DriftAction.Update,
+                    rationale: "New field added",
+                    testType: TestType.CONTRACT,
+                    endpoint: "GET /api/v1/orders",
+                    updateInstructions: "Assert new field",
+                },
+            ],
+        });
+        expect(result.content).toBeDefined();
+        expect(result.isError).toBeUndefined();
+    });
+    it("succeeds when every existing test is covered by ignoredTestFiles", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            ignoredTestFiles: [testFile],
+        });
+        expect(result.isError).toBeUndefined();
+    });
+    it("rejects a bare basename in ignoredTestFiles at the schema level — ambiguous across files sharing that name", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            ignoredTestFiles: ["unrelated_test.py"],
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("must be absolute paths");
+    });
+    it("rejects a recommendation with action: IGNORE at the schema level — must use ignoredTestFiles", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const testFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(testFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            recommendations: [{ testFilePath: testFile, action: DriftAction.Ignore, rationale: "No change needed", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            // ignoredTestFiles intentionally omitted — IGNORE must not silently persist via recommendations.
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Use ignoredTestFiles for IGNORE tests");
+    });
+    it("fails with a descriptive error naming the file missing from both recommendations and ignoredTestFiles", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const coveredFile = path.join(tmpDir, "covered_test.py");
+        const droppedFile = path.join(tmpDir, "secret_test.py");
+        await fs.writeFile(coveredFile, "# test");
+        await fs.writeFile(droppedFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [
+            { testFile: coveredFile, source: TestSource.Skyramp },
+            { testFile: droppedFile, source: TestSource.Skyramp },
+        ]);
+        const result = await handler({
+            stateFile,
+            recommendations: [{ testFilePath: coveredFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            // droppedFile intentionally absent from both recommendations and ignoredTestFiles
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("secret_test.py");
+        expect(result.content[0].text).toContain("not accounted for");
+    });
+    it("persists a reconciled maintenanceVerdicts + ignoredTestFiles record to the state file", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const updatedFile = path.join(tmpDir, "orders_contract_test.py");
+        const ignoredFile = path.join(tmpDir, "unrelated_test.py");
+        await fs.writeFile(updatedFile, "# test");
+        await fs.writeFile(ignoredFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [
+            { testFile: updatedFile, source: TestSource.Skyramp },
+            { testFile: ignoredFile, source: TestSource.Skyramp },
+        ]);
+        await handler({
+            stateFile,
+            recommendations: [{ testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            ignoredTestFiles: [ignoredFile],
+        });
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.ignoredTestFiles).toEqual([ignoredFile]);
+        expect(written.maintenanceVerdicts).toEqual([
+            { testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" },
+        ]);
+        // Original existingTests must survive the write-back untouched.
+        expect(written.existingTests).toHaveLength(2);
+    });
+    it("fails loud when persisting maintenanceVerdicts to state fails, instead of silently applying edits anyway", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const updatedFile = path.join(tmpDir, "orders_contract_test.py");
+        await fs.writeFile(updatedFile, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile: updatedFile, source: TestSource.Skyramp }]);
+        // Make the state file unwritable so writeRepoData's overwrite fails with EACCES.
+        await fs.chmod(stateFile, 0o444);
+        try {
+            const result = await handler({
+                stateFile,
+                recommendations: [{ testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("Failed to persist maintenance reconciliation");
+        }
+        finally {
+            await fs.chmod(stateFile, 0o644);
+        }
+    });
+    it("does not require accounting for a test when there are no existing tests at all", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const stateFile = await writeStateFile(tmpDir, []);
+        const result = await handler({ stateFile });
+        expect(result.isError).toBeUndefined();
+    });
+    // ── Multi-repo (`repository` param) ─────────────────────────────────────────
+    // A run-scoped state file holds the primary repo at the root and each related
+    // repo under `relatedRepos[<owner/repo>]`. `args.repository` must scope both
+    // the completeness check and the maintenanceVerdicts/ignoredTestFiles write-back
+    // to the matching section only.
+    async function writeMultiRepoStateFile(stateFile, primary, related) {
+        const now = "2026-01-01T00:00:00.000Z";
+        await fs.writeFile(stateFile, JSON.stringify({
+            existingTests: primary.existingTests,
+            analysisScope: {},
+            newEndpoints: [],
+            metadata: {
+                sessionId: "test-session",
+                stateType: "unified",
+                repositoryPath: primary.repositoryPath,
+                repository: "org/primary",
+                createdAt: now,
+                updatedAt: now,
+            },
+            relatedRepos: {
+                [related.repo]: {
+                    repositoryPath: related.repositoryPath,
+                    data: { existingTests: related.existingTests, analysisScope: {}, newEndpoints: [] },
+                },
+            },
+        }), "utf-8");
+    }
+    it("scopes the completeness check and write-back to a related (non-primary) repo section, leaving the primary section untouched", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const primaryDir = path.join(tmpDir, "primary");
+        const secondaryDir = path.join(tmpDir, "secondary");
+        await fs.mkdir(primaryDir, { recursive: true });
+        await fs.mkdir(secondaryDir, { recursive: true });
+        const secondaryTestFile = path.join(secondaryDir, "orders_contract_test.py");
+        await fs.writeFile(secondaryTestFile, "# test");
+        const stateFile = path.join(tmpDir, "analyze-changes-state.json");
+        await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
+        const result = await handler({
+            stateFile,
+            repository: "org/secondary",
+            recommendations: [{ testFilePath: secondaryTestFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        // UPDATE converts to VERIFY — the agent has no write access to a related repo's
+        // checkout, so no edit is ever attempted there.
+        expect(written.relatedRepos["org/secondary"].data.maintenanceVerdicts).toEqual([
+            { testFilePath: secondaryTestFile, action: DriftAction.Verify, rationale: "[related repo — no write access, needs manual review] Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" },
+        ]);
+        // Primary section must be untouched by a write scoped to the related repo.
+        expect(written.maintenanceVerdicts).toBeUndefined();
+        expect(written.existingTests).toEqual([]);
+    });
+    it("also converts DELETE to VERIFY for a related repo — no action type gets write access there", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const primaryDir = path.join(tmpDir, "primary");
+        const secondaryDir = path.join(tmpDir, "secondary");
+        await fs.mkdir(primaryDir, { recursive: true });
+        await fs.mkdir(secondaryDir, { recursive: true });
+        const secondaryTestFile = path.join(secondaryDir, "reset_contract_test.py");
+        await fs.writeFile(secondaryTestFile, "# test");
+        const stateFile = path.join(tmpDir, "analyze-changes-state.json");
+        await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
+        const result = await handler({
+            stateFile,
+            repository: "org/secondary",
+            recommendations: [{ testFilePath: secondaryTestFile, action: DriftAction.Delete, rationale: "Endpoint removed", testType: TestType.CONTRACT, endpoint: "DELETE /api/v1/reset" }],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.relatedRepos["org/secondary"].data.maintenanceVerdicts).toEqual([
+            { testFilePath: secondaryTestFile, action: DriftAction.Verify, rationale: "[related repo — no write access, needs manual review] Endpoint removed", testType: TestType.CONTRACT, endpoint: "DELETE /api/v1/reset" },
+        ]);
+    });
+    it("fails the completeness check for a related repo's missing test, unaffected by the primary repo's own state", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const primaryDir = path.join(tmpDir, "primary");
+        const secondaryDir = path.join(tmpDir, "secondary");
+        await fs.mkdir(primaryDir, { recursive: true });
+        await fs.mkdir(secondaryDir, { recursive: true });
+        const primaryTestFile = path.join(primaryDir, "covered_test.py");
+        const secondaryTestFile = path.join(secondaryDir, "secret_test.py");
+        await fs.writeFile(primaryTestFile, "# test");
+        await fs.writeFile(secondaryTestFile, "# test");
+        const stateFile = path.join(tmpDir, "analyze-changes-state.json");
+        await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [{ testFile: primaryTestFile, source: TestSource.Skyramp }] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
+        // Primary repo's own test is fully accounted for, but that must not satisfy
+        // the related repo's completeness check.
+        const result = await handler({
+            stateFile,
+            repository: "org/secondary",
+            recommendations: [],
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("secret_test.py");
+    });
+});

package/build/tools/test-management/analyzeChangesTool.d.ts

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { CandidateUiPage } from "../../utils/uiPageEnumerator.js";
+import type { FrontendFileIntegration } from "../../types/FrontendIntegration.js";
 import { TraceFile } from "../../types/RepositoryAnalysis.js";
 import { ScannedEndpoint } from "../../utils/repoScanner.js";
 import { TraceParseResult } from "../../utils/trace-parser.js";
@@ -24,4 +25,12 @@ export declare const analyzeChangesInputSchema: {
 export declare const NO_UI_INSTRUCTIONS = "No UI changes detected \u2014 no blueprint capture needed.";
 export declare const NO_RESOLVABLE_URLS_INSTRUCTIONS = "Frontend changes detected but no candidate URLs could be resolved (workspace baseUrl missing or no router files matched). UI recommendations will be source-grounded only.";
 export declare function buildCaptureInstructions(pages: CandidateUiPage[]): string;
+/**
+ * Instruction block for changed frontend files the server determined have no
+ * production importer (SKYR-3855) — dead/orphaned components. Used both to
+ * replace the capture instructions entirely (every changed frontend file is
+ * unintegrated) and to append a scoped note when only some files are
+ * (`buildCaptureInstructions` still runs for the rest in that case).
+ */
+export declare function buildUnintegratedInstructions(results: FrontendFileIntegration[]): string;
 export declare function registerAnalyzeChangesTool(server: McpServer): void;

package/build/tools/test-management/analyzeChangesTool.js

@@ -12,11 +12,12 @@ import { StateManager, registerSession, storeSessionData, setTestsRepoDir, getAc
 import { buildRecommendationPrompt } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
 import { hasFlutterSdkDep, isFrontendFile, isTestFile } from "../../prompts/test-recommendation/scopeAssessment.js";
 import { enumerateCandidateUiPages } from "../../utils/uiPageEnumerator.js";
+import { checkFrontendFileIntegration } from "../../utils/frontendIntegration.js";
 import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-recommendation/recommendationSections.js";
 import { TestDiscoveryService } from "../../services/TestDiscoveryService.js";
 import { ScenarioSource, AnalysisScope } from "../../types/RepositoryAnalysis.js";
 import { computeBranchDiff } from "../../utils/branchDiff.js";
-import { parseFileEndpoints, extractResourceFromPath, classifyEndpointsByChangedFiles, } from "../../utils/routeParsers.js";
+import { classifyEndpointsByChangedFiles, selectRemovalCandidateFiles, recoverRemovedEndpointsFromBase, } from "../../utils/routeParsers.js";
 import { scanAllRepoEndpoints, scanRelatedEndpoints, grepRouterMountingContext, findCandidateRouteFiles, } from "../../utils/repoScanner.js";
 import { detectProjectMetadata } from "../../utils/projectMetadata.js";
 import { draftScenariosFromEndpoints } from "../../utils/scenarioDrafting.js";
@@ -32,24 +33,6 @@ const GENERIC_MODULE_NAMES = new Set([
     "config", "settings", "exceptions", "errors", "base", "common",
     "app", "main", "index", "server", "init", "deps", "dependencies",
 ]);
-function resolveMountPrefixTokens(mountFileContents, changedFiles) {
-    const tokens = changedFiles.flatMap((file) => {
-        const mod = path.basename(file).replace(/\.[^.]+$/, "").toLowerCase();
-        if (GENERIC_MODULE_NAMES.has(mod))
-            return [];
-        const modRe = new RegExp(`\\b${mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
-        return mountFileContents.flatMap((content) => {
-            if (!modRe.test(content.toLowerCase()))
-                return [];
-            const matches = [...content.matchAll(/prefix\s*=\s*["'](\/?[^"']+)/g)];
-            return matches.flatMap((m) => {
-                const token = extractResourceFromPath(m[1]);
-                return token !== "unknown" ? [token] : [];
-            });
-        });
-    });
-    return [...new Set(tokens)];
-}
 /** Exported for testing: maps a parsed trace result to a TraceFile. */
 export function buildTraceFileEntry(tracePath, result) {
     return {
@@ -285,54 +268,6 @@ function isNonApplicationFile(filePath) {
 const ROUTE_FILE_PATTERN = /route|controller|endpoint|handler|view|urls|api|router|service|gateway|resolver|\bserver\b/i;
 const ROUTE_FILE_BASENAME_PATTERN = /\bapp\b|\bmain\b/i;
 const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|java|kt|go|rb|php|rs|cs|ex|exs)$/;
-/**
- * Recover endpoints from files deleted in this branch by reading their
- * content from the base branch via `git show`. Only checks files whose
- * name matches route-file heuristics to keep I/O bounded.
- */
-async function recoverDeletedFileEndpoints(repositoryPath, baseBranch, deletedFiles) {
-    const candidates = deletedFiles.filter((f) => SOURCE_EXTS.test(f) && (ROUTE_FILE_PATTERN.test(f) || ROUTE_FILE_BASENAME_PATTERN.test(path.basename(f))));
-    if (candidates.length === 0)
-        return [];
-    const git = simpleGit(repositoryPath);
-    const results = [];
-    const endpointMap = new Map();
-    for (const file of candidates) {
-        try {
-            const content = await git.show([`${baseBranch}:${file}`]);
-            for (const ep of parseFileEndpoints(content, file)) {
-                const normalizedPath = ep.path.startsWith("/") ? ep.path : `/${ep.path}`;
-                const key = `${file}::${normalizedPath}`;
-                const existing = endpointMap.get(key);
-                if (existing) {
-                    existing.methods.add(ep.method);
-                }
-                else {
-                    endpointMap.set(key, {
-                        path: normalizedPath,
-                        methods: new Set([ep.method]),
-                        sourceFile: file,
-                    });
-                }
-            }
-        }
-        catch (err) {
-            logger.debug("Failed to recover endpoints from deleted file", {
-                file,
-                baseBranch,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    for (const data of endpointMap.values()) {
-        results.push({
-            path: data.path,
-            methods: Array.from(data.methods),
-            sourceFile: data.sourceFile,
-        });
-    }
-    return results;
-}
 export const analyzeChangesInputSchema = {
     repositoryPath: z
         .string()
@@ -364,7 +299,7 @@ export const analyzeChangesInputSchema = {
     prNumber: z
         .number()
         .optional()
-        .describe("GitHub PR number. When provided, fetches previous TestBot comments on this PR and skips re-recommending tests already suggested in earlier commits — reduces duplicate recommendations across multiple pushes to the same PR."),
+        .describe("GitHub PR number. When provided, fetches previous Testbot comments on this PR and skips re-recommending tests already suggested in earlier commits — reduces duplicate recommendations across multiple pushes to the same PR."),
     repository: z
         .string()
         .optional()
@@ -403,6 +338,30 @@ If a candidate URL 404s or redirects unexpectedly, navigate from the workspace b
 
 If \`browser_blueprint\` fails on every candidate URL (app unreachable, all 404s), proceed and log an \`issuesFound\` info entry. Recommendations will be source-grounded; non-UI work is unaffected.`;
 }
+/**
+ * Instruction block for changed frontend files the server determined have no
+ * production importer (SKYR-3855) — dead/orphaned components. Used both to
+ * replace the capture instructions entirely (every changed frontend file is
+ * unintegrated) and to append a scoped note when only some files are
+ * (`buildCaptureInstructions` still runs for the rest in that case).
+ */
+export function buildUnintegratedInstructions(results) {
+    const listing = results
+        .filter((r) => !r.integrated)
+        .map((r) => {
+        const token = path.basename(r.file).replace(/\.[^.]+$/, "");
+        return `  - \`${r.file}\` (checked for a production import of \`${token}\` — none found)`;
+    })
+        .join("\n");
+    return `**Server-side integration check found no production importer for the following changed component(s) — do not treat this as unproven:**
+${listing}
+
+These components have no DOM presence in the running app: no route, page, or other production file imports or renders them. Handle them as follows:
+- **Never record traces or generate UI tests against a substitute surface** (a different page or component that happens to be visible). A test on an unrelated surface validates nothing about this PR.
+- **DO write the change-targeting test directly from code analysis** — you know the component's structure, selectors, and expected behavior from the diff. Target the component's own elements/attributes. The test is EXPECTED TO FAIL because the component never mounts; that failing test documents the integration gap and is more valuable than prose. Mark its report entry accordingly (e.g. "expected failure: component has no production importer").
+- Log an \`issuesFound\` entry (high severity) naming the unintegrated file(s) above and stating that the changed code is unreachable in the running app.
+- Backend/other work in this PR is unaffected — proceed with it normally.`;
+}
 export function registerAnalyzeChangesTool(server) {
     server.registerTool(TOOL_NAME, {
         annotations: {
@@ -526,11 +485,16 @@ export function registerAnalyzeChangesTool(server) {
             // HTTP methods, eliminating the need for path resolution and MULTI sentinels.
             let classifiedEndpoints;
             if (diffData) {
-                // Recover endpoints from deleted files by reading base-branch content
-                const deletedFileEndpoints = diffData.deletedFiles.length > 0
-                    ? await recoverDeletedFileEndpoints(params.repositoryPath, diffData.baseBranch, diffData.deletedFiles)
+                // Recover endpoints that existed in the base branch from every candidate
+                // file (deleted files AND modified files that may have dropped a route via
+                // line-edit). classifyEndpointsByChangedFiles filters out any that still
+                // exist in the current catalog, leaving only genuine removals.
+                const removalCandidateFiles = selectRemovalCandidateFiles(diffData);
+                const git = simpleGit(params.repositoryPath);
+                const recoveredBaseEndpoints = removalCandidateFiles.length > 0
+                    ? await recoverRemovedEndpointsFromBase(removalCandidateFiles, (file) => git.show([`${diffData.baseBranch}:${file}`]))
                     : [];
-                classifiedEndpoints = classifyEndpointsByChangedFiles(diffData, scannedEndpoints, deletedFileEndpoints);
+                classifiedEndpoints = classifyEndpointsByChangedFiles(diffData, scannedEndpoints, recoveredBaseEndpoints);
                 classifiedEndpoints = {
                     ...classifiedEndpoints,
                     // changed/new endpoints come from scannedEndpoints, which is already
@@ -617,79 +581,9 @@ export function registerAnalyzeChangesTool(server) {
                     return [];
                 return [{ file: f, content: content.trimEnd() }];
             });
-            // Compute changedResources from classified endpoints for test discovery filtering.
-            // undefined    → full-repo mode (no diff context)
-            // []           → PR mode, no endpoints found → skip external tests
-            // [...names]   → PR mode with resolved resource names → filter external by relevance
-            let changedResources;
-            if (!classifiedEndpoints) {
-                changedResources = undefined;
-            }
-            else {
-                const allClassified = [
-                    ...classifiedEndpoints.changedEndpoints,
-                    ...classifiedEndpoints.newEndpoints,
-                    ...classifiedEndpoints.removedEndpoints,
-                ];
-                const FRAMEWORK_SUFFIX_RE = /\.(service|controller|transformer|handler|middleware|resolver|repository|module|guard|interceptor|pipe|filter|decorator|input|output|dto|schema)$/i;
-                if (allClassified.length > 0) {
-                    // Scanned endpoints always have full paths — extractResourceFromPath
-                    // never returns "unknown" for properly resolved paths.
-                    // Exception: NestJS versioned controllers register relative paths (e.g. "GET /")
-                    // which resolve to "unknown". Fall through to file-path extraction in that case.
-                    const resolved = allClassified
-                        .map((ep) => extractResourceFromPath(ep.path))
-                        .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
-                    if (resolved.length > 0) {
-                        changedResources = resolved;
-                    }
-                    else {
-                        // All endpoints resolved to "unknown" (e.g. NestJS relative paths) —
-                        // first try to extract resource names from router mount prefixes.
-                        const changedSourceFiles = classifiedEndpoints.changedFiles ?? [];
-                        const mountedResources = resolveMountPrefixTokens(routerMountContextContents, changedSourceFiles);
-                        if (mountedResources.length > 0) {
-                            changedResources = mountedResources;
-                        }
-                        else {
-                            // Fall back to extracting resource names from changed file paths.
-                            const candidateFiles = classifiedEndpoints.unmatchedFiles.length > 0
-                                ? classifiedEndpoints.unmatchedFiles
-                                : classifiedEndpoints.changedFiles ?? [];
-                            const fromFiles = candidateFiles
-                                .map((f) => extractResourceFromPath(f.replace(/\.[^./]+$/, "").replace(FRAMEWORK_SUFFIX_RE, "")))
-                                .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
-                            changedResources = fromFiles.length > 0 ? fromFiles : ["unknown"];
-                        }
-                    }
-                }
-                else if (classifiedEndpoints.unmatchedFiles.length > 0) {
-                    // Changed files don't map to any endpoint (e.g. DTO, service, output
-                    // formatter, migration). Extract resource names from the file paths so
-                    // external tests whose names overlap with these resources are surfaced
-                    // for drift assessment.
-                    // Strip the file extension and common framework suffixes (.service,
-                    // .controller, .input, .output, etc.) before extracting so that
-                    // "event-types.service.ts" yields "event-types" rather than
-                    // "event-types.service", which would fail relevance scoring against
-                    // test files that contain "event" and "types" but not "service".
-                    const fromFiles = classifiedEndpoints.unmatchedFiles
-                        .map((f) => extractResourceFromPath(f.replace(/\.[^./]+$/, "").replace(FRAMEWORK_SUFFIX_RE, "")))
-                        .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
-                    changedResources = fromFiles.length > 0 ? fromFiles : ["unknown"];
-                }
-                else {
-                    // No endpoints and no unmatched files — the diff touches only non-route
-                    // files (e.g. schema, model, DTO). Extract resource tokens from the
-                    // changed file paths so tests that import the changed symbol are still
-                    // surfaced for drift assessment. Fall back to [] only if extraction
-                    // yields nothing (e.g. a file with a non-resource name like utils.py).
-                    const fromChangedFiles = (classifiedEndpoints.changedFiles ?? [])
-                        .map((f) => extractResourceFromPath(f.replace(/\.[^./]+$/, "").replace(FRAMEWORK_SUFFIX_RE, "")))
-                        .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
-                    changedResources = fromChangedFiles.length > 0 ? fromChangedFiles : [];
-                }
-            }
+            // PR mode → [] excludes external tests from pre-loading (agent discovers via grep).
+            // No diff context → undefined triggers full-repo mode in TestDiscoveryService.
+            const changedResources = classifiedEndpoints ? [] : undefined;
             // Compute changed frontend files once — reused for both discoverTests (component
             // test promotion) and uiContext below (page enumeration). Uses classifiedEndpoints
             // changedFiles so it reflects the same diff scope as the rest of the analysis.
@@ -707,7 +601,6 @@ export function registerAnalyzeChangesTool(server) {
                     testType: test.testType,
                     language: test.language,
                     framework: test.framework,
-                    apiSchema: test.apiSchema,
                     apiEndpoint: test.apiEndpoint,
                     source: test.source,
                     generatedAt: test.generatedAt,
@@ -1038,7 +931,7 @@ export function registerAnalyzeChangesTool(server) {
                 const entry = t.apiEndpoint
                     ? `${dp} [external] (covers: ${t.apiEndpoint})`
                     : `${dp} [external]`;
-                addEntry(t.testType || "unknown", entry);
+                addEntry(t.testType, entry);
             }
             // Pass 2: Skyramp tests — tagged [skyramp] so the LLM can positively identify the source
             for (const t of existingTests) {
@@ -1048,7 +941,7 @@ export function registerAnalyzeChangesTool(server) {
                 const entry = t.apiEndpoint
                     ? `${dp} [skyramp] (covers: ${t.apiEndpoint})`
                     : `${dp} [skyramp]`;
-                addEntry(t.testType || "unknown", entry);
+                addEntry(t.testType, entry);
             }
             // Pass 3: low-relevance external tests (name-only) — capped to avoid context overflow
             const LOW_RELEVANCE_CAP = 20;
@@ -1060,7 +953,7 @@ export function registerAnalyzeChangesTool(server) {
                 if (relevantExternalSet.has(t.testFile))
                     continue;
                 if (lowRelevanceCount < LOW_RELEVANCE_CAP) {
-                    addEntry(t.testType || "unknown", `${displayPath(t.testFile)} [external]`);
+                    addEntry(t.testType, `${displayPath(t.testFile)} [external]`);
                     lowRelevanceCount++;
                 }
                 else {
@@ -1228,9 +1121,14 @@ export function registerAnalyzeChangesTool(server) {
                 if (changedFrontendFiles.length === 0)
                     return undefined;
                 const candidateUiPages = await enumerateCandidateUiPages(params.repositoryPath, changedFrontendFiles);
+                // SKYR-3855: deterministic production-importer check, computed here so
+                // downstream consumers (testbot prompt) can skip UI generation for
+                // unintegrated components on a server fact instead of a mid-run grep.
+                const frontendFileIntegration = checkFrontendFileIntegration(params.repositoryPath, changedFrontendFiles);
                 return {
                     changedFrontendFiles,
                     candidateUiPages,
+                    frontendFileIntegration,
                 };
             })();
             // Derive the UI blueprint-capture instructions the agent acts on after
@@ -1238,11 +1136,24 @@ export function registerAnalyzeChangesTool(server) {
             // pre-flight tool, now folded in here so the agent makes one analysis call
             // instead of two. The captures stay in the agent's tool-result history and
             // serve as element vocabulary when it writes UI recommendation reasoning.
+            //
+            // SKYR-3855: when the integration check finds no production importer for
+            // some/all changed frontend files, that overrides/augments the normal
+            // capture flow — see buildUnintegratedInstructions.
+            const unintegratedFrontendFiles = (uiContext?.frontendFileIntegration ?? []).filter((r) => !r.integrated);
+            const allFrontendFilesUnintegrated = !!uiContext &&
+                uiContext.changedFrontendFiles.length > 0 &&
+                unintegratedFrontendFiles.length === uiContext.changedFrontendFiles.length;
             const uiInstructions = !uiContext || uiContext.changedFrontendFiles.length === 0
                 ? NO_UI_INSTRUCTIONS
-                : uiContext.candidateUiPages.length === 0
-                    ? NO_RESOLVABLE_URLS_INSTRUCTIONS
-                    : buildCaptureInstructions(uiContext.candidateUiPages);
+                : allFrontendFilesUnintegrated
+                    ? buildUnintegratedInstructions(unintegratedFrontendFiles)
+                    : (uiContext.candidateUiPages.length === 0
+                        ? NO_RESOLVABLE_URLS_INSTRUCTIONS
+                        : buildCaptureInstructions(uiContext.candidateUiPages)) +
+                        (unintegratedFrontendFiles.length > 0
+                            ? `\n\n${buildUnintegratedInstructions(unintegratedFrontendFiles)}`
+                            : "");
             const unifiedState = {
                 existingTests,
                 newEndpoints: newEndpointsForDrafting,