@skyramp/mcp 0.3.4 → 0.3.5

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

@@ -5,6 +5,7 @@ import { MAX_TESTS_TO_GENERATE, MAX_RECOMMENDATIONS, MAX_CRITICAL_TESTS, PATH_PA
 import { TASK_ANALYZE_MAINTAIN, TASK_GENERATE, TASK_SUBMIT, taskRef } from "../test-recommendation/recommendationShared.js";
 import { getTraceRecordingPromptText } from "../../playwright/traceRecordingPrompt.js";
 import { isContractConsumerModeEnabled, isPomReuseEnabled } from "../../utils/featureFlags.js";
+import { setReportLanguage } from "../../utils/reportLanguage.js";
 import { resolveServiceDetailsRef } from "../../utils/utils.js";
 import { buildServiceContext, readWorkspaceServices, } from "../prompt-utils.js";
 // Cached at module-load — flags are process-wide and cannot change per call.
@@ -77,6 +78,14 @@ export function getTestbotPrompt(opts) {
     // SKYR-4023: user-facing report language. English display names improve
     // instruction-following vs bare codes; Intl.DisplayNames (Node >=18) names any
     // code correctly, falling back to the raw code only if it can't be resolved.
+    // SKYR-4185: rendering the prompt is the single capture point for the
+    // report language — the prompt registration AND the testbot resource both
+    // come through here, so skyramp_submit_report's language guardrail sees it
+    // regardless of which surface served the prompt (no dual wiring to forget).
+    // Set on EVERY render, not just non-English ones: last render wins, so an
+    // en/argless render disarms a language captured earlier in a long-lived
+    // server process instead of falsely rejecting an English report.
+    setReportLanguage(language && language !== 'en' ? language : undefined);
     let reportLanguageBlock = '';
     if (language && language !== 'en') {
         const reportLanguageName = new Intl.DisplayNames(['en'], { type: 'language' }).of(language) ?? language;
@@ -408,7 +417,7 @@ This is a plan-only evaluation run: the application under test is NOT running, a
 
 ${userPrompt ? "Generate only the tests that the user requested from the Additional Recommendations. The rules below still apply." : "Drift-based maintenance (Task 1) is complete. This step only processes the GENERATE list. Exception: if a GENERATE item targets a resource with an existing `[skyramp]` contract test, UPDATE that test file (see covered-resource handling below) — a new test case added to an existing file counts toward the budget and is reported in `newTestsCreated`."}
 
-- **MANDATORY — use the plan returned by \`skyramp_register_test_plan\` as-is**: Before generating anything, call \`skyramp_register_test_plan\` (\`stateFile\` required) with your complete candidate list — every test you would generate OR recommend, including the Execution Plan's own pre-ranked GENERATE/ADDITIONAL items and any candidate you drafted yourself, with a \`discriminator\` claim \`{kind, changedCodeAnchor}\` for candidates probing changed logic. Its returned GENERATE list — not the Execution Plan's raw pre-ranked GENERATE section — governs ADD actions from this point on. You MUST generate exactly those scenarios in the exact order listed, keeping each item's \`scenarioName\` exactly as registered — the generation tools match on it and reject renamed or substituted scenarios. If parameter grounding uncovers a distinct bug-catching scenario not already registered, generate it after all planned GENERATE items are complete and report it in \`newTestsCreated\` — this is an additional test driven by source-code analysis and does not count against the GENERATE budget.${hasRelatedRepos ? `\n  - **Multi-repo exception:** this run has related repositories, so the per-repo GENERATE lists are NOT final — they are candidates re-selected by the cross-repo round-robin described in Task 1's "Cross-repo test generation". Register the pooled, type-distributed selection instead of any single repo's GENERATE list. (In single-repo runs, register the GENERATE list exactly as-is.)` : ""}
+- **MANDATORY — use the plan returned by \`skyramp_register_test_plan\` as-is**: Before generating anything, call \`skyramp_register_test_plan\` (\`stateFile\` required) with your complete candidate list — every test you would generate OR recommend, including the Execution Plan's own pre-ranked GENERATE/ADDITIONAL items and any candidate you drafted yourself, with a \`discriminator\` claim \`{kind, changedCodeAnchor}\` for candidates probing changed logic. Its returned GENERATE list — not the Execution Plan's raw pre-ranked GENERATE section — governs ADD actions from this point on. You MUST generate exactly those scenarios in the exact order listed, keeping each item's \`scenarioName\` exactly as registered — the generation tools match on it and reject renamed or substituted scenarios. If parameter grounding uncovers a distinct bug-catching scenario not already registered, generate it after all planned GENERATE items are complete and report it in \`newTestsCreated\` — this is an additional test driven by source-code analysis and does not count against the GENERATE budget.${hasRelatedRepos ? `\n  - **Multi-repo exception:** this run has related repositories, so the per-repo GENERATE lists are NOT final — they are candidates re-selected by the cross-repo round-robin described in Task 1's "Cross-repo test generation". Register the pooled, type-distributed selection instead of any single repo's GENERATE list — call \`skyramp_register_test_plan\` ONCE for the whole run, with candidates from EVERY repo pooled into one list, including at least one UI candidate when any repo changed frontend files (the tool rejects a pooled registration without one). (In single-repo runs, register the GENERATE list exactly as-is.)` : ""}
 - **Do not fabricate tests outside the GENERATE list provided by \`skyramp_analyze_changes\`.** Changes that only modify, delete, or add fields to an EXISTING covered endpoint or component are maintenance: handle them in ${taskRef(TASK_ANALYZE_MAINTAIN)} by UPDATE/DELETE of the existing test, never by creating a new spec. If the GENERATE list is empty, create zero new tests and proceed to ${taskRef(TASK_SUBMIT)}.
 - Scenario JSON files are always new files — always generate them for new methods. Every generated scenario JSON must have a corresponding new integration test generated from it via \`skyramp_integration_test_generation\`.
 - Covered-resource handling (aligns with Execution Plan Step 0): When a GENERATE item targets a resource that already has an existing test file covering the same endpoint:

package/build/tools/submitReportTool.js

@@ -8,11 +8,12 @@ import { TestType, HttpMethod } from "../types/TestTypes.js";
 import { DriftAction } from "../types/TestAnalysis.js";
 import { TestExecutionStatus } from "../types/TestExecution.js";
 import { IssueFoundCategory } from "../types/TestbotReport.js";
-import { StateManager, runArtifactDir } from "../utils/AnalysisStateManager.js";
+import { StateManager, runArtifactDir, getTestsRepoDir } from "../utils/AnalysisStateManager.js";
 import { toolError, testFileMatches } from "../utils/utils.js";
 import { matchesApprovedPlan } from "../utils/planMatchKeys.js";
 import { isTestbotEnabled } from "../utils/featureFlags.js";
-import { findUnbackedClaims, listChangedFiles } from "../utils/reportVerification.js";
+import { findUnbackedClaims, listChangedFiles, listChangedFilesAcross } from "../utils/reportVerification.js";
+import { getReportLanguage, isEnforcedReportLanguage, findLanguageViolations, findLanguageNearMisses, reportLanguageDisplayName, } from "../utils/reportLanguage.js";
 import { rederiveReuseOutcome } from "./code-refactor/reuse-state.js";
 // SKYR-3879 Path B: which testTypes the register-plan checkpoint gates. Mirrors
 // the generation tools actually wired to planGuard (batch-scenario/integration,
@@ -543,6 +544,10 @@ export function registerSubmitReportTool(server) {
     }, async (params) => {
         const startTime = Date.now();
         let errorResult;
+        // Residual-leak telemetry (SKYR-4185): filled by the language guardrail
+        // below when a report language is enforced, spread into the analytics
+        // event in the finally. Empty (no properties) for non-enforced runs.
+        const languageTelemetry = {};
         // The report goes next to the state file, so in a Testbot run the state file has to
         // be in the run directory — that is where the action reads the report back from.
         // Two ways that breaks, both ending in a report nobody reads while this tool says
@@ -567,6 +572,70 @@ export function registerSubmitReportTool(server) {
                     `earlier run or one typed by hand.`);
             }
         }
+        // SKYR-4185: report-language guardrail. The language was captured when the
+        // testbot prompt was rendered (see reportLanguage.ts) — the instruction to
+        // write free-text fields in it is prose the agent sometimes ignores
+        // (letsramp/api-insight#215 shipped English testResults[].details in an
+        // otherwise-Japanese report). Reject rather than ship a half-translated
+        // report; the listed paths tell the agent exactly what to rewrite. Fields
+        // the agent does not author here (testMaintenance description from
+        // skyramp_actions verdicts, the server default commitMessage) are exempt —
+        // rejecting those would loop, since resubmitting cannot change them.
+        const reportLanguage = getReportLanguage();
+        if (reportLanguage && !isEnforcedReportLanguage(reportLanguage)) {
+            logger.warning(`Report language '${reportLanguage}' has no enforcement rules — skipping the language guardrail`);
+        }
+        if (isEnforcedReportLanguage(reportLanguage)) {
+            const textFields = [
+                { path: "businessCaseAnalysis", text: params.businessCaseAnalysis },
+            ];
+            params.newTestsCreated.forEach((t, i) => {
+                textFields.push({ path: `newTestsCreated[${i}].description`, text: t.description });
+                textFields.push({ path: `newTestsCreated[${i}].reasoning`, text: t.reasoning });
+            });
+            (params.additionalRecommendations ?? []).forEach((r, i) => {
+                textFields.push({ path: `additionalRecommendations[${i}].description`, text: r.description });
+                textFields.push({ path: `additionalRecommendations[${i}].reasoning`, text: r.reasoning });
+                r.steps.forEach((s, j) => {
+                    textFields.push({ path: `additionalRecommendations[${i}].steps[${j}].description`, text: s.description });
+                });
+            });
+            params.testResults.forEach((t, i) => {
+                textFields.push({ path: `testResults[${i}].details`, text: t.details });
+            });
+            params.issuesFound.forEach((f, i) => {
+                textFields.push({ path: `issuesFound[${i}].description`, text: f.description });
+            });
+            (params.nextSteps ?? []).forEach((s, i) => {
+                textFields.push({ path: `nextSteps[${i}]`, text: s });
+            });
+            (params.testMaintenanceDetails ?? []).forEach((d, i) => {
+                textFields.push({ path: `testMaintenanceDetails[${i}].beforeDetails`, text: d.beforeDetails });
+                textFields.push({ path: `testMaintenanceDetails[${i}].afterDetails`, text: d.afterDetails });
+            });
+            if (params.commitMessage && params.commitMessage !== DEFAULT_COMMIT_MESSAGE) {
+                textFields.push({ path: "commitMessage", text: params.commitMessage });
+            }
+            const languageViolations = findLanguageViolations(textFields, reportLanguage);
+            if (languageViolations.length > 0) {
+                const languageName = reportLanguageDisplayName(reportLanguage);
+                errorResult = toolError(`This run's report language is ${languageName}, but ${languageViolations.length} free-text field(s) are written in English:\n` +
+                    languageViolations.map((v) => `  - ${v}`).join("\n") +
+                    `\nRewrite ONLY the listed fields in ${languageName} and resubmit the report. ` +
+                    `Keep code identifiers, endpoint paths, file names, test IDs, enum values ` +
+                    `(Pass/Fail/Skipped, severity values, testType), and anything inside backticks untranslated.`);
+                return errorResult;
+            }
+            // The sub-threshold band (a single stray English word) is accepted by
+            // design; count what ships so the leniency's real-world leak rate is
+            // visible in Amplitude before anyone tightens the threshold.
+            const nearMisses = findLanguageNearMisses(textFields, reportLanguage);
+            languageTelemetry.reportLanguage = reportLanguage;
+            languageTelemetry.languageNearMissCount = String(nearMisses.length);
+            if (nearMisses.length > 0) {
+                logger.info(`Report language ${reportLanguage}: accepting ${nearMisses.length} field(s) with a single stray English word`, { fields: nearMisses });
+            }
+        }
         const dedupedNewTests = deduplicateById([...params.newTestsCreated]);
         const dedupedRecommendations = deduplicateById([...(params.additionalRecommendations ?? [])]);
         const stateManager = StateManager.fromStatePath(params.stateFile);
