@skyramp/mcp 0.0.62 → 0.0.63-rc.2

package/build/index.js

@@ -18,20 +18,12 @@ import { registerE2ETestTool } from "./tools/generate-tests/generateE2ERestTool.
 import { registerLoginTool } from "./tools/auth/loginTool.js";
 import { registerLogoutTool } from "./tools/auth/logoutTool.js";
 import { registerFixErrorTool } from "./tools/fixErrorTool.js";
-import { registerAnalyzeRepositoryTool } from "./tools/test-recommendation/analyzeRepositoryTool.js";
-import { registerRecommendTestsTool } from "./tools/test-recommendation/recommendTestsTool.js";
 import { registerRecommendTestsPrompt } from "./prompts/test-recommendation/registerRecommendTestsPrompt.js";
 import { registerModularizationTool } from "./tools/code-refactor/modularizationTool.js";
 import { registerCodeReuseTool } from "./tools/code-refactor/codeReuseTool.js";
 import { registerScenarioTestTool } from "./tools/generate-tests/generateScenarioRestTool.js";
-import { registerDiscoverTestsTool } from "./tools/test-maintenance/discoverTestsTool.js";
-import { registerAnalyzeTestDriftTool } from "./tools/test-maintenance/analyzeTestDriftTool.js";
-import { registerExecuteBatchTestsTool } from "./tools/test-maintenance/executeBatchTestsTool.js";
-import { registerCalculateHealthScoresTool } from "./tools/test-maintenance/calculateHealthScoresTool.js";
-import { registerActionsTool } from "./tools/test-maintenance/actionsTool.js";
-import { registerStateCleanupTool } from "./tools/test-maintenance/stateCleanupTool.js";
+import { registerAnalyzeChangesTool, registerAnalyzeTestHealthTool, registerExecuteTestsTool, registerActionsTool, registerStateCleanupTool, } from "./tools/test-management/index.js";
 import { registerTestbotPrompt, registerTestbotResource, } from "./prompts/testbot/testbot-prompts.js";
-import { registerInitTestbotTool } from "./tools/initTestbotTool.js";
 import { registerSubmitReportTool } from "./tools/submitReportTool.js";
 import { registerInitializeWorkspaceTool } from "./tools/workspace/initializeWorkspaceTool.js";
 import { registerAnalysisResources } from "./resources/analysisResources.js";
