@skyramp/mcp 0.3.8 → 0.4.0-rc.1

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

@@ -1,42 +1,23 @@
 import { z } from "zod";
 import * as crypto from "crypto";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 import yaml from "js-yaml";
-import { simpleGit } from "simple-git";
 import { logger } from "../../utils/logger.js";
-import { dualChannelResult } from "../../utils/utils.js";
 import { parseWorkspaceAuthType, getDefaultAuthHeader, WorkspaceAuthType, readWorkspaceConfigRaw } from "../../utils/workspaceAuth.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { makeProgressReporter } from "../../utils/progress.js";
 import { StateManager, registerSession, storeSessionData, rememberTestsRepoDir, getActiveRunStatePath, setActiveRunStatePath, } from "../../utils/AnalysisStateManager.js";
-import { buildRecommendationPrompt, computeScoredCandidates } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
-import { hasFlutterSdkDep, isFrontendFile, isTestFile } from "../../prompts/test-recommendation/scopeAssessment.js";
-import { buildExternalCoverageSet } from "../../prompts/test-recommendation/recommendationShared.js";
-import { resolveSubjectEndpoints } from "../../utils/subjectEndpoints.js";
-import { collectChangedRouteLines } from "../../utils/changedRoutes.js";
-import { CandidateSource, computeCandidateId } from "../../types/Recommendation.js";
-import { selectPlan } from "../../recommendation/planRanker.js";
-import { buildApprovedPlanItem } from "../../utils/planMatchKeys.js";
-import { enumerateCandidateUiPages, MAX_CANDIDATE_PAGES } from "../../utils/uiPageEnumerator.js";
-import { checkFrontendFileIntegration } from "../../utils/frontendIntegration.js";
-import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-recommendation/recommendationSections.js";
+import { isTestFile } from "../../utils/testFileClassification.js";
+import { isPlanOnlyMode } from "../../utils/planOnlyMode.js";
 import { TestDiscoveryService } from "../../services/TestDiscoveryService.js";
-import { isDiscoveredTestFile } from "../../utils/testFileClassification.js";
-import { ScenarioSource, AnalysisScope } from "../../types/RepositoryAnalysis.js";
-import { computeBranchDiff } from "../../utils/branchDiff.js";
-import { classifyEndpointsByChangedFiles, selectRemovalCandidateFiles, recoverRemovedEndpointsFromBase, } from "../../utils/routeParsers.js";
-import { classifyUnmatchedFilesByPathAffinity } from "../../utils/pathAffinityClassification.js";
-import { scanAllRepoEndpoints, scanRelatedEndpoints, grepRouterMountingContext, findCandidateRouteFiles, } from "../../utils/repoScanner.js";
+import { AnalysisScope } from "../../types/RepositoryAnalysis.js";
+import { computeBranchDiff, changedFileNames, } from "../../utils/branchDiff.js";
 import { detectProjectMetadata } from "../../utils/projectMetadata.js";
-import { draftScenariosFromEndpoints, draftResponseShapeScenarios, capScenarios } from "../../utils/scenarioDrafting.js";
-import { mapUnmatchedFilesToImporterEndpoints, buildHopResponseShapeInputs, deriveResourceTokensForFile, deriveResourceToken, extractChangedSymbols, sliceDiffByFile } from "../../utils/importerHop.js";
-import { extractChangedSelectors, MAX_CHANGED_SELECTORS } from "../../utils/frontendSelectors.js";
-import { buildAnalysisOutputText } from "../../prompts/test-recommendation/analysisOutputPrompt.js";
+import { diffBlocksByPath } from "../../utils/branchDiff.js";
+import { collectRemovedUiElements } from "../../utils/removedUiElements.js";
 import { parseTraceFile, discoverTraceFiles, discoverPlaywrightZips, } from "../../utils/trace-parser.js";
 import { TestSource } from "../../types/TestAnalysis.js";
