@skyramp/mcp 0.3.3 → 0.3.4

package/build/playwright/registerPlaywrightTools.js

@@ -4,11 +4,37 @@
  */
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
+import { dualChannelResult } from "../utils/utils.js";
 import { PlaywrightTraceService, } from "./PlaywrightTraceService.js";
 let _service = null;
 export function getPlaywrightTraceService() {
     return _service;
 }
+/**
+ * The one browser tool whose result is re-shaped on the way out — see
+ * toStructuredBlueprintResult.
+ */
+const BLUEPRINT_TOOL = "browser_blueprint";
+/**
+ * Re-shape a browser_blueprint result onto both MCP result channels.
+ *
+ * SKYR-4194. The browser tools are registered here as passthroughs, and the fork
+ * returns the captured DOM as one `content[]` text block with no
+ * `structuredContent` — the shape whose spill the agent's file reader refuses.
+ * See `dualChannelResult` for why both channels carry the payload.
+ *
+ * An error result is returned untouched: the SDK's outputSchema check returns
+ * early on `isError`, so it needs no structuredContent.
+ */
+function toStructuredBlueprintResult(result) {
+    if (result?.isError)
+        return result;
+    const blueprint = (result?.content ?? [])
+        .filter((block) => block?.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+    return dualChannelResult({ blueprint });
+}
 export async function registerPlaywrightTools(server, options) {
     _service = new PlaywrightTraceService(options);
     try {
@@ -68,9 +94,23 @@ export async function registerPlaywrightTools(server, options) {
     logger.info(`Filtering to ${filteredTools.length} essential tools (from ${tools.length} total)`);
     for (const tool of filteredTools) {
         const zodSchema = jsonSchemaToZod(tool.inputSchema);
+        const isBlueprint = tool.name === BLUEPRINT_TOOL;
         server.registerTool(tool.name, {
             description: tool.description || `Playwright tool: ${tool.name}`,
             inputSchema: zodSchema,
+            // SKYR-4194: only browser_blueprint returns its payload via
+            // structuredContent, which requires a declared outputSchema. The other
+            // browser tools return small results, and some return images, which this
+            // text-only re-shaping would drop.
+            ...(isBlueprint
+                ? {
+                    outputSchema: {
+                        blueprint: z
+                            .string()
+                            .describe("The captured PageBlueprint — sections, elements, and their logical names. Read and follow this field."),
+                    },
+                }
+                : {}),
         }, async (params) => {
             if (!_service?.isInitialized()) {
                 return {
@@ -83,7 +123,8 @@ export async function registerPlaywrightTools(server, options) {
                     isError: true,
                 };
             }
-            return _service.callTool(tool.name, params);
+            const result = await _service.callTool(tool.name, params);
+            return isBlueprint ? toStructuredBlueprintResult(result) : result;
         });
     }
     logger.info(`Registered ${filteredTools.length} Playwright tools: ${filteredTools.map((t) => t.name).join(", ")}`);

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

@@ -154,6 +154,25 @@ expect(getResponseValue(productsPostResponse, "created_at")).toMatch(/^\\d{4}-\\
             },
         ],
     },
+    {
+        title: "Assert a nullable field is present, not merely null",
+        description: "Reading a field's value cannot tell a null field from a missing one — `get_response_value` / `getValue` return the same result for both, so `is None` does not prove the field exists. Use a schema check with an example body instead.",
+        subPoints: [
+            "An example carrying `null` for the field asserts presence and nullness together, and fails when the field is absent.",
+            "An example carrying a concrete value only asserts that value's type, so a nullable field checked against a string example fails once the real value is null.",
+            "`check_schema` / `checkSchema` takes the RESPONSE OBJECT, not a parsed body. The `@skyramp/skyramp` type declaration says otherwise and is wrong — passing a plain object makes every check silently return false (SKYR-4189).",
+        ],
+        examples: [
+            {
+                language: "python",
+                code: `assert skyramp.check_schema(order_response, '{"cancelled_at": null}')`,
+            },
+            {
+                language: "javascript",
+                code: `expect(checkSchema(orderResponse, '{"cancelled_at": null}')).toBe(true);`,
+            },
+        ],
+    },
 ];
 export function renderRule(index, rule) {
     const subPoints = rule.subPoints && rule.subPoints.length > 0

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

@@ -15,7 +15,7 @@ export function buildFileRenameStrategy() {
 }
 /** Strategy string for in-place UPDATE edits. */
 export function buildUpdateStrategy() {
-    return `Apply each file in update_context yourself with the Edit tool, using its current_content and the changes described in context. Preserve all existing test logic — only add or adjust what context describes.
+    return `Apply each file in update_context yourself with the Edit tool. Read the file first, then make the changes described in context. Preserve all existing test logic — only add or adjust what context describes.
 
 When a file provides edit_sites, apply each site directly using its anchor as the Edit target — do not re-grep or re-page the file to relocate the sites; they were already found for you.
 
@@ -25,7 +25,7 @@ After editing, re-read each file to confirm the change landed, then call skyramp
 }
 /** Strategy string for REGENERATE — call generation tool to overwrite the file. */
 export function buildRegenerateStrategy() {
-    return `For each file in regenerate_context, call the appropriate generation tool (skyramp_integration_test_generation or skyramp_contract_test_generation) with outputDir set to the file's directory and output set to the filename. Use existing_content to determine the test type, endpoint, auth pattern, and language. The generation tool will overwrite the file. Do NOT use skyramp_ui_test_generation here — UI test regeneration requires a recorded trace (playwrightInput) and must be handled separately.`;
+    return `For each file in regenerate_context, call the appropriate generation tool (skyramp_integration_test_generation or skyramp_contract_test_generation) with outputDir set to the file's directory and output set to the filename. The generation tool will overwrite the file. Do NOT use skyramp_ui_test_generation here — UI test regeneration requires a recorded trace (playwrightInput) and must be handled separately.`;
 }
 /** Strategy string for DELETE — remove obsolete test files whose covered endpoints/UI no longer exist. */
 export function buildDeleteStrategy() {

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

@@ -347,10 +347,7 @@ Static endpoint scan results are **best-effort hints only**. Do not assume the s
 ${staticHintCount > 0 ? `Static hints available: ${staticHintCount}. Verify every hinted method/path against source before using it.` : "Static hints available: 0. Build the endpoint list from source, router context, spec, and diff."}
 
 ${p.candidateRouteFiles && p.candidateRouteFiles.length > 0
-            ? `Candidate files to inspect:\n${p.candidateRouteFiles
-                .slice(0, 15)
-                .map((f) => `- \`${f}\``)
-                .join("\n")}${p.candidateRouteFiles.length > 15 ? `\n_(${p.candidateRouteFiles.length - 15} more files not shown)_` : ""}`
+            ? ""
             : staticHintCount > 0
                 ? "Candidate files to inspect: none identified by static scanning. Verify the static hints against their source files, changed files, router context, and specs above."
                 : "Candidate files to inspect: use the changed files and routing entry-point files above."}

package/build/prompts/test-recommendation/recommendationSections.d.ts

@@ -32,4 +32,4 @@ export declare function buildTestQualityCriteria(): string;
 export declare function buildGenerationRules(isUIOnlyPR: boolean): string;
 export declare function buildVerificationChecklist(topN: number, maxGen: number, codeReviewStepLabel?: string): string;
 export declare function buildFewShotExamples(): string;
-export declare function buildToolWorkflows(authHeaderValue: string, authTypeValue?: string, explicitScheme?: string): string;
+export declare function buildToolWorkflows(authHeaderValue: string, authTypeValue?: string, explicitScheme?: string, enrichStepLabel?: string): string;

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

@@ -1,6 +1,6 @@
 import { isContractConsumerModeEnabled } from "../../utils/featureFlags.js";
 import { resolveServiceDetailsRef } from "../../utils/utils.js";
-import { WorkspaceAuthType, getAuthScheme, isAuthorizationHeaderName, AUTH_MIDDLEWARE_PATTERNS_STR } from "../../utils/workspaceAuth.js";
+import { WorkspaceAuthType, getAuthScheme, isAuthorizationHeaderName } from "../../utils/workspaceAuth.js";
 // Cached at module-load — flags are process-wide and cannot change per call.
 const CONSUMER_MODE_ENABLED = isContractConsumerModeEnabled();
 const SERVICE_REFS = resolveServiceDetailsRef();
@@ -243,7 +243,7 @@ Reasoning: Catches a missing 404 guard on DELETE — verifies the handler return
 </example>
 </examples>`;
 }
-export function buildToolWorkflows(authHeaderValue, authTypeValue = "", explicitScheme) {
+export function buildToolWorkflows(authHeaderValue, authTypeValue = "", explicitScheme, enrichStepLabel = "2") {
     const isAuthorizationHeader = isAuthorizationHeaderName(authHeaderValue);
     const noAuth = !authHeaderValue;
     let authGuidance;
@@ -251,7 +251,7 @@ export function buildToolWorkflows(authHeaderValue, authTypeValue = "", explicit
     if (noAuth) {
         authGuidance = `**Auth Verification Required:** The workspace config indicates no authentication, but you MUST verify this independently before omitting auth:
 1. **OpenAPI spec** \u2192 check \`securitySchemes\` / \`securityDefinitions\` for \`type: http\`, \`type: apiKey\`, or \`type: oauth2\`
-2. **Source code** \u2192 look for known auth signals (${AUTH_MIDDLEWARE_PATTERNS_STR}).
+2. **Source code** \u2192 look for the auth middleware signals listed in Step ${enrichStepLabel} of the Execution Plan.
 3. **Route definitions** \u2192 check if routes have auth decorators or middleware applied
 4. **Still unknown** \u2192 proceed with \`authHeader: ""\` and note "auth pattern unrecognized" in your recommendation description.
 If you find auth requirements, pass the appropriate \`authHeader\` and \`authScheme\` to EVERY tool call. Only pass \`authHeader: ""\` if you confirm the API is truly unauthenticated.
@@ -270,7 +270,7 @@ If you find auth requirements, pass the appropriate \`authHeader\` and \`authSch
             authGuidance = `**Auth Scheme:** The workspace \`api.authType\` is \`"${authTypeValue}"\`.
 **Where to find the scheme** (check in order):
 1. **OpenAPI spec** \u2192 look at \`securitySchemes\` / \`securityDefinitions\` for \`type: http, scheme: bearer\` or \`type: apiKey\`
-2. **Source code** \u2192 auth middleware signals: ${AUTH_MIDDLEWARE_PATTERNS_STR}
+2. **Source code** \u2192 the auth middleware signals listed in Step ${enrichStepLabel} of the Execution Plan
 3. **Workspace config** \u2192 use \`api.authType\` value as the scheme if source is inconclusive
 Pass the prefix as \`authScheme\` (e.g., \`"Bearer"\`, \`"Token"\`, \`"Basic"\`). If the API uses raw tokens with no prefix, pass \`authScheme: ""\`.
 **Do NOT guess the scheme.**
@@ -280,7 +280,7 @@ To skip auth entirely, pass \`authHeader: ""\`.`;
             authGuidance = `**Auth Scheme:** No \`api.authType\` in workspace config.
 **Where to find the scheme** (check in order):
 1. **OpenAPI spec** \u2192 look at \`securitySchemes\` / \`securityDefinitions\` for \`type: http, scheme: bearer\` or \`type: apiKey\`
-2. **Source code** \u2192 auth middleware signals: ${AUTH_MIDDLEWARE_PATTERNS_STR}
+2. **Source code** \u2192 the auth middleware signals listed in Step ${enrichStepLabel} of the Execution Plan
 3. **Fallback** \u2192 use \`"Bearer"\` only if the project clearly uses JWT or OAuth; otherwise pass \`authScheme: ""\`
 Pass the prefix as \`authScheme\` (e.g., \`"Bearer"\`, \`"Token"\`, \`"Basic"\`). If the API uses raw tokens with no prefix, pass \`authScheme: ""\`.
 **Do NOT guess the scheme.**

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

@@ -5,7 +5,7 @@ import { logger } from "../../utils/logger.js";
 import { buildArchitectPreamble, buildContextFetchingGuidance, buildReasoningProtocol, buildToolWorkflows, buildFewShotExamples, buildVerificationChecklist, getAuthSnippets, MAX_TESTS_TO_GENERATE, MAX_RECOMMENDATIONS, } from "./recommendationSections.js";
 import { CATEGORY_PRIORITY, Novelty, PriorityTier } from "../../types/TestRecommendation.js";
 import { buildScopeAssessmentSection, isFrontendFile } from "./scopeAssessment.js";
-import { buildExecutionPlan, EXEC_STEP_CODE_REVIEW } from "./diffExecutionPlan.js";
+import { buildExecutionPlan, EXEC_STEP_CODE_REVIEW, EXEC_STEP_ENRICH } from "./diffExecutionPlan.js";
 import { buildFullRepoRecommendations } from "./fullRepoCatalog.js";
 import { ANALYSIS_STEP_EXTRACT } from "./analysisOutputPrompt.js";
 import { TASK_GENERATE, buildExternalCoverageSet, externalDedupKey, isAttackSurfaceSecurityBoundary, taskRef, } from "./recommendationShared.js";
@@ -345,8 +345,15 @@ Treat the endpoint lists above as static hints. If source/diff inspection finds
                     diffEndpointKeys.add(`${m.method} ${ep.path}`);
             }
         }
-        const summaryLines = allEndpoints
-            .flatMap((ep) => (ep.methods ?? []).flatMap((m) => (m.interactions ?? []).map((i) => `  ${m.method} ${ep.path} → ${i.response.statusCode} (${i.type}): ${i.description}`)))
+        // SKYR-4188: `description` held exactly "<METHOD> <path>" in 11,273 of 11,273
+        // interaction lines on eval run 32227152533 — a copy of the start of its own
+        // line. Emit it only when it says something the line does not already say.
+        const interactionLabel = (i, method, path) => i.description && i.description !== `${method} ${path}` ? `: ${i.description}` : "";
+        // detailBlocks repeats every summary line and adds the bodies. The two cover
+        // the same endpoints unless the scope is a diff, so outside a diff the summary
+        // is pure repetition.
+        const summaryLines = !isDiffScope ? "" : allEndpoints
+            .flatMap((ep) => (ep.methods ?? []).flatMap((m) => (m.interactions ?? []).map((i) => `  ${m.method} ${ep.path} → ${i.response.statusCode} (${i.type})${interactionLabel(i, m.method, ep.path)}`)))
             .join("\n");
         const detailEndpoints = isDiffScope
             ? allEndpoints.filter((ep) => (ep.methods ?? []).some((m) => diffEndpointKeys.has(`${m.method} ${ep.path}`)))
@@ -357,13 +364,12 @@ Treat the endpoint lists above as static hints. If source/diff inspection finds
             const qParams = i.request.queryParams ? `\n    queryParams: ${JSON.stringify(i.request.queryParams)}` : "";
             const resBody = i.response.body ? `\n    responseBody: ${JSON.stringify(i.response.body)}` : "";
             const headers = i.request.headers ? `\n    headers: ${JSON.stringify(i.request.headers)}` : "";
-            return `  ${m.method} ${ep.path} → ${i.response.statusCode} (${i.type}): ${i.description}${reqBody}${qParams}${resBody}${headers}`;
+            return `  ${m.method} ${ep.path} → ${i.response.statusCode} (${i.type})${interactionLabel(i, m.method, ep.path)}${reqBody}${qParams}${resBody}${headers}`;
         })))
             .join("\n");
         interactionSection = `
 ## Endpoint Interactions
-${summaryLines}
-
+${summaryLines ? `${summaryLines}\n` : ""}
 ### Detailed (request/response bodies)
 ${isDiffScope ? "Changed endpoints only. " : ""}Use source code schemas (Zod/Pydantic/DTOs) for actual request bodies and query parameters.
 ${detailBlocks}
@@ -557,7 +563,7 @@ ${isDiffScope
 5. \`skyramp_ui_test_generation({ playwrightInput: "<absolute_path_to_zip>" })\`
 
 **For E2E tests:** Same browser recording flow, then call \`skyramp_e2e_test_generation\` with the zip.`
-            : buildToolWorkflows(authHeaderValue, authTypeValue, workspaceAuthScheme))
+            : buildToolWorkflows(authHeaderValue, authTypeValue, workspaceAuthScheme, EXEC_STEP_ENRICH))
         : ""}
 
 ${mainSection}

package/build/prompts/testbot/testbot-prompts.js

@@ -55,7 +55,7 @@ export function parseRelatedRepositories(raw) {
     }
 }
 export function getTestbotPrompt(opts) {
-    const { prTitle, prDescription, summaryOutputFile, repositoryPath, baseBranch, maxRecommendations = MAX_RECOMMENDATIONS, prNumber, userPrompt, services, uiCredentials, testsRepoDir, relatedRepositories, primaryRepo, planOnly = false, language, } = opts;
+    const { prTitle, prDescription, repositoryPath, baseBranch, maxRecommendations = MAX_RECOMMENDATIONS, prNumber, userPrompt, services, uiCredentials, testsRepoDir, relatedRepositories, primaryRepo, planOnly = false, language, } = opts;
     // maxCritical is intentionally unused (reserved) — see TestbotPromptOptions.
     const maxGenerate = Math.min(Math.max(opts.maxGenerate ?? MAX_TESTS_TO_GENERATE, 0), maxRecommendations);
     // TODO(SKYR-3636 follow-up): migrate Task 1 + Task 2 step bodies to PromptPlan
@@ -643,7 +643,7 @@ In these cases:
 
 ${task3CountRule}
 
-${reportLanguageBlock}Call \`skyramp_submit_report\` with \`summaryOutputFile\`: "${summaryOutputFile}" and \`stateFile\` (from \`skyramp_analyze_changes\` output) — the stateFile is required for execution outcome tracking. Field names, types, and formats are defined in the tool's parameter schema — follow them exactly.
+${reportLanguageBlock}Call \`skyramp_submit_report\` with \`stateFile\` (from \`skyramp_analyze_changes\` output) — the stateFile is required for execution outcome tracking, and the report is written beside it. Field names, types, and formats are defined in the tool's parameter schema — follow them exactly.
 
 ${hasRelatedRepos ? `
 - **MULTI-REPO attribution**: Set the \`repository\` field (\`owner/repo\`) on EVERY \`newTestsCreated\`, \`testResults\`, \`issuesFound\`, and \`additionalRecommendations\` item — including items about the PRIMARY repo — so each finding is unambiguously attributed. The primary repo's \`repository\` is \`${primaryRepo || "<the primary repo's owner/repo>"}\`; items derived from a related repo's diff (from the \`<related_repositories>\` analysis) carry that repo's \`repository\` value. In \`businessCaseAnalysis\`, include a short per-repo subsection and call out any cross-repo correlations you found.
@@ -652,13 +652,10 @@ ${hasRelatedRepos ? `
   - For \`testType: "contract"\` entries: **\`primaryEndpoint\` is required** (e.g. \`"GET /api/v1/users/{user_id}"\`). The tool will reject the submission without it — do not omit it or you will be forced to resubmit.
 
 ${getTraceRecordingPromptText({ outputDir: `${repositoryPath}/.skyramp`, modularize: false })}`;
-    // TODO: merge stateFile and summaryOutputFile into a single file (follow-up PR).
-    // Currently the stateFile path is derived server-side from RUNNER_TEMP (GitHub Actions only);
-    // other CI systems (Jenkins, GitLab, Buildkite) require the caller to set RUNNER_TEMP.
-    // Once merged, the path flows through summaryOutputFile — already testbot-controlled and
-    // CI-agnostic — eliminating the RUNNER_TEMP dependency and the LLM confusion that motivated
-    // removing stateOutputFile from the prompt schema. Remove the RUNNER_TEMP branch in
-    // AnalysisStateManager.ts when this is done.
+    // Neither path reaches the agent any more: SKYR-4147 made the report derive from the
+    // state file's directory, and that directory comes from the environment via
+    // runArtifactDir(). Keep it that way — a path the model retypes out of this prose is a
+    // path the model can corrupt, which is the defect SKYR-4147 fixed.
 }
 export function buildWorkspaceRecoveryPrefix(repositoryPath) {
     return `IMPORTANT: The existing .skyramp/workspace.yml failed to parse or validate. Before proceeding with any tasks below, you MUST call skyramp_init_scan with workspacePath "${repositoryPath}" and force: true, then call skyramp_init_workspace with workspacePath "${repositoryPath}", the discovered services, scanToken, and force: true to regenerate the workspace file.\n\n`;
@@ -670,9 +667,6 @@ export function registerTestbotPrompt(server) {
         argsSchema: {
             prTitle: z.string().describe("Pull request title"),
             prDescription: z.string().describe("Pull request description/body"),
-            summaryOutputFile: z
-                .string()
-                .describe("File path where the agent should write the testbot summary report"),
             repositoryPath: z
                 .string()
                 .default(".")
@@ -737,7 +731,6 @@ export function registerTestbotPrompt(server) {
         let prompt = getTestbotPrompt({
             prTitle: args.prTitle,
             prDescription: args.prDescription,
-            summaryOutputFile: args.summaryOutputFile,
             repositoryPath: args.repositoryPath,
             baseBranch: args.baseBranch,
             maxRecommendations: args.maxRecommendations,

package/build/recommendation/discriminators.d.ts

@@ -27,5 +27,11 @@ export interface DiscriminatorValidation {
  *  1. `changedCodeAnchor` must be a non-trivial string (>= 8 chars after trim)
  *     occurring verbatim in `diffText` — grounds the claim in the real change.
  *  2. The `kind`-specific structural predicate must hold over `steps[]`.
+ *
+ * `reposWithoutDiff` names repos in the run whose section carries no branch
+ * diff (e.g. a related repo that fell back to its default branch, SKYR-4203).
+ * An anchor those repos' changes could contain cannot be disproven, so an
+ * unmatched anchor then fails with a "could not be checked" reason instead of
+ * the "not grounded" one — still unverified (no boost), but distinguishable.
  */
-export declare function validateDiscriminator(scenario: DraftedScenario, declared: DiscriminatorClaim, diffText: string): DiscriminatorValidation;
+export declare function validateDiscriminator(scenario: DraftedScenario, declared: DiscriminatorClaim, diffText: string, reposWithoutDiff?: string[]): DiscriminatorValidation;

package/build/recommendation/discriminators.js

@@ -14,10 +14,16 @@ const MIN_NEAR_MISS_LENGTH = 3;
  *  1. `changedCodeAnchor` must be a non-trivial string (>= 8 chars after trim)
  *     occurring verbatim in `diffText` — grounds the claim in the real change.
  *  2. The `kind`-specific structural predicate must hold over `steps[]`.
+ *
+ * `reposWithoutDiff` names repos in the run whose section carries no branch
+ * diff (e.g. a related repo that fell back to its default branch, SKYR-4203).
+ * An anchor those repos' changes could contain cannot be disproven, so an
+ * unmatched anchor then fails with a "could not be checked" reason instead of
+ * the "not grounded" one — still unverified (no boost), but distinguishable.
  */
-export function validateDiscriminator(scenario, declared, diffText) {
+export function validateDiscriminator(scenario, declared, diffText, reposWithoutDiff = []) {
     try {
-        const anchorResult = verifyAnchor(declared?.changedCodeAnchor, diffText);
+        const anchorResult = verifyAnchor(declared?.changedCodeAnchor, diffText, reposWithoutDiff);
         if (!anchorResult.verified)
             return anchorResult;
         const steps = Array.isArray(scenario?.steps) ? scenario.steps : [];
@@ -43,7 +49,7 @@ export function validateDiscriminator(scenario, declared, diffText) {
     }
 }
 // ── Anchor grounding ──
-function verifyAnchor(rawAnchor, diffText) {
+function verifyAnchor(rawAnchor, diffText, reposWithoutDiff = []) {
     const anchor = typeof rawAnchor === "string" ? rawAnchor.trim() : "";
     if (anchor.length < MIN_ANCHOR_LENGTH) {
         return {
@@ -57,6 +63,13 @@ function verifyAnchor(rawAnchor, diffText) {
     // text — compare whitespace-collapsed forms with diff markers stripped, or
     // legitimate multi-line anchors are systematically false-demoted.
     if (!diff.includes(anchor) && !normalizeForAnchorMatch(diff).includes(normalizeForAnchorMatch(anchor))) {
+        if (reposWithoutDiff.length > 0) {
+            return {
+                verified: false,
+                reason: `changedCodeAnchor "${anchor}" was not found in the available PR diffs, and no branch diff exists for ` +
+                    `${reposWithoutDiff.join(", ")} (likely checked out on the default branch), so the claim could not be checked against those changes.`,
+            };
+        }
         return {
             verified: false,
             reason: `changedCodeAnchor "${anchor}" does not occur verbatim in the PR diff, so the discriminator claim is not grounded in the actual change.`,

package/build/resources/testbotResource.js

@@ -29,7 +29,6 @@ export function registerTestbotResource(server) {
         const prompt = getTestbotPrompt({
             prTitle: param("prTitle", ""),
             prDescription: param("prDescription", ""),
-            summaryOutputFile: param("summaryOutputFile", ""),
             repositoryPath,
             baseBranch: uri.searchParams.get("baseBranch") || undefined,
             maxRecommendations: isNaN(maxRec) ? MAX_RECOMMENDATIONS : maxRec,

package/build/services/ScenarioGenerationService.js

@@ -2,6 +2,7 @@ import { AUTH_PLACEHOLDER_TOKEN } from "../types/TestTypes.js";
 import { isAuthorizationHeaderName } from "../utils/workspaceAuth.js";
 import { inferExpectedStatus } from "../utils/httpDefaults.js";
 import { logger } from "../utils/logger.js";
+import { deriveBasePath } from "../utils/urlPath.js";
 // Keys that trigger built-in prototype setters when used as bracket-notation
 // property names on a plain object — guard against prototype pollution from
 // LLM-controlled or user-controlled JSON input.
@@ -22,7 +23,10 @@ export class ScenarioGenerationService {
         let destination = params.destination;
         let scheme = "https";
         let port = 443;
-        let basePath = "";
+        // Shared with generateBatchScenarioRestTool, which must predict this exact
+        // prefix to match workspace queryParamOverrides against the path this
+        // method will emit below (SKYR-4127). Keep it derived in one place.
+        const basePath = deriveBasePath(params.baseURL);
         if (params.baseURL) {
             try {
                 const parsed = new URL(params.baseURL);
@@ -33,7 +37,6 @@ export class ScenarioGenerationService {
                     : scheme === "https"
                         ? 443
                         : 80;
-                basePath = parsed.pathname.replace(/\/$/, "");
             }
             catch {
                 logger.warning("Could not parse baseURL, using destination param", {

package/build/services/TestExecutionService.js

@@ -9,6 +9,8 @@ import { logger } from "../utils/logger.js";
 import { TestExecutionStatus, } from "../types/TestExecution.js";
 import { TestType } from "../types/TestTypes.js";
 import { buildContainerEnv } from "./containerEnv.js";
+import { getWorkspaceScopedQueryParams } from "../utils/workspaceAuth.js";
+import { extractEnvVarNames } from "../workspace/queryParamResolution.js";
 import { EXECUTOR_DOCKER_IMAGE } from "../utils/versions.js";
 import { walkDir } from "../utils/fileWalk.js";
 export { EXECUTOR_DOCKER_IMAGE };
@@ -817,7 +819,29 @@ export class TestExecutionService {
                 mountedPaths.add(saveStorageTarget);
             }
         }
-        const env = buildContainerEnv(options, saveStorageTargetPath);
+        // Forward the environment variables this workspace's query params declare
+        // via `env.VAR` (SKYR-4127). The references resolve where the test runs, so
+        // without this they resolve to nothing inside the container and the query
+        // param is dropped from the request silently.
+        //
+        // getWorkspaceScopedQueryParams already returns undefined on a read or
+        // parse failure, so those degrade quietly to the pre-existing behavior.
+        // This guard covers only an unexpected throw, and must not fail an
+        // otherwise valid execution.
+        let passthroughNames = [];
+        try {
+            const scoped = await getWorkspaceScopedQueryParams(workspacePath);
+            if (scoped) {
+                passthroughNames = extractEnvVarNames(scoped);
+                if (passthroughNames.length > 0) {
+                    logger.debug(`Forwarding workspace-declared environment variables to the executor: ${passthroughNames.join(", ")}`);
+                }
+            }
+        }
+        catch (err) {
+            logger.warning(`Could not resolve workspace environment passthrough: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const env = buildContainerEnv(options, saveStorageTargetPath, process.env, passthroughNames);
         // Capture output
         let output = "";
         class DockerStream extends Writable {

package/build/services/TestGenerationService.js

@@ -2,7 +2,8 @@ import path from "path";
 import fs from "fs";
 import { SkyrampClient } from "@skyramp/skyramp";
 import { analyzeOpenAPIWithGivenEndpoint } from "../utils/analyze-openapi.js";
-import { isAuthorizationHeaderName, KNOWN_AUTH_HEADERS, resolveAuthFromWorkspace, getWorkspaceSkipTLSVerify, getWorkspaceDefaultQueryParams, mergeQueryParamsString, } from "../utils/workspaceAuth.js";
+import { isAuthorizationHeaderName, KNOWN_AUTH_HEADERS, resolveAuthFromWorkspace, getWorkspaceSkipTLSVerify, getWorkspaceScopedQueryParams, mergeQueryParamsString, } from "../utils/workspaceAuth.js";
+import { extractPathname, resolveQueryParamsForPath, contributesNothing } from "../workspace/queryParamResolution.js";
 import { getPathParameterValidationError, OUTPUT_DIR_FIELD_NAME, PATH_PARAMS_FIELD_NAME, QUERY_PARAMS_FIELD_NAME, FORM_PARAMS_FIELD_NAME, validateParams, validatePath, validateRequestData, } from "../utils/utils.js";
 import { getEntryPoint } from "../utils/telemetry.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
@@ -364,17 +365,31 @@ The generated test file remains unchanged and ready to use as-is.
                     logger.warning("Could not resolve skipTLSVerify from workspace config");
                 }
             }
-            // Workspace-declared default query params (SKYR-4050): api.defaultQueryParams
-            // are attached to every generated request for the service. Existing
-            // queryParams entries (explicit caller values) always win on a key collision.
+            // Workspace-declared query params (SKYR-4050, path-scoped in SKYR-4127):
+            // api.defaultQueryParams is the base map; api.queryParamOverrides layers
+            // the most-specific matching pathPattern on top. Existing queryParams
+            // entries (explicit caller values) always win on a key collision.
             if (!SKIP_DEFAULT_QUERY_PARAMS_TEST_TYPES.has(this.getTestType())) {
                 try {
                     const repoPath = generateOptions.outputDir || process.cwd();
-                    const defaults = await getWorkspaceDefaultQueryParams(repoPath);
-                    if (defaults) {
-                        generateOptions.queryParams = mergeQueryParamsString(generateOptions.queryParams, defaults);
-                        logger.info("Merged workspace defaultQueryParams into queryParams", {
-                            keys: Object.keys(defaults),
+                    const scoped = await getWorkspaceScopedQueryParams(repoPath);
+                    // Skip the merge entirely when the resolved config contributes
+                    // nothing — otherwise an empty/null defaultQueryParams declaration
+                    // with no overrides would set queryParams to "" where the old code
+                    // left the field untouched (Finding 4, SKYR-4127 final review).
+                    if (scoped && !contributesNothing(scoped)) {
+                        const pathname = extractPathname(generateOptions.uri);
+                        if (!pathname && scoped.overrides.length > 0) {
+                            logger.warning("queryParamOverrides configured but this generation call has no single endpoint path; " +
+                                "applying api.defaultQueryParams only", { patterns: scoped.overrides.map((o) => o.pathPattern) });
+                        }
+                        const effective = pathname
+                            ? resolveQueryParamsForPath(scoped, pathname)
+                            : { ...scoped.base };
+                        generateOptions.queryParams = mergeQueryParamsString(generateOptions.queryParams, effective);
+                        logger.info("Merged workspace query params into queryParams", {
+                            keys: Object.keys(effective),
+                            pathname,
                         });
                     }
                 }

package/build/services/containerEnv.d.ts

@@ -8,7 +8,18 @@ import { TestExecutionOptions } from "../types/TestExecution.js";
  * host.docker.internal is mapped via ExtraHosts in TestExecutionService.
  */
 export declare function rewriteLocalhostForDocker(url: string): string;
+/** Why a name is refused, or null when it is allowed. The two reasons need
+ *  different messages: a reserved name is already provided by the executor, so
+ *  the declaration is only redundant, while a credential name is refused. */
+export declare function passthroughDenyReason(name: string): "reserved" | "credential" | null;
+/** True when a name is refused regardless of who declared it. */
+export declare function isDeniedPassthroughName(name: string): boolean;
+/** A name is interpolated directly into a Docker `Env` entry, which is a plain
+ *  `NAME=value` string. A name holding `=`, whitespace or a newline produces a
+ *  malformed entry and can inject a second variable. workspace.yml supplies
+ *  these names, so `env.FOO=BAR` would yield the name `FOO=BAR`. */
+export declare function isValidEnvVarName(name: string): boolean;
 /**
  * Build the environment variable array for the Docker executor container.
  */
-export declare function buildContainerEnv(options: Pick<TestExecutionOptions, "token" | "language" | "useHostNetwork">, saveStoragePath?: string, hostEnv?: Record<string, string | undefined>): string[];
+export declare function buildContainerEnv(options: Pick<TestExecutionOptions, "token" | "language" | "useHostNetwork">, saveStoragePath?: string, hostEnv?: Record<string, string | undefined>, passthroughNames?: string[]): string[];

package/build/services/containerEnv.js

@@ -1,3 +1,4 @@
+import { logger } from "../utils/logger.js";
 /**
  * Rewrite localhost / 127.0.0.1 URLs to host.docker.internal so the Docker
  * executor container can reach services running on the host machine.
@@ -9,10 +10,67 @@
 export function rewriteLocalhostForDocker(url) {
     return url.replace(/^(https?:\/\/)(localhost|127\.0\.0\.1)([:/?#]|$)/, (_, scheme, _host, rest) => `${scheme}host.docker.internal${rest}`);
 }
+/** Names a workspace declaration may never forward. Matching is
+ *  case-insensitive: `process.env` is case-insensitive on Windows, so a
+ *  lower-case declaration there returns the real value and would otherwise
+ *  pass the checks below.
+ *
+ *  Two distinct concerns share one list. The first is CI identity: testbot puts
+ *  the workflow's GitHub token in the MCP process env so the agent's `gh` calls
+ *  authenticate, and a declaration naming it would push it into the container
+ *  and from there into a query string — where the SUT's own access log records
+ *  it. The second is internal signals the executor sets for itself, which a
+ *  declaration must not be able to spoof or override.
+ *
+ *  Deliberately NOT a blanket `*_TOKEN`: a token for the customer's own SUT is
+ *  exactly the kind of value an RBAC query param carries, and refusing it would
+ *  break the feature this list exists to protect. */
+// Names the executor sets for itself. API_KEY carries the Skyramp LLM key and
+// is forwarded unconditionally by the built-in block below, so a declaration
+// adds nothing. UI Smart LLM features keep working either way.
+const PASSTHROUGH_RESERVED_EXACT = new Set([
+    "API_KEY",
+    "PYTEST_ADDOPTS",
+    "PLAYWRIGHT_SAVE_STORAGE_PATH",
+]);
+const PASSTHROUGH_RESERVED_PREFIXES = ["SKYRAMP_"];
+// CI identity and secret-shaped names. Testbot puts the workflow GitHub token
+// in the MCP process env, and a declaration would send it to the container and
+// into a query string, where the SUT access log records it.
+const PASSTHROUGH_CREDENTIAL_EXACT = new Set(["GITHUB_TOKEN", "GH_TOKEN"]);
+const PASSTHROUGH_CREDENTIAL_PREFIXES = ["ACTIONS_", "AWS_"];
+const PASSTHROUGH_CREDENTIAL_SUBSTRINGS = ["_SECRET", "_PRIVATE_KEY"];
+/** Why a name is refused, or null when it is allowed. The two reasons need
+ *  different messages: a reserved name is already provided by the executor, so
+ *  the declaration is only redundant, while a credential name is refused. */
+export function passthroughDenyReason(name) {
+    const upper = name.toUpperCase();
+    if (PASSTHROUGH_CREDENTIAL_EXACT.has(upper) ||
+        PASSTHROUGH_CREDENTIAL_PREFIXES.some((p) => upper.startsWith(p)) ||
+        PASSTHROUGH_CREDENTIAL_SUBSTRINGS.some((s) => upper.includes(s))) {
+        return "credential";
+    }
+    if (PASSTHROUGH_RESERVED_EXACT.has(upper) ||
+        PASSTHROUGH_RESERVED_PREFIXES.some((p) => upper.startsWith(p))) {
+        return "reserved";
+    }
+    return null;
+}
+/** True when a name is refused regardless of who declared it. */
+export function isDeniedPassthroughName(name) {
+    return passthroughDenyReason(name) !== null;
+}
+/** A name is interpolated directly into a Docker `Env` entry, which is a plain
+ *  `NAME=value` string. A name holding `=`, whitespace or a newline produces a
+ *  malformed entry and can inject a second variable. workspace.yml supplies
+ *  these names, so `env.FOO=BAR` would yield the name `FOO=BAR`. */
+export function isValidEnvVarName(name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
 /**
  * Build the environment variable array for the Docker executor container.
  */
-export function buildContainerEnv(options, saveStoragePath, hostEnv = process.env) {
+export function buildContainerEnv(options, saveStoragePath, hostEnv = process.env, passthroughNames = []) {
     const env = [
         // Omit entirely when empty so os.getenv() returns None in the test —
         // unauthenticated endpoints won't send an empty auth header (E7).
@@ -68,6 +126,41 @@ export function buildContainerEnv(options, saveStoragePath, hostEnv = process.en
             env.push(`${key}=${val}`);
         }
     }
+    // Environment variables the workspace's query params declare via `env.VAR`
+    // (SKYR-4127). These references resolve where the test RUNS — inside this
+    // container — so a name that does not reach it resolves to nothing, and an
+    // unresolved query param is dropped from the request silently, yielding a
+    // passing test that exercised the wrong identity.
+    //
+    // The list comes from what workspace.yml declared, never from enumerating the
+    // ambient environment: nothing is forwarded that the workspace did not name.
+    // Forwarded on presence, not truthiness, for the same reason as the
+    // credentials above — an empty value is a legitimate declaration.
+    const seen = new Set();
+    for (const name of passthroughNames) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        if (!isValidEnvVarName(name)) {
+            logger.warning(`Ignoring ${JSON.stringify(name)} declared in workspace.yml: it is not a valid environment variable name.`);
+            continue;
+        }
+        const denyReason = passthroughDenyReason(name);
+        if (denyReason === "reserved") {
+            logger.warning(`Ignoring the workspace.yml declaration of ${name}: the executor sets this variable itself. ` +
+                `Its value still reaches the test.`);
+            continue;
+        }
+        if (denyReason === "credential") {
+            logger.warning(`Refusing to forward ${name} to the test executor: the name is credential-shaped. ` +
+                `Declare a variable that carries only the value the request needs.`);
+            continue;
+        }
+        const val = hostEnv[name];
+        if (val !== undefined) {
+            env.push(`${name}=${val}`);
+        }
+    }
     if (hostEnv.SKYRAMP_DEBUG) {
         env.push(`SKYRAMP_DEBUG=${hostEnv.SKYRAMP_DEBUG}`);
     }

package/build/tools/executeSkyrampTestTool.d.ts

@@ -10,4 +10,13 @@ export type ContractExecutionMode = (typeof CONTRACT_EXECUTION_MODES)[number];
  */
 export declare function resolveEffectiveToken(unauthenticated?: boolean, paramToken?: string, envToken?: string): string;
 export declare function shouldInjectSkyrampBaseUrl(testType: TestType, contractMode?: ContractExecutionMode): boolean;
+/**
+ * Append the recorded video path to execution output.
+ *
+ * Applied to the failure return as well as the success one (SKYR-4156): a video is
+ * most useful for a test that just failed, and surfacing it only on success meant a
+ * failing UI test reported no recording at all unless Playwright happened to print
+ * its own attachment line.
+ */
+export declare function withVideoInfo(output: string, videoPath?: string): string;
 export declare function registerExecuteSkyrampTestTool(server: McpServer): void;