@skyramp/mcp 0.3.3 → 0.3.5

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

@@ -6,10 +6,11 @@ import * as path from "path";
 import yaml from "js-yaml";
 import { simpleGit } from "simple-git";
 import { logger } from "../../utils/logger.js";
+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";
@@ -367,6 +368,14 @@ These components have no DOM presence in the running app: no route, page, or oth
 - Log an \`issuesFound\` entry (high severity) naming the unintegrated file(s) above and stating that the changed code is unreachable in the running app.
 - Backend/other work in this PR is unaffected — proceed with it normally.`;
 }
+/**
+ * Assemble the tool result. See `dualChannelResult` for why the payload is
+ * carried on both result channels.
+ */
+export function buildAnalyzeChangesResult(parts) {
+    const executionPlan = `\`\`\`json\n${parts.structuredSummary}\n\`\`\`\n\n## UI Blueprint Capture — do this BEFORE writing UI recommendation reasoning\n${parts.uiInstructions}\n\n${parts.outputText}\n\n---\n\n## Pre-built Test Catalog — Fill in placeholders from source code, then display verbatim\n⚠️ Do NOT reformat, rename sections, or generate a new catalog. Replace \`<…from source>\` values, then show this output exactly as-is, grouped by test type.\n\n${parts.recommendationPrompt}`;
+    return dualChannelResult({ executionPlan });
+}
 export function registerAnalyzeChangesTool(server) {
     server.registerTool(TOOL_NAME, {
         annotations: {
@@ -376,8 +385,14 @@ export function registerAnalyzeChangesTool(server) {
             openWorldHint: true, // may fetch PR comments from GitHub
         },
         description: `Scan repository API endpoints and discover existing tests — first step of the unified Test Health Analysis Flow. Returns a stateFile path and ranked test recommendations. Pass stateFile to skyramp_analyze_test_health and skyramp_actions.`,
-        // TODO: Replace description-embedded output format with outputSchema — structural
-        // output schema reduces token usage vs natural language in description.
+        // SKYR-4182: the payload is returned via structuredContent, which requires a
+        // declared outputSchema. This also keeps the result out of the single-line
+        // `.json` spill shape that Read cannot paginate — see buildAnalyzeChangesResult.
+        outputSchema: {
+            executionPlan: z
+                .string()
+                .describe("Analysis summary, UI blueprint capture instructions, and the ranked Execution Plan. Read and follow this field."),
+        },
         inputSchema: analyzeChangesInputSchema,
     }, async (params, extra) => {
         let errorResult;
@@ -419,12 +434,9 @@ export function registerAnalyzeChangesTool(server) {
                     logger.info("All user-changed files are non-application — skipping analysis", {
                         changedFiles: filesToCheck,
                     });
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `All ${filesToCheck.length} changed file(s) are non-application (CI/CD, docs, lock files, config). No test analysis needed for this diff.\n\nChanged files: ${filesToCheck.join(", ")}`,
-                            }],
-                    };
+                    return dualChannelResult({
+                        executionPlan: `All ${filesToCheck.length} changed file(s) are non-application (CI/CD, docs, lock files, config). No test analysis needed for this diff.\n\nChanged files: ${filesToCheck.join(", ")}`,
+                    });
                 }
             }
             // ── Step 2: Scan endpoints ──
@@ -569,22 +581,17 @@ export function registerAnalyzeChangesTool(server) {
                     logger.info("GraphQL-only diff detected — REST testing not supported", {
                         changedFiles: diffData.changedFiles,
                     });
-                    return {
-                        content: [{
-                                type: "text",
-                                text: [
-                                    "**GraphQL-only diff detected.**",
-                                    "",
-                                    "The changed files appear to be GraphQL schema, artifact, or endpoint implementation files.",
-                                    "Skyramp currently supports REST API testing only — GraphQL introspection,",
-                                    "query validation, and type-name grounding are not yet supported.",
-                                    "",
-                                    "No test recommendations can be generated for this diff.",
-                                    "",
-                                    `Changed files: ${diffData.changedFiles.join(", ")}`,
-                                ].join("\n"),
-                            }],
-                    };
+                    return dualChannelResult({ executionPlan: [
+                            "**GraphQL-only diff detected.**",
+                            "",
+                            "The changed files appear to be GraphQL schema, artifact, or endpoint implementation files.",
+                            "Skyramp currently supports REST API testing only — GraphQL introspection,",
+                            "query validation, and type-name grounding are not yet supported.",
+                            "",
+                            "No test recommendations can be generated for this diff.",
+                            "",
+                            `Changed files: ${diffData.changedFiles.join(", ")}`,
+                        ].join("\n") });
                 }
             }
             await sendProgress(50, 100, "Discovering existing tests...");