-import { parsePRComments } from "../../utils/pr-comment-parser.js";
 /** Exported for testing: maps a parsed trace result to a TraceFile. */
 export function buildTraceFileEntry(tracePath, result) {
     return {
@@ -47,169 +28,6 @@ export function buildTraceFileEntry(tracePath, result) {
     };
 }
 const TOOL_NAME = "skyramp_analyze_changes";
-const SECURITY_RELEVANT_DIFF_PATTERN = /\b(?:auth|authorization|permission|permissions|admin[-_\s]?key|x-admin-key|role|roles|rbac|owner|ownership|guard|auth[-_\s]?middleware|permission[-_\s]?middleware|require[-_\s]?(?:auth|admin|role)|authorize|authorized|authenticated|require_admin_key|destructive)\b/i;
-export function isSecurityRelevantDiff(diffContent) {
-    return SECURITY_RELEVANT_DIFF_PATTERN.test(diffContent);
-}
-// Must match testbot/src/constants.ts BOT_EMAIL
-const BOT_EMAIL = "test-bot@skyramp.dev";
-/**
- * Get files added by the last bot commit that still exist on disk.
- * Fallback for when PR comment file names don't match actual files
- * (e.g. after a force push that rewrote history).
- */
-async function getBotCommittedFiles(repoPath) {
-    try {
-        const git = simpleGit(repoPath);
-        const botShaRaw = await git.raw([
-            "log", "--author=" + BOT_EMAIL, "-1", "--format=%H",
-        ]);
-        const lastBotSha = botShaRaw.trim();
-        if (!lastBotSha)
-            return [];
-        const diffOutput = await git.raw([
-            "diff-tree", "--no-commit-id", "--name-only", "-r", "--diff-filter=A", lastBotSha,
-        ]);
-        return diffOutput
-            .trim()
-            .split("\n")
-            .filter(Boolean)
-            .filter(f => {
-            const abs = path.join(repoPath, f);
-            return fs.existsSync(abs);
-        });
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Get files changed by user commits (excluding bot commits) since the last bot commit.
- * Focuses on user intent — what did the developer push after the bot ran?
- * Returns null if no bot commit exists (first run) or on error.
- *
- * Uses git.raw() throughout because simple-git's .log() parser cannot
- * reliably handle custom --format flags. Filters out bot-authored commits
- * client-side because git's --not flag applies to revision specs, not --author.
- */
-async function getUserChangedFiles(repoPath) {
-    try {
-        const git = simpleGit(repoPath);
-        // Find the last bot commit — use git.raw() because simple-git's .log()
-        // parser cannot handle a custom --format flag reliably.
-        const botShaRaw = await git.raw([
-            "log", "--author=" + BOT_EMAIL, "-1", "--format=%H",
-        ]);
-        const lastBotSha = botShaRaw.trim();
-        if (!lastBotSha)
-            return null;
-        // Get all commits in the range, then filter out bot-authored ones client-side.
-        // git's --not flag applies to revision specs, not --author.
-        const rangeLog = await git.raw([
-            "log", "--format=%H %ae", `${lastBotSha}..HEAD`,
-        ]);
-        const userShas = rangeLog
-            .trim()
-            .split("\n")
-            .filter(Boolean)
-            .filter(line => !line.endsWith(BOT_EMAIL))
-            .map(line => line.split(" ")[0]);
-        if (userShas.length === 0)
-            return [];
-        // Union all files touched by user commits
-        const fileSet = new Set();
-        for (const sha of userShas) {
-            const filesRaw = await git.raw([
-                "diff-tree", "--no-commit-id", "--name-only", "-r", sha,
-            ]);
-            filesRaw.trim().split("\n").filter(Boolean).forEach(f => fileSet.add(f));
-        }
-        return Array.from(fileSet);
-    }
-    catch {
-        return null;
-    }
-}
-const NON_APP_PATTERNS = [
-    // CI/CD
-    /^\.github\//,
-    /^\.circleci\//,
-    /^\.gitlab-ci/,
-    /^\.travis\.yml$/,
-    /^Jenkinsfile/,
-    /^\.buildkite\//,
-    /^\.drone\.yml$/,
-    // Docs
-    /\.md$/i,
-    /\.mdx$/i,
-    /\.rst$/i,
-    /\.txt$/i,
-    /^docs\//i,
-    /^documentation\//i,
-    /^CHANGELOG/i,
-    /^CONTRIBUTING/i,
-    /^README/i,
-    /^LICENSE/i,
-    // Lock files & dependency manifests (not the manifest itself, just locks)
-    /package-lock\.json$/,
-    /yarn\.lock$/,
-    /pnpm-lock\.yaml$/,
-    /poetry\.lock$/,
-    /Pipfile\.lock$/,
-    /Gemfile\.lock$/,
-    /composer\.lock$/,
-    /go\.sum$/,
-    /Cargo\.lock$/,
-    // Config / infra (non-code)
-    /^\.env/,
-    /\.eslintrc/,
-    /\.prettierrc/,
-    /\.editorconfig$/,
-    /^\.vscode\//,
-    /^\.idea\//,
-    /docker-compose.*\.ya?ml$/i,
-    /^Dockerfile/i,
-    /^\.dockerignore$/,
-    /^\.gitignore$/,
-    /^\.gitattributes$/,
-    /tsconfig.*\.json$/,
-    /jest\.config\./,
-    /babel\.config\./,
-    /^renovate\.json$/,
-    /^\.pre-commit-config/,
-];
-// ── filterEndpointsBySpec ──────────────────────────────────────────────────
-// Pure helper extracted so unit tests can exercise the filtering + merge logic
-// without spinning up the full analyzeChanges handler.
-export function filterEndpointsBySpec(scannedEndpoints, specPaths, specPathItems, diffChangedPaths) {
-    if (!specPaths || specPaths.size === 0)
-        return scannedEndpoints;
-    const filtered = scannedEndpoints.filter(ep => {
-        const normalized = ep.path.replace(/:[a-zA-Z_][a-zA-Z0-9_]*/g, m => `{${m.slice(1)}}`);
-        if (specPaths.has(ep.path) || specPaths.has(normalized))
-            return true;
-        if (diffChangedPaths.has(ep.path))
-            return true;
-        return false;
-    });
-    const scannedPathSet = new Set(filtered.map(ep => ep.path));
-    // Also track normalized (:param → {param}) forms so Express-style scanned paths
-    // (e.g. /api/v1/users/:id) don't produce a duplicate when the spec uses /api/v1/users/{id}.
-    const scannedNormalizedSet = new Set(filtered.map(ep => ep.path.replace(/:[a-zA-Z_][a-zA-Z0-9_]*/g, m => `{${m.slice(1)}}`)));
-    const HTTP_VERBS = new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
-    for (const specPath of specPaths) {
-        if (!scannedPathSet.has(specPath) && !scannedNormalizedSet.has(specPath)) {
-            const pathObj = specPathItems[specPath];
-            const specMethods = Object.keys(pathObj ?? {})
-                .filter(k => HTTP_VERBS.has(k))
-                .map(m => m.toUpperCase());
-            if (specMethods.length > 0) {
-                filtered.push({ path: specPath, methods: specMethods, sourceFile: "" });
-            }
-        }
-    }
-    return filtered;
-}
 const GRAPHQL_EXT = /\.(graphql|gql)$/i;
 const GRAPHQL_SCHEMA_CONTENT_PATTERN = /^\s*(type\s+(Query|Mutation|Subscription)\s*\{|schema\s*\{|extend\s+type|directive\s+@)/m;
 const GRAPHQL_IMPLEMENTATION_CONTENT_PATTERN = /(?:@Resolver\b|from\s+["'](?:@nestjs\/graphql|apollo-server|graphql-yoga|type-graphql)["']|\b(?:ApolloServer|GraphQLObjectType|GraphQLSchema|makeExecutableSchema|buildSchema)\b|(?:\btypeDefs\b[\s\S]{0,200}\bresolvers\b|\bresolvers\b[\s\S]{0,200}\btypeDefs\b))/m;
@@ -239,39 +57,7 @@ export async function isGraphQLFile(filePath, repositoryPath) {
         return false;
     }
 }
-function isGraphQLEndpointPath(endpointPath) {
-    return /(?:^|\/)graphql(?:\/|$)/i.test(endpointPath);
-}
-async function isUnsupportedGraphQLEndpoint(endpoint, repositoryPath, checkGraphQLFile = (filePath) => isGraphQLFile(filePath, repositoryPath)) {
-    return isGraphQLEndpointPath(endpoint.path) ||
-        await checkGraphQLFile(endpoint.sourceFile);
-}
-export async function filterUnsupportedGraphQLEndpoints(endpoints, repositoryPath) {
-    const graphqlFileCache = new Map();
-    const checkGraphQLFile = (filePath) => {
-        if (!filePath)
-            return Promise.resolve(false);
-        const cached = graphqlFileCache.get(filePath);
-        if (cached)
-            return cached;
-        const result = isGraphQLFile(filePath, repositoryPath);
-        graphqlFileCache.set(filePath, result);
-        return result;
-    };
-    const filtered = [];
-    for (const endpoint of endpoints) {
-        if (!(await isUnsupportedGraphQLEndpoint(endpoint, repositoryPath, checkGraphQLFile))) {
-            filtered.push(endpoint);
-        }
-    }
-    return filtered;
-}
-function isNonApplicationFile(filePath) {
-    return NON_APP_PATTERNS.some((p) => p.test(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)$/;
+// ── Seed and fixture data ───────────────────────────────────────────────────
 export const analyzeChangesInputSchema = {
     repositoryPath: z
         .string()
@@ -289,25 +75,21 @@ export const analyzeChangesInputSchema = {
         .string()
         .optional()
         .describe("Directory containing existing tests (auto-detected if omitted)"),
-    topN: z
-        .number()
-        .optional()
-        .default(MAX_RECOMMENDATIONS)
-        .describe(`Number of ranked test recommendations to generate. Defaults to ${MAX_RECOMMENDATIONS}.`),
-    maxGenerate: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe(`Number of tests to generate and execute. Defaults to ${MAX_TESTS_TO_GENERATE} (diff mode) or all recommendations (full repo).`),
+    // The legacy count arguments are declared nowhere on purpose. zod strips an
+    // undeclared key, so a caller that still sends one keeps a working call while
+    // the name never appears in the schema the agent lists.
     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. Accepted and applied nowhere: nothing reads previous Testbot comments on the pull request any more. Pass it if the caller supplies it."),
     repository: z
         .string()
         .optional()
         .describe("The owner/repo this call analyzes (e.g. 'letsramp/api-insight'). In a multi-repo run, ALWAYS set it — for the primary AND every related repo. All calls in one Testbot run share ONE state file automatically (you do NOT pass a file path); each repo's analysis is stored as its own section within it. The primary's analysis is kept at the root and tagged with its owner/repo; related repos are stored as keyed sections. Omit only for a single-repo run."),
+    primaryRepository: z
+        .string()
+        .optional()
+        .describe("The owner/repo of the run's PRIMARY repository. In a multi-repo run set it on EVERY skyramp_analyze_changes call, for the primary and each related repo, so the state file's root is the primary whichever call comes first. Omit in a single-repo run."),
     testsRepoDir: z
         .string()
         .refine((v) => path.isAbsolute(v), { message: "testsRepoDir must be an absolute path" })
@@ -319,103 +101,59 @@ export const analyzeChangesInputSchema = {
         .default(false)
         .describe("When true, diffs the base ref against the working tree (captures uncommitted and unstaged changes). Use for local-dev workflows. Defaults to false (CI mode — committed changes only)."),
 };
-// ── UI blueprint-capture instructions ──
-// Moved here from the former skyramp_ui_analyze_changes pre-flight tool. These
-// strings + buildCaptureInstructions are appended to the tool output so the
-// agent captures browser_blueprints on the candidate UI pages after this call.
-// The captures stay in its tool-result history and serve as element vocabulary
-// for UI recommendation reasoning (enforced at submit time by the Blueprint
-// Citation Invariant in the testbot prompt).
-export const NO_UI_INSTRUCTIONS = `No UI changes detected — no blueprint capture needed.`;
-export const NO_RESOLVABLE_URLS_INSTRUCTIONS = `Frontend changes detected but no candidate URLs could be resolved (no route files matched the changed files or their importers, and no frontend baseUrl to fall back to). UI recommendations will be source-grounded only.`;
-export function buildCaptureInstructions(pages) {
-    const pathOnly = pages.some((p) => p.baseUrlResolved === false);
-    const pagesYaml = pages
-        .map((p, i) => `  ${i + 1}. ${p.url}  (sourcedFrom: ${p.sourcedFrom.join(", ") || "(none)"}${p.via ? `, via: ${p.via.join(", ")}` : ""}, strategy: ${p.strategy})`)
-        .join("\n");
-    const capNote = pages.length >= MAX_CANDIDATE_PAGES
-        ? `\n(The list is capped at ${MAX_CANDIDATE_PAGES} pages — direct route matches first, then the pages that render the most changed files.)`
-        : "";
-    // The server could not resolve a frontend baseUrl (no frontend service with
-    // `api.baseUrl`, no SKYRAMP_TEST_BASE_URL). The paths are still exact; the
-    // agent supplies the host.
-    const baseUrlStep = pathOnly
-        ? `
-**The entries above are URL paths, not full URLs** — the workspace declares no frontend service with \`api.baseUrl\`. Determine the frontend base URL once before capturing — the testbot workflow's \`targetReadyCheckCommand\` or the dev-server port in \`package.json\` scripts usually names it — then prefix every path with it. Log an \`issuesFound\` info entry recommending that \`api.baseUrl\` be set on the frontend service in \`.skyramp/workspace.yml\`.
-`
-        : "";
-    return `Frontend changes detected. **Before writing any UI recommendation \`reasoning\`, capture blueprints on the candidate UI pages below.** Those captures stay in your tool-result history and serve as element vocabulary — the recommendation catalog further down gives you the authoring rules; you bring the observed elements.
-
-**Candidate ${pathOnly ? "URL paths" : "URLs"}:**
-${pagesYaml}${capNote}
-${baseUrlStep}
-**For each candidate URL:**
-  - \`browser_navigate\` to the URL
-  - \`browser_blueprint\` to capture the page
-
-You don't need to thread the blueprints back into a tool call — they're in your context once captured.
-
-If a candidate URL 404s or redirects unexpectedly, navigate from the frontend base URL and explore (admin apps mount routes under base prefixes the source extraction can't see). If the page rendered but lacks the changed feature (gated UI: modal, dropdown, accordion), do NOT iterate further during this step — UI recs will fall back to source-grounded prose for those, and the agent's later trace recording (Task 2) will navigate into the gate via capture-act-capture.
-
-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)`;
+/** SKYR-4182: structuredContent needs a declared outputSchema, and the schema
+ *  has to accept the early exit as well as a full analysis — hence the optional
+ *  fields. */
+export const analyzeChangesOutputSchema = {
+    sessionId: z.string().optional(),
+    stateFile: z.string().optional(),
+    repositoryPath: z.string(),
+    repositoryName: z.string(),
+    repository: z.string().optional(),
+    relatedRepositories: z.array(z.string()).optional(),
+    analysisScope: z.string(),
+    planOnly: z.boolean(),
+    currentBranch: z.string().optional(),
+    baseBranch: z.string().optional(),
+    changedFiles: z.array(z.object({ path: z.string(), deleted: z.boolean() })),
+    existingTestFiles: z
+        .object({
+        skyramp: z.array(z.string()),
+        external: z.array(z.string()),
+        relevantExternal: z.array(z.string()),
     })
-        .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.`;
-}
-/**
- * Assemble the tool result. See `dualChannelResult` for why the payload is
- * carried on both result channels.
- */
-export function buildAnalyzeChangesResult(parts) {
-    const executionPlan = `\`\`\`json\n${parts.structuredSummary}\n\`\`\`\n\n## UI Blueprint Capture — do this BEFORE writing UI recommendation reasoning\n${parts.uiInstructions}\n\n${parts.outputText}\n\n---\n\n## Pre-built Test Catalog — Fill in placeholders from source code, then display verbatim\n⚠️ Do NOT reformat, rename sections, or generate a new catalog. Replace \`<…from source>\` values, then show this output exactly as-is, grouped by test type.\n\n${parts.recommendationPrompt}`;
-    return dualChannelResult({ executionPlan });
-}
+        .optional(),
+    workspace: z
+        .object({
+        baseUrl: z.string(),
+        authMethod: z.string(),
+        authHeader: z.string().optional(),
+        openApiSpecPath: z.string().optional(),
+        openApiSpecLoaded: z.boolean(),
+    })
+        .optional(),
+    uiContext: z
+        .object({
+        removedElements: z
+            .array(z.object({ attribute: z.string(), value: z.string(), file: z.string() }))
+            .optional(),
+    })
+        .optional(),
+    nextStep: z.string().optional(),
+};
 /**
- * Coverage is discovered from the working tree, so a test file the PR itself adds looks
- * identical to pre-existing coverage. This is what the budgeter reads to decide whether
- * an empty plan is a dedup artifact or the author's own coverage.
- *
- * No diff means no answer, so it reports `true` and the reserve stays shut. `diffData` is
- * absent in full-repo scope — where fullRepoCatalog deliberately drops externally covered
- * scenarios, and promoting them back would contradict the prompt the agent reads — and
- * after a branch-diff failure, where nothing is known about the changed files at all.
- *
- * Classification comes from discovery, not from `isTestFile`: the flag has to agree with
- * whatever built the coverage keys it guards.
- *
- * `userChangedFiles` is the bot-filtered list. The bot commits its generated tests onto
- * the branch it analyzed, and those filenames are exactly what the discovery patterns
- * exist to match — so reading the raw base..HEAD list shut the reserve on every re-run
- * of a branch: run 1 generates the tests, run 2 sees them. When the filter cannot answer
- * (no bot commit yet, or a git failure) the raw list stands. That is safe in the same
- * direction as the `!diffData` case: the raw list can only hold MORE files, so the
- * fallback shuts the reserve rather than opening it.
+ * Assemble the tool result. The payload is carried on BOTH channels because
+ * each agent CLI reads a different one and none falls back: Claude Code takes
+ * `structuredContent`, Cursor takes `content[]`. `content[]` must be the
+ * literal JSON serialization of `structuredContent` — that exact form is what
+ * GitHub Copilot CLI de-duplicates on.
  */
-export function computeDiffChangesTestFiles(diffData, userChangedFiles) {
-    if (!diffData)
-        return true;
-    return (userChangedFiles ?? diffData.changedFiles).some(isDiscoveredTestFile);
+export function buildAnalyzeChangesResult(data) {
+    const structuredContent = JSON.parse(JSON.stringify(data));
+    return {
+        structuredContent,
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+    };
 }
 export function registerAnalyzeChangesTool(server) {
     server.registerTool(TOOL_NAME, {
@@ -423,17 +161,12 @@ export function registerAnalyzeChangesTool(server) {
             readOnlyHint: false, // writes a state file to disk
             destructiveHint: false,
             idempotentHint: false,
-            openWorldHint: true, // may fetch PR comments from GitHub
+            openWorldHint: true, // reads an OpenAPI spec by URL when one is configured
         },
-        description: `Scan repository API endpoints and discover existing tests — first step of the unified Test Health Analysis Flow. Returns a stateFile path and ranked test recommendations. Pass stateFile to skyramp_analyze_test_health and skyramp_actions.`,
+        description: `Read the repository and the current change, and discover the existing tests — first step of the unified Test Health Analysis Flow. Returns DATA only, no instructions: a stateFile path, the branch and its base, the changed files with their status, the existing test files, the workspace base URL and auth, the OpenAPI spec path, the repository's seed and fixture data files, and the identifying attributes the change removed from surviving files. It proposes no tests and it tells you nothing about the diff — read the diff and decide what the change warrants. Pass stateFile to skyramp_register_test_plan (required before you write any test), skyramp_analyze_test_health and skyramp_actions.`,
         // SKYR-4182: the payload is returned via structuredContent, which requires a
-        // declared outputSchema. This also keeps the result out of the single-line
-        // `.json` spill shape that Read cannot paginate — see buildAnalyzeChangesResult.
-        outputSchema: {
-            executionPlan: z
-                .string()
-                .describe("Analysis summary, UI blueprint capture instructions, and the ranked Execution Plan. Read and follow this field."),
-        },
+        // declared outputSchema.
+        outputSchema: analyzeChangesOutputSchema,
         inputSchema: analyzeChangesInputSchema,
     }, async (params, extra) => {
         let errorResult;
@@ -464,177 +197,24 @@ export function registerAnalyzeChangesTool(server) {
                     logger.warning("Failed to obtain branch diff, continuing without diff", { error: msg });
                 }
             }
-            // ── Early return: all changed files are non-application ──
-            // Use user-only commits since last bot run (if a bot commit exists) so that
-            // bot-committed test files don't count as application changes.
-            if (analysisScope === AnalysisScope.CurrentBranchDiff && diffData && diffData.changedFiles.length > 0) {
-                const userFiles = await getUserChangedFiles(params.repositoryPath);
-                const filesToCheck = userFiles ?? diffData.changedFiles;
-                const appFiles = filesToCheck.filter(f => !isNonApplicationFile(f));
-                if (filesToCheck.length > 0 && appFiles.length === 0) {
-                    logger.info("All user-changed files are non-application — skipping analysis", {
-                        changedFiles: filesToCheck,
-                    });
-                    return dualChannelResult({
-                        executionPlan: `All ${filesToCheck.length} changed file(s) are non-application (CI/CD, docs, lock files, config). No test analysis needed for this diff.\n\nChanged files: ${filesToCheck.join(", ")}`,
-                    });
-                }
-            }
-            // ── Step 2: Scan endpoints ──
-            let scannedEndpoints = [];
-            let rawRelatedEndpointCount;
-            if (analysisScope !== AnalysisScope.CurrentBranchDiff) {
-                await sendProgress(25, 100, "Scanning all repository endpoints...");
-                try {
-                    scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
-                    logger.info("Pre-scanned repo endpoints", {
-                        count: scannedEndpoints.length,
-                    });
-                }
-                catch (err) {
-                    logger.warning("Endpoint pre-scan failed", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-            else if (diffData) {
-                await sendProgress(25, 100, "Scanning related endpoints from diff...");
-                try {
-                    scannedEndpoints = scanRelatedEndpoints(params.repositoryPath, diffData.changedFiles);
-                    rawRelatedEndpointCount = scannedEndpoints.length;
-                    logger.info("Scanned related endpoints", {
-                        count: scannedEndpoints.length,
-                    });
-                }
-                catch (err) {
-                    rawRelatedEndpointCount = 0;
-                    logger.warning("Related endpoint scan failed", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                const beforeGraphQLFilter = scannedEndpoints.length;
-                scannedEndpoints = await filterUnsupportedGraphQLEndpoints(scannedEndpoints, params.repositoryPath);
-                if (scannedEndpoints.length !== beforeGraphQLFilter) {
-                    logger.info("Filtered unsupported GraphQL endpoints from related scan", {
-                        before: beforeGraphQLFilter,
-                        after: scannedEndpoints.length,
-                    });
-                }
-                // No fallback to scanAllRepoEndpoints in PR mode.
-                // If the scanner found 0 related endpoints, the PR likely touches
-                // non-route code (services, models, schemas, client SDK). Flooding
-                // all repo endpoints into the prompt causes the LLM to test
-                // irrelevant neighboring endpoints instead of focusing on the diff.
-            }
-            await sendProgress(40, 100, "Classifying changed endpoints...");
-            // ── Step 2.5: Classify endpoints by changed files ──
-            // Cross-reference changedFiles against scannedEndpoints[].sourceFile to
-            // identify new/modified/removed endpoints — replaces fragile regex parsing
-            // of diff hunks. Scanned endpoints always have full paths and concrete
-            // HTTP methods, eliminating the need for path resolution and MULTI sentinels.
-            let classifiedEndpoints;
-            // Importer-hop mapping (SKYR-3855): unmatched non-route backend files
-            // (DTOs, services, models) hopped one import edge to the endpoints that
-            // reference them. Kept separate from classifiedEndpoints.changedEndpoints
-            // (which it also feeds into, below) so Step 9 can draft response-shape
-            // scenarios specifically for these endpoints.
-            let hopResult = { endpoints: [], byFile: {} };
+            // The changed-file listing the result carries. Read from
+            // `--name-status`, which is the same listing skyramp_register_test_plan
+            // verifies a candidate's `changedFile` against — one source, so the two
+            // cannot disagree about what the change touched.
+            let changedNames = [];
             if (diffData) {
-                // 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}`]), params.repositoryPath, diffData.baseBranch)
-                    : [];
-                classifiedEndpoints = classifyEndpointsByChangedFiles(diffData, scannedEndpoints, recoveredBaseEndpoints);
-                classifiedEndpoints = {
-                    ...classifiedEndpoints,
-                    // changed/new endpoints come from scannedEndpoints, which is already
-                    // GraphQL-filtered in branch-diff mode. Removed endpoints are recovered
-                    // from the base branch separately and still need unsupported-protocol filtering.
-                    removedEndpoints: await filterUnsupportedGraphQLEndpoints(classifiedEndpoints.removedEndpoints, params.repositoryPath),
-                };
-                logger.info("Classified endpoints from changed files", {
-                    changed: classifiedEndpoints.changedEndpoints.length,
-                    new: classifiedEndpoints.newEndpoints.length,
-                    removed: classifiedEndpoints.removedEndpoints.length,
-                    unmatched: classifiedEndpoints.unmatchedFiles.length,
-                });
-                // ── Importer-hop classification (SKYR-3855) ──
-                // A changed DTO/service/model file declares no route of its own, so it
-                // never matches classifyEndpointsByChangedFiles' exact sourceFile check
-                // and lands in unmatchedFiles. Hop one import edge: find already-scanned
-                // endpoints whose source imports the unmatched file AND shares its REST
-                // resource, then fold them into changedEndpoints so diffContext.modifiedEndpoints,
-                // novelty classification, and drift analysis all light up. Never fatal —
-                // any failure just leaves classification exactly as it was.
-                if (classifiedEndpoints.unmatchedFiles.length > 0) {
-                    try {
-                        hopResult = mapUnmatchedFilesToImporterEndpoints(params.repositoryPath, classifiedEndpoints.unmatchedFiles, scannedEndpoints, [...classifiedEndpoints.changedEndpoints, ...classifiedEndpoints.newEndpoints], diffData.diffContent);
-                        // `byFile` can be non-empty even when `endpoints` is empty — the hop
-                        // still found a valid mapping, but every candidate was already present
-                        // in changedEndpoints/newEndpoints (e.g. the controller and its DTO both
-                        // changed in the same PR) and got deduped out of `endpoints`. The
-                        // response-shape drafting step (below) re-derives its endpoint list
-                        // from `scannedEndpoints` via `buildHopResponseShapeInputs`, keyed off
-                        // `byFile`, so it isn't affected by that dedup — only the
-                        // `changedEndpoints` merge here needs the (deduped) `endpoints` array.
-                        if (Object.keys(hopResult.byFile).length > 0) {
-                            logger.info("Importer-hop mapped unmatched files to endpoints", {
-                                byFile: hopResult.byFile,
-                            });
-                            if (hopResult.endpoints.length > 0) {
-                                classifiedEndpoints = {
-                                    ...classifiedEndpoints,
-                                    changedEndpoints: [...classifiedEndpoints.changedEndpoints, ...hopResult.endpoints],
-                                };
-                            }
-                        }
-                    }
-                    catch (err) {
-                        logger.warning("Importer-hop classification failed — continuing without it", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                        hopResult = { endpoints: [], byFile: {} };
-                    }
+                try {
+                    changedNames = changedFileNames(await computeBranchDiff(params.repositoryPath, params.baseBranch, false, true));
                 }
-            }
-            // ── Early return: GraphQL-only diff — REST testing not supported ──
-            // Uses (userFiles ?? diffData.changedFiles) to match the existing non-app
-            // early-return pattern — bot-committed .graphql files must not trigger this.
-            if (analysisScope === AnalysisScope.CurrentBranchDiff &&
-                classifiedEndpoints &&
-                classifiedEndpoints.changedEndpoints.length === 0 &&
-                classifiedEndpoints.newEndpoints.length === 0 &&
-                classifiedEndpoints.removedEndpoints.length === 0 &&
-                diffData) {
-                const userFiles = await getUserChangedFiles(params.repositoryPath);
-                const filesToCheck = userFiles ?? diffData.changedFiles;
-                // Exclude non-application files (docs, CI, configs) before the graphql check.
-                // Non-app files are neutral — a README-only diff must NOT fire this early return.
-                const appFilesToCheck = filesToCheck.filter(f => !isNonApplicationFile(f));
-                const allGraphQL = appFilesToCheck.length > 0 &&
-                    (await Promise.all(appFilesToCheck.map(f => isGraphQLFile(f, params.repositoryPath)))).every(Boolean);
-                if (allGraphQL) {
-                    logger.info("GraphQL-only diff detected — REST testing not supported", {
-                        changedFiles: diffData.changedFiles,
+                catch (error) {
+                    logger.warning("Failed to list changed file names, continuing without them", {
+                        error: error instanceof Error ? error.message : String(error),
                     });
-                    return dualChannelResult({ executionPlan: [
-                            "**GraphQL-only diff detected.**",
-                            "",
-                            "The changed files appear to be GraphQL schema, artifact, or endpoint implementation files.",
-                            "Skyramp currently supports REST API testing only — GraphQL introspection,",
-                            "query validation, and type-name grounding are not yet supported.",
-                            "",
-                            "No test recommendations can be generated for this diff.",
-                            "",
-                            `Changed files: ${diffData.changedFiles.join(", ")}`,
-                        ].join("\n") });
                 }
             }
+            // No endpoint scan, in either mode. A full-repo run used to hand the
+            // agent a catalog built by framework route parsers; it reads the
+            // repository and enumerates what it serves itself.
             await sendProgress(50, 100, "Discovering existing tests...");
             // ── Step 3: Discover existing tests ──
             // Always scan from repositoryPath so tests in any subdirectory (e.g.
@@ -645,142 +225,31 @@ export function registerAnalyzeChangesTool(server) {
             // testsRepoDir is a cross-repo path override — honour it when set.
             // Otherwise always scan the full repo root.
             const testDir = params.testsRepoDir ?? undefined;
-            const routerMountContext = grepRouterMountingContext(params.repositoryPath);
-            // Read contents once — used for token extraction and LLM prompt injection.
-            const ROUTER_INLINE_LIMIT = 4096;
-            const routerMountContextContents = routerMountContext.map((f) => {
-                try {
-                    const abs = path.isAbsolute(f) ? f : path.join(params.repositoryPath, f);
-                    if (fs.statSync(abs).size > ROUTER_INLINE_LIMIT * 10)
-                        return ""; // skip very large files
-                    return fs.readFileSync(abs, "utf-8");
-                }
-                catch {
-                    return "";
-                }
-            });
-            // Size-capped subset for LLM prompt injection.
-            const ROUTER_INLINE_MAX_FILES = 3;
-            const routerFileContents = routerMountContext
-                .slice(0, ROUTER_INLINE_MAX_FILES)
-                .flatMap((f, i) => {
-                const content = routerMountContextContents[i] ?? "";
-                if (!content || content.length > ROUTER_INLINE_LIMIT)
-                    return [];
-                return [{ file: f, content: content.trimEnd() }];
-            });
-            // PR mode → [] excludes external tests from pre-loading (agent discovers via grep).
-            // No diff context → undefined triggers full-repo mode in TestDiscoveryService.
-            // SKYR-3924: a diff that changed NO endpoints but did change schema/model/DTO files
-            // yields no endpoint signal, so external tests would be skipped entirely and the
-            // breaking existing tests never enter the maintenance scope. Derive resource tokens
-            // from the changed files via the shared importer-hop derivation and use them, so
-            // discoverTests partitions and PRE-LOADS the relevant existing tests.
-            // Per-file diff slices — lazily computed once and shared by the changedSymbols
-            // (SKYR-3924) and changedSelectors (UI promotion pass 3) derivations below, so a diff
-            // that triggers both isn't sliced twice.
+            // No route hints. The server used to grep for router entry points, list
+            // candidate route files and inline the first few router files' contents.
+            // All three guessed at a surface the agent reads for itself.
+            // Per-file diff slices — lazily computed once and shared by the
+            // changedSelectors derivation and the removed-element collection below,
+            // so a diff that reaches both is not sliced twice.
             let _diffByFile = null;
-            const getDiffByFile = () => (_diffByFile ??= diffData?.diffContent ? sliceDiffByFile(diffData.diffContent) : new Map());
-            let changedResources = classifiedEndpoints ? [] : undefined;
-            let changedSymbols;
-            if (classifiedEndpoints &&
-                classifiedEndpoints.changedEndpoints.length === 0 &&
-                classifiedEndpoints.newEndpoints.length === 0 &&
-                classifiedEndpoints.removedEndpoints.length === 0 &&
-                diffData?.diffContent) {
-                // Only changed application-source files carry a resource signal — skip test
-                // files, configs, workflows, and docs (they'd contribute filename noise like
-                // "workspace" or "skyramp-testbot").
-                const SOURCE_EXT = /\.(ts|tsx|js|jsx|py|java|kt|go|rb|php|rs|cs|ex|exs)$/;
-                const files = (classifiedEndpoints.changedFiles ?? diffData.changedFiles ?? [])
-                    .filter((f) => SOURCE_EXT.test(f) && !isTestFile(f));
-                // A schema/DTO/model file is named for its module, not the REST resource — its
-                // class names are the real signal (DeploymentCreate → "deployment", not the
-                // "actions" filename). For those files prefer the symbol-derived tokens and drop
-                // the generic filename token; otherwise use all tokens.
-                const SCHEMA_FILE = /\/(schemas?|models?|dtos?|entities|serializers?|types)\/|\.(dto|schema|model|entity|serializer)\.[^/]+$/i;
-                // Per-file diff sections (with @@ headers) so each file's tokens derive
-                // only from its own hunk — passing the full multi-file diff would mix
-                // symbols across files. Falls back to the full diff if a path doesn't
-                // match (no worse than the prior behavior). SKYR-3924.
-                const diffByFile = getDiffByFile();
-                const derived = new Set();
-                const symbols = new Set();
-                for (const f of files) {
-                    const fileDiff = diffByFile.get(f) ?? diffData.diffContent;
-                    const all = deriveResourceTokensForFile(f, fileDiff);
-                    const filenameToken = deriveResourceToken(f);
-                    const symbolTokens = all.filter((t) => t !== filenameToken);
-                    // deriveResourceTokensForFile already drops generic tokens (via importerHop's
-                    // GENERIC_RESOURCE_TOKENS / GENERIC_SYMBOL_TOKENS), so no extra filter is needed here.
-                    const chosen = SCHEMA_FILE.test(f) && symbolTokens.length > 0 ? symbolTokens : all;
-                    for (const t of chosen)
-                        derived.add(t);
-                    // Raw changed symbol names, derived from THIS file's diff slice only (not the full
-                    // multi-file diff) so an unrelated changed file — a test or doc — can't inject its
-                    // symbols. Uses the per-file slice from diffByFile.get(f).
-                    for (const s of extractChangedSymbols(diffByFile.get(f) ?? ""))
-                        symbols.add(s);
-                }
-                if (derived.size > 0) {
-                    changedResources = [...derived];
-                    // Raw changed symbol names (e.g. "DeploymentCreate") for a content grep against
-                    // test bodies — catches tests that reference the changed type by name but whose
-                    // path/URL doesn't token-match the resource (e.g. a schema unit test).
-                    changedSymbols = [...symbols];
-                    logger.info("Schema-only diff: derived changedResources from changed files (SKYR-3924)", {
-                        changedResources,
-                        changedSymbols,
-                    });
-                }
-            }
-            // 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.
-            const flutterSdkDep = hasFlutterSdkDep(params.repositoryPath);
-            const changedFrontendFiles = (classifiedEndpoints?.changedFiles ?? diffData?.changedFiles ?? [])
-                .filter(f => isFrontendFile(f, { hasFlutterSdkDep: flutterSdkDep }) && !isTestFile(f));
-            // Selector literals (data-testid values, CSS class tokens) added/removed in the
-            // frontend diff — drives discovery pass 3, which promotes page objects/specs that
-            // couple to a changed component by selector rather than by filename or import
-            // (see TestDiscoveryService Step 2). Derived from each changed frontend file's own
-            // diff slice so an unrelated file can't inject selectors.
-            let changedSelectors;
-            if (changedFrontendFiles.length > 0 && diffData?.diffContent) {
-                const diffByFile = getDiffByFile();
-                // Total cap across all changed files (each file is separately capped inside
-                // extractChangedSelectors). Bounds pass 3's O(externalFiles × selectors) scan so a
-                // large frontend PR can't produce a pathologically long selector set.
-                const MAX_TOTAL_SELECTORS = 200;
-                const selectors = new Set();
-                outer: for (const f of changedFrontendFiles) {
-                    const fileSelectors = extractChangedSelectors(diffByFile.get(f) ?? "");
-                    if (fileSelectors.length >= MAX_CHANGED_SELECTORS) {
-                        logger.warning(`changedSelectors: file '${f}' hit the per-file cap (${MAX_CHANGED_SELECTORS}); its selector extraction may be truncated`);
-                    }
-                    for (const s of fileSelectors) {
-                        selectors.add(s);
-                        if (selectors.size >= MAX_TOTAL_SELECTORS) {
-                            logger.warning(`changedSelectors: hit the total cap (${MAX_TOTAL_SELECTORS}) across ${changedFrontendFiles.length} changed frontend file(s); remaining selectors ignored for UI promotion pass 3`);
-                            break outer;
-                        }
-                    }
-                }
-                if (selectors.size > 0) {
-                    changedSelectors = [...selectors];
-                    logger.info("Derived changedSelectors from frontend diff (UI promotion pass 3)", {
-                        count: changedSelectors.length,
-                    });
-                }
-            }
+            const getDiffByFile = () => (_diffByFile ??= diffData?.diffContent ? diffBlocksByPath(diffData.diffContent) : new Map());
+            // No resource tokens are derived from the changed files. Deriving them
+            // guessed which existing tests were relevant from filenames and symbol
+            // names; `TestDiscoveryService` now takes the external tests uncut, up to
+            // its full-repo cap, and the agent reads them and decides.
+            // No frontend/backend classification of the changed files. It read a
+            // path's extension and directory to decide what kind of file it was, and
+            // that verdict gated whether the agent did any UI work at all. The agent
+            // reads the diff.
             let existingTests = [];
             let discoveredRelevantExternalPaths = [];
+            let testDiscoveryFailed = false;
             try {
                 const testDiscoveryService = new TestDiscoveryService();
                 // Run-scoped: only the primary call carries testsRepoDir, so never
                 // let a related repo's call clear it (SKYR-4204).
                 rememberTestsRepoDir(params.testsRepoDir);
-                const discoveryResult = await testDiscoveryService.discoverTests(testDir ?? params.repositoryPath, { changedResources, changedSymbols, preciseResources: (changedSymbols?.length ?? 0) > 0, changedFrontendFiles, changedSelectors });
+                const discoveryResult = await testDiscoveryService.discoverTests(testDir ?? params.repositoryPath);
                 existingTests = discoveryResult.tests.map((test) => ({
                     testFile: test.testFile,
                     testType: test.testType,
@@ -799,6 +268,7 @@ export function registerAnalyzeChangesTool(server) {
                 });
             }
             catch (err) {
+                testDiscoveryFailed = true;
                 logger.warning("Test discovery failed, continuing with empty list", {
                     error: err instanceof Error ? err.message : String(err),
                 });
@@ -885,81 +355,6 @@ export function registerAnalyzeChangesTool(server) {
                     });
                 }
             }
-            // ── Step 4c: Filter scanned endpoints against spec ──
-            // Sequencing: scannedEndpoints is populated at Step 2 (~line 400),
-            // but wsSchemaPath and specPaths aren't known until Step 4b (above).
-            // All of 1b, 5, 10a, and 8 must run here — after specPaths is assigned
-            // and before Step 7 (~line 604) builds skeletonEndpoints.
-            if (specPaths && specPaths.size > 0) {
-                // Build a set of paths that the current diff explicitly changed — these
-                // are preserved even if missing from spec (spec may lag the code on new PRs).
-                // removedEndpoints intentionally excluded: deleted paths won't appear in
-                // scannedEndpoints (they no longer exist in code), so there is nothing to
-                // preserve — including them would only produce spurious spec-lag warnings.
-                const diffChangedPaths = new Set([
-                    ...(classifiedEndpoints?.changedEndpoints ?? []).map(ep => ep.path),
-                    ...(classifiedEndpoints?.newEndpoints ?? []).map(ep => ep.path),
-                ]);
-                const beforeCount = scannedEndpoints.length;
-                // ── Steps 4c + 4c-merge: filter against spec, merge spec-only paths ──
-                scannedEndpoints = filterEndpointsBySpec(scannedEndpoints, specPaths, spec.paths ?? {}, diffChangedPaths);
-                logger.info("Filtered scanned endpoints against OpenAPI spec", {
-                    before: beforeCount, after: scannedEndpoints.length,
-                    delta: scannedEndpoints.length - beforeCount, // positive = net added (spec merge), negative = net removed
-                });
-                // Warn when diff-changed endpoints were missing from spec — indicates spec lag
-                const specLagPaths = [...diffChangedPaths].filter(p => !specPaths.has(p) &&
-                    !specPaths.has(p.replace(/:[a-zA-Z_][a-zA-Z0-9_]*/g, m => `{${m.slice(1)}}`)));
-                if (specLagPaths.length > 0) {
-                    logger.warning("Spec may be lagging code — diff-changed paths missing from spec (kept in catalog)", {
-                        paths: specLagPaths, schemaPath: wsSchemaPath,
-                    });
-                }
-            }
-            // ── Step 4d: Filter unsupported protocol endpoints (GraphQL) ──
-            // Must run AFTER spec-merge above — specs may include /graphql and the
-            // merge step would re-add it if this ran earlier.
-            {
-                const beforeUnsupported = scannedEndpoints.length;
-                scannedEndpoints = await filterUnsupportedGraphQLEndpoints(scannedEndpoints, params.repositoryPath);
-                if (scannedEndpoints.length < beforeUnsupported) {
-                    logger.info("Filtered unsupported protocol endpoints (GraphQL)", {
-                        removed: beforeUnsupported - scannedEndpoints.length,
-                    });
-                }
-            }
-            // ── Step 4e: Path-affinity classification fallback (SKYR-3857) ──
-            // classifyEndpointsByChangedFiles (Step 2.5, above) matched changed files
-            // to endpoints by exact sourceFile equality against the catalog as it stood
-            // BEFORE the spec merge (Step 4c) — deliberately: this fallback needs the
-            // final, spec-merged, GraphQL-filtered scannedEndpoints to have anything to
-            // match against for a repo whose catalog is entirely spec-derived (every
-            // entry sourceFile: ""), which is exactly the case it exists to cover. It
-            // still runs well before diffContext/hasApiChanges (built much later, from
-            // classifiedEndpoints) are derived, so the merged classification below is
-            // visible everywhere that matters.
-            if (classifiedEndpoints?.unmatchedFiles?.length) {
-                const fallback = classifyUnmatchedFilesByPathAffinity(classifiedEndpoints.unmatchedFiles, scannedEndpoints, 
-                // changed+new are the dedup list (sourceFile::path keys — prevents
-                // double-adding). removedEndpoints is passed separately: its entries
-                // are keyed by the DELETED file's path so dedup can never match them;
-                // the fallback excludes them from its candidates by path+method so a
-                // stale spec-merged entry can't resurrect a removed endpoint as
-                // "modified".
-                [...classifiedEndpoints.changedEndpoints, ...classifiedEndpoints.newEndpoints], undefined, diffData?.diffContent, classifiedEndpoints.removedEndpoints);
-                if (fallback.endpoints.length > 0) {
-                    const mappedFiles = new Set(fallback.mappedFiles);
-                    classifiedEndpoints = {
-                        ...classifiedEndpoints,
-                        changedEndpoints: [...classifiedEndpoints.changedEndpoints, ...fallback.endpoints],
-                        unmatchedFiles: classifiedEndpoints.unmatchedFiles.filter((f) => !mappedFiles.has(f)),
-                    };
-                    logger.info("Path-affinity fallback recovered endpoint classification", {
-                        files: mappedFiles.size,
-                        endpoints: fallback.endpoints.length,
-                    });
-                }
-            }
             // ── Step 5: Detect project metadata ──
             const projectMeta = detectProjectMetadata(params.repositoryPath);
             // ── Step 6: Trace files ──
@@ -979,164 +374,9 @@ export function registerAnalyzeChangesTool(server) {
                     });
                 }
             }
-            // ── Step 7: Build skeleton endpoints ──
-            const skeletonResponse = (method) => method === "POST"
-                ? { statusCode: 201, description: "Created" }
-                : method === "DELETE"
-                    ? { statusCode: 204, description: "No Content" }
-                    : { statusCode: 200, description: "OK" };
-            const skeletonEndpoints = scannedEndpoints.map((ep) => ({
-                path: ep.path,
-                resourceGroup: ep.path.split("/").filter(Boolean).pop() || "unknown",
-                pathParams: (ep.path.match(/\{(\w+)\}/g) || []).map((p) => ({
-                    name: p.slice(1, -1),
-                    type: "string",
-                    required: true,
-                })),
-                methods: ep.methods.map((m) => ({
-                    method: m,
-                    description: "",
-                    queryParams: [],
-                    authRequired: true,
-                    sourceFile: ep.sourceFile,
-                    interactions: [
-                        {
-                            description: `${m} ${ep.path}`,
-                            type: "success",
-                            request: {},
-                            response: skeletonResponse(m),
-                        },
-                    ],
-                })),
-            }));
-            // ── Step 8: Merge trace interactions ──
-            if (traceResult && traceResult.entries.length > 0) {
-                for (const entry of traceResult.entries) {
-                    let rawPath = entry.path;
-                    try {
-                        rawPath = new URL(rawPath).pathname;
-                    }
-                    catch {
-                        /* already a path */
-                    }
-                    const normalizedPath = rawPath
-                        .replace(/\/[0-9a-f-]{20,}/gi, "/{id}")
-                        .replace(/\/\d+/g, "/{id}");
-                    const existing = skeletonEndpoints.find((ep) => {
-                        const epNorm = ep.path.replace(/\{\w+\}/g, "/{id}");
-                        return epNorm === normalizedPath;
-                    });
-                    if (existing) {
-                        const methodObj = existing.methods.find((m) => m.method === entry.method);
-                        if (methodObj) {
-                            const alreadyHasStatus = methodObj.interactions.some((i) => i.response.statusCode === entry.statusCode);
-                            if (!alreadyHasStatus) {
-                                const traceRequest = {};
-                                if (entry.requestBody)
-                                    traceRequest.body = entry.requestBody;
-                                if (entry.queryParams)
-                                    traceRequest.queryParams = entry.queryParams;
-                                methodObj.interactions.push({
-                                    description: `${entry.method} ${entry.path} \u2192 ${entry.statusCode} (from trace)`,
-                                    type: "success",
-                                    request: Object.keys(traceRequest).length > 0 ? traceRequest : {},
-                                    response: {
-                                        statusCode: entry.statusCode,
-                                        description: `Observed in trace (${traceResult.format})`,
-                                        ...(entry.responseBody
-                                            ? { body: entry.responseBody }
-                                            : {}),
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            // ── Step 9: Draft scenarios ──
-            // Only new endpoints are passed as "diff-direct" — draftDiffDirectScenarios
-            // generates success-oriented scenarios (200/201/204) which are wrong for
-            // removed endpoints. Removal coverage (verify-404) is handled by the LLM
-            // from the diffContext.removedEndpoints signal in the recommendation prompt.
-            // Classified endpoints have full paths and concrete methods (no MULTI sentinels).
-            const newEndpointsForDrafting = classifiedEndpoints?.newEndpoints.flatMap((ep) => ep.methods.map((m) => ({
-                method: m,
-                path: ep.path,
-                sourceFile: ep.sourceFile,
-            }))) ?? [];
-            const changedEndpointsForSecurityExpansion = classifiedEndpoints?.changedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
-                method: m,
-                path: ep.path,
-                sourceFile: ep.sourceFile,
-            }))) ?? [];
-            const securityRelevantDiff = Boolean(diffData?.diffContent && isSecurityRelevantDiff(diffData.diffContent));
-            // Full-repo mode: no diff context, so seed scenario drafting from the entire
-            // skeletonEndpoints catalog. We gate on analysisScope (not just array length)
-            // to avoid drafting catalog-wide scenarios for PR-mode diffs that happened to
-            // add zero new endpoints (only changed or removed existing ones).
-            const fullRepoMode = analysisScope !== AnalysisScope.CurrentBranchDiff;
-            const scenarioDraftSeed = newEndpointsForDrafting.length > 0
-                ? newEndpointsForDrafting
-                : fullRepoMode
-                    ? skeletonEndpoints.flatMap(ep => ep.methods.map(m => ({
-                        method: typeof m === "string" ? m : m.method,
-                        path: ep.path,
-                        sourceFile: m.sourceFile ?? "",
-                    })))
-                    : [];
-            const removedEndpointsForDrafting = classifiedEndpoints?.removedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
-                method: m,
-                path: ep.path,
-                sourceFile: ep.sourceFile,
-            }))) ?? [];
-            const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints, scenarioDraftSeed, wsAuthType, {
-                changedEndpoints: changedEndpointsForSecurityExpansion,
-                securityRelevantDiff,
-            }, removedEndpointsForDrafting);
-            // Response-shape scenarios for importer-hop-mapped endpoints (SKYR-3855):
-            // deterministic coverage for backend changes (DTOs/services) that touch no
-            // route directly, so the ranked plan mentions the actual change instead of
-            // falling back to generic structural tests on unrelated resources.
-            // See `buildHopResponseShapeInputs` for why this is keyed off `byFile`
-            // rather than `hopResult.endpoints`.
-            const hopResponseShapeInputs = buildHopResponseShapeInputs(hopResult, scannedEndpoints, diffData?.diffContent);
-            const responseShapeScenarios = hopResponseShapeInputs.endpoints.length > 0
-                ? draftResponseShapeScenarios(hopResponseShapeInputs.endpoints, hopResult.byFile, hopResponseShapeInputs.addedFieldsByFile)
-                : [];
-            // `codeInferredScenarios` is already capped internally by
-            // draftScenariosFromEndpoints, but `responseShapeScenarios` is appended
-            // afterward — re-cap the combined list so the global MAX_TOTAL_SCENARIOS
-            // bound (prompt size/cost, ranking input) still holds.
-            let allDraftedScenarios = capScenarios([...codeInferredScenarios, ...responseShapeScenarios]);
-            if (traceResult && traceResult.userFlows.length > 0) {
-                const traceScenarios = traceResult.userFlows
-                    .slice(0, 5)
-                    .map((flow, idx) => ({
-                    scenarioName: `trace-flow-${idx + 1}`,
-                    description: `User flow from trace: ${flow.entries.map((e) => `${e.method} ${e.path}`).join(" \u2192 ")}`,
-                    category: "workflow",
-                    priority: "high",
-                    steps: flow.entries.map((e, stepIdx) => ({
-                        order: stepIdx + 1,
-                        method: e.method,
-                        path: e.path,
-                        description: `${e.method} ${e.path} \u2192 ${e.statusCode}`,
-                        interactionType: e.statusCode < 400
-                            ? "success"
-                            : "error",
-                        requestBody: e.requestBody,
-                        responseBody: e.responseBody,
-                        expectedStatusCode: e.statusCode,
-                    })),
-                    chainingKeys: [],
-                    requiresAuth: true,
-                    estimatedComplexity: flow.entries.length > 3
-                        ? "complex"
-                        : "moderate",
-                    source: ScenarioSource.Trace,
-                }));
-                allDraftedScenarios = capScenarios([...traceScenarios, ...codeInferredScenarios, ...responseShapeScenarios]);
-            }
+            // Nothing is drafted here. The server proposed scenarios from the
+            // catalog and from trace flows; the agent drafts every candidate and
+            // registers it through the plan tool.
             await sendProgress(80, 100, "Building unified state...");
             // ── Step 10: Build full RepositoryAnalysis for ranked recommendations ──
             const sessionId = crypto.randomUUID();
@@ -1201,91 +441,23 @@ export function registerAnalyzeChangesTool(server) {
             // Relativize against repositoryPath to avoid leaking absolute machine paths
             // into the prompt, state file, and PR reports.
             const relevantExternalTestPaths = discoveredRelevantExternalPaths.map(p => path.relative(params.repositoryPath, p));
-            // Build the full RepositoryAnalysis object — same structure as analyzeRepositoryTool
-            // so buildRecommendationPrompt can reason over enriched endpoint + scenario data
-            // Build diffContext from classifiedEndpoints — ScannedEndpoint already
-            // has full paths and concrete methods, so no grouping/MULTI handling needed.
-            const diffContext = classifiedEndpoints ? {
-                currentBranch: classifiedEndpoints.currentBranch,
-                baseBranch: classifiedEndpoints.baseBranch,
-                changedFiles: classifiedEndpoints.changedFiles,
-                newEndpoints: classifiedEndpoints.newEndpoints.map((ep) => ({
-                    path: ep.path,
-                    methods: ep.methods.map((m) => ({
-                        method: m,
-                        sourceFile: ep.sourceFile,
-                        interactionCount: 0,
-                    })),
-                })),
-                modifiedEndpoints: classifiedEndpoints.changedEndpoints.map((ep) => ({
-                    path: ep.path,
-                    methods: ep.methods.map((m) => ({
-                        method: m,
-                        sourceFile: ep.sourceFile,
-                        changeType: "modified",
-                    })),
-                })),
-                removedEndpoints: classifiedEndpoints.removedEndpoints.map((ep) => ({
-                    path: ep.path,
-                    methods: ep.methods.map((m) => ({
-                        method: m,
-                        sourceFile: ep.sourceFile,
-                        changeType: "removed",
-                    })),
-                })),
-                affectedServices: classifiedEndpoints.affectedServices,
-                summary: "",
+            // Build the full RepositoryAnalysis object — same structure as
+            // analyzeRepositoryTool. It is stored in the in-process session store for
+            // the MCP resources and registerRecommendTestsPrompt; the tool result
+            // does not carry it.
+            // The branch diff itself — which branch, against which base, which files.
+            // No endpoint lists: the scan that produced them ran a route parser over
+            // the diff, and the agent reads the diff directly instead.
+            // No `summary`: the server used to write a sentence about the diff here
+            // and it has written an empty string since. Nothing reads the field.
+            const diffContext = diffData ? {
+                currentBranch: diffData.currentBranch,
+                baseBranch: diffData.baseBranch,
+                changedFiles: diffData.changedFiles,
             } : undefined;
-            // ── Route discovery context for LLM grounding and state persistence ──
-            // fullAnalysis lives only in inMemorySessionStore (for MCP resources
-            // and registerRecommendTestsPrompt). The disk state carries only the
-            // slim fields that downstream tools (health, execute, actions) need.
-            // routerMountContext and candidateRouteFiles are computed here so they
-            // can be persisted to the state file for downstream tools (health, drift).
-            // Without them, analyzeTestHealth would work only off the static catalog
-            // which has wrong paths for nested resources and unsupported frameworks.
-            const routeLikeUnmatchedFiles = [];
-            for (const file of classifiedEndpoints?.unmatchedFiles ?? []) {
-                const routeLike = SOURCE_EXTS.test(file) &&
-                    (ROUTE_FILE_PATTERN.test(file) || ROUTE_FILE_BASENAME_PATTERN.test(path.basename(file)));
-                if (routeLike && !(await isGraphQLFile(file, params.repositoryPath))) {
-                    routeLikeUnmatchedFiles.push(file);
-                }
-            }
-            const shouldIncludeCandidateRouteFiles = analysisScope !== AnalysisScope.CurrentBranchDiff ||
-                rawRelatedEndpointCount === 0 ||
-                scannedEndpoints.length === 0 ||
-                routeLikeUnmatchedFiles.length > 0;
-            let candidateRouteFiles;
-            if (shouldIncludeCandidateRouteFiles) {
-                candidateRouteFiles = [];
-                for (const file of findCandidateRouteFiles(params.repositoryPath)) {
-                    if (!(await isGraphQLFile(file, params.repositoryPath))) {
-                        candidateRouteFiles.push(file);
-                    }
-                }
-            }
-            // Write the full diff to a temp file before building state so the path
-            // can be persisted and read by analyzeTestHealthTool for per-line detection.
-            let diffFilePath;
-            if (diffData?.diffContent) {
-                diffFilePath = path.join(os.tmpdir(), `skyramp-diff-${sessionId}.diff`);
-                await fs.promises.writeFile(diffFilePath, diffData.diffContent, { encoding: "utf-8", mode: 0o600 });
-            }
-            const routeDiscovery = {
-                candidateFiles: [
-                    ...(diffData?.changedFiles ?? []),
-                    ...(candidateRouteFiles ?? []),
-                ].filter((file, index, files) => files.indexOf(file) === index),
-                staticHints: scannedEndpoints.map((ep) => ({
-                    path: ep.path,
-                    methods: ep.methods,
-                    sourceFile: ep.sourceFile,
-                })),
-                openApiPaths: specPaths ? [...specPaths] : [],
-                routerMountContext,
-                ...(diffFilePath ? { diffFilePath } : {}),
-            };
+            // No `routeDiscovery`. Its three parts — a candidate route-file list, a
+            // router entry-point grep and the OpenAPI path list — were the server's
+            // guess at the repository's surface. Nothing downstream read them.
             const fullAnalysis = {
                 metadata: {
                     repositoryName: path.basename(params.repositoryPath),
@@ -1310,7 +482,6 @@ export function registerAnalyzeChangesTool(server) {
                     userFlows: [],
                     dataFlows: [],
                     integrationPatterns: [],
-                    draftedScenarios: allDraftedScenarios,
                 },
                 artifacts: {
                     openApiSpecs: wsSchemaPath ? [{ path: wsSchemaPath, version: "from-workspace-config", endpointCount: 0, baseUrl: wsBaseUrl, authType: wsAuthMethod }] : [],
@@ -1318,11 +489,7 @@ export function registerAnalyzeChangesTool(server) {
                     traceFiles: traceResult ? [buildTraceFileEntry(traceFiles[0], traceResult)] : [],
                     notFound: [],
                 },
-                apiEndpoints: {
-                    totalCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.length, 0),
-                    baseUrl: wsBaseUrl,
-                    endpoints: skeletonEndpoints,
-                },
+                workspace: { baseUrl: wsBaseUrl },
                 authentication: {
                     method: wsAuthMethod,
                     configLocation: wsAuthHeader ? ".skyramp/workspace.yml" : "",
@@ -1342,7 +509,6 @@ export function registerAnalyzeChangesTool(server) {
                     hasCoverageReports: false,
                     relevantExternalTestPaths,
                 },
-                routeDiscovery,
                 ...(diffContext ? { branchDiffContext: diffContext } : {}),
             };
             // Store RecommendationState in memory so it's compatible with skyramp_recommend_tests if needed
@@ -1352,175 +518,73 @@ export function registerAnalyzeChangesTool(server) {
                 analysis: fullAnalysis,
             };
             storeSessionData(sessionId, recommendationState);
-            // SKYR-3879 Path B: size-capped raw diff text, persisted (not just the
-            // file path above) so skyramp_register_test_plan can verify a
-            // discriminator's changedCodeAnchor occurs verbatim in the diff without
-            // an extra file read of its own.
-            const DIFF_TEXT_CAP = 200_000;
-            const diffText = diffData?.diffContent ? diffData.diffContent.slice(0, DIFF_TEXT_CAP) : undefined;
-            // Compute UI context from the diff's changed files using the shared
-            // `isFrontendFile` classifier. Persisting this in the stateFile lets
-            // skyramp_analyze_test_health and the recommendation prompt consume the
-            // same classification without re-deriving it. Absent on backend-only PRs.
-            //
-            // candidateUiPages is enumerated programmatically via the strategy
-            // ladder in uiPageEnumerator (framework route grep + import graph,
-            // source-grounded routes, root fallback). The agent uses these to capture
-            // browser_blueprints — see uiInstructions below, which this tool returns
-            // so the agent captures element vocabulary for UI rec reasoning.
+            // UI context. Nothing here classifies a file as frontend any more, so it
+            // is built for every run that has a diff rather than only for one the
+            // server judged to have touched the frontend.
             const uiContext = await (async () => {
-                // changedFrontendFiles computed above (before discoverTests) — reuse here.
-                if (changedFrontendFiles.length === 0)
+                if (!diffData)
                     return undefined;
-                // 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.
-                // Computed first: the enumerator resolves changed non-route files to
-                // the pages that import them.
-                const frontendFileIntegration = checkFrontendFileIntegration(params.repositoryPath, changedFrontendFiles);
-                const candidateUiPages = await enumerateCandidateUiPages(params.repositoryPath, changedFrontendFiles, frontendFileIntegration);
-                return {
-                    changedFrontendFiles,
-                    candidateUiPages,
-                    frontendFileIntegration,
-                };
+                // SKYR-4305: identifying `data-*` attributes the diff removed from a
+                // file that survives it — grounding for the removal test the removal
+                // check requires, since a removed element appears in no blueprint.
+                // Purely additive: a failure here must never cost the analyze call.
+                let removedElements = [];
+                if (diffData?.diffContent) {
+                    try {
+                        removedElements = collectRemovedUiElements({
+                            // Every changed file that is not a test. A removed `data-testid`
+                            // is found by reading the diff, not by the file's extension.
+                            changedFrontendFiles: (diffData.changedFiles ?? []).filter((f) => !isTestFile(f)),
+                            deletedFiles: diffData.deletedFiles ?? [],
+                            diffByFile: getDiffByFile(),
+                            existingTestFiles: [
+                                ...existingTests.map((t) => t.testFile),
+                                ...discoveredRelevantExternalPaths,
+                            ],
+                            discoveryFailed: testDiscoveryFailed,
+                        });
+                    }
+                    catch (err) {
+                        logger.warning("removedUiElements: collection failed, continuing without removal-guard grounding", {
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                        removedElements = [];
+                    }
+                }
+                if (removedElements.length > 0) {
+                    logger.info("Removed UI elements detected (removal-guard grounding)", {
+                        count: removedElements.length,
+                        removed: removedElements.map((e) => `${e.attribute}="${e.value}"`),
+                    });
+                }
+                return removedElements.length > 0 ? { removedElements } : {};
             })();
-            // Derive the UI blueprint-capture instructions the agent acts on after
-            // this call. Mirrors the branching of the former skyramp_ui_analyze_changes
-            // 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
-                : allFrontendFilesUnintegrated
-                    ? buildUnintegratedInstructions(unintegratedFrontendFiles)
-                    : (uiContext.candidateUiPages.length === 0
-                        ? NO_RESOLVABLE_URLS_INSTRUCTIONS
-                        : buildCaptureInstructions(uiContext.candidateUiPages)) +
-                        (unintegratedFrontendFiles.length > 0
-                            ? `\n\n${buildUnintegratedInstructions(unintegratedFrontendFiles)}`
-                            : "");
-            // ── SKYR-3879 Path B: budget context + pre-seeded approved plan ──
-            // Computed BEFORE the state write (not after, alongside the
-            // recommendation prompt) so both this pre-seed and buildRecommendationPrompt
-            // derive their GENERATE/ADDITIONAL split from the exact same numbers —
-            // computeScoredCandidates is the single source of truth for both.
-            const topN = params.topN ?? MAX_RECOMMENDATIONS;
-            const scoredResult = computeScoredCandidates(fullAnalysis, analysisScope, topN, params.maxGenerate);
-            // Resolve each scenario's subject endpoints once, here — this is the only
-            // point that has the scenarios, the diff, and runs before BOTH consumers
-            // (selectPlan below, and the two prompt renderers). `scored.scenario` is
-            // the SAME object as the entry in `allDraftedScenarios` (assigned by
-            // reference into businessContext.draftedScenarios, then into
-            // repositoryAnalysis.scenarios below), so this mutation also fills what
-            // gets persisted. Filling later would leave one consumer keying off a
-            // different subject (SKYR-4214).
-            const changedRoutesForSubjects = collectChangedRouteLines(diffText ?? "");
-            for (const scored of scoredResult.scored) {
-                scored.scenario.subjectEndpoints = resolveSubjectEndpoints(scored.scenario, {
-                    changedRoutes: changedRoutesForSubjects,
-                });
-            }
-            const externalCoverage = buildExternalCoverageSet(testLocationsByType);
-            const diffChangesTestFiles = computeDiffChangesTestFiles(diffData, await getUserChangedFiles(params.repositoryPath));
-            const planBudgetContext = {
-                maxGenerate: scoredResult.maxGen,
-                maxTotal: topN,
-                isUIOnlyPR: scoredResult.isUIOnlyPR,
-                hasFrontendChanges: scoredResult.hasFrontendChanges,
-                externalCoverageKeys: [...externalCoverage],
-                diffChangesTestFiles,
-            };
-            let approvedPlan;
-            if (scoredResult.scored.length > 0) {
-                const budgetCtx = {
-                    maxGenerate: planBudgetContext.maxGenerate,
-                    maxTotal: planBudgetContext.maxTotal,
-                    isUIOnlyPR: planBudgetContext.isUIOnlyPR,
-                    hasFrontendChanges: planBudgetContext.hasFrontendChanges,
-                    externalCoverage,
-                    diffChangesTestFiles,
-                };
-                const serverCandidates = scoredResult.scored.map(({ scenario, priority, novelty }) => ({
-                    scenario,
-                    priority,
-                    novelty,
-                    source: CandidateSource.SERVER,
-                    candidateId: computeCandidateId(scenario),
-                }));
-                const plan = selectPlan(serverCandidates, { ...budgetCtx, diffText });
-                approvedPlan = {
-                    planId: crypto.randomUUID(),
-                    createdAt: new Date().toISOString(),
-                    generate: plan.generate.map(buildApprovedPlanItem),
-                    additional: plan.additional.map(buildApprovedPlanItem),
-                    demotions: [],
-                    dropped: plan.dropped,
-                };
-            }
+            // The server proposes no tests. It returns the analysis; the agent
+            // drafts its own plan from it and registers that through
+            // skyramp_register_test_plan.
             const unifiedState = {
                 existingTests,
-                newEndpoints: newEndpointsForDrafting,
                 analysisScope,
                 ...(uiContext ? { uiContext } : {}),
-                ...(diffText ? { diffText } : {}),
-                planBudgetContext,
-                ...(approvedPlan ? { approvedPlan } : {}),
+                // Only what another tool or prompt reads back. The workspace base URL,
+                // the spec path, the auth method, the project metadata, the relevant
+                // external test paths and the changed-file names were all written here
+                // for v1 stages that no longer exist; the tool result carries the ones
+                // the agent still needs.
                 repositoryAnalysis: {
-                    skeletonEndpoints,
-                    projectMeta,
-                    wsBaseUrl,
+                    // The IDE recommendation prompt reads these four.
                     wsAuthHeader,
                     wsAuthType,
                     wsAuthScheme,
-                    wsSchemaPath,
-                    wsAuthMethod,
-                    specFetchSucceeded,
-                    scenarios: allDraftedScenarios,
-                    diffFilePath,
                     testLocations: testLocationsByType,
-                    diff: classifiedEndpoints
-                        ? {
-                            currentBranch: classifiedEndpoints.currentBranch,
-                            baseBranch: classifiedEndpoints.baseBranch,
-                            changedFiles: classifiedEndpoints.changedFiles,
-                            newEndpoints: classifiedEndpoints.newEndpoints.map((ep) => ({
-                                path: ep.path,
-                                methods: ep.methods.map((m) => ({
-                                    method: m,
-                                    sourceFile: ep.sourceFile,
-                                })),
-                            })),
-                            modifiedEndpoints: classifiedEndpoints.changedEndpoints.map((ep) => ({
-                                path: ep.path,
-                                methods: ep.methods.map((m) => ({
-                                    method: m,
-                                    sourceFile: ep.sourceFile,
-                                })),
-                            })),
-                            removedEndpoints: classifiedEndpoints.removedEndpoints.map((ep) => ({
-                                path: ep.path,
-                                methods: ep.methods.map((m) => ({
-                                    method: m,
-                                    sourceFile: ep.sourceFile,
-                                })),
-                            })),
-                            affectedServices: classifiedEndpoints.affectedServices,
-                        }
+                    // NAMES only, never content: the state file's readers ask which files
+                    // the change touched, and the agent reads the diff itself.
+                    // skyramp_register_test_plan still recomputes the listing at verify time
+                    // from `baseBranch`, so the two cannot drift apart.
+                    diff: diffData
+                        ? { baseBranch: diffData.baseBranch, changedFiles: changedNames.map((file) => file.path) }
                         : undefined,
                     sessionId,
-                    routerMountContext,
-                    candidateRouteFiles,
-                    routeDiscovery,
-                    relevantExternalTestPaths,
                 },
             };
             // Clean up old state files (>24 hours) before creating new one.
@@ -1547,6 +611,7 @@ export function registerAnalyzeChangesTool(server) {
             // same run-scoped stateFile.
             await stateManager.writeRepoData(unifiedState, {
                 repo: params.repository,
+                primaryRepo: params.primaryRepository,
                 repositoryPath: params.repositoryPath,
                 step: "analyze_changes",
             });
@@ -1561,121 +626,49 @@ export function registerAnalyzeChangesTool(server) {
             catch {
                 // Client may not support resource list notifications
             }
-            await sendProgress(90, 100, "Generating ranked recommendations...");
-            // ── Step 12: Generate ranked recommendations inline ──
-            // topN computed earlier (SKYR-3879 Path B pre-seed, before the state write).
-            // ── Step 13: Fetch PR comment history for deduplication ──
-            let prContext;
-            if (params.prNumber) {
-                try {
-                    // Derive repo owner/name from git remote
-                    const { execFileSync } = await import("child_process");
-                    const remoteUrl = execFileSync("git", ["-C", params.repositoryPath, "remote", "get-url", "origin"], { encoding: "utf-8", timeout: 5_000 }).trim();
-                    // Parse owner/repo from https or ssh remote URLs
-                    const match = remoteUrl.match(/[:/]([^/]+)\/([^/.]+?)(\.git)?$/);
-                    if (match) {
-                        prContext = await parsePRComments(match[1], match[2], params.prNumber);
-                        logger.info("Fetched PR comment history", {
-                            prNumber: params.prNumber,
-                            previousRecommendations: prContext.previousRecommendations.length,
-                            implementedFiles: prContext.implementedTestFiles.length,
-                        });
-                    }
-                }
-                catch (err) {
-                    logger.warning("Failed to fetch PR comment history — continuing without it", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                // Fallback: if comment-based implementedTestFiles is empty (names didn't
-                // match disk, e.g. after a force push), recover from the actual bot commit.
-                if (prContext && prContext.implementedTestFiles.length === 0 && analysisScope === AnalysisScope.CurrentBranchDiff) {
-                    const botFiles = await getBotCommittedFiles(params.repositoryPath);
-                    if (botFiles.length > 0) {
-                        logger.info("Recovered implementedTestFiles from bot commit (comment names did not match disk)", {
-                            files: botFiles,
-                        });
-                        prContext.implementedTestFiles = botFiles;
-                    }
-                }
-            }
-            if (uiContext && uiContext.changedFrontendFiles.length > 0) {
-                logger.info("Frontend changes detected — UI rec grounding relies on the agent's own browser_blueprint history", { candidateUiPages: uiContext.candidateUiPages.map((p) => p.url) });
-            }
-            const recommendationPrompt = buildRecommendationPrompt(fullAnalysis, analysisScope, topN, prContext, wsAuthHeader, wsAuthType, wsAuthScheme, params.maxGenerate, sessionId);
+            // No pull-request comment history. `prNumber` is still accepted, and
+            // nothing reads it: skipping a test because an earlier comment mentioned
+            // it dropped tests the current diff still needed.
             await sendProgress(100, 100, "Analysis complete.");
-            const stateSize = await stateManager.getSizeFormatted();
-            const structuredSummary = JSON.stringify({
-                sessionId,
-                stateFile,
-                summary: {
-                    repositoryName: path.basename(params.repositoryPath),
-                    projectType: projectMeta.projectType,
-                    primaryFramework: projectMeta.primaryFramework,
-                    existingTestCount: existingTests.length,
-                    newEndpointCount: classifiedEndpoints?.newEndpoints.length ?? 0,
-                    modifiedEndpointCount: classifiedEndpoints?.changedEndpoints.length ?? 0,
-                    removedEndpointCount: classifiedEndpoints?.removedEndpoints.length ?? 0,
-                    endpointCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.length, 0),
-                    newEndpoints: (classifiedEndpoints?.newEndpoints ?? []).flatMap((ep) => ep.methods.map((m) => `${m} ${ep.path}`)),
-                    modifiedEndpoints: (classifiedEndpoints?.changedEndpoints ?? []).flatMap((ep) => ep.methods.map((m) => `${m} ${ep.path}`)),
-                },
-                // Surface uiContext inline so the testbot prompt can iterate
-                // candidateUiPages and inspect changedFrontendFiles without
-                // re-reading the stateFile. Absent on backend-only PRs.
-                ...(uiContext ? { uiContext } : {}),
-                stateFileSize: stateSize,
-                nextStep: "Call skyramp_analyze_test_health with stateFile to run drift analysis and health scoring",
-            }, null, 2);
-            // Build a DiffSummary for buildAnalysisOutputText from classified endpoints.
-            const parsedDiffShim = classifiedEndpoints
-                ? {
-                    currentBranch: classifiedEndpoints.currentBranch,
-                    baseBranch: classifiedEndpoints.baseBranch,
-                    changedFiles: classifiedEndpoints.changedFiles,
-                    diffStat: diffData?.diffStat ?? "",
-                    newEndpoints: classifiedEndpoints.newEndpoints.flatMap((ep) => ep.methods.map((m) => ({
-                        method: m,
-                        path: ep.path,
-                        sourceFile: ep.sourceFile,
-                    }))),
-                    modifiedEndpoints: classifiedEndpoints.changedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
-                        method: m,
-                        path: ep.path,
-                        sourceFile: ep.sourceFile,
-                    }))),
-                    removedEndpoints: classifiedEndpoints.removedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
-                        method: m,
-                        path: ep.path,
-                        sourceFile: ep.sourceFile,
-                    }))),
-                    affectedServices: classifiedEndpoints.affectedServices,
-                }
-                : undefined;
-            const outputText = buildAnalysisOutputText({
+            const relatedRepositories = await stateManager.listRelatedRepos();
+            // Existing test files, split by who owns them and relativized so no
+            // absolute machine path reaches the agent.
+            const skyrampTestFiles = [];
+            const externalTestFiles = [];
+            for (const test of existingTests) {
+                const target = test.source === TestSource.External ? externalTestFiles : skyrampTestFiles;
+                target.push(displayPath(test.testFile));
+            }
+            return buildAnalyzeChangesResult({
                 sessionId,
                 stateFile,
                 repositoryPath: params.repositoryPath,
+                repositoryName: path.basename(params.repositoryPath),
+                ...(params.repository ? { repository: params.repository } : {}),
+                ...(relatedRepositories.length ? { relatedRepositories } : {}),
                 analysisScope,
-                parsedDiff: parsedDiffShim,
-                diffFilePath,
-                candidateRouteFiles,
-                scannedEndpoints,
-                wsBaseUrl,
-                wsAuthHeader: wsAuthHeader ?? "",
-                wsAuthType: wsAuthType ?? "",
-                wsSchemaPath,
-                specFetchSucceeded,
-                routerMountContext,
-                routerFileContents,
-                unmatchedFiles: classifiedEndpoints?.unmatchedFiles,
-                nextTool: "skyramp_analyze_test_health",
-            });
-            return buildAnalyzeChangesResult({
-                structuredSummary,
-                uiInstructions,
-                outputText,
-                recommendationPrompt,
+                planOnly: isPlanOnlyMode(),
+                ...(diffData
+                    ? {
+                        currentBranch: diffData.currentBranch,
+                        baseBranch: diffData.baseBranch,
+                    }
+                    : {}),
+                changedFiles: changedNames,
+                existingTestFiles: {
+                    skyramp: skyrampTestFiles,
+                    external: externalTestFiles,
+                    relevantExternal: relevantExternalTestPaths,
+                },
+                workspace: {
+                    baseUrl: wsBaseUrl,
+                    authMethod: wsAuthMethod,
+                    ...(wsAuthHeader ? { authHeader: wsAuthHeader } : {}),
+                    ...(wsSchemaPath ? { openApiSpecPath: wsSchemaPath } : {}),
+                    openApiSpecLoaded: specFetchSucceeded,
+                },
+                ...(uiContext?.removedElements?.length ? { uiContext } : {}),
+                nextStep: "skyramp_analyze_test_health, with this stateFile",
             });
         }
         catch (error) {