@@ -58,15 +50,20 @@ const server = new McpServer({
 - NEVER show CLI commands. ALWAYS use the MCP tools provided.
 - For UI and E2E tests, use the trace collection start/stop tools.
 
-## Test Recommendation Flow (2-step)
-1. Call \`skyramp_analyze_repository\` → returns a \`sessionId\`.
-   The analysis scans source code (code-first) to build enriched endpoints
-   (Path → Method → Interaction with request/response bodies, headers, cookies)
-   and draft user-flow scenarios for integration/E2E tests.
-2. Call \`skyramp_recommend_tests\` with \`sessionId\` → the LLM reasons over the
-   enriched data to recommend tests, referencing specific interactions and scenarios.
+## Test Management Flow
+Use \`skyramp_analyze_changes\` as the single entry point for both test recommendations and test health analysis.
 
-After analysis, you can also inspect data via MCP Resources:
+### Recommendations (2-step)
+1. Call \`skyramp_analyze_changes\` with \`repositoryPath\` and \`scope\` → scans endpoints, computes branch diff, discovers existing tests → returns a \`stateFile\` **and** inline ranked test recommendations.
+2. (Optional) Use the \`skyramp_recommend_tests\` prompt with \`stateFile\` in Cursor/IDE chat for a focused recommendation view.
+
+### Health Analysis (4-step)
+1. Call \`skyramp_analyze_changes\` with \`repositoryPath\` and \`scope\` → returns a \`stateFile\`.
+2. Call \`skyramp_analyze_test_health\` with \`stateFile\` → runs drift analysis + health scoring + LLM semantic assessment.
+3. (Optional) Call \`skyramp_execute_tests\` with \`stateFile\` → runs tests live to verify status.
+4. Call \`skyramp_actions\` with \`stateFile\` → executes UPDATE/REGENERATE/ADD recommendations.
+
+After \`skyramp_analyze_changes\`, inspect enriched data via MCP Resources (use the \`sessionId\` returned in the output):
 - \`skyramp://analysis/{sessionId}/summary\` — high-level overview
 - \`skyramp://analysis/{sessionId}/endpoints\` — compact endpoint listing
 - \`skyramp://analysis/{sessionId}/endpoints/{path}\` — full path detail
@@ -183,16 +180,12 @@ const codeQualityTools = [
     registerCodeReuseTool,
 ];
 codeQualityTools.forEach((registerTool) => registerTool(server));
-// Register test recommendation tools
-registerAnalyzeRepositoryTool(server);
-registerRecommendTestsTool(server);
 // Register analysis resources (MCP Resources for enriched data access)
 registerAnalysisResources(server);
-// Register test maintenance tools
-registerDiscoverTestsTool(server);
-registerAnalyzeTestDriftTool(server);
-registerExecuteBatchTestsTool(server);
-registerCalculateHealthScoresTool(server);
+// Register unified test-management tools (replaces separate test-maintenance tools)
+registerAnalyzeChangesTool(server);
+registerAnalyzeTestHealthTool(server);
+registerExecuteTestsTool(server);
 registerActionsTool(server);
 registerStateCleanupTool(server);
 // Register workspace management tools
@@ -206,7 +199,6 @@ const infrastructureTools = [
     registerTraceStopTool,
 ];
 if (process.env.SKYRAMP_FEATURE_TESTBOT === "1") {
-    infrastructureTools.push(registerInitTestbotTool);
     infrastructureTools.push(registerSubmitReportTool);
     logger.info("TestBot tools enabled via SKYRAMP_FEATURE_TESTBOT");
 }

package/build/prompts/test-maintenance/drift-analysis-prompt.js

@@ -0,0 +1,59 @@
+import { buildDriftScoringGuide, buildActionDecisionMatrix, buildBreakingChangePatterns, buildTestAssessmentGuidelines, buildAddRecommendationGuidelines, buildDriftOutputChecklist, } from "./driftAnalysisSections.js";
+export function buildDriftAnalysisPrompt(params) {
+    const { existingTests, parsedDiff, scannedEndpoints, repositoryPath, stateFile } = params;
+    // Detect new endpoints count from parsedDiff
+    let newEndpointCount = 0;
+    let diffSection = "";
+    if (parsedDiff) {
+        const lines = parsedDiff.split("\n");
+        const epMatches = parsedDiff.match(/(?:^|\n)\*\*(GET|POST|PUT|PATCH|DELETE)\s+[^\*]+\*\*/gm);
+        if (epMatches)
+            newEndpointCount = epMatches.length;
+        diffSection = `## Branch Diff
+\`\`\`
+${lines.slice(0, 200).join("\n")}
+\`\`\`
+`;
+    }
+    const testListSection = existingTests.length > 0
+        ? `## Existing Test Files (${existingTests.length})
+${existingTests
+            .map((t) => {
+            const score = t.drift?.driftScore !== undefined ? ` [drift: ${t.drift.driftScore}]` : "";
+            return `- ${t.testFile} (${t.testType})${score}`;
+        })
+            .join("\n")}
+`
+        : `## Existing Test Files
+No existing Skyramp tests found in repository.
+`;
+    const scannedSection = scannedEndpoints.length > 0
+        ? `## Scanned Endpoints (${scannedEndpoints.length})
+${scannedEndpoints.map((ep) => `- ${Array.isArray(ep.methods) ? ep.methods.join("|") : ep.method} ${ep.path}`).join("\n")}
+`
+        : "";
+    return `# Test Health Analysis
+
+**Repository**: \`${repositoryPath}\`
+**Existing tests**: ${existingTests.length}
+**New endpoints in diff**: ${newEndpointCount}
+
+${diffSection}
+${testListSection}
+${scannedSection}
+${buildDriftScoringGuide()}
+
+${buildActionDecisionMatrix()}
+
+${buildBreakingChangePatterns()}
+
+${buildTestAssessmentGuidelines()}
+
+${buildAddRecommendationGuidelines()}
+
+${buildDriftOutputChecklist(existingTests.length, newEndpointCount)}
+
+After completing the assessment above, call \`skyramp_actions\` with \`stateFile: "${stateFile}"\`
+
+**CRITICAL**: Do NOT create any .json or .md files. Only call skyramp_actions when done.`;
+}

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