@@ -710,7 +779,23 @@ export function registerSubmitReportTool(server) {
             const repoRoot = fullState?.metadata?.repositoryPath;
             if (repoRoot && repoRoot !== "unknown") {
                 try {
-                    const changedFiles = await listChangedFiles(repoRoot);
+                    // A run writes tests into up to three kinds of trees: the primary
+                    // checkout, the tests-repo checkout (testRepoPath), and related
+                    // repos. Scanning only the primary rejected a real, executed UI
+                    // test in the tests-repo checkout as "unbacked", forcing the agent
+                    // to demote it to additionalRecommendations (SKYR-4204 reopen,
+                    // run 32510028428).
+                    // The primary scan keeps its throwing form: an unscannable primary
+                    // degrades the whole check to a pass (SKYR-3883 semantics) via the
+                    // catch below. The extra trees are best-effort — a missing or
+                    // non-git one contributes nothing.
+                    const changedFiles = [
+                        ...(await listChangedFiles(repoRoot)),
+                        ...(await listChangedFilesAcross([
+                            getTestsRepoDir(),
+                            ...Object.values(fullState?.relatedRepos ?? {}).map((section) => section.repositoryPath),
+                        ])),
+                    ];
                     const unbacked = findUnbackedClaims({
                         repoRoot,
                         changedFiles,
@@ -815,6 +900,7 @@ export function registerSubmitReportTool(server) {
                 testResultCount: String(params.testResults.length),
                 payloadBytes: String(reportJson.length),
                 ...computeReportMetrics({ ...params, testMaintenance }),
+                ...languageTelemetry,
             }).catch(() => { });
         }
     });

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

@@ -10,7 +10,7 @@ import { dualChannelResult } from "../../utils/utils.js";
 import { parseWorkspaceAuthType, getDefaultAuthHeader, WorkspaceAuthType, readWorkspaceConfigRaw } from "../../utils/workspaceAuth.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { makeProgressReporter } from "../../utils/progress.js";
-import { StateManager, registerSession, storeSessionData, setTestsRepoDir, getActiveRunStatePath, setActiveRunStatePath, } from "../../utils/AnalysisStateManager.js";
+import { StateManager, registerSession, storeSessionData, rememberTestsRepoDir, getActiveRunStatePath, setActiveRunStatePath, } from "../../utils/AnalysisStateManager.js";
 import { buildRecommendationPrompt, computeScoredCandidates } from "../../prompts/test-recommendation/test-recommendation-prompt.js";
 import { hasFlutterSdkDep, isFrontendFile, isTestFile } from "../../prompts/test-recommendation/scopeAssessment.js";
 import { buildExternalCoverageSet } from "../../prompts/test-recommendation/recommendationShared.js";
@@ -736,7 +736,9 @@ export function registerAnalyzeChangesTool(server) {
             let discoveredRelevantExternalPaths = [];
             try {
                 const testDiscoveryService = new TestDiscoveryService();
-                setTestsRepoDir(params.testsRepoDir);
+                // Run-scoped: only the primary call carries testsRepoDir, so never
+                // let a related repo's call clear it (SKYR-4204).
+                rememberTestsRepoDir(params.testsRepoDir);
                 const discoveryResult = await testDiscoveryService.discoverTests(testDir ?? params.repositoryPath, { changedResources, changedSymbols, preciseResources: (changedSymbols?.length ?? 0) > 0, changedFrontendFiles, changedSelectors });
                 existingTests = discoveryResult.tests.map((test) => ({
                     testFile: test.testFile,

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

@@ -10,6 +10,8 @@ import { SCENARIO_CATEGORIES, CATEGORY_PRIORITY, Novelty, PriorityTier } from ".
 import { HttpMethod, TestType } from "../../types/TestTypes.js";
 import { CandidateSource, computeCandidateId, scenarioMergeKey, DiscriminatorKind } from "../../types/Recommendation.js";
 import { selectPlan } from "../../recommendation/planRanker.js";
+import { reservedUISlots } from "../../recommendation/budgeters/shared.js";
+import { inferScenarioType } from "../../recommendation/diversity.js";
 import { validateDiscriminator } from "../../recommendation/discriminators.js";
 import { isAttackSurfaceSecurityBoundary } from "../../prompts/test-recommendation/recommendationShared.js";
 import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-recommendation/recommendationSections.js";
@@ -84,10 +86,12 @@ const registerTestPlanSchema = {
         .string()
         .refine((p) => path.isAbsolute(p), { message: "stateFile must be an absolute path" })
         .describe("Path to state file from skyramp_analyze_changes"),
-    repository: z
-        .string()
-        .optional()
-        .describe("The owner/repo whose analysis section to register against (e.g. 'letsramp/api-insight'). In a multi-repo run, ALWAYS set it. Omit only for a single-repo run."),
+    // No `repository` argument, deliberately (SKYR-4204 reopen). The approved
+    // plan is run-wide — one pooled registration covers every repository in the
+    // run — so unlike the per-repo tools (analyze_test_health, actions,
+    // execute_test) there is no section to select: the tool reads the root and
+    // derives run-wide facts (diff union, budget flags, scenario lookup) itself.
+    // A legacy caller still passing `repository` has it stripped harmlessly.
     candidates: z
         .array(registerCandidateSchema)
         .default([])
@@ -245,12 +249,17 @@ function resolveBudgetContext(stateData, fullState) {
     const hasFrontendChanges = sections.some((s) => s?.planBudgetContext?.hasFrontendChanges ?? false);
     const hasApiChanges = sections.some(sectionHasApiChanges);
     const rootPbc = fullState?.planBudgetContext;
+    // SKYR-4211: external-test coverage is also a per-section fact — a backend
+    // candidate already covered by an external test recorded in a RELATED repo's
+    // section must dedup the same as one covered in the primary. Union the keys
+    // across all sections, like the flags above.
+    const externalCoverage = new Set(sections.flatMap((s) => s?.planBudgetContext?.externalCoverageKeys ?? []));
     return {
         maxGenerate: rootPbc?.maxGenerate ?? base.maxGenerate,
         maxTotal: rootPbc?.maxTotal ?? base.maxTotal,
         isUIOnlyPR: hasFrontendChanges && !hasApiChanges,
         hasFrontendChanges,
-        externalCoverage: base.externalCoverage,
+        externalCoverage,
     };
 }
 function describeGenerationCall(item) {
@@ -359,12 +368,16 @@ export function registerRegisterTestPlanTool(server) {
     }, async (params) => {
         let errorResult;
         try {
-            logger.info(`Registering test plan${params.repository ? ` for repository ${params.repository}` : ""}`, {
+            logger.info("Registering run-wide test plan", {
                 candidateCount: params.candidates?.length ?? 0,
             });
             const stateManager = StateManager.fromStatePath(params.stateFile);
-            const stateData = await stateManager.readRepoData(params.repository);
-            const repositoryPath = (await stateManager.getRepoRepositoryPath(params.repository)) || "";
+            // The plan is run-wide, so register always reads the ROOT (primary)
+            // section — there is no section selector (routing by one is what let a
+            // related-repo registration run with that section's context —
+            // SKYR-4204 reopen). Run-wide facts (diff union, budget flags,
+            // scenario lookup) come from fullState below.
+            const stateData = await stateManager.readData();
             if (!stateData) {
                 errorResult = toolError(`State file is empty or invalid: ${params.stateFile}. Call skyramp_analyze_changes first to generate a valid state file.`);
                 return errorResult;
@@ -388,9 +401,19 @@ export function registerRegisterTestPlanTool(server) {
             ];
             const diffText = diffSections.map((s) => s.diff).filter(Boolean).join("\n");
             const reposWithoutDiff = diffSections.filter((s) => !s.diff).map((s) => s.repo);
-            const allScenarios = stateData.repositoryAnalysis?.scenarios ?? [];
+            // Scenario lookup for server-candidate recovery spans ALL sections —
+            // the primary's drafted scenarios must resolve even when `repository`
+            // targets a related repo (SKYR-4204 reopen: the same single-section
+            // shape as the diff union above).
+            const allScenarios = [
+                ...(fullState?.repositoryAnalysis?.scenarios ?? []),
+                ...Object.values(fullState?.relatedRepos ?? {}).flatMap((section) => section.data?.repositoryAnalysis?.scenarios ?? []),
+            ];
             const agentCandidates = buildAgentCandidates(params.candidates ?? []);
-            const serverCandidates = recoverServerCandidates(stateData.approvedPlan, allScenarios);
+            // The approved plan is run-wide and persists at the ROOT (see the
+            // persist step below), so prior-plan recovery reads the root first;
+            // the section fallback covers state written by older builds.
+            const serverCandidates = recoverServerCandidates(fullState?.approvedPlan ?? stateData.approvedPlan, allScenarios);
             // Merge by scenario-name identity, NOT the full content-hashed candidateId:
             // the server (analyze_changes) and the agent frequently draft their own
             // independent steps[] for "the same" scenario (identical scenarioName),
@@ -433,7 +456,44 @@ export function registerRegisterTestPlanTool(server) {
                     "Submit your complete candidate list (every test you would generate or recommend) in `candidates` — an empty plan would block all generation.");
                 return errorResult;
             }
+            // Review (mcp#774): enforce ONE run-wide plan at the tool boundary. A
+            // re-registration whose pool shares no scenario with the active plan
+            // is the per-repo-partial signature (the demoshop rig's second,
+            // backend-only call) — accepting it would silently REPLACE the run's
+            // plan with a subset and drop every earlier agent candidate. Genuine
+            // full-list updates overlap the active plan and replace it as before.
+            // The overlap test spans GENERATE ∪ ADDITIONAL: with maxGenerate=0 the
+            // active plan's GENERATE is empty while ADDITIONAL carries every
+            // candidate, and a disjoint partial could otherwise still replace it
+            // silently (Copilot review on #774).
+            const priorItems = [
+                ...(fullState?.approvedPlan?.generate ?? []),
+                ...(fullState?.approvedPlan?.additional ?? []),
+            ];
+            if (priorItems.length > 0) {
+                const poolKeys = new Set(allCandidates.map(mergeKey));
+                const overlaps = priorItems.some((item) => poolKeys.has(scenarioMergeKey(item.scenarioName) || item.candidateId));
+                if (!overlaps) {
+                    errorResult = toolError(`A run-wide plan is already active (${fullState.approvedPlan.planId}: ` +
+                        `${priorItems.map((i) => i.scenarioName).join(", ")}) and this submission shares none of its ` +
+                        "scenarios. skyramp_register_test_plan REPLACES the whole run's plan — resubmit ONE pooled candidate " +
+                        "list for the entire run (your previous candidates plus these changes), not a per-repo subset.");
+                    return errorResult;
+                }
+            }
             const budgetContext = resolveBudgetContext(stateData, fullState);
+            // SKYR-4204 reopen: a reserved UI slot is only fillable from the
+            // candidate pool. A pool with no UI candidate on a run with frontend
+            // changes would silently plan zero UI tests (runs 32419025266,
+            // 32431042133, 32431106864) — reject so the agent self-corrects in one
+            // step, exactly like the empty-candidates rejection above.
+            if (reservedUISlots(budgetContext) > 0 &&
+                !allCandidates.some((c) => inferScenarioType(c.scenario) === TestType.UI)) {
+                errorResult = toolError("This run has frontend changes, so the plan reserves a UI slot — but no submitted or recovered " +
+                    "candidate has testType 'ui'. Resubmit your full candidate list including at least one UI candidate " +
+                    "for the changed frontend (see uiContext.changedFrontendFiles).");
+                return errorResult;
+            }
             const result = selectPlan(allCandidates, { ...budgetContext, demotions, diffText });
             const approvedPlan = {
                 planId: crypto.randomUUID(),
@@ -442,8 +502,16 @@ export function registerRegisterTestPlanTool(server) {
                 additional: result.additional.map(buildApprovedPlanItem),
                 demotions: result.demotions,
             };
+            // The approved plan is the ONE run-wide authority (the prompt mandates
+            // a single pooled registration on multi-repo runs), so it persists at
+            // the state-file ROOT regardless of `repository`. Per-section plans
+            // blinded every root-reading consumer — planGuard let generation run
+            // unguarded, submitReportTool's reconciliation was inert, and the eval
+            // extractor saw "no plan" (SKYR-4204 reopen). writeData preserves the
+            // relatedRepos sections and the root metadata.
             try {
-                await stateManager.writeRepoData({ ...stateData, approvedPlan }, { repo: params.repository, repositoryPath, step: TOOL_NAME });
+                const { metadata: _meta, relatedRepos: _sections, ...rootData } = fullState ?? {};
+                await stateManager.writeData({ ...rootData, approvedPlan }, { step: TOOL_NAME });
             }
             catch (error) {
                 errorResult = toolError(`Failed to persist approved test plan to state file: ${error.message}. Retry this call.`);

package/build/types/TestbotReport.d.ts

@@ -14,7 +14,9 @@ export declare enum IssueFoundCategory {
 /**
  * Shape of the JSON report written by skyramp_submit_report and read by testbot
  * for rendering as Markdown. All fields mirror the corresponding Zod schemas in
- * submitReportTool.ts — keep the two in sync.
+ * submitReportTool.ts — keep the two in sync. This type describes what a READER
+ * may encounter across MCP versions; the Zod schemas define what the current
+ * producer must submit, so a field can be required on submit but optional here.
  */
 export interface TestbotReport {
     businessCaseAnalysis: string;
@@ -25,6 +27,9 @@ export interface TestbotReport {
         fileName: string;
         reasoning: string;
         description: string;
+        /** `owner/repo` attribution in multi-repo runs (SKYR-3786). Absent = the
+         *  primary repo, or a single-repo run. */
+        repository?: string;
         scenarioFile?: string;
         traceFile?: string;
         frontendTrace?: string;
@@ -53,6 +58,8 @@ export interface TestbotReport {
         status: "Pass" | "Fail" | "Skipped";
         details: string;
         videoPath?: string;
+        /** See newTestsCreated[].repository. */
+        repository?: string;
     }[];
     additionalRecommendations?: {
         testId: string;
@@ -74,11 +81,17 @@ export interface TestbotReport {
         openApiSpec?: string;
         backendTrace?: string;
         frontendTrace?: string;
+        /** See newTestsCreated[].repository. */
+        repository?: string;
     }[];
     issuesFound: {
         description: string;
         severity?: "critical" | "high" | "medium" | "low";
-        category: IssueFoundCategory;
+        /** Required by the submit_report schema since 0.3.4; absent in reports
+         *  written by older MCP versions. Readers treat absence as Bug. */
+        category?: IssueFoundCategory;
+        /** See newTestsCreated[].repository. */
+        repository?: string;
     }[];
     nextSteps: string[];
     commitMessage: string;

package/build/utils/AnalysisStateManager.d.ts

@@ -10,6 +10,18 @@ import type { ExternalTestRunRecord } from "../types/ExternalTestExecution.js";
 import type { VideoRecord } from "../types/TestExecution.js";
 export type { CandidateUiPage } from "./uiPageEnumerator.js";
 export declare function setTestsRepoDir(dir: string | undefined): void;
+/**
+ * Record the run's tests repo without ever clearing a known value.
+ *
+ * The tests repo is a RUN-scoped fact, but analyze_changes is called once per
+ * repository and only the PRIMARY call carries `testsRepoDir` — a related
+ * repo's call omits it. An unconditional set therefore wiped the primary's
+ * value on the second call of every multi-repo run, and by report time the
+ * tests repo was unknown: a UI test generated there looked unbacked by any
+ * working tree and the agent demoted it out of newTestsCreated (SKYR-4204,
+ * run 32536569467). Callers that mean to clear it use setTestsRepoDir.
+ */
+export declare function rememberTestsRepoDir(dir: string | undefined): void;
 export declare function getTestsRepoDir(): string | undefined;
 /** Filename of the run-scoped analysis state file under `runArtifactDir()`.
  *  Single-sourced so the constructor that WRITES there and `resolveRunStatePath`

package/build/utils/AnalysisStateManager.js

@@ -19,6 +19,21 @@ let _testsRepoDir;
 export function setTestsRepoDir(dir) {
     _testsRepoDir = dir;
 }
+/**
+ * Record the run's tests repo without ever clearing a known value.
+ *
+ * The tests repo is a RUN-scoped fact, but analyze_changes is called once per
+ * repository and only the PRIMARY call carries `testsRepoDir` — a related
+ * repo's call omits it. An unconditional set therefore wiped the primary's
+ * value on the second call of every multi-repo run, and by report time the
+ * tests repo was unknown: a UI test generated there looked unbacked by any
+ * working tree and the agent demoted it out of newTestsCreated (SKYR-4204,
+ * run 32536569467). Callers that mean to clear it use setTestsRepoDir.
+ */
+export function rememberTestsRepoDir(dir) {
+    if (dir)
+        _testsRepoDir = dir;
+}
 export function getTestsRepoDir() {
     return _testsRepoDir;
 }

package/build/utils/reportLanguage.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Report-language enforcement for `skyramp_submit_report` (SKYR-4185).
+ *
+ * The report language (SKYR-4023) reaches the MCP server only as a testbot
+ * prompt/resource arg, and the instruction to write free-text report fields in
+ * that language is prose the agent sometimes ignores — the customer-visible
+ * failure this module exists to close. The prompt render captures the language
+ * here (same server process serves the prompt and later handles the report
+ * tool), and the report tool rejects submissions whose free-text fields leaked
+ * back into English.
+ *
+ * Capture is fail-open by design: if the testbot prompt was never served
+ * (local/IDE flows, or a run broken enough that the agent has no instructions),
+ * the language stays unset and no report is ever falsely rejected.
+ */
+/** Capture the report language at prompt-serve time. Last render wins:
+ *  `undefined` clears any earlier capture, so a long-lived server (IDE use)
+ *  that renders a ja prompt and later an English/argless one disarms the
+ *  guardrail rather than falsely rejecting a legitimately-English report. */
+export declare function setReportLanguage(language: string | undefined): void;
+export declare function getReportLanguage(): string | undefined;
+/** Test isolation only — module state persists across tests in one process. */
+export declare function resetReportLanguage(): void;
+export declare function isEnforcedReportLanguage(language: string | undefined): language is string;
+/** English display name for a language code, falling back to the raw code when
+ *  Intl rejects it as a structurally invalid tag (e.g. "ja_JP") — the code is
+ *  ultimately caller-supplied, and a name lookup must never throw. */
+export declare function reportLanguageDisplayName(language: string): string;
+export interface ReportTextField {
+    /** Where the text came from, in the tool's input terms (e.g. "testResults[2].details"). */
+    path: string;
+    text: string;
+}
+/** Field paths whose text leaked English under an enforced report language.
+ *  Empty for non-enforced languages — unknown languages are skipped, never guessed. */
+export declare function findLanguageViolations(fields: ReportTextField[], language: string): string[];
+/** Field paths in the deliberately-lenient band: some English prose, but under
+ *  the rejection threshold (i.e. exactly one stray word at the current
+ *  MIN_PROSE_WORDS of 2). These SHIP — the guardrail accepts them so a lone
+ *  technical word ("flaky", "timeout") never blocks a report. Counted into the
+ *  submit-report analytics event so the residual leak rate is measurable
+ *  before anyone tightens the threshold. */
+export declare function findLanguageNearMisses(fields: ReportTextField[], language: string): string[];

package/build/utils/reportLanguage.js

@@ -0,0 +1,125 @@
+/**
+ * Report-language enforcement for `skyramp_submit_report` (SKYR-4185).
+ *
+ * The report language (SKYR-4023) reaches the MCP server only as a testbot
+ * prompt/resource arg, and the instruction to write free-text report fields in
+ * that language is prose the agent sometimes ignores — the customer-visible
+ * failure this module exists to close. The prompt render captures the language
+ * here (same server process serves the prompt and later handles the report
+ * tool), and the report tool rejects submissions whose free-text fields leaked
+ * back into English.
+ *
+ * Capture is fail-open by design: if the testbot prompt was never served
+ * (local/IDE flows, or a run broken enough that the agent has no instructions),
+ * the language stays unset and no report is ever falsely rejected.
+ */
+let sessionReportLanguage;
+/** Capture the report language at prompt-serve time. Last render wins:
+ *  `undefined` clears any earlier capture, so a long-lived server (IDE use)
+ *  that renders a ja prompt and later an English/argless one disarms the
+ *  guardrail rather than falsely rejecting a legitimately-English report. */
+export function setReportLanguage(language) {
+    sessionReportLanguage = language;
+}
+export function getReportLanguage() {
+    return sessionReportLanguage;
+}
+/** Test isolation only — module state persists across tests in one process. */
+export function resetReportLanguage() {
+    sessionReportLanguage = undefined;
+}
+// Languages the guardrail can enforce: detection is script-presence-based, so a
+// language is enforceable only when its expected script is disjoint from Latin.
+// English ('en') is deliberately absent — it is the default, not enforced.
+// A Map, not a plain object: the key is caller-supplied, and object indexing
+// would resolve prototype keys ("toString") to inherited members whose later
+// .test() call crashes the tool.
+const TARGET_SCRIPTS = new Map([
+    // Hiragana, Katakana (incl. halfwidth), CJK ideographs (incl. ext A / compat).
+    ["ja", /[぀-ヿ㐀-䶿一-鿿豈-﫿ｦ-ﾟ]/],
+]);
+export function isEnforcedReportLanguage(language) {
+    return language !== undefined && TARGET_SCRIPTS.has(language);
+}
+/** English display name for a language code, falling back to the raw code when
+ *  Intl rejects it as a structurally invalid tag (e.g. "ja_JP") — the code is
+ *  ultimately caller-supplied, and a name lookup must never throw. */
+export function reportLanguageDisplayName(language) {
+    try {
+        return new Intl.DisplayNames(["en"], { type: "language" }).of(language) ?? language;
+    }
+    catch {
+        return language;
+    }
+}
+// Tokens that are legitimate untranslated content in any report language — the
+// prompt's own "do NOT translate" list: enum values, HTTP verbs, test types.
+const UNTRANSLATED_WORDS = new Set([
+    // Exact enum values only. NOT "passed"/"failed" — those are ordinary English
+    // prose and are exactly what leaks in pytest summaries ("1 passed in 0.88s",
+    // "failed: count was 13"; see letsramp/api-insight#215).
+    "pass", "fail", "skipped", "error", "unknown",
+    "critical", "high", "medium", "low",
+    "get", "post", "put", "patch", "delete", "head", "options",
+    "ui", "e2e", "api", "contract", "integration", "smoke", "fuzz", "load", "mock",
+    "http", "https", "json", "yaml", "ok",
+]);
+/** A field must contain at least this many plain English prose words (after the
+ *  stripping below) to be flagged — so identifier-and-timing-only details like
+ *  "10.8s, products_contract_test.py" stay legal, and one stray word ("flaky")
+ *  never rejects a report. Two is deliberate: the shortest real leak observed
+ *  ("1 passed in 0.88s", api-insight#215) has exactly two prose words. */
+const MIN_PROSE_WORDS = 2;
+/** Count the plain English prose words in `text`, or return 0 when the target
+ *  language's script is present (the field is compliant regardless of any
+ *  English around it). Backticked spans, file names/paths, identifiers
+ *  (snake_case/camelCase/ALL-CAPS), digit-bearing tokens, and the prompt's
+ *  untranslated vocabulary are all excluded from the count. */
+function countProseWords(text, script) {
+    if (script.test(text))
+        return 0;
+    const withoutCode = text.replace(/`[^`]*`/g, " ");
+    let proseWords = 0;
+    for (const raw of withoutCode.split(/\s+/)) {
+        const token = raw.replace(/^[^A-Za-z0-9]+/, "").replace(/[^A-Za-z0-9]+$/, "");
+        // Pure alphabetic words only: anything with digits or interior punctuation
+        // (paths, file names, snake_case, versions, "10.8s") is not prose.
+        if (token.length < 2 || !/^[A-Za-z]+$/.test(token))
+            continue;
+        if (/[a-z][A-Z]/.test(token))
+            continue; // camelCase identifier
+        if (token === token.toUpperCase())
+            continue; // acronym / enum shout (GET, FAILED)
+        if (UNTRANSLATED_WORDS.has(token.toLowerCase()))
+            continue;
+        proseWords++;
+    }
+    return proseWords;
+}
+/** Field paths whose text leaked English under an enforced report language.
+ *  Empty for non-enforced languages — unknown languages are skipped, never guessed. */
+export function findLanguageViolations(fields, language) {
+    const script = TARGET_SCRIPTS.get(language);
+    if (!script)
+        return [];
+    return fields
+        .filter((f) => countProseWords(f.text, script) >= MIN_PROSE_WORDS)
+        .map((f) => f.path);
+}
+/** Field paths in the deliberately-lenient band: some English prose, but under
+ *  the rejection threshold (i.e. exactly one stray word at the current
+ *  MIN_PROSE_WORDS of 2). These SHIP — the guardrail accepts them so a lone
+ *  technical word ("flaky", "timeout") never blocks a report. Counted into the
+ *  submit-report analytics event so the residual leak rate is measurable
+ *  before anyone tightens the threshold. */
+export function findLanguageNearMisses(fields, language) {
+    const script = TARGET_SCRIPTS.get(language);
+    if (!script)
+        return [];
+    return fields
+        .filter((f) => {
+        const words = countProseWords(f.text, script);
+        return words > 0 && words < MIN_PROSE_WORDS;
+    })
+        .map((f) => f.path);
+}

package/build/utils/reportVerification.d.ts

@@ -14,6 +14,16 @@ import { DriftAction } from "../types/TestAnalysis.js";
  * `--untracked-files=all` lists each untracked file individually (otherwise git
  * collapses a brand-new directory to "dir/", which would defeat path matching).
  */
+/**
+ * Union of listChangedFiles over every tree a run legitimately writes to —
+ * the primary checkout, the tests-repo checkout (testRepoPath), and related
+ * repos (SKYR-4204 reopen: the backing check scanned only the primary, so a
+ * UI test generated into the tests-repo checkout was rejected as unbacked and
+ * demoted out of the report — run 32510028428). Undefined and duplicate roots
+ * are skipped; a root where git fails (missing dir, not a repo) contributes
+ * nothing rather than failing the whole check.
+ */
+export declare function listChangedFilesAcross(roots: Array<string | undefined>): Promise<string[]>;
 export declare function listChangedFiles(repoRoot: string): Promise<string[]>;
 export interface UnbackedClaimsInput {
     /** Absolute path of the primary repo checkout the report pertains to. */

package/build/utils/reportVerification.js

@@ -19,6 +19,37 @@ const execFileAsync = promisify(execFile);
  * `--untracked-files=all` lists each untracked file individually (otherwise git
  * collapses a brand-new directory to "dir/", which would defeat path matching).
  */
+/**
+ * Union of listChangedFiles over every tree a run legitimately writes to —
+ * the primary checkout, the tests-repo checkout (testRepoPath), and related
+ * repos (SKYR-4204 reopen: the backing check scanned only the primary, so a
+ * UI test generated into the tests-repo checkout was rejected as unbacked and
+ * demoted out of the report — run 32510028428). Undefined and duplicate roots
+ * are skipped; a root where git fails (missing dir, not a repo) contributes
+ * nothing rather than failing the whole check.
+ */
+export async function listChangedFilesAcross(roots) {
+    const seenRoots = new Set();
+    const seenFiles = new Set();
+    const files = [];
+    for (const root of roots) {
+        if (!root || seenRoots.has(root))
+            continue;
+        seenRoots.add(root);
+        try {
+            for (const f of await listChangedFiles(root)) {
+                if (seenFiles.has(f))
+                    continue;
+                seenFiles.add(f);
+                files.push(f);
+            }
+        }
+        catch {
+            // Non-git or missing tree — nothing to contribute.
+        }
+    }
+    return files;
+}
 export async function listChangedFiles(repoRoot) {
     const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd: repoRoot });
     const files = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",