@skyramp/mcp 0.3.1-ldw-beta → 0.3.2-rc.pom-1

package/build/commands/commandLibrary.d.ts

@@ -9,4 +9,3 @@ export declare function getCommandIds(): OneClickCommandId[];
 export declare function lookupCommand(id: string): OneClickCommandDef;
 export { TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND } from "./testThisEndpointCommand.js";
 export { FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND } from "./recommendTestsAndExecuteCommand.js";
-export { LOCAL_DEV_TEST_CHANGES_COMMAND } from "./localDevTestChangesCommand.js";

package/build/commands/commandLibrary.js

@@ -1,28 +1,23 @@
-import { isLocalDevEnabled, isOneClickEnabled } from "../utils/featureFlags.js";
 import { TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND } from "./testThisEndpointCommand.js";
 import { FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND } from "./recommendTestsAndExecuteCommand.js";
-import { LOCAL_DEV_TEST_CHANGES_COMMAND } from "./localDevTestChangesCommand.js";
-/** Base predefined one-click commands */
-const BASE_COMMAND_LIBRARY = {
+/**
+ * To add a new predefined workflow:
+ * 1. Add a new id to OneClickCommandId in types/OneClickCommands.ts
+ * 2. Create a new file in commands/ (e.g. myWorkflowCommand.ts) with steps and export the command
+ * 3. Import the command here and add it to COMMAND_LIBRARY
+ * 4. The generic buildWorkflowFromCommand() will render detailed instructions from your steps
+ *    (no schema changes needed in oneClickTool.ts — the workflow param description is generated dynamically)
+ */
+/** All predefined one-click commands */
+const COMMAND_LIBRARY = {
     test_given_endpoint_comprehensively: TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND,
     full_repo_scan_recommend_generate_and_execute_top_n_tests: FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND,
 };
-/** All enabled predefined one-click commands */
-function getCommandLibrary() {
-    const commands = {};
-    if (isOneClickEnabled()) {
-        Object.assign(commands, BASE_COMMAND_LIBRARY);
-    }
-    if (isLocalDevEnabled()) {
-        commands.local_dev_test_changes = LOCAL_DEV_TEST_CHANGES_COMMAND;
-    }
-    return commands;
-}
 export function getAllCommands() {
-    return Object.values(getCommandLibrary()).filter((cmd) => Boolean(cmd));
+    return Object.values(COMMAND_LIBRARY);
 }
 export function getCommandIds() {
-    return getAllCommands().map((cmd) => cmd.id);
+    return Object.keys(COMMAND_LIBRARY);
 }
 /**
  * Look up a command by its string ID. Accepts any string so the tool handler
@@ -30,7 +25,7 @@ export function getCommandIds() {
  * the ID is not found.
  */
 export function lookupCommand(id) {
-    const cmd = getCommandLibrary()[id];
+    const cmd = COMMAND_LIBRARY[id];
     if (!cmd) {
         const available = getCommandIds().join(", ");
         throw new Error(`Unknown workflow: "${id}". Valid workflow IDs: ${available}.`);
@@ -40,4 +35,3 @@ export function lookupCommand(id) {
 // Re-export commands for consumers that import from commandLibrary
 export { TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND } from "./testThisEndpointCommand.js";
 export { FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND } from "./recommendTestsAndExecuteCommand.js";
-export { LOCAL_DEV_TEST_CHANGES_COMMAND } from "./localDevTestChangesCommand.js";

package/build/index.js

@@ -24,47 +24,24 @@ import { registerCodeReuseTool } from "./tools/code-refactor/codeReuseTool.js";
 import { registerEnhanceAssertionsTool } from "./tools/code-refactor/enhanceAssertionsTool.js";
 import { registerBatchScenarioTestTool } from "./tools/generate-tests/generateBatchScenarioRestTool.js";
 import { registerMockTool } from "./tools/generate-tests/generateMockRestTool.js";
-import { registerBatchMockTool } from "./tools/generate-tests/batchMockGenerationTool.js";
-import { registerAnalyzeChangesTool, registerAnalyzeTestHealthTool, registerActionsTool, } from "./tools/test-management/index.js";
+import { registerAnalyzeChangesTool, registerAnalyzeTestHealthTool, registerActionsTool, registerRegisterTestPlanTool, } from "./tools/test-management/index.js";
 import { registerTestbotPrompt } from "./prompts/testbot/testbot-prompts.js";
 import { registerSutSetupResource } from "./resources/sutSetupResource.js";
 import { registerTestbotResource } from "./resources/testbotResource.js";
-import { registerLocalDevPrompt } from "./prompts/local-dev/local-dev-prompts.js";
 import { registerSubmitReportTool } from "./tools/submitReportTool.js";
 import { registerInitializeWorkspaceTool } from "./tools/workspace/initializeWorkspaceTool.js";
 import { registerInitScanWorkspaceTool } from "./tools/workspace/initScanWorkspaceTool.js";
 import { registerOneClickTool } from "./tools/one-click/oneClickTool.js";
-import { registerEnrichTestWithMocksTool } from "./tools/enrichTestWithMocksTool.js";
-import { registerPreflightMockCheckTool } from "./tools/preflightMockCheckTool.js";
-import { registerGenerateEnrichedIntegrationTestTool } from "./tools/generateEnrichedIntegrationTestTool.js";
-import { registerLocalDevWorkerComposeTool } from "./tools/localDevWorkerComposeTool.js";
-import { registerQueryProxyMocksTool } from "./tools/queryProxyMocksTool.js";
 import { registerAnalysisResources } from "./resources/analysisResources.js";
 import { registerProgressResource } from "./resources/progressResource.js";
 import { AnalyticsService } from "./services/AnalyticsService.js";
 import { registerInitTriggerOnMCPInitialized } from "./utils/initAgent.js";
-import { isTestbotEnabled, isLocalDevEnabled } from "./utils/featureFlags.js";
+import { isTestbotEnabled } from "./utils/featureFlags.js";
 import { registerPlaywrightTools, registerTraceRecordingPrompt, getPlaywrightTraceService, } from "./playwright/index.js";
-// One-click routing instructions — injected into MCP server instructions so agents
-// know to delegate to the one-click tool rather than self-orchestrating.
-// Suppressed in testbot mode where the testbot prompt drives orchestration.
 const oneClickEnabled = process.env.SKYRAMP_FEATURE_ONE_CLICK === "1";
-const localDevEnabled = isLocalDevEnabled();
-const localDevInstructions = `\n- When the user asks to test local changes, validate a feature branch, mock services and test, or run local-dev: MUST call \`skyramp_one_click_tool\` with workflow \`local_dev_test_changes\`, \`callingAgent\` set to the current MCP client (\`cursor\` or \`claude\` for skill installation; VS Code does not support repo-local Agent Skills), \`repositoryPath\`, and \`baseBranch\` (default "main"). Do NOT self-orchestrate — the one-click tool handles skill installation, workspace init, and prompt invocation.
-- **Proxy / K8s worker**: When the user mentions a Skyramp proxy, K8s worker, kubeconfig, namespace, or provides proxy setup instructions (helm deploy worker, kubectl port-forward, proxy intercepts, seed traffic), do NOT execute those steps manually with bash commands. Instead, pass \`proxyKubeconfig\` and \`proxyNamespace\` (or \`proxyUrl\`) to \`skyramp_one_click_tool\`. The MCP tools handle proxy access internally — \`skyramp_query_proxy_mocks\` runs kubectl port-forward and queries captured traffic automatically. Manual kubectl, helm, or curl commands for proxy setup are unnecessary and waste agent turns.`;
-const fullOneClickInstructions = `\n- When the user asks to comprehensively, thoroughly, or deeply test a specific endpoint: MUST call \`skyramp_one_click_tool\` with workflow \`test_given_endpoint_comprehensively\` first. Do NOT self-orchestrate the steps manually.\n- When the user asks to scan the full repo, recommend, generate, and execute top N tests: MUST call \`skyramp_one_click_tool\` with workflow \`full_repo_scan_recommend_generate_and_execute_top_n_tests\`.${localDevEnabled ? localDevInstructions : ""}`;
-// Testbot suppresses one-click workflows (it has its own orchestration via testbot prompt),
-// but local-dev routing is always active when the flag is set — they serve different use cases.
-let oneClickInstructions = "";
-if (isTestbotEnabled()) {
-    oneClickInstructions = localDevEnabled ? localDevInstructions : "";
-}
-else if (oneClickEnabled) {
-    oneClickInstructions = fullOneClickInstructions;
-}
-else if (localDevEnabled) {
-    oneClickInstructions = localDevInstructions;
-}
+const oneClickInstructions = oneClickEnabled
+    ? `\n- When the user asks to comprehensively, thoroughly, or deeply test a specific endpoint: MUST call \`skyramp_one_click_tool\` with workflow \`test_given_endpoint_comprehensively\` first. Do NOT self-orchestrate the steps manually.\n- When the user asks to scan the full repo, recommend, generate, and execute top N tests: MUST call \`skyramp_one_click_tool\` with workflow \`full_repo_scan_recommend_generate_and_execute_top_n_tests\`.`
+    : "";
 const server = new McpServer({
     name: "Skyramp MCP Server",
     version: "1.0.0",
@@ -144,10 +121,6 @@ if (isTestbotEnabled()) {
     registerSutSetupResource(server);
     logger.info("Testbot SUT setup resource enabled via SKYRAMP_FEATURE_TESTBOT");
 }
-if (isLocalDevEnabled()) {
-    prompts.push(registerLocalDevPrompt);
-    logger.info("Local-dev prompt enabled via SKYRAMP_FEATURE_LOCAL_DEV");
-}
 prompts.forEach((registerPrompt) => registerPrompt(server));
 logger.info("All prompts registered successfully");
 // Register test generation tools
@@ -161,7 +134,6 @@ const testGenerationTools = [
     registerUITestTool,
     registerBatchScenarioTestTool,
     registerMockTool,
-    registerBatchMockTool,
 ];
 testGenerationTools.forEach((registerTool) => registerTool(server));
 // Register modularization and code quality tools
@@ -179,18 +151,14 @@ registerProgressResource(server);
 registerAnalyzeChangesTool(server);
 registerAnalyzeTestHealthTool(server);
 registerActionsTool(server);
+registerRegisterTestPlanTool(server);
 // Register workspace management tools
 registerInitScanWorkspaceTool(server);
 registerInitializeWorkspaceTool(server);
 // Register one-click orchestrated workflows
-if (oneClickEnabled || localDevEnabled) {
+if (oneClickEnabled) {
     registerOneClickTool(server);
-    logger.info("One-click tools enabled", {
-        enabledBy: {
-            SKYRAMP_FEATURE_ONE_CLICK: oneClickEnabled,
-            SKYRAMP_FEATURE_LOCAL_DEV: localDevEnabled,
-        },
-    });
+    logger.info("One-click tools enabled via SKYRAMP_FEATURE_ONE_CLICK");
 }
 // Register other Skyramp tools
 const infrastructureTools = [
@@ -200,10 +168,6 @@ const infrastructureTools = [
     registerTraceTool,
     registerTraceStopTool,
 ];
-if (isLocalDevEnabled()) {
-    infrastructureTools.push(registerEnrichTestWithMocksTool, registerPreflightMockCheckTool, registerGenerateEnrichedIntegrationTestTool, registerLocalDevWorkerComposeTool, registerQueryProxyMocksTool);
-    logger.info("Local-dev tools enabled via SKYRAMP_FEATURE_LOCAL_DEV");
-}
 if (isTestbotEnabled()) {
     infrastructureTools.push(registerSubmitReportTool);
     logger.info("Testbot tools enabled via SKYRAMP_FEATURE_TESTBOT");
@@ -232,38 +196,6 @@ process.on("uncaughtException", async (error) => {
     }
     process.exit(1);
 });
-// Handle unhandled promise rejections — without this handler Node.js 15+
-// terminates the process on any unhandled rejection, which drops the MCP
-// connection if e.g. a progress notification write fails on a broken transport.
-process.on("unhandledRejection", async (reason) => {
-    const error = reason instanceof Error ? reason : new Error(String(reason));
-    // EPIPE means the client already disconnected — exit cleanly
-    if ("code" in error && error.code === "EPIPE") {
-        process.exit(0);
-    }
-    // gRPC/Docker connectivity errors — log and survive.
-    // These occur when Docker containers/networks are destroyed while the MCP
-    // server has pending gRPC calls to the Skyramp worker. The server should
-    // stay alive so non-Docker tools remain available.
-    const msg = error.message || "";
-    const isDockerDisconnect = /UNAVAILABLE|DEADLINE_EXCEEDED|ECONNREFUSED|ECONNRESET|connection reset|socket hang up|stream removed/i.test(msg);
-    if (isDockerDisconnect) {
-        logger.info("gRPC/Docker connection lost (container or network likely destroyed)", {
-            error: msg,
-        });
-        return;
-    }
-    logger.error("Unhandled promise rejection", {
-        error: error.message,
-        stack: error.stack,
-    });
-    try {
-        await AnalyticsService.pushServerCrashEvent("unhandledRejection", error.message, error.stack);
-    }
-    catch {
-        // Best effort — don't let telemetry failure cascade
-    }
-});
 // Start MCP server
 async function main() {
     const transport = new StdioServerTransport();
@@ -299,11 +231,6 @@ async function main() {
         logger.error("STDIN error, parent likely disconnected", { error: err });
         handleParentDisconnect("stdin error");
     });
-    // Handle stdout errors (EPIPE = client stopped reading, broken pipe)
-    process.stdout.on("error", (err) => {
-        logger.error("STDOUT error, client likely disconnected", { error: err });
-        handleParentDisconnect("stdout error");
-    });
     // Handle process termination signals
     process.on("SIGTERM", () => handleParentDisconnect("SIGTERM"));
     process.on("SIGINT", () => handleParentDisconnect("SIGINT"));

package/build/prompts/code-reuse.d.ts

@@ -1 +1,7 @@
-export declare function getCodeReusePrompt(testFile: string, language: string, framework?: string): string;
+import type { ScopedPom } from "../utils/pom-scope/index.js";
+export declare function isPomAwareTarget(language: string, framework?: string): boolean;
+export declare function getCodeReusePrompt(testFile: string, language: string, framework?: string, scopedPoms?: {
+    tier1: ScopedPom[];
+    tier2: ScopedPom[];
+    scannedNoOverlap?: boolean;
+}): string;

package/build/prompts/code-reuse.js

@@ -18,11 +18,14 @@ const LANGUAGE_MAP = {
         fileName: "skyrampUtils.ts",
     },
 };
-export function getCodeReusePrompt(testFile, language, framework) {
-    const isTypescriptPlaywright = language.toLowerCase() === "typescript" &&
-        framework?.toLowerCase() === "playwright";
-    if (isTypescriptPlaywright) {
-        return getPomAwareCodeReusePrompt(testFile);
+export function isPomAwareTarget(language, framework) {
+    const lang = language.toLowerCase();
+    return (lang === "typescript" || lang === "javascript") && framework?.toLowerCase() === "playwright";
+}
+export function getCodeReusePrompt(testFile, language, framework, scopedPoms) {
+    const lang = language.toLowerCase();
+    if (isPomAwareTarget(lang, framework)) {
+        return getPomAwareCodeReusePrompt(testFile, lang, scopedPoms);
     }
     const ext = LANGUAGE_MAP[language].extension || "py";
     const fileName = LANGUAGE_MAP[language].fileName || "SkyrampUtils.py";

package/build/prompts/code-reuse.test.js

@@ -0,0 +1,62 @@
+import { getCodeReusePrompt } from "./code-reuse.js";
+const POM = "POM-AWARE CODE REUSE"; // unique to the POM branch
+const pom = (file, score = 2, rareHits = 2, matchedTokens = ["a-b-c"]) => ({ file, score, rareHits, matchedTokens });
+describe("getCodeReusePrompt routing", () => {
+    it("routes javascript + playwright to the POM-aware prompt", () => {
+        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright")).toContain(POM);
+    });
+    it("still routes typescript + playwright to the POM-aware prompt", () => {
+        expect(getCodeReusePrompt("t.spec.ts", "typescript", "playwright")).toContain(POM);
+    });
+    it("routes javascript + non-playwright to SkyrampUtils", () => {
+        expect(getCodeReusePrompt("t.spec.js", "javascript", "jest")).not.toContain(POM);
+    });
+    it("routes python to SkyrampUtils (no regression)", () => {
+        expect(getCodeReusePrompt("t.py", "python", "pytest")).not.toContain(POM);
+    });
+    it("does not trigger POM path when framework is undefined", () => {
+        expect(getCodeReusePrompt("t.spec.ts", "typescript")).not.toContain(POM);
+    });
+});
+describe("getCodeReusePrompt scoped POM list", () => {
+    it("emits the pre-detected two-tier STEP 1 when scoped files are supplied", () => {
+        const p = getCodeReusePrompt("t.spec.js", "javascript", "playwright", { tier1: [pom("/repo/pages/loginPage.js")], tier2: [pom("/repo/pages/homePage.js", 0.3, 1, ["menu-link-/alerts-item"])] });
+        expect(p).toContain("ALREADY DETECTED");
+        expect(p).toContain("/repo/pages/loginPage.js");
+        expect(p).toContain("catalog fully");
+        expect(p).toContain("/repo/pages/homePage.js");
+        expect(p).toContain("signature level");
+        expect(p).toContain("menu-link-/alerts-item"); // matched tokens surface for tier-2 mapping evidence
+        expect(p).not.toContain("DETECT POM CLASSES");
+    });
+    it("emits the glob STEP 1 when no scoped files are supplied", () => {
+        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright")).toContain("DETECT POM CLASSES");
+    });
+    it("emits the glob STEP 1 when both tiers are empty (fallback)", () => {
+        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright", { tier1: [], tier2: [] }))
+            .toContain("DETECT POM CLASSES");
+    });
+    it("returns the short skip response on a clean scan with zero overlap", () => {
+        const p = getCodeReusePrompt("t.spec.js", "javascript", "playwright", {
+            tier1: [], tier2: [], scannedNoOverlap: true,
+        });
+        expect(p).toContain("No reusable POM layer detected");
+        expect(p).toContain("verify: true"); // escape hatch mandates re-verify
+        expect(p).not.toContain("COMPLIANCE RULES"); // NOT the full workflow prompt
+        expect(p.length).toBeLessThan(2000);
+    });
+    it("keeps the full agent-driven fallback when scoping was inconclusive", () => {
+        // no scopedPoms argument = scan didn't run or didn't conclude
+        const p = getCodeReusePrompt("t.spec.js", "javascript", "playwright");
+        expect(p).toContain("COMPLIANCE RULES");
+        expect(p).not.toContain("No reusable POM layer detected");
+    });
+    it("leaves the SkyrampUtils path untouched for non-Playwright languages", () => {
+        const p = getCodeReusePrompt("t.py", "python", undefined, { tier1: [], tier2: [], scannedNoOverlap: true });
+        expect(p).not.toContain("No reusable POM layer detected");
+        expect(p).toContain("SkyrampUtils");
+    });
+    it("does not annotate when scoping simply was not attempted", () => {
+        expect(getCodeReusePrompt("t.spec.js", "javascript", "playwright")).not.toContain("No reusable POM layer detected");
+    });
+});

package/build/prompts/enhance-assertions/sharedAssertionRules.d.ts

@@ -12,5 +12,4 @@ export interface AssertionEnrichmentRule {
     examples: AssertionEnrichmentExample[];
 }
 export declare function renderRule(index: number, rule: AssertionEnrichmentRule): string;
-export declare function renderSharedAssertionRules(): string;
 export declare function getAssertionsPrompt(specificRules: AssertionEnrichmentRule[], scope: string, testFile: string, enhanceType: EnhanceType): string;

package/build/prompts/enhance-assertions/sharedAssertionRules.js

@@ -122,20 +122,6 @@ expect(getResponseValue(productsPostResponse, "created_at")).toMatch(/^\\d{4}-\\
             },
         ],
     },
-    {
-        title: "Use exact recorded JSON paths",
-        description: "Do not add object-wrapper prefixes or nested paths that are not present in the actual response body. Use the exact JSON path from the recorded response body.",
-        subPoints: [
-            `If the body is flat (\`{"id": "acc_...", "tax_exempt": true}\`), use \`"tax_exempt"\`, not \`"account.tax_exempt"\`.`,
-            "Only use dot notation when the recorded response genuinely nests the field under that key.",
-        ],
-        examples: [
-            {
-                language: "javascript",
-                code: `expect(getResponseValue(accountResponse, "tax_exempt")).toBe(true);`,
-            },
-        ],
-    },
     {
         title: "Computed response fields, derived using dynamic formulas",
         description: "When the response contains a field whose value is derived from a calculation, assert the result using a formula built from prior response values and request inputs, not a hardcoded literal.",
@@ -172,9 +158,6 @@ ${ex.code}
 function renderRules(rules) {
     return rules.map((rule, i) => renderRule(i + 1, rule)).join("\n\n");
 }
-export function renderSharedAssertionRules() {
-    return renderRules(SHARED_RULES);
-}
 export function getAssertionsPrompt(specificRules, scope, testFile, enhanceType) {
     const allRules = [...SHARED_RULES, ...specificRules];
     const ruleChecklistKeys = allRules

package/build/prompts/initialize-workspace/initializeWorkspacePrompt.js

@@ -13,7 +13,7 @@ After scanning the workspace, before calling the skyramp_init_workspace tool, yo
     "framework": "<framework>",
     "testDirectory": "<path>",
     "api": { "schemaPath": "<path-or-url>", "baseUrl": "<url>", "authType": "<type>", "authHeader": "<header>" },
-    "runtimeDetails": { "runtime": "<runtime>", "serverStartCommand": "<command>", "serverStopCommand": "<docker stop command>", "dockerNetwork": "<network>" }
+    "runtimeDetails": { "runtime": "<runtime>", "serverStartCommand": "<command>", "dockerNetwork": "<network>" }
   }
 ]
 \`\`\`
@@ -68,7 +68,7 @@ API schemas (look inside the service directory and check known framework default
 <runtime_config>
 Inspect the repo root (and subdirectories like .devcontainer/) for shared runtime configuration:
 1. CLAUDE.md or AGENTS.md: if either file exists at the repo root, check it for dev/test/CI setup instructions including how to start services, required environment variables, and runtime configuration.
-2. Docker Compose files: scan for ALL compose files including docker-compose.yml, docker-compose.yaml, docker-compose.*.yml (such as docker-compose.testbot.yml or docker-compose.dev.yml), compose.yml, and compose.*.yaml in the repo root and subdirectories. Distinguish between application compose files and infrastructure-only compose files. Infrastructure compose files contain only supporting services like databases, Redis, Minio, mail servers, or message queues and do NOT run the application itself. Application compose files contain the actual application services that build from the repo source code (look for "build:" directives pointing to the repo, or services that map to discovered application directories). Only use application compose files for determining runtime, serverStartCommand, and serverStopCommand. When a non-default compose file is found, the serverStartCommand and serverStopCommand must reference it explicitly (such as "docker compose -f docker-compose.testbot.yml up -d --build <service-name>" and "docker compose -f docker-compose.testbot.yml stop <service-name>"). Docker Compose ALWAYS prefixes the network name with the project name. If compose has "networks: { my-net: ... }", the actual network name is "<project-name>_my-net". If there is no explicit networks section, the default network is "<project-name>_default". The project name is the basename of the working directory where docker compose runs.
+2. Docker Compose files: scan for ALL compose files including docker-compose.yml, docker-compose.yaml, docker-compose.*.yml (such as docker-compose.testbot.yml or docker-compose.dev.yml), compose.yml, and compose.*.yaml in the repo root and subdirectories. Distinguish between application compose files and infrastructure-only compose files. Infrastructure compose files contain only supporting services like databases, Redis, Minio, mail servers, or message queues and do NOT run the application itself. Application compose files contain the actual application services that build from the repo source code (look for "build:" directives pointing to the repo, or services that map to discovered application directories). Only use application compose files for determining runtime and serverStartCommand. When a non-default compose file is found, the serverStartCommand must reference it explicitly (such as "docker compose -f docker-compose.testbot.yml up -d <service-name>"). Docker Compose ALWAYS prefixes the network name with the project name. If compose has "networks: { my-net: ... }", the actual network name is "<project-name>_my-net". If there is no explicit networks section, the default network is "<project-name>_default". The project name is the basename of the working directory where docker compose runs.
 3. Makefile: extract start and dev targets.
 4. Root package.json scripts: extract workspace-level commands.
 </runtime_config>
@@ -135,20 +135,18 @@ Create one service entry per deployable unit. You MUST include every backend/API
 <runtime_fields>
 1. runtimeDetails.runtime (required): One of local, docker, or k8s. Detect per service:
    - If the service is listed in an application docker compose file (one that builds or runs the application, not infrastructure-only files containing only databases, caches, or queues) or has a Dockerfile as its intended run method, use "docker".
-   - If k8s manifests exist (charts/, k8s/, deploy/) AND the service is intended to run in K8s for local development, use "k8s".
+   - If k8s manifests exist (charts/, k8s/, deploy/), use "k8s".
    - If the service has no Docker or k8s configuration and is run directly via a language runtime (npm, python, java, etc.), use "local".
    A repo may have MIXED runtimes. A backend in docker-compose.yml uses "docker" while a frontend run with pnpm or npm locally uses "local". Include ALL services regardless of runtime.
    If the frontend is bundled inside the API Docker container (no separate frontend service in the compose file), both frontend and backend services should use runtime "docker", share the same baseUrl (the container's exposed URL), and use the same serverStartCommand since they run in the same container.
-   IMPORTANT — proxy parameters are NOT runtime indicators: If proxyKubeconfig, proxyNamespace, or proxyUrl appear in the conversation context, they are for a Skyramp proxy worker that collects traffic samples for mock generation. They do NOT indicate the repo's runtime. Do not use proxy K8s params to set runtime, k8sNamespace, or k8sContext. Determine the runtime solely from the repo's own files (docker-compose.yml, Dockerfile, k8s manifests that are part of the repo's own local dev workflow). Note that many repos have K8s deployment manifests for staging/production but use Docker Compose for local development — check which setup the repo actually uses for local dev.
 2. runtimeDetails.serverStartCommand: The command to start or deploy the service. It MUST match the runtime:
-   - For "docker" runtime: Use a Docker command that rebuilds application services from the working tree before starting them, such as "docker compose up -d --build <service-name>" for the default docker-compose.yml, or "docker compose -f <compose-file> up -d --build <service-name>" when using a non-default compose file. This is always derivable from the application docker compose file and service name. If the compose service has no build context and only references an image, note that the command cannot rebuild local code.
+   - For "docker" runtime: Use a Docker command such as "docker compose up -d <service-name>" for the default docker-compose.yml, or "docker compose -f <compose-file> up -d <service-name>" when using a non-default compose file. This is always derivable from the application docker compose file and service name.
    - For "k8s" runtime: Use a deploy command such as "kubectl apply -f deploy/", "helm install myrelease .", or "skaffold run". This is always derivable from the manifests or charts present in the repo.
    - For "local" runtime: Use an application command such as "uvicorn main:app", "npm run dev", or "java -jar app.jar". Derive from Makefile, package.json scripts, or README. If no start command is discoverable, omit this field entirely.
    NEVER mix runtime types with incompatible commands (for example, using "uvicorn" with runtime "docker" will cause errors). For "local" runtime, NEVER fabricate a command. Only use commands found in Makefile, package.json scripts, or README.
-3. runtimeDetails.serverStopCommand: Optional command to stop the service after test execution. ONLY set when runtime is "docker" and serverStartCommand starts persistent Docker infrastructure. For docker compose starts, prefer matching stop/down commands from the same compose file. Omit this field for "local" and "k8s" runtimes, or when teardown is unsafe or not discoverable.
-4. runtimeDetails.dockerNetwork: Docker network name. ONLY set when runtime is "docker". NEVER set for "local" or "k8s".
-5. runtimeDetails.k8sNamespace: Kubernetes namespace. ONLY set when runtime is "k8s". NEVER set for "local" or "docker".
-6. runtimeDetails.k8sContext: Kubernetes context. ONLY set when runtime is "k8s". NEVER set for "local" or "docker".
+3. runtimeDetails.dockerNetwork: Docker network name. ONLY set when runtime is "docker". NEVER set for "local" or "k8s".
+4. runtimeDetails.k8sNamespace: Kubernetes namespace. ONLY set when runtime is "k8s". NEVER set for "local" or "docker".
+5. runtimeDetails.k8sContext: Kubernetes context. ONLY set when runtime is "k8s". NEVER set for "local" or "docker".
 </runtime_fields>
 
 ### Verification
@@ -161,8 +159,8 @@ Before calling skyramp_init_workspace, confirm all of the following:
 5. Every service with authType apiKey has authHeader explicitly set to the actual custom header name (such as "X-API-Key" or "X-Admin-Key"). If you cannot find the header name in the source code, env vars, or README, do NOT use authType apiKey. Use authType none instead and add a YAML comment explaining auth is unresolved.
 6. framework matches language (python uses pytest or robot, typescript or javascript uses playwright, java uses junit).
 7. testDirectory follows the stable resolution rules above: framework config file when present (Playwright testDir in playwright.config.ts, pytest testpaths in pytest.ini or pyproject.toml, JUnit test source dir in pom.xml or build.gradle); otherwise the deterministic default (tests/skyramp for a single service, tests/skyramp/<serviceDirName> for multiple services).
-8. If serverStartCommand is provided, it matches the runtime. If serverStopCommand is provided, runtime is "docker" and the command is a Docker command.
-9. For services in docker-compose.yml: runtime MUST be "docker" and the command MUST be a docker command such as "docker compose up -d --build <service-name>" when the service has a build context. Always include it since it is derivable from the service name.
+8. If serverStartCommand is provided, it matches the runtime.
+9. For services in docker-compose.yml: runtime MUST be "docker" and the command MUST be a docker command such as "docker compose up -d <service-name>". Always include it since it is derivable from the service name.
 10. NEVER use application-level commands (uvicorn, npm, node, python, java, etc.) with runtime "docker".
 11. For "local" runtime: if no start command is discoverable from Makefile, package.json scripts, or README, omit serverStartCommand rather than guessing.
 12. dockerNetwork is set only when runtime is "docker".

package/build/prompts/pom-aware-code-reuse.d.ts

@@ -1 +1,6 @@
-export declare function getPomAwareCodeReusePrompt(testFile: string): string;
+import type { ScopedPom } from "../utils/pom-scope/index.js";
+export declare function getPomAwareCodeReusePrompt(testFile: string, language?: string, scopedPoms?: {
+    tier1: ScopedPom[];
+    tier2: ScopedPom[];
+    scannedNoOverlap?: boolean;
+}): string;