@@ -0,0 +1,153 @@
+/**
+ * Modular section builders for the Drift Analysis prompt,
+ * mirroring the recommendationSections.ts pattern.
+ */
+export function buildDriftScoringGuide() {
+    return `## Drift Score Guide (0–100)
+
+| Score | Label | Meaning |
+|-------|-------|---------|
+| 0–20  | IGNORE | No meaningful drift — test is still valid as-is |
+| 21–40 | VERIFY | Minor changes detected — review but likely fine |
+| 41–70 | UPDATE | Breaking changes detected — test needs edits |
+| 71–100 | REGENERATE | Major structural changes — regenerate from scratch |
+
+Assign each existing test a score based on how much the codebase has changed relative to what the test expects.`;
+}
+export function buildActionDecisionMatrix() {
+    return `## Action Decision Matrix
+
+For each test, choose one of:
+
+| Action | When to use |
+|--------|------------|
+| **IGNORE** | Drift score 0–20; no breaking changes AND no additive field gaps detected |
+| **VERIFY** | Drift score 21–40; minor changes, manual review recommended |
+| **UPDATE** | Drift score 25–70; breaking changes OR additive fields added to a covered endpoint (new response field the test doesn't assert) |
+| **REGENERATE** | Drift score 71–100; endpoint removed, major restructuring, or test is fundamentally broken |
+| **ADD** | New endpoint detected in diff that has no corresponding test yet |
+
+Rules:
+- Prefer UPDATE over REGENERATE when changes are localized (e.g., only the URL path changed).
+- Prefer IGNORE over VERIFY when all changed files are unrelated to the test's endpoint.
+- Always use ADD for new endpoints when the action is scoped to new test creation.
+- **Additive changes (new response fields) on a covered endpoint always trigger UPDATE** — even if existing assertions still pass. The test needs a new assertion for the added field.`;
+}
+export function buildBreakingChangePatterns() {
+    return `## Breaking Change Patterns to Detect
+
+Scan the diff lines for these high-signal patterns:
+
+### Endpoint-level breaking changes
+- \`-  @app.route("/old-path")\` / \`+  @app.route("/new-path")\` — renamed endpoint
+- \`-  router.get("/old")\` / \`+  router.get("/new")\` — renamed route
+- \`-  @GetMapping("/old")\` / \`+  @GetMapping("/new")\` — Spring rename
+- Lines removing a route decorator entirely (endpoint removed)
+
+### Request/response shape changes
+- Field type changes: \`- field: int\` → \`+ field: string\`
+- Required field added: \`+ required: [..., "newField"]\`
+- Response field removed: \`- "responseField":\`
+- Enum value changes: \`- status: "active"\` → \`+ status: "enabled"\`
+
+### Auth changes
+- \`+ @require_auth\`, \`+ @login_required\`, \`+ middleware(authMiddleware)\`
+- \`- @require_auth\` (auth removed)
+- Token type changed: Bearer → Cookie
+
+### Status code changes
+- \`- return 200\` → \`+ return 201\`
+- \`- status_code=200\` → \`+ status_code=204\`
+- \`- res.status(201)\` → \`+ res.status(200)\`
+
+### Additive response field changes (non-breaking but coverage gap)
+These do NOT break existing assertions but leave the new field untested. Always flag as UPDATE for covered endpoints.
+- \`+ "newField": queryset.filter(...).count()\` added inside a \`Response({...})\` or \`res.json({...})\`
+- \`+ newField = serializers.XXXField()\` added to a serializer used by a tested endpoint
+- \`+ "newField":\` added to a response body dict returned by the endpoint
+- New key added inside an existing dict/object returned by the endpoint`;
+}
+export function buildTestAssessmentGuidelines() {
+    return `## Per-Test Assessment (4 Steps)
+
+For each existing test file, follow these steps:
+
+### Step 1: Check endpoint existence
+Does the endpoint the test targets still exist in the codebase?
+- If the endpoint path/method is no longer present → score 80+, action: REGENERATE
+- If the endpoint was renamed → score 50–70, action: UPDATE (path substitution)
+
+### Step 2: Check request/response shape (breaking changes)
+Has the request body or response structure changed in a way that breaks the test?
+- Compare test's expected fields against current schema/model definitions
+- Type changes (string→int, int→string) → score 60+, action: UPDATE or REGENERATE
+- New required fields the test doesn't send → score 50+, action: UPDATE
+- Response fields the test asserts on have been removed → score 50+, action: UPDATE
+
+### Step 2b: Check additive response field changes (coverage gaps)
+**Even if existing assertions still pass**, does the diff add a new field to the response of an endpoint this test already covers?
+- Look at the diff for lines like \`+ "newField":\` or \`+ newField =\` inside a view/serializer this test hits
+- If YES → score 30, action: UPDATE — add an assertion for the new field (e.g. \`assert "newField" in response_body\` or \`assert response_body["newField"] >= 0\`)
+- This applies even when the test only checks status codes — the test should be extended to cover the new field
+- **Do NOT score IGNORE if a new response field was added to a covered endpoint**
+
+### Step 3: Check auth changes
+Has the authentication mechanism for this endpoint changed?
+- Auth added where none existed → score 40+, action: UPDATE
+- Auth method changed (bearer→cookie) → score 50+, action: UPDATE
+- Auth removed → score 30+, action: VERIFY or UPDATE
+
+### Step 4: Assign score and action
+Based on the above, assign a final drift score 0–100 and choose the action (IGNORE / VERIFY / UPDATE / REGENERATE).
+Provide a 1-2 sentence rationale.
+- If Step 2b flagged an additive field → score must be ≥ 30 and action must be UPDATE, even if Steps 2/3 found no breaking changes.`;
+}
+export function buildAddRecommendationGuidelines() {
+    return `## ADD Recommendations for New Endpoints
+
+For each new endpoint detected in the diff (not yet covered by any existing test):
+
+### Test type priority by HTTP method
+| Method | Recommended test types |
+|--------|----------------------|
+| POST / PUT / PATCH | integration, contract |
+| GET | contract, smoke |
+| DELETE | integration, smoke |
+
+### ADD recommendation format
+For each new endpoint, include:
+1. The endpoint path and method
+2. The recommended test types (from the table above)
+3. The Skyramp tool to call (e.g., \`skyramp_contract_test_generation\`, \`skyramp_integration_test_generation\`)
+4. The \`endpointURL\` to use (combine base URL + path)
+5. The language/framework to use (from workspace config or project metadata)`;
+}
+export function buildDriftOutputChecklist(existingTestCount, newEndpointCount) {
+    return `## Output Checklist
+
+Complete ALL of the following before calling skyramp_actions:
+
+### Existing tests (${existingTestCount} total)
+For EACH existing test, output:
+\`\`\`
+Test: <testFile>
+Drift Score: <0-100>
+Action: <IGNORE | VERIFY | UPDATE | REGENERATE>
+Rationale: <1-2 sentence explanation>
+\`\`\`
+
+${newEndpointCount > 0
+        ? `### New endpoints (${newEndpointCount} detected)
+For EACH new endpoint, output:
+\`\`\`
+Endpoint: <METHOD> <path>
+Action: ADD
+Test types: <contract | integration | smoke | ...>
+Rationale: <1 sentence>
+\`\`\``
+        : `### New endpoints
+No new endpoints detected in this diff.`}
+
+### Final step
+After completing all assessments above, call \`skyramp_actions\` with the stateFile to execute the recommended changes.`;
+}

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

