@skyramp/mcp 0.4.3 → 0.4.4-rc.1

package/build/tools/submitReportTool.js

@@ -5,15 +5,17 @@ import { constants as fsConstants } from "fs";
 import * as path from "path";
 import { AnalyticsService } from "../services/AnalyticsService.js";
 import { SCENARIO_CATEGORIES, categoryExpectsRed, } from "../types/TestRecommendation.js";
-import { TESTBOT_SUPPORTED_TEST_TYPES, TestType } from "../types/TestTypes.js";
+import { ProgrammingLanguage, TESTBOT_SUPPORTED_TEST_TYPES, TestType, } from "../types/TestTypes.js";
 import { STEP_METHOD_DESCRIPTION, stepMethodSchema, } from "../types/StepMethod.js";
 import { DriftAction } from "../types/TestAnalysis.js";
-import { TestExecutionStatus } from "../types/TestExecution.js";
+import { isResult, TestExecutionStatus } from "../types/TestExecution.js";
 import { IssueFoundCategory } from "../types/TestbotReport.js";
 import { StateManager, runArtifactDir, getTestsRepoDir, resolveOwnRunStatePath, } from "../utils/AnalysisStateManager.js";
 import { toolError, testFileMatches } from "../utils/utils.js";
 import { isTestbotEnabled, isUtilsReuseEnabled, } from "../utils/featureFlags.js";
-import { answerFor, unknownAnswerObjections, } from "../recommendation/answers.js";
+import { BLOCKER_DESCRIPTION, closingAnswerFor, needsBlocker, REFUSED_ANSWER_PREFIX, refusedAnswerObjections, unknownAnswerObjections, } from "../recommendation/answers.js";
+import { blockersIn, probeBlockers } from "../recommendation/blockerProbes.js";
+import { blockerSchema, blockerText, hasBlocker, refutedEvidence, verifyBlocker, } from "../recommendation/blockers.js";
 import { checkDeliveredMatchesPlan, checkMaintenanceDelivered, } from "../recommendation/verifiers/deliveredMatchesPlan.js";
 import { checkReportedCategoryMatchesPlan, checkRequirementConflictReported, } from "../recommendation/verifiers/reportedCategory.js";
 import { checkDefectsReported, checkIssueTraceability, } from "../recommendation/verifiers/issueTraceability.js";
@@ -79,6 +81,28 @@ function rowsLeavingCoverage(rows) {
         MAINTENANCE_COVERAGE_ACTIONS.has(row.action) &&
         row?.reportOnly !== true);
 }
+/** The VERIFY rows this run owes one run: the test is read, not edited, so its
+ *  only run is the one after the edits. */
+function verifyRows(rows) {
+    return (rows ?? []).filter((row) => row?.action === DriftAction.Verify && row?.reportOnly !== true);
+}
+/** The rows that back a `maintains` claim: an edit this run made, or a VERIFY
+ *  whose test this server ran after the edits to a result. A VERIFY that never
+ *  ran, or whose run left only the Unknown reservation, backs nothing. In the
+ *  plan-only lane nothing runs, so a VERIFY backs the claim without a run. */
+function rowsBackingMaintains(rows, executions, planOnly) {
+    return [
+        ...rowsLeavingCoverage(rows),
+        ...verifyRows(rows).filter((row) => {
+            if (planOnly)
+                return true;
+            if (typeof row.testFilePath !== "string")
+                return false;
+            const run = executions?.[canonicalTestPath(row.testFilePath)];
+            return (run?.phase === "after" && isResult(run.status));
+        }),
+    ];
+}
 /** Objection ids for an untested declared change, `coverage:change:<id>`. The
  *  change table reads the agent's answer back off them. */
 const CHANGE_OBJECTION_PREFIX = "coverage:change:";