@@ -729,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,
@@ -1601,15 +1610,12 @@ export function registerAnalyzeChangesTool(server) {
                 unmatchedFiles: classifiedEndpoints?.unmatchedFiles,
                 nextTool: "skyramp_analyze_test_health",
             });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `\`\`\`json\n${structuredSummary}\n\`\`\`\n\n## UI Blueprint Capture — do this BEFORE writing UI recommendation reasoning\n${uiInstructions}\n\n${outputText}\n\n---\n\n## Pre-built Test Catalog — Fill in placeholders from source code, then display verbatim\n⚠️ Do NOT reformat, rename sections, or generate a new catalog. Replace \`<…from source>\` values, then show this output exactly as-is, grouped by test type.\n\n${recommendationPrompt}`,
-                    },
-                ],
-                isError: false,
-            };
+            return buildAnalyzeChangesResult({
+                structuredSummary,
+                uiInstructions,
+                outputText,
+                recommendationPrompt,
+            });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);

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

@@ -62,7 +62,7 @@ export function registerAnalyzeTestHealthTool(server) {
         inputSchema: {
             stateFile: z
                 .string()
-                .describe("Path to the analyze-changes-state.json file returned by skyramp_analyze_changes (the stateFile field in its output). Do NOT pass summaryOutputFile or testbot-result.txt here."),
+                .describe("Path to the analyze-changes-state.json file returned by skyramp_analyze_changes (the stateFile field in its output). Do NOT pass testbot-result.txt here."),
             blueprintCaptured: z
                 .boolean()
                 .optional()
@@ -88,10 +88,10 @@ export function registerAnalyzeTestHealthTool(server) {
                 return toolError(`State file is empty or invalid: ${args.stateFile}${args.repository ? ` (no section for repository ${args.repository})` : ""}. Call skyramp_analyze_changes first to generate a valid state file.`);
             }
             if (!repositoryPath || typeof repositoryPath !== "string") {
-                return toolError(`repositoryPath not found in state file metadata. The stateFile parameter must be the analyze-changes-state.json path returned by skyramp_analyze_changes — not summaryOutputFile or testbot-result.txt. Re-run skyramp_analyze_changes to regenerate it.`);
+                return toolError(`repositoryPath not found in state file metadata. The stateFile parameter must be the analyze-changes-state.json path returned by skyramp_analyze_changes — not testbot-result.txt. Re-run skyramp_analyze_changes to regenerate it.`);
             }
             if (!Array.isArray(stateData.existingTests)) {
-                return toolError(`stateFile does not contain test discovery data (existingTests missing). The stateFile parameter must be the analyze-changes-state.json path returned by skyramp_analyze_changes — not summaryOutputFile or testbot-result.txt.`);
+                return toolError(`stateFile does not contain test discovery data (existingTests missing). The stateFile parameter must be the analyze-changes-state.json path returned by skyramp_analyze_changes — not testbot-result.txt.`);
             }
             // External tests: UPDATE only — REGENERATE/DELETE are report-only (enforced in
             // skyramp_actions). Already scoped to relevant ones by discovery.

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([])
@@ -128,38 +132,57 @@ function toDraftedScenario(input) {
         testType: input.testType,
     };
 }
-/** Build the agent-submitted candidates, running discriminator verification
- *  against the persisted diff text. Failed claims demote (never reject). */
-function buildAgentCandidates(candidates, diffText) {
-    const demotions = [];
-    const built = candidates.map((input) => {
+/** Build the agent-submitted candidates. Discriminator claims are verified
+ *  later, by {@link applyDiscriminatorClaims}, once the merge has settled which
+ *  scenario each name resolves to. */
+function buildAgentCandidates(candidates) {
+    return candidates.map((input) => {
         const scenario = toDraftedScenario(input);
-        const candidateId = computeCandidateId(scenario);
-        let verifiedDiscriminator;
-        if (input.discriminator) {
-            const claim = input.discriminator;
-            const result = validateDiscriminator(scenario, claim, diffText);
-            if (result.verified) {
-                verifiedDiscriminator = claim.kind;
-            }
-            else {
-                demotions.push({
-                    candidateId,
-                    reason: result.reason ?? `${claim.kind} discriminator claim could not be verified.`,
-                });
-            }
-        }
-        const candidate = {
+        return {
             scenario,
             priority: derivePriorityTier(scenario),
             novelty: Novelty.NEW,
             source: CandidateSource.AGENT,
-            candidateId,
-            ...(verifiedDiscriminator ? { verifiedDiscriminator } : {}),
+            candidateId: computeCandidateId(scenario),
         };
-        return candidate;
     });
-    return { candidates: built, demotions };
+}
+/**
+ * Verify each declared discriminator against the candidate that actually won
+ * the merge, and mark it. Failed claims demote (never reject).
+ *
+ * Runs AFTER the merge, not while building the agent's candidates: a server
+ * pre-seeded candidate wins the name, so verifying the agent's copy first
+ * attaches the result to a candidate that is about to be discarded — silently
+ * stripping the verification. Verification is against the WINNER's
+ * steps, so a claim that only held for the agent's rewrite is correctly refused
+ * rather than carried across.
+ *
+ * The marker is cleared before the current claim is applied. Each call replaces
+ * the agent's previous submission (see the `candidates` schema), and
+ * recoverServerCandidates restores whatever the LAST plan recorded — so keeping
+ * it would let a boost earned by an earlier registration outlive the claim that
+ * earned it, on a submission that no longer makes that claim or whose new claim
+ * fails.
+ */
+function applyDiscriminatorClaims(candidates, claimsByKey, diffText, reposWithoutDiff = []) {
+    const demotions = [];
+    const marked = candidates.map((candidate) => {
+        const { verifiedDiscriminator: _stale, ...unmarked } = candidate;
+        const claim = claimsByKey.get(scenarioMergeKey(candidate.scenario.scenarioName) || candidate.candidateId);
+        if (!claim)
+            return unmarked;
+        const result = validateDiscriminator(candidate.scenario, claim, diffText, reposWithoutDiff);
+        if (result.verified) {
+            return { ...unmarked, verifiedDiscriminator: claim.kind };
+        }
+        demotions.push({
+            candidateId: candidate.candidateId,
+            reason: result.reason ?? `${claim.kind} discriminator claim could not be verified.`,
+        });
+        return unmarked;
+    });
+    return { candidates: marked, demotions };
 }
 /** Recover full Candidates for pre-seeded ("server") plan items by matching
  *  candidateId back to the analyzed scenarios (repositoryAnalysis.scenarios) —
@@ -190,15 +213,54 @@ function recoverServerCandidates(priorPlan, allScenarios) {
     }
     return recovered;
 }
-function resolveBudgetContext(stateData) {
+/** Whether a repo section's persisted diff classification contains any new,
+ *  modified, or removed endpoint — the same signal `computeScoredCandidates`
+ *  derives `hasApiChanges` from at analyze time. */
+function sectionHasApiChanges(data) {
+    const diff = data?.repositoryAnalysis?.diff;
+    return ((diff?.newEndpoints?.length ?? 0) > 0 ||
+        (diff?.modifiedEndpoints?.length ?? 0) > 0 ||
+        (diff?.removedEndpoints?.length ?? 0) > 0);
+}
+function resolveBudgetContext(stateData, fullState) {
     const pbc = stateData.planBudgetContext;
-    return {
+    const base = {
         maxGenerate: pbc?.maxGenerate ?? MAX_TESTS_TO_GENERATE,
         maxTotal: pbc?.maxTotal ?? MAX_RECOMMENDATIONS,
         isUIOnlyPR: pbc?.isUIOnlyPR ?? false,
         hasFrontendChanges: pbc?.hasFrontendChanges ?? false,
         externalCoverage: new Set(pbc?.externalCoverageKeys ?? []),
     };
+    const relatedSections = Object.values(fullState?.relatedRepos ?? {}).map((section) => section.data);
+    if (relatedSections.length === 0)
+        return base;
+    // SKYR-4204: isUIOnlyPR/hasFrontendChanges are per-SECTION facts — each
+    // analyze call computes them from its own repo's diff. The approved plan is
+    // one run-wide decision, so a frontend-only PRIMARY diff must not put the
+    // budgeter on its all-UI branch (backendGenerateCount() = 0) while a related
+    // repo carries endpoint changes; that pinned GENERATE to UI placeholders and
+    // left every API candidate in ADDITIONAL regardless of maxGenerate. Derive
+    // the flags across ALL sections. A related repo checked out on its default
+    // branch classifies no endpoint changes, so it leaves a UI-only run UI-only.
+    // Budget numbers come from the root (primary) section: the testbot prompt
+    // passes topN/maxGenerate only to the primary analyze call, so related
+    // sections carry defaults.
+    const sections = [fullState ?? undefined, ...relatedSections];
+    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,
+    };
 }
 function describeGenerationCall(item) {
     switch (item.testType) {
@@ -306,20 +368,52 @@ 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;
             }
-            const diffText = stateData.diffText ?? "";
-            const allScenarios = stateData.repositoryAnalysis?.scenarios ?? [];
-            const { candidates: agentCandidates, demotions } = buildAgentCandidates(params.candidates ?? [], diffText);
-            const serverCandidates = recoverServerCandidates(stateData.approvedPlan, allScenarios);
+            // SKYR-4203: one register call carries candidates for EVERY repo of the
+            // run, but `stateData` is a single repo's section — and the candidate
+            // schema has no per-candidate repository, so a related repo's anchors
+            // were unverifiable by construction. Verify anchors (and rank diff-hunk
+            // proximity) against the union of ALL sections' diffs: an anchor
+            // grounded in a related repo's change is as real as one in the
+            // primary's. Sections with no diff (a related repo checked out on its
+            // default branch) are collected so an unmatched anchor reads as
+            // uncheckable rather than ungrounded.
+            const fullState = await stateManager.readFullState();
+            const diffSections = [
+                { repo: fullState?.metadata?.repository ?? "the primary repository", diff: fullState?.diffText },
+                ...Object.entries(fullState?.relatedRepos ?? {}).map(([repo, section]) => ({
+                    repo,
+                    diff: section.data?.diffText,
+                })),
+            ];
+            const diffText = diffSections.map((s) => s.diff).filter(Boolean).join("\n");
+            const reposWithoutDiff = diffSections.filter((s) => !s.diff).map((s) => s.repo);
+            // 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 ?? []);
+            // 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),
@@ -341,7 +435,18 @@ export function registerRegisterTestPlanTool(server) {
                 merged.set(mergeKey(candidate), candidate);
             for (const candidate of serverCandidates)
                 merged.set(mergeKey(candidate), candidate);
-            const allCandidates = [...merged.values()];
+            // The agent declares a claim per scenario NAME, so key the claims the
+            // same way the merge does and verify against whichever copy survived.
+            const claimsByKey = new Map();
+            // Keyed through mergeKey, not scenarioMergeKey alone: a name that
+            // slugifies to nothing (e.g. an all-non-ASCII name) would be stored
+            // under "" while the lookup falls back to the candidateId, so the claim
+            // would be neither verified nor demoted.
+            (params.candidates ?? []).forEach((input, i) => {
+                if (input.discriminator)
+                    claimsByKey.set(mergeKey(agentCandidates[i]), input.discriminator);
+            });
+            const { candidates: allCandidates, demotions } = applyDiscriminatorClaims([...merged.values()], claimsByKey, diffText, reposWithoutDiff);
             // An empty union would persist an authoritative plan with an empty
             // GENERATE list, which the generation gate then enforces — bricking
             // the run until re-registration. Reject instead so the agent can
@@ -351,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;
             }
-            const budgetContext = resolveBudgetContext(stateData);
+            // 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(),
@@ -360,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/TestExecution.d.ts

@@ -26,6 +26,20 @@ export interface TestExecutionResult extends TestExecutionData {
     testFile: string;
     videoPath?: string;
 }
+/**
+ * One browser execution's recorded video, as persisted in run state by
+ * skyramp_execute_test and read back by skyramp_submit_report (SKYR-4156).
+ *
+ * `status`/`executedAt` are not rendered in the report — they identify WHICH
+ * execution the referenced recording belongs to, which matters because a retried
+ * test leaves a video directory behind for every attempt.
+ */
+export interface VideoRecord {
+    /** Host path to the recorded video.webm. */
+    videoPath: string;
+    status: TestExecutionStatus;
+    executedAt: string;
+}
 export interface BatchExecutionResult {
     totalTests: number;
     passed: number;

package/build/types/TestTypes.js

@@ -216,8 +216,9 @@ export const baseTestSchema = {
         .string()
         .default("")
         .describe("MUST be string of comma separated values like 'id=1,name=John' for URL query parameters. "
-        + "Workspace-configured api.defaultQueryParams (if set) are merged in automatically — "
-        + "no need to repeat them here. An explicit value for the same key here overrides the workspace default."),
+        + "Workspace-configured api.defaultQueryParams (if set) are merged in automatically, with any "
+        + "api.queryParamOverrides entry whose pathPattern matches this endpoint layered on top — "
+        + "no need to repeat them here. An explicit value for the same key here overrides both."),
     formParams: z
         .string()
         .default("")

package/build/types/TestbotPromptOptions.d.ts

@@ -16,7 +16,6 @@ export interface RelatedRepository {
 export interface TestbotPromptOptions {
     prTitle: string;
     prDescription: string;
-    summaryOutputFile: string;
     repositoryPath: string;
     baseBranch?: string;
     maxRecommendations?: number;

package/build/types/TestbotReport.d.ts

@@ -2,10 +2,21 @@ import type { DriftAction } from "./TestAnalysis.js";
 import type { TestExecutionStatus } from "./TestExecution.js";
 import type { HttpMethod, TestType } from "./TestTypes.js";
 import type { ReuseOutcome } from "./ReuseOutcome.js";
+/** Classification of an issuesFound entry. Bug is a product/code defect; the
+ *  other values are tooling noise that the Testbot report renders in its
+ *  Configuration Errors section instead of Issues Found. */
+export declare enum IssueFoundCategory {
+    Bug = "bug",
+    Lint = "lint",
+    Type = "type",
+    Config = "config"
+}
 /**
  * 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;
@@ -16,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;
@@ -44,6 +58,8 @@ export interface TestbotReport {
         status: "Pass" | "Fail" | "Skipped";
         details: string;
         videoPath?: string;
+        /** See newTestsCreated[].repository. */
+        repository?: string;
     }[];
     additionalRecommendations?: {
         testId: string;
@@ -65,10 +81,17 @@ export interface TestbotReport {
         openApiSpec?: string;
         backendTrace?: string;
         frontendTrace?: string;
+        /** See newTestsCreated[].repository. */
+        repository?: string;
     }[];
     issuesFound: {
         description: string;
         severity?: "critical" | "high" | "medium" | "low";
+        /** 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/types/TestbotReport.js

@@ -1 +1,10 @@
-export {};
+/** Classification of an issuesFound entry. Bug is a product/code defect; the
+ *  other values are tooling noise that the Testbot report renders in its
+ *  Configuration Errors section instead of Issues Found. */
+export var IssueFoundCategory;
+(function (IssueFoundCategory) {
+    IssueFoundCategory["Bug"] = "bug";
+    IssueFoundCategory["Lint"] = "lint";
+    IssueFoundCategory["Type"] = "type";
+    IssueFoundCategory["Config"] = "config";
+})(IssueFoundCategory || (IssueFoundCategory = {}));

package/build/types/index.d.ts

@@ -2,6 +2,7 @@ export { TestExecutionStatus } from "./TestExecution.js";
 export { DriftAction } from "./TestAnalysis.js";
 export { TestType, HttpMethod } from "./TestTypes.js";
 export type { TestbotReport } from "./TestbotReport.js";
+export { IssueFoundCategory } from "./TestbotReport.js";
 export { ReuseDeclinedBy, ReuseVerificationOutcome } from "./ReuseOutcome.js";
 export type { ReuseOutcome, ReuseSkippedEntry } from "./ReuseOutcome.js";
 export type { RelatedRepository, TestbotPromptOptions, } from "./TestbotPromptOptions.js";

package/build/types/index.js

@@ -1,4 +1,5 @@
 export { TestExecutionStatus } from "./TestExecution.js";
 export { DriftAction } from "./TestAnalysis.js";
 export { TestType, HttpMethod } from "./TestTypes.js";
+export { IssueFoundCategory } from "./TestbotReport.js";
 export { ReuseDeclinedBy, ReuseVerificationOutcome } from "./ReuseOutcome.js";