@@ -1,6 +1,12 @@
 function buildEnrichmentInstructions(p) {
     const isDiffScope = p.analysisScope === "current_branch_diff";
+    const useHealthFlow = p.nextTool === "skyramp_analyze_test_health";
     if (!isDiffScope) {
+        const nextStep = useHealthFlow
+            ? `### Step 3: Identify tests at risk of drift
+Call \`skyramp_analyze_test_health\` with \`stateFile: "${p.stateFile ?? p.sessionId}"\``
+            : `### Step 3: Call recommend tests
+Call \`skyramp_recommend_tests\` with \`sessionId: "${p.sessionId}"\``;
         return `## Your Task — Enrich & Recommend (full repo)
 
 ### Step 1: Read key files
@@ -12,8 +18,7 @@ to understand the tech stack, endpoint shapes, auth mechanisms, and request/resp
 Map how endpoints relate to each other — which POST creates resources consumed by other endpoints?
 **Resolve nested/sub-router paths** from the Router Mounting section above.
 
-### Step 3: Call recommend tests
-Call \`skyramp_recommend_tests\` with \`sessionId: "${p.sessionId}"\``;
+${nextStep}`;
     }
     const changedFiles = p.parsedDiff?.changedFiles.join(", ") ?? "";
     const hasApiEndpoints = p.parsedDiff && (p.parsedDiff.newEndpoints.length > 0 || p.parsedDiff.modifiedEndpoints.length > 0);
@@ -29,14 +34,13 @@ Mounting context.`
 UI-only PR — read changed components to find API calls (fetch, axios, hooks).`
             : `### Step 2: Identify affected endpoints
 No API route changes detected — read changed files to identify affected endpoints.`;
-    return `## Your Task — Enrich & Recommend (PR-scoped)
-
-### Step 1: Read the changed files
-${changedFiles}
-
-${step2}
+    const step3Content = useHealthFlow
+        ? `### Step 3: Identify tests at risk of drift
+Assess which existing tests may be broken by the changes in this diff.
 
-### Step 3: Draft integration scenarios
+### Step 4: Call analyze test health
+Call \`skyramp_analyze_test_health\` with \`stateFile: "${p.stateFile ?? p.sessionId}"\``
+        : `### Step 3: Draft integration scenarios
 Draft multi-step scenarios simulating realistic user workflows:
 - **Cross-resource data flow**: Foreign key relationships, parent→child creation, verification
 - **Search/filter verification**: Create data, search, verify results
@@ -47,6 +51,14 @@ Draft multi-step scenarios simulating realistic user workflows:
 
 ### Step 4: Call recommend tests
 Call \`skyramp_recommend_tests\` with \`sessionId: "${p.sessionId}"\``;
+    return `## Your Task — Enrich & Recommend (PR-scoped)
+
+### Step 1: Read the changed files
+${changedFiles}
+
+${step2}
+
+${step3Content}`;
 }
 export function buildAnalysisOutputText(p) {
     const isDiffScope = p.analysisScope === "current_branch_diff";

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

@@ -1,62 +1,58 @@
 import { z } from "zod";
-import { StateManager, getSessionFilePath, hasSessionData, getSessionData, } from "../../utils/AnalysisStateManager.js";
+import { StateManager, } from "../../utils/AnalysisStateManager.js";
 import { logger } from "../../utils/logger.js";
 import { buildRecommendationPrompt } from "./test-recommendation-prompt.js";
-import { getWorkspaceAuthHeader } from "../../utils/workspaceAuth.js";
 export function registerRecommendTestsPrompt(server) {
     server.registerPrompt("skyramp_recommend_tests", {
-        description: "Generate test recommendations from enriched repository analysis. " +
-            "Provide a sessionId from skyramp_analyze_repository.",
+        description: "Generate ranked test recommendations from a test-management analysis. " +
+            "Provide a stateFile path from skyramp_analyze_changes.",
         argsSchema: {
-            sessionId: z
+            stateFile: z
                 .string()
-                .describe("Session ID from skyramp_analyze_repository"),
-            scope: z
-                .enum(["full_repo", "current_branch_diff"])
-                .default("full_repo")
+                .describe("State file path returned by skyramp_analyze_changes"),
+            topN: z
+                .number()
+                .int()
+                .positive()
+                .default(10)
                 .optional()
-                .describe("Analysis scope (defaults to the scope used during analysis)"),
+                .describe("Maximum number of ranked recommendations to return (default: 10)"),
         },
     }, async (args) => {
-        const sessionId = args.sessionId;
-        if (!sessionId) {
-            throw new Error("sessionId is required");
+        const stateFile = args.stateFile;
+        if (!stateFile) {
+            throw new Error("stateFile is required");
         }
-        // Try process memory first, then fall back to state file
-        let data = null;
-        if (hasSessionData(sessionId)) {
-            data = getSessionData(sessionId);
+        const mgr = StateManager.fromStatePath(stateFile);
+        if (!mgr.exists()) {
+            throw new Error(`State file "${stateFile}" not found. Run skyramp_analyze_changes first.`);
         }
-        else {
-            const registeredPath = getSessionFilePath(sessionId);
-            const mgr = registeredPath
-                ? StateManager.fromStatePath(registeredPath)
-                : StateManager.fromSessionId(sessionId);
-            if (!mgr.exists()) {
-                throw new Error(`Analysis session "${sessionId}" not found. Run skyramp_analyze_repository first.`);
-            }
-            data = await mgr.readData();
+        const fullState = await mgr.readFullState();
+        const state = fullState ?? null;
+        if (!state?.repositoryAnalysis?.fullAnalysis) {
+            throw new Error(`State file "${stateFile}" has no analysis data. Re-run skyramp_analyze_changes.`);
         }
-        if (!data?.analysis) {
-            throw new Error(`Session "${sessionId}" has no analysis data.`);
-        }
-        const scope = args.scope || data.analysisScope || "full_repo";
-        const effectiveTopN = scope === "current_branch_diff" ? 7 : 10;
-        const workspaceAuthHeader = data.repositoryPath
-            ? await getWorkspaceAuthHeader(data.repositoryPath)
-            : undefined;
-        const prompt = buildRecommendationPrompt(data.analysis, scope, effectiveTopN, data.prContext, workspaceAuthHeader);
+        const { fullAnalysis, sessionId, wsAuthHeader } = state.repositoryAnalysis;
+        const repositoryPath = fullState?.metadata?.repositoryPath ?? "";
+        const analysisScope = state.analysisScope === "branch_diff"
+            ? "current_branch_diff"
+            : "full_repo";
+        const effectiveTopN = args.topN;
+        const prompt = buildRecommendationPrompt(fullAnalysis, analysisScope, effectiveTopN, undefined, wsAuthHeader);
         logger.info("Serving recommendation prompt via MCP Prompt", {
-            sessionId,
-            scope,
+            stateFile,
+            analysisScope,
         });
+        const resourceLinks = sessionId
+            ? `\nAvailable MCP Resources:\n- skyramp://analysis/${sessionId}/summary\n- skyramp://analysis/${sessionId}/endpoints\n- skyramp://analysis/${sessionId}/scenarios\n- skyramp://analysis/${sessionId}/diff\n`
+            : "";
         return {
             messages: [
                 {
                     role: "user",
                     content: {
                         type: "text",
-                        text: `Session: ${sessionId}\nRepository: ${data.repositoryPath}\nScope: ${scope}\n\nAvailable MCP Resources:\n- skyramp://analysis/${sessionId}/summary\n- skyramp://analysis/${sessionId}/endpoints\n- skyramp://analysis/${sessionId}/scenarios\n- skyramp://analysis/${sessionId}/diff\n\n${prompt}`,
+                        text: `State file: ${stateFile}\nRepository: ${repositoryPath}\nScope: ${analysisScope}\n${resourceLinks}\n${prompt}`,
                     },
                 },
             ],

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

@@ -1,4 +1,4 @@
-import { buildPrioritizationDimensions, buildTestExamples, buildTestPatternGuidelines, buildTestQualityCriteria, buildGenerationRules, buildToolWorkflows, buildCoverageChecklist, } from "./recommendationSections.js";
+import { buildPrioritizationDimensions, buildTestExamples, buildTestPatternGuidelines, buildTestQualityCriteria, buildGenerationRules, buildToolWorkflows, buildCoverageChecklist, MAX_TESTS_TO_GENERATE, } from "./recommendationSections.js";
 function formatTestLocations(locs) {
     const entries = Object.entries(locs || {});
     if (entries.length === 0)
@@ -10,11 +10,18 @@ export function buildRecommendationPrompt(analysis, analysisScope = "full_repo",
     const isDiffScope = analysisScope === "current_branch_diff";
     const diffContext = analysis.branchDiffContext;
     const openApiSpec = analysis.artifacts?.openApiSpecs?.[0];
+    // ── Filter out bot-generated test files from changedFiles ──
+    // Prevents bot-committed test files from being treated as application changes
+    // on subsequent testbot runs on the same PR.
+    const SKYRAMP_TEST_FILE_PATTERN = /(?:_test|_smoke|_contract|_fuzz|_integration|_load|_e2e|_ui)\.[^/]+$|scenario_[^/]+\.json$/;
+    const filteredChangedFiles = diffContext
+        ? diffContext.changedFiles.filter(f => !SKYRAMP_TEST_FILE_PATTERN.test(f))
+        : [];
     // ── Frontend / UI change detection ──
     const FRONTEND_FILE_PATTERN = /\.(tsx?|jsx?|vue|svelte|css|scss|less|html)$/;
     const API_DIR_PATTERN = /\/(api|routes?|controllers?|routers?|handlers?|endpoints?|server)\//;
     const hasFrontendChanges = isDiffScope && diffContext
-        ? diffContext.changedFiles.some(f => FRONTEND_FILE_PATTERN.test(f) &&
+        ? filteredChangedFiles.some(f => FRONTEND_FILE_PATTERN.test(f) &&
             !API_DIR_PATTERN.test(f) &&
             /\/(components?|pages?|views?|layouts?|app|src\/app|frontend|client|public|styles?)\//i.test(f))
         : false;
@@ -62,7 +69,7 @@ ${endpointLines}
         diffSection = `
 ## Branch Diff Context
 Branch: \`${diffContext.currentBranch}\` → base: \`${diffContext.baseBranch}\`
-Changed files: ${diffContext.changedFiles.join(", ")}
+Changed files: ${filteredChangedFiles.join(", ")}
 New endpoints:
 ${fmtEps(diffContext.newEndpoints, (m) => `${m.sourceFile}, ${m.interactionCount} interactions`)}
 Modified endpoints:
@@ -154,14 +161,54 @@ Use base URL: \`${analysis.apiEndpoints.baseUrl}\` and auth: \`${authHeaderValue
     // ── PR History ──
     let prHistorySection = "";
     if (prContext && prContext.previousRecommendations.length > 0) {
-        const recLines = prContext.previousRecommendations
-            .map((r) => `  - [${r.status.toUpperCase()}] ${r.testType} — ${r.endpoint}${r.scenarioName ? ` (scenario: ${r.scenarioName})` : ""}`)
-            .join("\n");
-        prHistorySection = `
-## PR History (PR #${prContext.prNumber})
+        const implemented = prContext.previousRecommendations.filter(r => r.status === "implemented");
+        const recommended = prContext.previousRecommendations.filter(r => r.status === "recommended");
+        let historyBody = "";
+        if (implemented.length > 0) {
+            const implLines = implemented
+                .map((r) => `  - ${r.testType} — ${r.endpoint}`)
+                .join("\n");
+            const fileLines = prContext.implementedTestFiles.length > 0
+                ? `\nExisting test files (in working tree):\n${prContext.implementedTestFiles.map(f => "  - \`" + f + "\`").join("\n")}\n`
+                : "";
+            historyBody += `### Previously Generated Tests
+${implLines}${fileLines}`;
+        }
+        if (prContext.executionResults.length > 0) {
+            const resultLines = prContext.executionResults
+                .map((r) => `  - \`${r.testFile}\` — ${r.status}`)
+                .join("\n");
+            historyBody += `### Execution Results from Prior Run
+${resultLines}
+If a test failed previously, check whether the failure was environmental or a real bug,
+and adjust the test approach if needed.
+`;
+        }
+        if (recommended.length > 0) {
+            const recLines = recommended
+                .map((r) => `  - ${r.testType} — ${r.endpoint}${r.scenarioName ? ` (scenario: ${r.scenarioName})` : ""}`)
+                .join("\n");
+            historyBody += `
+### Previously Recommended (not generated)
 ${recLines}
-**Do NOT re-recommend tests already listed above.**
+These were recommended but not generated in the prior run. Consider promoting them
+to generation if they still apply to the current code changes.
 `;
+        }
+        prHistorySection = `
+## PR History (PR #${prContext.prNumber})
+Tests from prior bot runs are still in the working tree — the maintenance pipeline
+(Task 2) keeps them up to date. Use the history below to **avoid duplicating** existing
+coverage and to fill gaps:
+- **Do NOT re-recommend** tests listed under "Previously Generated Tests" — they already
+  exist and are maintained automatically.
+- **Promote** previously recommended-but-not-generated tests into the top
+  ${MAX_TESTS_TO_GENERATE} generation slots if they still apply to the current code.
+- **Add new** recommendations only for endpoints or code paths introduced in the latest
+  commit that aren't covered by existing tests.
+- If prior execution results show failures, note the issue but do not re-recommend
+  the test — Task 2 handles fixes for existing tests.
+${historyBody}`;
     }
     // ── Compose all sections ──
     const scopeNote = isDiffScope