@@ -350,7 +374,7 @@ const issueFoundSchema = z
         .optional()
         .describe("The `id` of the plan defect this issue reports, from the `defects` list you registered with skyramp_register_test_plan. Spell it as that list spells it: an id the plan does not declare traces nothing. " +
         "Set it on the `category: bug` entry that reports the defect. A `defectId` on a `lint`, `type` or `config` entry does not report the defect — the report renders those in its own Configuration Errors section. " +
-        "CHECKED: every plan defect has a `bug` issue that names it, and a `bug` entry with no `plannedTestId` traces through this defect when a delivered test that expects to fail cites it, when a `maintains` entry you registered cites it, or when you answered `defects:untested:<id>` at plan time. Leave it out for an issue the plan did not declare."),
+        "CHECKED: every plan defect has a `bug` issue that names it, and a `bug` entry with no `plannedTestId` traces through this defect when a delivered test that expects to fail cites it, or when a `maintains` entry you registered cites it. Leave it out for an issue the plan did not declare."),
     sourceFile: citationString.describe("Path of the application file whose code is missing or wrong, relative to the repository root (e.g. 'src/crud/products.py'). " +
         "REQUIRED when category is 'bug'. " +
         "For code that is MISSING — an unmounted router, an unregistered route, an import never added — name the file where the line should be, not the file that defines what is unmounted. " +
@@ -1217,6 +1241,9 @@ async function pathExists(file) {
  *  missing timestamp on either side falls back to "a run is a run", which is the
  *  behaviour before this and never invents an objection. */
 function runOfWhatWasWritten(file) {
+    if (file.how === "verified")
+        return (file.recordedPhase === "after" &&
+            file.recordedStatus !== TestExecutionStatus.Unknown);
     if (file.how === "updated")
         return file.recordedPhase === "after";
     if (file.recordedPhase === undefined)
@@ -1229,7 +1256,8 @@ function runOfWhatWasWritten(file) {
         return true;
     return ran >= wrote;
 }
-/** Every test file this run wrote has an execution this server performed.
+/** Every test file this run wrote, and every VERIFY file it read, has an
+ *  execution this server performed.
  *
  *  Informational, like every check here: it surfaces the gap for a person to read
  *  and the agent can answer it. The agent is not blocked — a hard ban on running a
@@ -1257,9 +1285,11 @@ function checkEveryWrittenTestRan(written) {
         // drove itself is not visible here.
         message: file.how === "generated"
             ? "This run generated this test file, and this server recorded no run of it after it was written."
-            : file.recordedPhase === "before"
-                ? "This run edited this test file, and the only run of it this server recorded is from before the edit."
-                : "This run edited this test file, and this server recorded no run of it.",
+            : file.how === "verified"
+                ? "This run marked this test file VERIFY, and this server recorded no run of it after the edits."
+                : file.recordedPhase === "before"
+                    ? "This run edited this test file, and the only run of it this server recorded is from before the edit."
+                    : "This run edited this test file, and this server recorded no run of it.",
         evidence: file.recordedPhase === "before"
             ? `${file.file} — the only recorded skyramp_execute_test run of this file is the pre-edit baseline`
             : file.how === "generated" && file.recordedPhase !== undefined
@@ -1382,11 +1412,12 @@ export function registerSubmitReportTool(server) {
                 answer: z
                     .string()
                     .describe("Why the objection does not apply, or what you decided instead. A blank or whitespace-only answer closes nothing and the objection stays open."),
+                blocker: blockerSchema.optional().describe(BLOCKER_DESCRIPTION),
             })
                 .strict())
                 .optional()
                 .default([])
-                .describe("One answer per check that objected to your previous call and that you do not intend to fix. An answered objection is published with your answer beside it and no longer counted open; an unanswered one is published on its own. Answers persist across calls, so an id answered once stays answered. There is no call limit."),
+                .describe("One answer per check that objected to your previous call and that you do not intend to fix. An answered objection is published with your answer beside it and no longer counted open; an unanswered one is published on its own. An objection about a bug with no test is the exception: it closes only when the answer also sets `blocker`, and a sentence on its own leaves it open and published. Answers persist across calls, so an id answered once stays answered — with the blocker it carried. There is no call limit."),
             stateFile: z
                 .string()
                 .optional()
@@ -2195,9 +2226,10 @@ export function registerSubmitReportTool(server) {
         // Every file this run wrote, from the server's own records — one canonical
         // absolute path each, which is also the key an execution is recorded under.
         // Generated files come from the generators; edited files from the maintenance
-        // triage, narrowed by `rowsLeavingCoverage` to UPDATE and REGENERATE. The rest
-        // cannot be run: DELETE removed the file, VERIFY and IGNORE never edited one,
-        // and a `reportOnly` row only advised a change this run did not make.
+        // triage, narrowed by `rowsLeavingCoverage` to UPDATE and REGENERATE. A VERIFY
+        // file was not written but owes the same after-edit run. The rest owe none:
+        // DELETE removed the file, IGNORE never touched one, and a `reportOnly` row
+        // only advised a change this run did not make.
         //
         // A verdict names the SPEC, never `pomFile`: a POM-backed row edits the page
         // object, but the execution is recorded against the spec.
@@ -2232,6 +2264,23 @@ export function registerSubmitReportTool(server) {
                     filesWritten.set(key, "updated");
             }
         }
+        // A VERIFY file is not written, but owes the same after-edit run
+        // (SKYR-4523). Primary only: the server turns every edit to a related
+        // repository's test into a VERIFY the agent never chose. A language
+        // skyramp_execute_test does not accept can never record a run.
+        const runnableLanguages = Object.values(ProgrammingLanguage);
+        for (const verdict of verifyRows(stateData.maintenanceVerdicts)) {
+            const raw = verdict.testFilePath?.trim();
+            if (!raw)
+                continue;
+            const key = canonicalTestPath(raw);
+            const row = stateData.existingTests?.find((t) => canonicalTestPath(t.testFile) === key);
+            // An uncatalogued file has no row for its result to land on.
+            if (!row || !runnableLanguages.includes(row.language))
+                continue;
+            if (!filesWritten.has(key) && !deletedPaths.has(key))
+                filesWritten.set(key, "verified");
+        }
         // The LATEST run of each file, because a re-run replaces the record. An edited
         // file needs a run of the edit, so its pre-edit baseline does not answer for
         // it — `phase` is what tells the two apart. A generated file has no baseline,
@@ -2240,6 +2289,7 @@ export function registerSubmitReportTool(server) {
             file,
             {
                 phase: String(record?.phase ?? ""),
+                status: String(record?.status ?? ""),
                 executedAt: String(record?.executedAt ?? ""),
             },
         ])));
@@ -2256,6 +2306,7 @@ export function registerSubmitReportTool(server) {
                 file,
                 how,
                 recordedPhase: run?.phase,
+                recordedStatus: run?.status,
                 executedAt: run?.executedAt,
                 generatedAt: generatedAt.get(file),
             });
@@ -2265,6 +2316,7 @@ export function registerSubmitReportTool(server) {
         const executionCoverage = {
             generated: written.filter((f) => f.how === "generated").length,
             updated: written.filter((f) => f.how === "updated").length,
+            verified: written.filter((f) => f.how === "verified").length,
             executed: written.filter(runOfWhatWasWritten).length,
         };
         // A skipped test is not an execution. Refuse before writing a report so the
@@ -2423,10 +2475,11 @@ export function registerSubmitReportTool(server) {
                 }, dedupedNewTests, params.testResults, params.issuesFound ?? [], isPlanOnlyMode(), 
             // The triage's own verdicts, not this tool's input, so the join is against
             // what the run is recorded as having edited — and only the rows that left a
-            // test standing and were actually applied, so a no-op assessment, a deletion
-            // or a report-only recommendation cannot corroborate. The verdicts rather
-            // than the published rows because `reportOnly` lives here.
-            rowsLeavingCoverage(stateData.maintenanceVerdicts));
+            // test standing and were actually applied, or a VERIFY whose test ran after
+            // the edits — so an unrun assessment, a deletion or a report-only
+            // recommendation cannot corroborate. The verdicts rather than the
+            // published rows because `reportOnly` lives here.
+            rowsBackingMaintains(stateData.maintenanceVerdicts, stateData.testExecutions, isPlanOnlyMode()));
             // Read defensively, like the crash-contained checks above: the plan comes
             // off disk, so its declared array type holds only on the validated path.
             const stillOpen = Array.isArray(stateData.plan?.openObjections)
@@ -2460,6 +2513,14 @@ export function registerSubmitReportTool(server) {
                 typeof entry?.answer === "string" &&
                 entry.answer.trim().length > 0);
             const carriedByKey = new Map(carried.map((entry) => [answerKey(entry.objection), entry]));
+            // Probed here for the same reason the plan tool probes before building its
+            // context: the checks below are synchronous. Both this call's blockers and
+            // the carried ones, so a carried close is re-judged rather than trusted.
+            const blockerChecks = await probeBlockers([
+                ...blockersIn(acknowledged),
+                ...blockersIn(carried),
+            ]);
+            const judge = (blocker) => verifyBlocker(blocker, blockerChecks);
             // What the LAST call raised. Without it there is nothing to notice a
             // fixed objection's absence against.
             const previouslyRaised = (Array.isArray(stateData.reportObjections?.raisedObjections)
@@ -2486,12 +2547,35 @@ export function registerSubmitReportTool(server) {
                 ...raised,
                 ...previouslyRaised.map((entry) => entry.objection),
             ];
+            const raisedKeys = new Set(raised.map(answerKey));
             const reportStageObjections = [
                 ...raised,
                 ...unknownAnswerObjections(answerable, acknowledged, {
                     scope: "this run raised",
                     suggestion: "Answer only the ids this tool has listed on this run. A plan-time objection is answered through skyramp_register_test_plan's own answers, not here.",
                 }),
+                // The same refusal plan time raises: a sentence sent for an objection that
+                // takes a blocker leaves that objection open, and this says so rather than
+                // letting the answer pass in silence. Against this call's answers only,
+                // like `registerPlan` — a carried one that closed nothing simply stays
+                // carried, and its objection stays published open.
+                ...refusedAnswerObjections(raised, acknowledged, judge, (id) => 
+                // The same rule the loop below applies to a carried answer. Without
+                // it a second, weaker answer for an objection an earlier call already
+                // closed raised `answers:refused:` beside the close this call still
+                // publishes as answered. Matched by id AND message, as `carriedByKey`
+                // is: one id can name a different bug on a later call, and a close
+                // carried for the first must not silence a refusal for the second.
+                carried.some((entry) => {
+                    if (entry.objection?.objectionId !== id)
+                        return false;
+                    if (!raisedKeys.has(answerKey(entry.objection)))
+                        return false;
+                    const blocker = hasBlocker(entry.blocker)
+                        ? entry.blocker
+                        : undefined;
+                    return (!needsBlocker(id) || (!!blocker && judge(blocker) !== "refuted"));
+                })),
             ];
             const raisedNow = new Set(reportStageObjections.map(answerKey));
             // A call with no execution result gives these checks nothing to judge, so
@@ -2521,12 +2605,57 @@ export function registerSubmitReportTool(server) {
             const answeredReportObjections = [];
             const openReportObjections = [];
             for (const objection of reportStageObjections) {
-                const answer = answerFor(objection, acknowledged) ??
-                    carriedByKey.get(answerKey(objection))?.answer;
-                if (answer)
-                    answeredReportObjections.push({ objection, answer });
-                else
+                // `closingAnswerFor` applies the blocker rule to THIS call's answers. A
+                // carried answer was accepted on an earlier call and is re-checked against
+                // the same rule here, because the objection it closed is recomputed every
+                // call. The answer and the blocker come from the ONE entry that closed it:
+                // searching for the blocker apart from the answer published the first
+                // blocker sent, refuted or belonging to no answer at all.
+                const wantsBlocker = needsBlocker(objection.objectionId);
+                const closingNow = closingAnswerFor(objection, acknowledged, judge);
+                const blockerNow = hasBlocker(closingNow?.blocker)
+                    ? closingNow.blocker
+                    : undefined;
+                const carriedEntry = carriedByKey.get(answerKey(objection));
+                const carriedBlocker = hasBlocker(carriedEntry?.blocker)
+                    ? carriedEntry?.blocker
+                    : undefined;
+                const answerNow = closingNow?.answer;
+                // A carried answer meets the same rule as the call that sent it: a
+                // blocker, and one this call's probe does not refute.
+                const carriedCloses = carriedEntry &&
+                    (!wantsBlocker ||
+                        (!!carriedBlocker && judge(carriedBlocker) !== "refuted"));
+                const answer = answerNow ?? (carriedCloses ? carriedEntry?.answer : undefined);
+                if (!answer) {
                     openReportObjections.push(objection);
+                    // A carried answer that closed this objection on an earlier call and
+                    // does not now is the probe changing its mind — the service came back
+                    // up. Without this the objection simply reappears with no reason.
+                    if (carriedEntry &&
+                        carriedBlocker &&
+                        judge(carriedBlocker) === "refuted") {
+                        openReportObjections.push({
+                            objectionId: `${REFUSED_ANSWER_PREFIX}${objection.objectionId}`,
+                            verifier: "answers",
+                            message: "The server checked the blocker this answer names and found the opposite, so the objection stays open.",
+                            evidence: `answered "${objection.objectionId}" on an earlier call with \`${carriedBlocker.kind}\`; ${refutedEvidence(carriedBlocker)}`,
+                            suggestion: "Write the test: what you named as the blocker is not in the way. If something else is, send the blocker that names it — the server checks each kind against the run it can see.",
+                        });
+                    }
+                    continue;
+                }
+                // A refuted blocker is not published, as at plan time: on an objection any
+                // answer closes, the sentence closes it and the untrue claim is dropped.
+                const sent = answerNow ? blockerNow : carriedBlocker;
+                const blocker = sent && judge(sent) !== "refuted" ? sent : undefined;
+                answeredReportObjections.push({
+                    objection,
+                    answer,
+                    ...(blocker
+                        ? { blocker, blockerVerified: judge(blocker) === "verified" }
+                        : {}),
+                });
             }
             objections = [
                 ...stillOpen.map((objection) => ({
@@ -2539,6 +2668,16 @@ export function registerSubmitReportTool(server) {
                     ...entry.objection,
                     stage: "plan",
                     answer: typeof entry.answer === "string" ? entry.answer : "",
+                    // A plan-time close that a blocker carried says so here, exactly as
+                    // the post-execution closes below do. Without this a probed close
+                    // was published as an ordinary sentence and the report lost the one
+                    // fact that distinguishes them.
+                    ...(hasBlocker(entry.blocker)
+                        ? {
+                            unverifiedBlocker: blockerText(entry.blocker),
+                            blockerVerified: !!entry.blockerVerified,
+                        }
+                        : {}),
                 })),
                 ...unverified
                     .filter((entry) => entry?.objection)
@@ -2546,16 +2685,29 @@ export function registerSubmitReportTool(server) {
                     ...entry.objection,
                     stage: "plan",
                     answer: typeof entry.answer === "string" ? entry.answer : "",
-                    unverifiedBlocker: typeof entry.blocker === "string" ? entry.blocker : "",
+                    // `unverifiedCloses[].blocker` is a `PlanBlocker`; reading it as a
+                    // string published an empty one on every plan-time close.
+                    ...(hasBlocker(entry.blocker)
+                        ? { unverifiedBlocker: blockerText(entry.blocker) }
+                        : {}),
                 })),
                 ...openReportObjections.map((objection) => ({
                     ...objection,
                     stage: "post-execution",
                 })),
-                ...answeredReportObjections.map(({ objection, answer }) => ({
+                // The blocker is published beside the answer exactly as the plan-time
+                // closes above are, and `blockerVerified` says whether a probe backed it
+                // or the server could only take it as given.
+                ...answeredReportObjections.map(({ objection, answer, blocker, blockerVerified }) => ({
                     ...objection,
                     stage: "post-execution",
                     answer,
+                    ...(blocker
+                        ? {
+                            unverifiedBlocker: blockerText(blocker),
+                            blockerVerified: !!blockerVerified,
+                        }
+                        : {}),
                 })),
                 ...resolvedObjections.map(({ objection, resolvedBy }) => ({
                     ...objection,
@@ -2593,10 +2745,10 @@ export function registerSubmitReportTool(server) {
                 //
                 // `testFileMatches` rather than a basename, so a spec under one directory
                 // cannot lend its coverage to a same-named spec under another; and only the
-                // rows that left a test standing, so DELETE and the no-op actions cannot
-                // corroborate a claim that an existing test covers the change.
+                // rows `rowsBackingMaintains` keeps, so DELETE, IGNORE and an unrun VERIFY
+                // cannot corroborate a claim that an existing test covers the change.
                 const editedPaths = [];
-                for (const row of rowsLeavingCoverage(stateData.maintenanceVerdicts)) {
+                for (const row of rowsBackingMaintains(stateData.maintenanceVerdicts, stateData.testExecutions, isPlanOnlyMode())) {
                     for (const full of [
                         row?.testFilePath,
                         row?.pomFile,

package/build/tools/test-management/registerTestPlanTool.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StateManager, UnifiedAnalysisState } from "../../utils/AnalysisStateManager.js";
-import { PlanResult } from "../../recommendation/registerPlan.js";
-import { ObjectionAnswer, PlanChange, PlanDefect, PlanInput, PlanMaintenance, VerifyContext } from "../../recommendation/types.js";
+import { Plan, PlanResult } from "../../recommendation/registerPlan.js";
+import { ObjectionAnswer, PlanBlocker, PlanChange, PlanDefect, PlanInput, PlanMaintenance, VerifyContext } from "../../recommendation/types.js";
 /** The whole run's state file: the primary repository at the root, every related
  *  repository under `relatedRepos`. */
 type RunState = Awaited<ReturnType<StateManager<UnifiedAnalysisState>["readFullState"]>>;
@@ -72,9 +72,9 @@ export declare const declarationFieldsSchema: z.ZodObject<{
             widgetType: z.ZodOptional<z.ZodEnum<["native", "custom", "unknown"]>>;
         }, "strip", z.ZodTypeAny, {
             role: string;
-            accessibleName: string;
             testId: string | null;
             stableId: string | null;
+            accessibleName: string;
             contextText: string[] | null;
             mutability?: "unknown" | "mutable" | "immutable" | undefined;
             widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -90,9 +90,9 @@ export declare const declarationFieldsSchema: z.ZodObject<{
     }, "strict", z.ZodTypeAny, {
         items?: {
             role: string;
-            accessibleName: string;
             testId: string | null;
             stableId: string | null;
+            accessibleName: string;
             contextText: string[] | null;
             mutability?: "unknown" | "mutable" | "immutable" | undefined;
             widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -130,9 +130,9 @@ export declare const declarationFieldsSchema: z.ZodObject<{
     elements?: {
         items?: {
             role: string;
-            accessibleName: string;
             testId: string | null;
             stableId: string | null;
+            accessibleName: string;
             contextText: string[] | null;
             mutability?: "unknown" | "mutable" | "immutable" | undefined;
             widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -328,9 +328,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
                 widgetType: z.ZodOptional<z.ZodEnum<["native", "custom", "unknown"]>>;
             }, "strip", z.ZodTypeAny, {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -346,9 +346,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         }, "strict", z.ZodTypeAny, {
             items?: {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -386,9 +386,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         elements?: {
             items?: {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -462,9 +462,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         elements?: {
             items?: {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -555,9 +555,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         elements?: {
             items?: {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -665,9 +665,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         elements?: {
             items?: {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -775,9 +775,9 @@ declare const registerPlannedTestSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
         elements?: {
             items?: {
                 role: string;
-                accessibleName: string;
                 testId: string | null;
                 stableId: string | null;
+                accessibleName: string;
                 contextText: string[] | null;
                 mutability?: "unknown" | "mutable" | "immutable" | undefined;
                 widgetType?: "unknown" | "custom" | "native" | undefined;
@@ -842,8 +842,14 @@ export declare function makeSpecFileReader(state: RunState): (relativePath: stri
  * `owner/repo` read off the origin remote, so the name is always matchable.
  */
 export declare function makeScreenRouteResolver(state: RunState): (relativePath: string, repository: string) => string[] | undefined;
-/** Every fact the verifiers check against, gathered once per registration. */
-export declare function buildVerifyContext(state: RunState): Promise<VerifyContext>;
+/** The blockers this registration is judged on: the ones it sends AND the ones the
+ *  stored plan carries. A carried close is re-probed on every registration — the
+ *  service that was down when it was accepted may be up now. */
+export declare function blockersToProbe(registration: PlanInput, previous?: Plan): PlanBlocker[];
+/** Every fact the verifiers check against, gathered once per registration. The
+ *  blockers are probed HERE rather than inside a verifier: an HTTP request and a
+ *  `git` call are both asynchronous and every verifier is not. */
+export declare function buildVerifyContext(state: RunState, blockers?: PlanBlocker[]): Promise<VerifyContext>;
 /**
  * What the agent reads back. Every objection carries its id so it can be answered,
  * and the text says the plan is stored either way — a objections list without that

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

@@ -12,7 +12,10 @@ import { collectChangedRuns } from "../../utils/changedRuns.js";
 import { LOCKFILE, NOT_SOURCE_DIR, } from "../../recommendation/verifiers/endpointGrounded.js";
 import { hasUITestTypeLabel, isHTTPStep, } from "../../recommendation/subjectStep.js";
 import { STEP_METHOD_DESCRIPTION, isUiStepVerb, normalizeStepMethod, stepMethodSchema, } from "../../types/StepMethod.js";
-import { registerPlan } from "../../recommendation/registerPlan.js";
+import { registerPlan, } from "../../recommendation/registerPlan.js";
+import { BLOCKER_DESCRIPTION } from "../../recommendation/answers.js";
+import { probeBlockers, blockersIn, } from "../../recommendation/blockerProbes.js";
+import { blockerSchema, verifyBlocker } from "../../recommendation/blockers.js";
 import { targetElementSchema } from "../submitReportTool.js";
 import { capturedBlueprintDigests } from "../../playwright/blueprintDigestStore.js";
 import { pullRequestText } from "../../recommendation/pullRequestText.js";
@@ -129,7 +132,7 @@ const plannedTestCitations = citationFields({
     changesSubject: "test proves",
     defectsSubject: "test proves",
     changesExtra: " This test proves one behaviour: list the id of every change that the behaviour covers. The server checks that each declared change has a planned test that cites it, or an answer. The server does not check that the test exercises the change. CHECKED on a `requirement_conflict` test: at least one cited change must have been read from the pull request or a requirements file, never only from the diff.",
-    defectsExtra: " The server checks that each declared defect has a planned test that cites it and expects to fail, or a blocker naming what stopped the test. The server does not check that the test reaches the defect. CHECKED on a `requirement_conflict` test: it must cite at least one defect.",
+    defectsExtra: " The server checks that each declared defect has a planned test that cites it and expects to fail. The server does not check that the test reaches the defect. CHECKED on a `requirement_conflict` test: it must cite at least one defect.",
 });
 // The fields `declarations` accepts. Named on its own so one list of them can be
 // derived from it — a hand-written second copy had already fallen behind.
@@ -527,7 +530,7 @@ const registerTestPlanSchema = {
         });
     })
         .default([])
-        .describe("The defects your code review found in the code that serves each change, whether or not the diff contains the line. Every defect closes one of three ways: a planned test that cites it in `defects` and expects to fail, a `maintains` entry that cites it because your edit to an existing test covers it, or a blocker naming what stopped the test. A pre-existing defect in a file this pull request touches belongs on this list. An empty list says the review found none; the check asks you to confirm that in one line. A requirement conflict is a defect: list it here, and the `requirement_conflict` test cites it."),
+        .describe("The defects your code review found in the code that serves each change, whether or not the diff contains the line. Every defect closes one of two ways: a planned test that cites it in `defects` and expects to fail, or a `maintains` entry that cites it because your edit to an existing test covers it. A service that is down does not stop the test: write it, and it runs once the service is back. A pre-existing defect in a file this pull request touches belongs on this list. An empty list says the review found none; the check asks you to confirm that in one line. A requirement conflict is a defect: list it here, and the `requirement_conflict` test cites it."),
     // REQUIRED, not `.default([])`. The MCP SDK wraps this shape in a plain
     // `z.object`, which STRIPS an undeclared top-level key, so with a default
     // `planned test:` for `planned tests:` stored an EMPTY plan and counted the
@@ -565,16 +568,16 @@ const registerTestPlanSchema = {
         repository: repositorySlugField("a maintenance entry", "which holds the test this run edits"),
         file: z
             .string()
-            .describe("Repository-relative path of the existing test this run edits. It has to resolve in the repository named above: a change is credited as covered only when it does, and `existingCoverage` objects when it does not."),
+            .describe("Repository-relative path of the existing test this run edits, or runs unchanged as a VERIFY. It has to resolve in the repository named above: a change is credited as covered only when it does, and `existingCoverage` objects when it does not."),
         differsBy: z
             .string()
-            .describe("What your edit changes in that test, in one sentence."),
+            .describe("What your edit changes in that test, in one sentence. For a test you run unchanged, what it asserts that the cited changes or defects reach."),
         changes: maintainedCitations.changes,
         defects: maintainedCitations.defects,
     })
         .strict())
         .optional()
-        .describe("Existing tests this run edits instead of planning new ones. Coverage counts the changes these cite, and the defect check counts the defects they cite, so a change or a defect already covered by a spec you are updating needs no planned test — and a duplicate spec beside the one you edited is the mistake. Declare maintenance here even when the plan holds no planned tests at all: a maintenance-only plan is a complete plan."),
+        .describe("Existing tests this run edits, or runs unchanged as a VERIFY, instead of planning new ones. A test you run unchanged is checked at report time: the report objects when this server recorded no run of it after the edits. Coverage counts the changes these cite, and the defect check counts the defects they cite, so a change or a defect already covered by a spec you are updating needs no planned test — and a duplicate spec beside the one you edited is the mistake. Declare maintenance here even when the plan holds no planned tests at all: a maintenance-only plan is a complete plan."),
     answers: z
         .array(z
         .object({
@@ -584,10 +587,7 @@ const registerTestPlanSchema = {
         answer: z
             .string()
             .describe("Why the objection does not apply, or what you decided instead."),
-        blocker: z
-            .string()
-            .optional()
-            .describe("What stopped this run from writing the test: a service that is not running, a paired branch that no longer exists, the one credential the run holds. An objection about a change or a defect with no test, or about a value a page and API change refuses that no UI test names, closes only with this. A reason the change is not worth testing is not a blocker."),
+        blocker: blockerSchema.optional().describe(BLOCKER_DESCRIPTION),
     })
         .strict())
         .default([])
@@ -795,10 +795,25 @@ function recordedPullRequest() {
     logger.warning("No pull request text was recorded before the plan was registered; the checks that read it will see an empty pull request.");
     return { title: "", description: "" };
 }
-/** Every fact the verifiers check against, gathered once per registration. */
-export async function buildVerifyContext(state) {
+/** The blockers this registration is judged on: the ones it sends AND the ones the
+ *  stored plan carries. A carried close is re-probed on every registration — the
+ *  service that was down when it was accepted may be up now. */
+export function blockersToProbe(registration, previous) {
+    return [
+        ...blockersIn(registration.answers),
+        ...blockersIn(previous?.answeredObjections ?? []),
+        ...blockersIn(previous?.unverifiedCloses ?? []),
+    ];
+}
+/** Every fact the verifiers check against, gathered once per registration. The
+ *  blockers are probed HERE rather than inside a verifier: an HTTP request and a
+ *  `git` call are both asynchronous and every verifier is not. */
+export async function buildVerifyContext(state, blockers = []) {
     const sections = repoSections(state);
-    const listings = await Promise.all(sections.map((section) => changedFilesForVerification(section)));
+    const [listings, checks] = await Promise.all([
+        Promise.all(sections.map((section) => changedFilesForVerification(section))),
+        probeBlockers(blockers),
+    ]);
     // Per repository, so a planned test is checked against the one it names. Every
     // planned test names one; a single-repository run names that one repository.
     return {
@@ -821,6 +836,7 @@ export async function buildVerifyContext(state) {
         citedFileExists: makeCitedFileCheck(state),
         readSpecFile: makeSpecFileReader(state),
         routesRenderingFile: makeScreenRouteResolver(state),
+        blockerVerdict: (blocker) => verifyBlocker(blocker, checks),
     };
 }
 // ── Output ──────────────────────────────────────────────────────────────────
@@ -930,7 +946,7 @@ export function registerRegisterTestPlanTool(server) {
                 const registration = buildRegistration(params, registrationNumber);
                 // The previous registration's answers are already on the stored plan, which
                 // the write below replaces.
-                const result = registerPlan(registration, await buildVerifyContext(fullState), fullState.plan);
+                const result = registerPlan(registration, await buildVerifyContext(fullState, blockersToProbe(registration, fullState.plan)), fullState.plan);
                 try {
                     const { metadata: _metadata, relatedRepos: _sections, ...rootData } = fullState;
                     await stateManager.appendData({

package/build/types/TestTypes.d.ts

@@ -255,6 +255,13 @@ export declare const codeRefactoringSchema: z.ZodObject<{
     codeReuse?: boolean | undefined;
     modularizeCode?: boolean | undefined;
 }>;
+/** The `testName` field for a recording-driven generation tool.
+ *
+ *  Single-sourced because the description is prompt text: it is the only thing
+ *  steering the agent's choice of title, it gets re-tuned against eval results,
+ *  and two copies would let the UI and E2E tools drift apart silently. Each
+ *  tool passes the title its own generator falls back to (SKYR-4468). */
+export declare const testNameField: (fallbackTitle: string) => z.ZodOptional<z.ZodString>;
 /** Test types skyramp_enhance_assertions supports — single-sourced so the
  *  tool's schema enum and generation-time baseline seeding cannot drift
  *  (contract additionally requires provider mode at the seeding site). */