@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/tools/runExistingTestsTool.js

@@ -12,6 +12,7 @@ import { buildPlaywrightArgs, parsePlaywrightJson, } from "../adapters/playwrigh
 import { buildPytestArgs, parsePytestJson } from "../adapters/pytestAdapter.js";
 import { buildJestArgs, buildVitestArgs, parseJestJson } from "../adapters/jestAdapter.js";
 import { buildMochaArgs, parseMochaJson } from "../adapters/mochaAdapter.js";
+import picomatch from "picomatch";
 import { AnalyticsService } from "../services/AnalyticsService.js";
 import { logger } from "../utils/logger.js";
 import { toolError } from "../utils/utils.js";
@@ -128,6 +129,81 @@ export function resolveRunConfig(config, opts = {}) {
     }
     return { runs: runnable.map(toResolvedRunConfig), skips };
 }
+/** The file part of a selector — `file::test title` keeps only `file`. */
+function selectorFile(selector) {
+    const idx = selector.indexOf("::");
+    return (idx >= 0 ? selector.slice(0, idx) : selector).trim();
+}
+/**
+ * Resolves a selector's file to a repo-relative path, the form `pathGlobs` are
+ * written in.
+ *
+ * Selectors arrive in whatever form the caller used — repo-relative, absolute, or
+ * a shorter tail. Discovery (analyze_changes) records the ABSOLUTE path of every
+ * test it found, so those paths are the authority: when a selector does not
+ * resolve to one of them directly, match it by tail to recover the real file.
+ */
+function toRepoRelative(file, workspacePath, knownTestFiles) {
+    let abs = path.isAbsolute(file) ? file : path.resolve(workspacePath, file);
+    if (knownTestFiles?.length && !knownTestFiles.includes(abs)) {
+        const match = knownTestFiles.find((known) => known.endsWith(`/${file}`));
+        if (match)
+            abs = match;
+    }
+    return path.relative(workspacePath, abs);
+}
+/**
+ * Partitions `selectors` into the ones this suite owns and the ones it does not,
+ * using the suite's own `pathGlobs` from workspace.yml.
+ *
+ * One repo commonly hosts several runners (mocha for a core package, vitest for
+ * app packages, Playwright for e2e), and handing a runner another runner's spec is
+ * not a test failure — it is a loader crash that yields no report at all. Which
+ * suite owns which paths is a fact about the repo, so it is recorded as config the
+ * user can read and correct, rather than guessed at run time. Run 30297865488 is
+ * the cautionary case: routing on a guessed framework tag sent Ghost's Playwright
+ * specs away from the Playwright suite, and nothing ran.
+ *
+ * A suite with no globs owns everything. That is deliberate: absent globs means
+ * the suite is unscoped, not that it owns nothing, and narrowing on no
+ * information would silently shrink the run.
+ */
+export function routeSelectorsToSuite(input) {
+    const globs = input.pathGlobs ?? [];
+    if (globs.length === 0)
+        return { kept: [...input.selectors], dropped: [] };
+    const kept = [];
+    const dropped = [];
+    for (const selector of input.selectors) {
+        const rel = toRepoRelative(selectorFile(selector), input.workspacePath, input.knownTestFiles);
+        if (picomatch.isMatch(rel, globs))
+            kept.push(selector);
+        else
+            dropped.push(selector);
+    }
+    return { kept, dropped };
+}
+/**
+ * The absolute test-file paths analyze_changes recorded, used to canonicalize a
+ * selector before glob matching. Best-effort: with no state file, an unreadable
+ * one, or a repo section that was never written, routing just resolves selectors
+ * against the repo root.
+ */
+async function loadKnownTestFiles(stateFile, repository) {
+    if (!stateFile)
+        return [];
+    try {
+        const sm = StateManager.fromStatePath(stateFile);
+        const state = await sm.readRepoData(repository);
+        return (state?.existingTests ?? [])
+            .map((t) => t.testFile)
+            .filter((f) => !!f);
+    }
+    catch (err) {
+        logger.warning(`${TOOL_NAME}: could not read existingTests for selector routing: ${err.message}`);
+        return [];
+    }
+}
 /** Maps a NormalizedSuite to the run-time config the runner consumes. */
 function toResolvedRunConfig(s) {
     return {
@@ -135,6 +211,7 @@ function toResolvedRunConfig(s) {
         framework: s.framework,
         testRunCommand: s.testRunCommand,
         testEnv: s.testEnv,
+        pathGlobs: s.pathGlobs,
     };
 }
 /** Combines per-suite runs into one ParsedExternalRun for the tool's summary
@@ -166,14 +243,57 @@ export function aggregateRuns(parsed) {
             }
         }
     }
+    // Only when EVERY suite was skipped is the whole run a skip — otherwise the
+    // suites that did run own the verdict. Surfacing it matters: the tool's caller
+    // branches on `skipped` to say why nothing ran instead of reporting a bare
+    // "ran 0 tests", which reads as a clean pass.
+    const allSkipped = parsed.length > 0 && parsed.every((p) => p.skipped);
+    const skipReasons = parsed.map((p) => p.skipReason).filter(Boolean);
     return {
         results,
         summary,
         environmentHealthy,
         healthDetail: details.length ? details.join(" | ") : undefined,
         diagnostics,
+        ...(allSkipped
+            ? { skipped: true, skipReason: skipReasons.join(" | ") || undefined }
+            : {}),
     };
 }
+/**
+ * How much of a failed run's stderr to carry into `healthDetail`/`skipReason`.
+ *
+ * This is often the ONLY record of the failure: a run command that shells out to
+ * a container writes to the MCP server's child process, not to the CI job log, so
+ * nothing else captures it. Run 30314973126 lost the real error to the previous
+ * 1200-char tail — it cut off mid-line, one line after the failing command.
+ */
+const STDERR_TAIL_CHARS = 4000;
+/**
+ * How much of a failed run's stdout to carry alongside the stderr tail.
+ *
+ * Every framework EXCEPT mocha reports via a file (`outputVia: "file"`), and those
+ * runners print their human-readable failure text — a Playwright global-setup stack
+ * trace, a pytest collection error — on STDOUT, which used to be dropped unread to
+ * avoid backpressure. So the stderr-only tail left exactly the failures it was added
+ * for with no cause attached: run 30402703836 reported `global.setup.ts` as failed
+ * and carried nothing about why, because the reason went to stdout.
+ */
+const STDOUT_TAIL_CHARS = 4000;
+/**
+ * Label and join whichever of the child's output streams carried something, so a
+ * failure path reports the cause regardless of which stream the runner chose.
+ */
+function buildOutputDiagnostic(stderrTail, stdoutTail) {
+    const parts = [];
+    const err = stripVTControlCharacters(stderrTail).trim();
+    const out = stripVTControlCharacters(stdoutTail).trim();
+    if (err)
+        parts.push(`stderr: ${err}`);
+    if (out)
+        parts.push(`stdout: ${out}`);
+    return parts.join(" | ");
+}
 /** POSIX single-quote a shell argument. */
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
@@ -200,7 +320,7 @@ export async function runExternalSuite(spec, cfg, opts) {
         ...(cfg.testEnv ?? {}),
         ...(spec.reportEnvVar ? { [spec.reportEnvVar]: reportPath } : {}),
     };
-    const { code, stdout, stderrTail } = await new Promise((resolve) => {
+    const { code, stdout, stderrTail, stdoutTail } = await new Promise((resolve) => {
         const child = spawn("bash", ["-c", cmd], {
             cwd: opts.workspacePath,
             env,
@@ -208,20 +328,33 @@ export async function runExternalSuite(spec, cfg, opts) {
         });
         let stderr = "";
         let out = "";
+        let outTail = "";
         child.stderr?.on("data", (d) => {
             stderr += d.toString();
             if (stderr.length > 16000)
                 stderr = stderr.slice(-16000);
         });
         child.stdout?.on("data", (d) => {
+            const chunk = d.toString();
+            // Always keep a bounded tail: for `outputVia: "file"` frameworks this is the
+            // ONLY record of why the run failed. Accumulating the full stream stays gated
+            // on "stdout" readers, which parse their JSON report out of it.
+            outTail += chunk;
+            if (outTail.length > STDOUT_TAIL_CHARS)
+                outTail = outTail.slice(-STDOUT_TAIL_CHARS);
             if (spec.outputVia !== "stdout")
                 return; // drain to avoid backpressure
-            out += d.toString();
+            out += chunk;
             if (out.length > 8_000_000)
                 out = out.slice(-8_000_000);
         });
-        child.on("close", (c) => resolve({ code: c, stdout: out, stderrTail: stderr.slice(-1200) }));
-        child.on("error", (e) => resolve({ code: -1, stdout: out, stderrTail: String(e) }));
+        child.on("close", (c) => resolve({
+            code: c,
+            stdout: out,
+            stderrTail: stderr.slice(-STDERR_TAIL_CHARS),
+            stdoutTail: outTail,
+        }));
+        child.on("error", (e) => resolve({ code: -1, stdout: out, stderrTail: String(e), stdoutTail: outTail }));
     });
     let report;
     try {
@@ -233,11 +366,40 @@ export async function runExternalSuite(spec, cfg, opts) {
     catch {
         if (spec.outputVia === "file")
             await fs.unlink(reportPath).catch(() => { });
+        const emptySummary = {
+            ran: 0,
+            failed: 0,
+            errored: 0,
+            skipped: 0,
+            truncated: opts.truncated,
+        };
+        const outputDetail = buildOutputDiagnostic(stderrTail, stdoutTail) || "(no output)";
+        // A SCOPED run that produced no report is not evidence the environment is
+        // down: the usual causes are a spec this runner cannot load (the wrong suite
+        // for the file) or this suite's own setup failing. Calling it unhealthy is
+        // what let a mocha loader crash read as a dead SUT and suppress PR findings,
+        // so report a skip and let the other suites speak for the environment.
+        //
+        // Do NOT guess between those causes here — run 30314973126 reported "they
+        // probably belong to another suite" about selectors that provably belonged to
+        // this one, while the real fault was the suite's containerised run command
+        // never emitting a report. State both and hand over the stderr.
+        if (opts.selectors.length > 0) {
+            return {
+                results: [],
+                summary: emptySummary,
+                environmentHealthy: true,
+                skipped: true,
+                skipReason: `${spec.framework} produced no parseable JSON report (exit ${code}) for the ${opts.selectors.length} selector(s) it was given, so this suite reported nothing either way. Either the selectors are not this suite's to run (check its testSuites pathGlobs) or its own run command failed before emitting a report — the output below says which. ${outputDetail}`,
+            };
+        }
+        // Nothing was narrowed, so a suite that cannot even produce a report does
+        // point at the environment.
         return {
             results: [],
-            summary: { ran: 0, failed: 0, errored: 0, skipped: 0, truncated: opts.truncated },
+            summary: emptySummary,
             environmentHealthy: false,
-            healthDetail: `${spec.framework} produced no parseable JSON report (exit ${code}); the suite likely failed to install/collect or the environment never came up. stderr: ${stripVTControlCharacters(stderrTail).trim() || "(empty)"}`,
+            healthDetail: `${spec.framework} produced no parseable JSON report (exit ${code}); the suite likely failed to install/collect or the environment never came up. ${outputDetail}`,
         };
     }
     if (spec.outputVia === "file")
@@ -246,13 +408,19 @@ export async function runExternalSuite(spec, cfg, opts) {
     // The parser builds healthDetail from the report contents only. When it flags
     // an unhealthy env (e.g. a Playwright global-setup spec failed), the report is
     // parseable but the actual cause — a stack trace, "container not found", a
-    // dependency download that hung — lives on the runner's stderr, which the
-    // report never carries. Append the stderr tail so a maintenance run's env
-    // failure is diagnosable from healthDetail alone, not only by re-running blind.
+    // dependency download that hung — lives on the runner's output, which the
+    // report never carries. Append it so a maintenance run's env failure is
+    // diagnosable from healthDetail alone, not only by re-running blind.
+    //
+    // Both streams, not just stderr: the runners that hit this path all report via a
+    // file and print their failure text on stdout, so a stderr-only tail named the
+    // failing setup spec and dropped the reason (run 30402703836). A dead end here
+    // costs the whole maintenance loop — with no baseline, testbot's step (f) skips
+    // the `mode: "verify"` re-run, so the agent never confirms its own fix.
     if (!parsed.environmentHealthy) {
-        const tail = stripVTControlCharacters(stderrTail).trim();
-        if (tail) {
-            parsed.healthDetail = `${parsed.healthDetail ?? `${spec.framework} environment unhealthy (exit ${code}).`} stderr: ${tail}`;
+        const detail = buildOutputDiagnostic(stderrTail, stdoutTail);
+        if (detail) {
+            parsed.healthDetail = `${parsed.healthDetail ?? `${spec.framework} environment unhealthy (exit ${code}).`} ${detail}`;
         }
     }
     return parsed;
@@ -325,11 +493,44 @@ export async function runExternalTests(params, deps = defaultDeps) {
         }
         return skippedRun;
     }
+    const knownTestFiles = await loadKnownTestFiles(params.stateFile, params.repository);
     const perSuite = [];
     for (const cfg of resolution.runs) {
+        const routing = routeSelectorsToSuite({
+            selectors: effective,
+            pathGlobs: cfg.pathGlobs,
+            knownTestFiles,
+            workspacePath: params.workspacePath,
+        });
+        // An empty selector list means "run the whole configured suite", so routing
+        // every selector away must NOT collapse into that: it would silently widen a
+        // scoped run into the entire suite. Skip the suite instead, loudly.
+        if (effective.length > 0 && routing.kept.length === 0) {
+            const owned = (cfg.pathGlobs ?? []).join(", ");
+            const routedOut = {
+                results: [],
+                summary: { ran: 0, failed: 0, errored: 0, skipped: 0, truncated },
+                environmentHealthy: true,
+                skipped: true,
+                skipReason: `suite "${cfg.serviceName}" owns ${owned}, and none of the ${routing.dropped.length} requested selector(s) fall under it — nothing for this suite to run. Widen its testSuites pathGlobs, or add a suite that owns those paths.`,
+            };
+            perSuite.push(routedOut);
+            if (params.stateFile) {
+                await persistExternalRun(params.stateFile, params.repository, {
+                    ...routedOut,
+                    mode,
+                    ranAt: deps.now(),
+                    repository: params.repository,
+                });
+            }
+            continue;
+        }
+        if (routing.dropped.length > 0) {
+            logger.warning(`${TOOL_NAME}: dropped ${routing.dropped.length} selector(s) outside ${cfg.serviceName}'s ${cfg.framework} suite paths (${(cfg.pathGlobs ?? []).join(", ")}): ${routing.dropped.join(", ")}`);
+        }
         const parsed = await deps.runner(cfg, {
             workspacePath: params.workspacePath,
-            selectors: effective,
+            selectors: routing.kept,
             mode,
             project: params.project,
             timeoutMs: params.timeoutMs,

package/build/tools/submitReportTool.js

@@ -12,6 +12,7 @@ import { toolError, testFileMatches } from "../utils/utils.js";
 import { matchesApprovedPlan } from "../utils/planMatchKeys.js";
 import { isTestbotEnabled } from "../utils/featureFlags.js";
 import { findUnbackedClaims, listChangedFiles } from "../utils/reportVerification.js";
+import { rederiveReuseOutcome } from "./code-refactor/reuse-state.js";
 // SKYR-3879 Path B: which testTypes the register-plan checkpoint gates. Mirrors
 // the generation tools actually wired to planGuard (batch-scenario/integration,
 // contract) — UI and E2E are on a separate blueprint-grounded pipeline and are
@@ -337,6 +338,34 @@ function computeReportMetrics(params) {
         issuesLow: String(countBy(params.issuesFound, (i) => i.severity === "low")),
     };
 }
+/**
+ * Attach the POM code-reuse outcome for a UI test, matched by the report's
+ * `fileName` (the basename skyramp_reuse_code keyed run state on).
+ *
+ * Server-derived, never supplied by the LLM — the same line this file already
+ * draws for testMaintenance's beforeStatus/afterStatus. `skyramp_reuse_code`
+ * computes every value in-process (tier-1 detection by selectScopedPoms, the call
+ * counts and violations by verifyReuse, the declines from the `// kept inline:`
+ * comments in the spec), so asking the agent to read them out of tool text and
+ * retype them later would leave the signal prose-mediated — droppable and
+ * fabricable, which is the failure this field exists to fix.
+ *
+ * The counts are RE-DERIVED from the delivered spec rather than read back from
+ * state: the execution fix-up can restore `<testFile>.raw.bak` over it afterwards
+ * by plain `cp`, which this tool never sees. See rederiveReuseOutcome.
+ *
+ * Non-UI tests, tests the reuse tool never ran for, and specs whose outcome cannot
+ * be re-derived all get nothing — which consumers already treat as "no reuse
+ * summary". */
+async function attachReuseOutcome(test, outcomes) {
+    if (test.testType !== TestType.UI || !outcomes)
+        return test;
+    const found = outcomes[path.basename(test.fileName)];
+    if (!found)
+        return test;
+    const reuse = await rederiveReuseOutcome(found);
+    return reuse ? { ...test, reuse } : test;
+}
 function deduplicateById(items) {
     const seen = new Set();
     const result = [];
@@ -558,9 +587,15 @@ export function registerSubmitReportTool(server) {
                         primaryRepository: fullState?.metadata?.repository,
                     });
                     if (unbacked.length > 0) {
+                        // Offer the attribution-correction path explicitly and show what DID change:
+                        // without it, the cheapest compliant move is a token no-op edit to the
+                        // mis-claimed file, which pollutes the delivered branch and leaves the report
+                        // crediting the wrong file (observed in the Ghost rc.pom-3 tester run, D-04).
+                        const changedList = changedFiles.slice(0, 20).map((f) => `  - ${f}`).join("\n");
                         errorResult = toolError(`${unbacked.length} report claim(s) are not backed by any change in the working tree — ` +
-                            `Testbot will not report file work that hasn't actually been made. Make the edit (or remove the claim), then resubmit:\n` +
-                            unbacked.map((u) => `  - ${u}`).join("\n"));
+                            `Testbot will not report file work that hasn't actually been made. If the work WAS done but in a different file, correct the claim's fileName/description to the file you actually edited (see the changed files below) — do NOT make a token edit to the claimed file just to satisfy this check. Otherwise make the edit, or remove the claim. Then resubmit.\n` +
+                            `Unbacked claims:\n${unbacked.map((u) => `  - ${u}`).join("\n")}\n` +
+                            `Files with actual working-tree changes:\n${changedList || "  (none)"}`);
                         return errorResult;
                     }
                 }
@@ -576,7 +611,7 @@ export function registerSubmitReportTool(server) {
         // generation — downstream scoring scripts don't expect them and fail if
         // they encounter these string fields while traversing the object.
         // Also normalize each item's `repository` (blank → undefined).
-        const sanitizedNewTests = dedupedNewTests.map(({ scenarioFile: _sf, traceFile: _tf, frontendTrace: _ft, ...rest }) => normalizeRepository(rest));
+        const sanitizedNewTests = await Promise.all(dedupedNewTests.map(({ scenarioFile: _sf, traceFile: _tf, frontendTrace: _ft, ...rest }) => attachReuseOutcome(normalizeRepository(rest), stateData.reuseOutcomes)));
         const report = {
             businessCaseAnalysis: params.businessCaseAnalysis,
             newTestsCreated: sanitizedNewTests,

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

@@ -16,11 +16,12 @@ export declare const analyzeChangesInputSchema: {
     scope: z.ZodOptional<z.ZodDefault<z.ZodEnum<["full_repo", "branch_diff"]>>>;
     baseBranch: z.ZodOptional<z.ZodString>;
     testDirectory: z.ZodOptional<z.ZodString>;
-    topN: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     maxGenerate: z.ZodOptional<z.ZodNumber>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     repository: z.ZodOptional<z.ZodString>;
     testsRepoDir: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    includeUncommitted: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 };
 export declare const NO_UI_INSTRUCTIONS = "No UI changes detected \u2014 no blueprint capture needed.";
 export declare const NO_RESOLVABLE_URLS_INSTRUCTIONS = "Frontend changes detected but no candidate URLs could be resolved (workspace baseUrl missing or no router files matched). UI recommendations will be source-grounded only.";

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

@@ -287,8 +287,8 @@ export const analyzeChangesInputSchema = {
         .describe("Directory containing existing tests (auto-detected if omitted)"),
     topN: z
         .number()
-        .default(MAX_RECOMMENDATIONS)
         .optional()
+        .default(MAX_RECOMMENDATIONS)
         .describe(`Number of ranked test recommendations to generate. Defaults to ${MAX_RECOMMENDATIONS}.`),
     maxGenerate: z
         .number()
@@ -309,6 +309,11 @@ export const analyzeChangesInputSchema = {
         .refine((v) => path.isAbsolute(v), { message: "testsRepoDir must be an absolute path" })
         .optional()
         .describe("Absolute path to a separate test repository clone. When set, existing test discovery scans this directory instead of repositoryPath. Used in cross-repo test delivery mode where tests live in a separate repo."),
+    includeUncommitted: z
+        .boolean()
+        .optional()
+        .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
@@ -391,7 +396,7 @@ export function registerAnalyzeChangesTool(server) {
             if (analysisScope === AnalysisScope.CurrentBranchDiff) {
                 await sendProgress(10, 100, "Computing branch diff...");
                 try {
-                    diffData = await computeBranchDiff(params.repositoryPath, params.baseBranch);
+                    diffData = await computeBranchDiff(params.repositoryPath, params.baseBranch, params.includeUncommitted ?? false);
                     logger.info("Branch diff computed", {
                         currentBranch: diffData.currentBranch,
                         baseBranch: diffData.baseBranch,
@@ -489,7 +494,7 @@ export function registerAnalyzeChangesTool(server) {
                 const removalCandidateFiles = selectRemovalCandidateFiles(diffData);
                 const git = simpleGit(params.repositoryPath);
                 const recoveredBaseEndpoints = removalCandidateFiles.length > 0
-                    ? await recoverRemovedEndpointsFromBase(removalCandidateFiles, (file) => git.show([`${diffData.baseBranch}:${file}`]))
+                    ? await recoverRemovedEndpointsFromBase(removalCandidateFiles, (file) => git.show([`${diffData.baseBranch}:${file}`]), params.repositoryPath, diffData.baseBranch)
                     : [];
                 classifiedEndpoints = classifyEndpointsByChangedFiles(diffData, scannedEndpoints, recoveredBaseEndpoints);
                 classifiedEndpoints = {
@@ -1181,6 +1186,56 @@ export function registerAnalyzeChangesTool(server) {
                 affectedServices: classifiedEndpoints.affectedServices,
                 summary: "",
             } : 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 } : {}),
+            };
             const fullAnalysis = {
                 metadata: {
                     repositoryName: path.basename(params.repositoryPath),
@@ -1237,6 +1292,7 @@ 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
@@ -1246,42 +1302,6 @@ export function registerAnalyzeChangesTool(server) {
                 analysis: fullAnalysis,
             };
             storeSessionData(sessionId, recommendationState);
-            // ── Step 11: Build UnifiedAnalysisState and save ──
-            // 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 });
-            }
             // 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
@@ -1367,7 +1387,7 @@ export function registerAnalyzeChangesTool(server) {
                     source: CandidateSource.SERVER,
                     candidateId: computeCandidateId(scenario),
                 }));
-                const plan = selectPlan(serverCandidates, budgetCtx);
+                const plan = selectPlan(serverCandidates, { ...budgetCtx, diffText });
                 approvedPlan = {
                     planId: crypto.randomUUID(),
                     createdAt: new Date().toISOString(),
@@ -1429,6 +1449,7 @@ export function registerAnalyzeChangesTool(server) {
                     sessionId,
                     routerMountContext,
                     candidateRouteFiles,
+                    routeDiscovery,
                     relevantExternalTestPaths,
                 },
             };
@@ -1526,6 +1547,8 @@ export function registerAnalyzeChangesTool(server) {
                     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