@skyramp/mcp 0.4.4-rc.1 → 0.4.4-rc.2

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

@@ -12,11 +12,11 @@ export function registerRecommendTestsPrompt(server) {
             "Parameters for generation tools must derive from the repository analysis, enrichedScenarios, " +
             "or source code you read — no invented field names, no guessed URLs. Provide a stateFile path " +
             "from skyramp_analyze_changes.",
-        argsSchema: {
+        argsSchema: z.object({
             stateFile: z
                 .string()
                 .describe("State file path returned by skyramp_analyze_changes"),
-        },
+        }),
     }, async (args) => {
         const stateFile = args.stateFile;
         if (!stateFile) {

package/build/prompts/testbot/testbot-prompts.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import type { RelatedRepository, TestbotPromptOptions } from "../../types/TestbotPromptOptions.js";
 /** "After generation, complete these steps" list at the end of Task 2. Exported
  *  for `referenceIntegrity.test.ts`, which compares it against the ordinals the

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

@@ -6,7 +6,7 @@ import { setReportLanguage } from "../../utils/reportLanguage.js";
 import { setPlanOnlyMode } from "../../utils/planOnlyMode.js";
 import { parseMaxFixAttemptsArg, resolveMaxFixAttempts, setMaxFixAttempts, } from "../../utils/fixAttempts.js";
 import { setPrimaryRepository } from "../../utils/AnalysisStateManager.js";
-import { recordPullRequestText, recordUiCredentials, } from "../../recommendation/pullRequestText.js";
+import { recordPullRequestText } from "../../recommendation/pullRequestText.js";
 import { AUTH_MIDDLEWARE_PATTERNS_STR } from "../../utils/workspaceAuth.js";
 import { TASK_ANALYZE_MAINTAIN, TASK_GENERATE, TASK_SUBMIT, TESTBOT_TASK1_MAINTAIN_LABELS, TESTBOT_TASK1_MULTIREPO_LABELS, TESTBOT_TASK1_STEP_LABELS, orderedLabels, stepSubRef, taskRef, } from "../test-recommendation/recommendationShared.js";
 import { getTraceRecordingPromptText } from "../../playwright/traceRecordingPrompt.js";
@@ -239,9 +239,6 @@ export function getTestbotPrompt(opts) {
     setPrimaryRepository({ repositoryPath, repo: primaryRepo });
     // Kept in the process for the plan tool, which is registered on this server.
     recordPullRequestText(prTitle, prDescription);
-    // Beside it and for the same reason: a `credential-missing` blocker is checked
-    // against whether this run was given any.
-    recordUiCredentials(uiCredentials);
     // The legacy count arguments are DECLARED NOWHERE, so zod strips them and their
     // names never reach the agent — not in a schema it lists, not in rendered text.
     // A number in front of the agent reads as a ceiling whatever the words around it
@@ -480,7 +477,7 @@ ${userPrompt ? "Follow-up requests never reach this step — Task 1's guardrails
 **How to generate each type (for ADD):**
 - **Integration**: call \`skyramp_batch_scenario_test_generation\` with ALL steps in a single call (pass the \`steps\` array with method, path, requestBody, statusCode for each step). Then call \`skyramp_integration_test_generation\` with the returned scenario file${INTEGRATION_CODE_REUSE_GEN_CLAUSE}.
   **Reuse the steps you declared in your own plan** — pass them straight through. Read a source model only for a field your plan does not already carry.
-  Scenario JSON and test files go in ${testDirInstruction}
+  Test files go in ${testDirInstruction} Pass that same directory as \`outputDir\` to \`skyramp_batch_scenario_test_generation\`. The tool writes the scenario JSON outside the repository, so it is not committed. Do NOT copy it into the test directory.
   **Pipeline for speed**: Call ALL \`skyramp_batch_scenario_test_generation\` calls in one batch. When they return, call ALL \`skyramp_integration_test_generation\` calls in the next batch. Do NOT serialize per-scenario (batch→integration→batch→integration) — batch ALL scenarios first, then generate ALL integration tests.
 - **Contract**: call \`skyramp_contract_test_generation\` with \`endpointURL\`, \`method\`, and \`requestData\` for POST/PUT/PATCH.
   Pass \`apiSchema\` if an OpenAPI spec exists.
@@ -711,7 +708,7 @@ export function registerTestbotPrompt(server) {
     logger.info("Registering testbot prompt");
     server.registerPrompt("skyramp_testbot", {
         description: "Run Skyramp Testbot to generate test recommendations and perform test maintenance for a pull request.",
-        argsSchema: {
+        argsSchema: z.object({
             prTitle: z.string().describe("Pull request title"),
             prDescription: z.string().describe("Pull request description/body"),
             repositoryPath: z
@@ -771,7 +768,7 @@ export function registerTestbotPrompt(server) {
                 // like the resource does, instead of rejecting the call.
                 .preprocess((v) => parseMaxFixAttemptsArg(v), z.number().int().min(1).max(10).optional())
                 .describe("Per-TEST-FILE cap on skyramp_execute_test calls in the final phase: the first run plus the fix-and-rerun iterations the agent may spend on an infrastructure failure for that one file (SKYR-4460). 1..10; falls back to SKYRAMP_MAX_FIX_ATTEMPTS, then 3."),
-        },
+        }),
     }, async (args) => {
         const services = await readWorkspaceServices(args.repositoryPath);
         let prompt = getTestbotPrompt({

package/build/recommendation/answers.d.ts

@@ -1,25 +1,10 @@
-import { ObjectionAnswer, Objection, PlanBlocker } from "./types.js";
-import { BlockerVerdict } from "./blockers.js";
-export { BLOCKER_DESCRIPTION } from "./blockers.js";
-/** What the server made of one answer's blocker. Passed in, never computed here:
- *  the probes are network and git calls and the verifiers reach neither. UNDEFINED
- *  where the caller ran no probes, which reads as `unverifiable` — the position
- *  every blocker close stood in before the checks existed. */
-export type BlockerJudge = (blocker: PlanBlocker) => BlockerVerdict;
+import { ObjectionAnswer, Objection } from "./types.js";
 /** The objection raised below carries this prefix and the id it objects to. */
 export declare const UNKNOWN_ANSWER_PREFIX = "answers:unknown:";
-/** The entry that closed one objection, matched by `objectionId` and never by
- *  position — the agent reorders its list between registrations. A whitespace-only
- *  answer closes nothing, and the FIRST NON-BLANK entry wins when one id is
- *  answered twice. Its `answer` comes back trimmed.
- *
- *  The ENTRY, so a caller that files the blocker files the one that arrived with
- *  THIS answer. Searching for the two separately took them from different entries:
- *  a blank-answer entry supplied the blocker, and a refuted claim was published
- *  beside an answer a later entry had closed. */
-export declare function closingAnswerFor(objection: Objection, acknowledged: ObjectionAnswer[], judge?: BlockerJudge): ObjectionAnswer | undefined;
-/** The closing answer as the sentence alone, for a caller that files no blocker. */
-export declare function answerFor(objection: Objection, acknowledged: ObjectionAnswer[], judge?: BlockerJudge): string | undefined;
+/** The answer to one objection, matched by `objectionId` and never by position — the
+ *  agent reorders its list between registrations. A whitespace-only answer closes
+ *  nothing, and the FIRST NON-BLANK entry wins when one id is answered twice. */
+export declare function answerFor(objection: Objection, acknowledged: ObjectionAnswer[]): string | undefined;
 /** One objection per answer naming an objection this call did not raise — a stale
  *  id, a typo and a pre-emptive answer all used to pass in silence. An id is
  *  recognised BY ITS PREFIX and never draws an objection of its own. `scope` and
@@ -28,49 +13,29 @@ export declare function unknownAnswerObjections(objections: Objection[], acknowl
     scope: string;
     suggestion: string;
 }): Objection[];
-/** The objections an answer does not close, only a planned test.
- *
- *  `coverage:stateTest:` — the missed bugs it exists for were reached by prose twice
- *  and skipped twice, so an answer would close the objection and leave the bug.
- *  `verifierContracts.ts` carries the evidence.
- *
- *  `defects:untested:` — a declared defect's test can always be written, even when
- *  the service it runs against is down: it is committed and runs once the service is
- *  back. Every blocker Wipro repo-1 sent for a defect (14 on one run, 2 on the next)
- *  named a limit of the browser tools, and none got a test.
- *
- *  `defects:expectedPass:` — a test that passes today proves nothing about a defect,
- *  and a sentence here would let one cited passing test stand in for the red one. */
-export declare const NON_ANSWERABLE_PREFIXES: readonly ["coverage:stateTest:", "defects:untested:", "defects:expectedPass:"];
+/** The one objection an answer does not close. Every other check in v2 can be
+ *  answered, and this one cannot: the missed bugs it exists for were reached by
+ *  prose twice and skipped twice, so an answer would close the objection and
+ *  leave the bug. `verifierContracts.ts` carries the evidence. */
+export declare const NON_ANSWERABLE_PREFIX = "coverage:stateTest:";
 export declare function isNonAnswerable(objectionId: unknown): boolean;
 /** The objections a sentence alone does not close either. A change with no test
  *  needs the test, a value a page and API change accepts or refuses needs a UI step
  *  that names it (the XR02 evidence is at `surfaceCase` and `surfaceReject` in
- *  `verifierContracts.ts`). Each closes only when the answer also names what stopped
- *  the test: a service that is not running, or the one credential the run holds. Measured on run
+ *  `verifierContracts.ts`), and a defect with no test needs the test — a defect
+ *  the code already had before this pull request included. Each closes only when the
+ *  answer also names what stopped the test: a service that is not running, a
+ *  branch that no longer exists, the one credential the run holds. Measured on run
  *  34176038240: across eight fixtures 45 objections were raised and 45 were
  *  closed, and the one class that a sentence cannot close was never raised at all.
  *  Prose closed every uncovered change, including changes nothing prevented a test
  *  from reaching. Runs 34423214322 and 34423217796 then lost three defects the
- *  baseline reported: each was listed and closed by a sentence.
- *
- *  A bug the report states is the same promise made after the tests run, so it
- *  closes the same way. Runs 34434835959 (repo15 RG21 and RG15) and 34434838150
- *  (repo10 RG03) answered three `issueTraceability:` objections with "outside this
- *  PR's surface" and "unobservable" and wrote no test — and RG21 and RG15 were the
- *  same 404 bootstrap bug, reported twice and tested neither time. */
-export declare const BLOCKER_ONLY_PREFIXES: readonly ["coverage:change:", "coverage:surfaceCase:", "coverage:surfaceReject:", "issueTraceability:"];
+ *  baseline reported: each was listed and closed by a sentence. */
+export declare const BLOCKER_ONLY_PREFIXES: readonly ["coverage:change:", "coverage:surfaceCase:", "coverage:surfaceReject:", "defects:untested:"];
 export declare function needsBlocker(objectionId: unknown): boolean;
 /** The objection raised below carries this prefix and the id it objects to. */
 export declare const REFUSED_ANSWER_PREFIX = "answers:refused:";
 /** One objection per answer to an objection only a planned test closes. The answered
  *  objection STAYS OPEN — this says so, rather than letting the answer pass in
  *  silence while the plan still owes the test. */
-export declare function refusedAnswerObjections(objections: Objection[], acknowledged: ObjectionAnswer[], judge?: BlockerJudge, 
-/** Whether an EARLIER call already closed this objection and that close still
- *  stands. The report tool carries answers across calls, so an objection closed
- *  on call 1 is raised again on call 2 and answered again there. Without this,
- *  a weaker second answer raised `answers:refused:` beside a close the report
- *  publishes as answered — the report then said both. `registerPlan` carries
- *  the previous registration's closes the same way. */
-closedEarlier?: (objectionId: string) => boolean): Objection[];
+export declare function refusedAnswerObjections(objections: Objection[], acknowledged: ObjectionAnswer[]): Objection[];

package/build/recommendation/answers.js

@@ -1,34 +1,9 @@
-import { hasBlocker, refutedEvidence } from "./blockers.js";
-export { BLOCKER_DESCRIPTION } from "./blockers.js";
-/** Whether this answer's blocker closes the objection: present, and not refuted by
- *  the server's own probe. */
-function blockerCloses(blocker, judge) {
-    if (!hasBlocker(blocker))
-        return false;
-    return !judge || judge(blocker) !== "refuted";
-}
-/** Whether one entry closes an objection that needs a blocker: the SAME rule
- *  `closingAnswerFor` applies, so a sibling that suppresses a refusal is a sibling
- *  that really closed. Reading the blocker alone let an entry with a good blocker
- *  and an empty answer suppress the refusal while closing nothing. */
-function closes(entry, judge) {
-    const answer = entry?.answer;
-    if (typeof answer !== "string" || answer.trim().length === 0)
-        return false;
-    return blockerCloses(entry?.blocker, judge);
-}
 /** The objection raised below carries this prefix and the id it objects to. */
 export const UNKNOWN_ANSWER_PREFIX = "answers:unknown:";
-/** The entry that closed one objection, matched by `objectionId` and never by
- *  position — the agent reorders its list between registrations. A whitespace-only
- *  answer closes nothing, and the FIRST NON-BLANK entry wins when one id is
- *  answered twice. Its `answer` comes back trimmed.
- *
- *  The ENTRY, so a caller that files the blocker files the one that arrived with
- *  THIS answer. Searching for the two separately took them from different entries:
- *  a blank-answer entry supplied the blocker, and a refuted claim was published
- *  beside an answer a later entry had closed. */
-export function closingAnswerFor(objection, acknowledged, judge) {
+/** The answer to one objection, matched by `objectionId` and never by position — the
+ *  agent reorders its list between registrations. A whitespace-only answer closes
+ *  nothing, and the FIRST NON-BLANK entry wins when one id is answered twice. */
+export function answerFor(objection, acknowledged) {
     const wantsBlocker = needsBlocker(objection.objectionId);
     for (const entry of acknowledged) {
         if (entry.objectionId !== objection.objectionId)
@@ -37,16 +12,12 @@ export function closingAnswerFor(objection, acknowledged, judge) {
         const answer = typeof rawAnswer === "string" ? rawAnswer.trim() : "";
         if (answer.length === 0)
             continue;
-        if (wantsBlocker && !blockerCloses(entry.blocker, judge))
+        if (wantsBlocker && String(entry.blocker ?? "").trim().length === 0)
             continue;
-        return { ...entry, answer };
+        return answer;
     }
     return undefined;
 }
-/** The closing answer as the sentence alone, for a caller that files no blocker. */
-export function answerFor(objection, acknowledged, judge) {
-    return closingAnswerFor(objection, acknowledged, judge)?.answer;
-}
 /** One objection per answer naming an objection this call did not raise — a stale
  *  id, a typo and a pre-emptive answer all used to pass in silence. An id is
  *  recognised BY ITS PREFIX and never draws an objection of its own. `scope` and
@@ -72,50 +43,32 @@ export function unknownAnswerObjections(objections, acknowledged, { scope, sugge
     }
     return raisedHere;
 }
-/** The objections an answer does not close, only a planned test.
- *
- *  `coverage:stateTest:` — the missed bugs it exists for were reached by prose twice
- *  and skipped twice, so an answer would close the objection and leave the bug.
- *  `verifierContracts.ts` carries the evidence.
- *
- *  `defects:untested:` — a declared defect's test can always be written, even when
- *  the service it runs against is down: it is committed and runs once the service is
- *  back. Every blocker Wipro repo-1 sent for a defect (14 on one run, 2 on the next)
- *  named a limit of the browser tools, and none got a test.
- *
- *  `defects:expectedPass:` — a test that passes today proves nothing about a defect,
- *  and a sentence here would let one cited passing test stand in for the red one. */
-export const NON_ANSWERABLE_PREFIXES = [
-    "coverage:stateTest:",
-    "defects:untested:",
-    "defects:expectedPass:",
-];
-const DEFECT_PREFIXES = ["defects:untested:", "defects:expectedPass:"];
+/** The one objection an answer does not close. Every other check in v2 can be
+ *  answered, and this one cannot: the missed bugs it exists for were reached by
+ *  prose twice and skipped twice, so an answer would close the objection and
+ *  leave the bug. `verifierContracts.ts` carries the evidence. */
+export const NON_ANSWERABLE_PREFIX = "coverage:stateTest:";
 export function isNonAnswerable(objectionId) {
     return (typeof objectionId === "string" &&
-        NON_ANSWERABLE_PREFIXES.some((prefix) => objectionId.startsWith(prefix)));
+        objectionId.startsWith(NON_ANSWERABLE_PREFIX));
 }
 /** The objections a sentence alone does not close either. A change with no test
  *  needs the test, a value a page and API change accepts or refuses needs a UI step
  *  that names it (the XR02 evidence is at `surfaceCase` and `surfaceReject` in
- *  `verifierContracts.ts`). Each closes only when the answer also names what stopped
- *  the test: a service that is not running, or the one credential the run holds. Measured on run
+ *  `verifierContracts.ts`), and a defect with no test needs the test — a defect
+ *  the code already had before this pull request included. Each closes only when the
+ *  answer also names what stopped the test: a service that is not running, a
+ *  branch that no longer exists, the one credential the run holds. Measured on run
  *  34176038240: across eight fixtures 45 objections were raised and 45 were
  *  closed, and the one class that a sentence cannot close was never raised at all.
  *  Prose closed every uncovered change, including changes nothing prevented a test
  *  from reaching. Runs 34423214322 and 34423217796 then lost three defects the
- *  baseline reported: each was listed and closed by a sentence.
- *
- *  A bug the report states is the same promise made after the tests run, so it
- *  closes the same way. Runs 34434835959 (repo15 RG21 and RG15) and 34434838150
- *  (repo10 RG03) answered three `issueTraceability:` objections with "outside this
- *  PR's surface" and "unobservable" and wrote no test — and RG21 and RG15 were the
- *  same 404 bootstrap bug, reported twice and tested neither time. */
+ *  baseline reported: each was listed and closed by a sentence. */
 export const BLOCKER_ONLY_PREFIXES = [
     "coverage:change:",
     "coverage:surfaceCase:",
     "coverage:surfaceReject:",
-    "issueTraceability:",
+    "defects:untested:",
 ];
 export function needsBlocker(objectionId) {
     return (typeof objectionId === "string" &&
@@ -126,14 +79,7 @@ export const REFUSED_ANSWER_PREFIX = "answers:refused:";
 /** One objection per answer to an objection only a planned test closes. The answered
  *  objection STAYS OPEN — this says so, rather than letting the answer pass in
  *  silence while the plan still owes the test. */
-export function refusedAnswerObjections(objections, acknowledged, judge, 
-/** Whether an EARLIER call already closed this objection and that close still
- *  stands. The report tool carries answers across calls, so an objection closed
- *  on call 1 is raised again on call 2 and answered again there. Without this,
- *  a weaker second answer raised `answers:refused:` beside a close the report
- *  publishes as answered — the report then said both. `registerPlan` carries
- *  the previous registration's closes the same way. */
-closedEarlier) {
+export function refusedAnswerObjections(objections, acknowledged) {
     const raised = new Set(objections
         .map((objection) => objection.objectionId)
         .filter((id) => isNonAnswerable(id) || needsBlocker(id)));
@@ -146,37 +92,21 @@ closedEarlier) {
         const answer = entry.answer;
         if (typeof answer !== "string" || answer.trim().length === 0)
             continue;
-        // An answer whose blocker the server did not refute DOES close an untested
-        // change. Refused: the sentence on its own, and a claim the probe found untrue.
-        // Read across EVERY entry for this id, not just this one: the agent may send
-        // two, and one of them closing means the objection is closed — refusing on the
-        // other raised a refusal beside a close for the same objection.
-        if (needsBlocker(id) &&
-            (acknowledged.some((other) => other.objectionId === id && closes(other, judge)) ||
-                closedEarlier?.(id))) {
+        // An answer that names a blocker DOES close an untested change, so it is not
+        // refused. Only the sentence on its own is.
+        if (needsBlocker(id) && String(entry.blocker ?? "").trim().length > 0)
             continue;
-        }
         seen.add(id);
-        const blocker = entry?.blocker;
-        const refutedBlocker = needsBlocker(id) && hasBlocker(blocker) ? blocker : undefined;
         refused.push({
             objectionId: `${REFUSED_ANSWER_PREFIX}${id}`,
             verifier: "answers",
-            message: refutedBlocker
-                ? "The server checked the blocker this answer names and found the opposite, so the objection stays open."
-                : needsBlocker(id)
-                    ? "The answer says why there is no test, and it does not say what stopped this run from writing one, so the objection stays open."
-                    : "This objection is closed only by a planned test, so the answer closed nothing and the objection stays open.",
-            evidence: refutedBlocker
-                ? `answered "${id}" with \`${refutedBlocker.kind}\`; ${refutedEvidence(refutedBlocker)}`
-                : `answered "${id}"${needsBlocker(id) ? " with no `blocker`" : ", which no answer closes"}`,
-            suggestion: refutedBlocker
-                ? "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."
-                : needsBlocker(id)
-                    ? "Plan the test and register the plan again. If this run cannot write one, send the same answer with `blocker` — `service-unreachable` with the URL, or `credential-missing` with the URL of the page that asked for the login. A reason it is not worth testing is not a blocker."
-                    : DEFECT_PREFIXES.some((prefix) => id.startsWith(prefix))
-                        ? "Plan a test that cites the defect in `defects` and sets `expected.outcome` to `fail`, then register the plan again. If a service the test needs is down, write the test anyway: it is committed and runs once the service is back."
-                        : "Add a planned test that names the record's state as `startState` and runs this route's mutation on it, then register the plan again. Every other objection takes an answer; this one takes a test.",
+            message: needsBlocker(id)
+                ? "The answer says why there is no test, and it does not say what stopped this run from writing one, so the objection stays open."
+                : "This objection is closed only by a planned test, so the answer closed nothing and the objection stays open.",
+            evidence: `answered "${id}"${needsBlocker(id) ? " with no `blocker`" : ", which no answer closes"}`,
+            suggestion: needsBlocker(id)
+                ? "Plan the test and register the plan again. If this run cannot write one, send the same answer with `blocker` naming what stopped it — a service that is not running, a paired branch that no longer exists, the one credential the run holds. A reason it is not worth testing is not a blocker."
+                : "Add a planned test that names the record's state as `startState` and runs this route's mutation on it, then register the plan again. Every other objection takes an answer; this one takes a test.",
         });
     }
     return refused;

package/build/recommendation/pullRequestText.d.ts

@@ -9,8 +9,6 @@ export declare function pullRequestText(): {
     description: string;
 } | undefined;
 export declare function clearPullRequestText(): void;
-export declare function recordUiCredentials(value: unknown): void;
-export declare function uiCredentialsSupplied(): boolean | undefined;
 /** The pull request as one searchable string. Whitespace runs fold to one space, so
  *  a quote wrapped across lines still matches the sentence it was taken from. */
 export declare const searchable: (pr: {

package/build/recommendation/pullRequestText.js

@@ -21,22 +21,6 @@ export function pullRequestText() {
 }
 export function clearPullRequestText() {
     recorded = undefined;
-    credentialsSupplied = undefined;
-}
-/** Whether the run was given browser credentials, recorded from the same place and
- *  for the same reason as the text above: the prompt and the plan tool share a
- *  process, so the flag is already here. A blocker of kind `credential-missing`
- *  is checked against it.
- *
- *  UNDEFINED when this process never rendered the prompt, which is not `false` —
- *  the server cannot tell a run with no credentials from a run it never saw, and
- *  the blocker is then unverifiable rather than true. */
-let credentialsSupplied;
-export function recordUiCredentials(value) {
-    credentialsSupplied = typeof value === "string" && value.trim().length > 0;
-}
-export function uiCredentialsSupplied() {
-    return credentialsSupplied;
 }
 /** The pull request as one searchable string. Whitespace runs fold to one space, so
  *  a quote wrapped across lines still matches the sentence it was taken from. */

package/build/recommendation/registerPlan.d.ts

@@ -1,4 +1,4 @@
-import { Objection, ObjectionAnswer, PlanBlocker, PlanChange, PlanDefect, PlanInput, PlanMaintenance, PlannedTest, VerifyContext } from "./types.js";
+import { Objection, ObjectionAnswer, PlanChange, PlanDefect, PlanInput, PlanMaintenance, PlannedTest, VerifyContext } from "./types.js";
 /** The plan as stored for the run. Every registration produces one; the newest
  *  replaces the last. */
 export interface Plan {
@@ -14,14 +14,11 @@ export interface Plan {
      *  `coverage` counts the changes they cite, so a reader of the plan has to be
      *  able to see which coverage came from maintenance rather than a new test. */
     maintains?: PlanMaintenance[];
-    /** Objections the agent answered, with the answers. A `blocker` here is one the
-     *  server PROBED and could not refute — an unreachable service that really did not
-     *  answer, a branch that really is gone — so the close is a checked one. */
+    /** Objections the agent answered, with the answers. */
     answeredObjections: Array<{
         objection: Objection;
         answer: string;
-        blocker?: PlanBlocker;
-        blockerVerified?: boolean;
+        blocker?: string;
     }>;
     /** Closed by a blocker nothing checked. Its own bucket rather than a flag on
      *  `answeredObjections`, so a run's count of them is a number the report can
@@ -32,7 +29,7 @@ export interface Plan {
     unverifiedCloses: Array<{
         objection: Objection;
         answer: string;
-        blocker: PlanBlocker;
+        blocker: string;
     }>;
     /** Objections with no answer. Rendered in the report — this is the accountability. */
     openObjections: Objection[];

package/build/recommendation/registerPlan.js

@@ -1,5 +1,4 @@
-import { hasBlocker } from "./blockers.js";
-import { answerFor, closingAnswerFor, isNonAnswerable, refusedAnswerObjections, unknownAnswerObjections, } from "./answers.js";
+import { answerFor, isNonAnswerable, refusedAnswerObjections, unknownAnswerObjections, } from "./answers.js";
 import { runPlanTimeVerifiers } from "./runVerifiers.js";
 import { logger } from "../utils/logger.js";
 function storedRegistrationNumber(registration) {
@@ -38,7 +37,7 @@ function carriedAnswerFor(objectionId, previous) {
             return {
                 objectionId,
                 answer,
-                ...(hasBlocker(entry.blocker) ? { blocker: entry.blocker } : {}),
+                ...(entry.blocker ? { blocker: entry.blocker } : {}),
             };
     }
     return undefined;
@@ -66,9 +65,6 @@ export function registerPlan(registration, ctx, previous) {
     const changes = registration.changes;
     const defects = registration.defects;
     const registrationNumber = storedRegistrationNumber(registration);
-    // Awaited by the caller before this context was built: every probe is an HTTP
-    // request or a `git` call, and nothing from here down is asynchronous.
-    const judge = ctx?.blockerVerdict?.bind(ctx);
     const verified = runPlanTimeVerifiers(registration, ctx);
     const objections = [
         ...verified,
@@ -76,15 +72,7 @@ export function registerPlan(registration, ctx, previous) {
             scope: "on this plan",
             suggestion: "Answer only the ids in the Objections list this registration returns. An objection you have since fixed is gone and needs no answer, and an objection raised after the tests run cannot be answered before them.",
         }),
-        ...refusedAnswerObjections(verified, acknowledged, judge, (id) => {
-            // The previous registration's close is carried below when this answer does
-            // not close. If that carried close still stands, it is the close.
-            const objection = verified.find((o) => o.objectionId === id);
-            const carried = carriedAnswerFor(id, previous);
-            return (!!objection &&
-                !!carried &&
-                !!closingAnswerFor(objection, [carried], judge));
-        }),
+        ...refusedAnswerObjections(verified, acknowledged),
     ];
     const carried = carriedAnswers(objections, acknowledged, previous);
     // The carried answers go last: `answerFor` takes the first non-blank entry, so
@@ -99,29 +87,15 @@ export function registerPlan(registration, ctx, previous) {
         // a planned test too, unless the answer names what stopped this run from
         // writing one. Either way an answer that does not close it leaves it open and
         // draws the refusal objection raised above.
-        const closing = isNonAnswerable(objection.objectionId)
+        const answer = isNonAnswerable(objection.objectionId)
             ? undefined
-            : closingAnswerFor(objection, answers, judge);
-        if (closing) {
-            const answer = closing.answer;
-            // The blocker that arrived with THIS answer. Searching for it apart from the
-            // answer took the two from different entries, and filed a refuted blocker,
-            // or one no answer closed, as the close.
-            const blocker = hasBlocker(closing.blocker) && judge?.(closing.blocker) !== "refuted"
-                ? closing.blocker
-                : undefined;
-            // A blocker the server PROBED and could not refute is a checked close and sits
-            // with the answers. One nothing could look at is counted apart: a run whose
-            // objections all close that way must not read like one that answered.
-            if (blocker && judge?.(blocker) === "verified") {
-                answeredObjections.push({
-                    objection,
-                    answer,
-                    blocker,
-                    blockerVerified: true,
-                });
-            }
-            else if (blocker)
+            : answerFor(objection, answers);
+        if (answer) {
+            const blocker = answers.find((entry) => entry.objectionId === objection.objectionId &&
+                String(entry.blocker ?? "").trim().length > 0)?.blocker;
+            // A blocker closes the objection and nothing here can check it, so it is
+            // counted apart from an answer the plan itself makes checkable.
+            if (blocker)
                 unverifiedCloses.push({ objection, answer, blocker });
             else
                 answeredObjections.push({ objection, answer });

package/build/recommendation/types.d.ts

@@ -164,24 +164,13 @@ export interface PlannedTest {
      *  included — the name is what joins the test to the diff it is checked against. */
     repository: string;
 }
-/** The kinds of thing that stop a run from writing a test AND that the server can
- *  check. Free text let an argument close an untested defect — run 34434835959
- *  closed one with "the PR description states no redirect or fallback" — so a
- *  blocker is now a claim of one of these, and the server probes it. */
-export type PlanBlockerKind = "service-unreachable" | "credential-missing";
-/** What stopped this run from writing the test, as a checkable claim. */
-export interface PlanBlocker {
-    kind: PlanBlockerKind;
-    /** `service-unreachable`: the URL the run needed. `credential-missing`: the URL
-     *  of the page that asked for the login. */
-    detail: string;
-}
 export interface ObjectionAnswer {
     objectionId: string;
     answer: string;
-    /** What stopped this run from writing the test. An objection about an untested
-     *  change, an untested defect or a reported bug closes only with one. */
-    blocker?: PlanBlocker;
+    /** 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 an untested change closes only with one of these. */
+    blocker?: string;
 }
 /** An existing test this run maintains instead of planning a new one, and the
  *  declared changes that maintenance covers. A removal already covered by a spec
@@ -266,12 +255,6 @@ export interface VerifyContext {
      *  the verifiers filesystem-free. Named a repository it asks that one, and a name
      *  this run does not know answers false. Omitted, it asks every one. */
     citedFileExists(relativePath: string, repository?: string): boolean;
-    /** What the server made of one answer's blocker. Injected for the same reason as
-     *  `citedFileExists`, and more so: the probes are HTTP requests and `git` calls,
-     *  and they are awaited before this context is built because the verifiers are
-     *  synchronous. UNDEFINED where the caller ran no probes — every blocker then
-     *  reads as unverifiable, which is where they all stood before the checks. */
-    blockerVerdict?(blocker: PlanBlocker): "verified" | "refuted" | "unverifiable";
     /** The text of a `spec:` file a plan change cites, from the first repository that
      *  holds it. UNDEFINED for a path no repository holds, a path outside every
      *  checkout, or a file too large to read. Injected for the same reason as

package/build/recommendation/verifierContracts.d.ts

@@ -126,7 +126,7 @@ export declare const EXPECTED_OUTCOME_CONTRACT: {
         };
         readonly executed: {
             readonly message: "This test failed, but it did not reach the behavior it was written for — it fell over earlier. A failure like this is not a caught bug.";
-            readonly suggestion: "If the blocker is the test's own setup — sign-in, token, a wrong path — fix it and run the test again. If the blocker is the defect this run reports (a route that is not mounted, a server error before the behaviour), answer this objection naming that issue: the failure then stands as evidence of that issue, not as a caught bug. If a service the test needs is down, answer this objection and set `blocker` to `service-unreachable` with the URL: the test stays committed and runs once the service is back.";
+            readonly suggestion: "If the blocker is the test's own setup — sign-in, token, a wrong path — fix it and run the test again. If the blocker is the defect this run reports (a route that is not mounted, a server error before the behaviour), answer this objection naming that issue: the failure then stands as evidence of that issue, not as a caught bug.";
         };
     };
     readonly suggestion: "Should this test fail until the defect is fixed, or is the category wrong for a test that pins behaviour the app already has?";
@@ -158,7 +158,7 @@ export declare const COVERAGE_CONTRACT: {
     readonly objections: {
         readonly change: {
             readonly message: "This declared change has no test in the plan.";
-            readonly suggestion: "Plan a test that exercises it. If an existing test already covers it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this change's id — maintenance is coverage, and a duplicate spec beside the one you edited is the mistake. If this run cannot write one, answer it and set `blocker` to what stopped the run — a service that is not running, the one credential the run holds. An answer with no blocker leaves this open: a change nothing prevented a test from reaching takes the test. Coverage per file is the basic minimum; coverage per change is what the plan is judged by, so a file covered by a shape test still leaves the change it makes untested.";
+            readonly suggestion: "Plan a test that exercises it. If an existing test already covers it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this change's id — maintenance is coverage, and a duplicate spec beside the one you edited is the mistake. If this run cannot write one, answer it and set `blocker` to what stopped the run — a service that is not running, a paired branch that no longer exists, the one credential the run holds. An answer with no blocker leaves this open: a change nothing prevented a test from reaching takes the test. Coverage per file is the basic minimum; coverage per change is what the plan is judged by, so a file covered by a shape test still leaves the change it makes untested.";
         };
         readonly noChanges: {
             readonly message: "The plan declares no changes, so nothing says what the pull request must make different.";
@@ -302,11 +302,11 @@ export declare const DEFECTS_CONTRACT: {
         };
         readonly untested: {
             readonly message: "This declared defect has no test in the plan.";
-            readonly suggestion: "Add a planned test that cites the defect in `defects` and sets `expected.outcome` to `fail`. A defect in a file this pull request touches gets the test whether or not this pull request introduced it. If an existing test already proves it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this defect's id — maintenance is proof, and a duplicate spec beside the one you edited is the mistake. Only a test closes this objection. If a service the test needs is down, write the test anyway: it is committed and runs once the service is back.";
+            readonly suggestion: "Add a planned test that cites the defect in `defects` and sets `expected.outcome` to `fail`. A defect in a file this pull request touches gets the test whether or not this pull request introduced it. If an existing test already proves it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this defect's id — maintenance is proof, and a duplicate spec beside the one you edited is the mistake. If something stopped this run from writing the test, answer it and set `blocker` to what stopped it.";
         };
         readonly expectedPass: {
             readonly message: "Every test that cites this defect expects to pass, and a test that passes today proves nothing about a defect.";
-            readonly suggestion: "Assert what the fixed code returns and set `expected.outcome` to `fail` with `why`. Only a test that expects to fail closes this objection.";
+            readonly suggestion: "Assert what the fixed code returns, set `expected.outcome` to `fail` with `why`, or answer in one line why a passing test is the proof.";
         };
         readonly unknownId: {
             readonly message: "A planned test cites a defect id that this plan does not declare.";

package/build/recommendation/verifierContracts.js

@@ -114,7 +114,7 @@ export const EXPECTED_OUTCOME_CONTRACT = {
         // 33988304641, P11), which the run that wrote `true` never drew.
         executed: {
             message: "This test failed, but it did not reach the behavior it was written for — it fell over earlier. A failure like this is not a caught bug.",
-            suggestion: "If the blocker is the test's own setup — sign-in, token, a wrong path — fix it and run the test again. If the blocker is the defect this run reports (a route that is not mounted, a server error before the behaviour), answer this objection naming that issue: the failure then stands as evidence of that issue, not as a caught bug. If a service the test needs is down, answer this objection and set `blocker` to `service-unreachable` with the URL: the test stays committed and runs once the service is back.",
+            suggestion: "If the blocker is the test's own setup — sign-in, token, a wrong path — fix it and run the test again. If the blocker is the defect this run reports (a route that is not mounted, a server error before the behaviour), answer this objection naming that issue: the failure then stands as evidence of that issue, not as a caught bug.",
         },
     },
     suggestion: "Should this test fail until the defect is fixed, or is the category wrong for a test that pins behaviour the app already has?",
@@ -149,7 +149,7 @@ export const COVERAGE_CONTRACT = {
     objections: {
         change: {
             message: "This declared change has no test in the plan.",
-            suggestion: "Plan a test that exercises it. If an existing test already covers it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this change's id — maintenance is coverage, and a duplicate spec beside the one you edited is the mistake. If this run cannot write one, answer it and set `blocker` to what stopped the run — a service that is not running, the one credential the run holds. An answer with no blocker leaves this open: a change nothing prevented a test from reaching takes the test. Coverage per file is the basic minimum; coverage per change is what the plan is judged by, so a file covered by a shape test still leaves the change it makes untested.",
+            suggestion: "Plan a test that exercises it. If an existing test already covers it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this change's id — maintenance is coverage, and a duplicate spec beside the one you edited is the mistake. If this run cannot write one, answer it and set `blocker` to what stopped the run — a service that is not running, a paired branch that no longer exists, the one credential the run holds. An answer with no blocker leaves this open: a change nothing prevented a test from reaching takes the test. Coverage per file is the basic minimum; coverage per change is what the plan is judged by, so a file covered by a shape test still leaves the change it makes untested.",
         },
         noChanges: {
             message: "The plan declares no changes, so nothing says what the pull request must make different.",
@@ -375,11 +375,11 @@ export const DEFECTS_CONTRACT = {
         },
         untested: {
             message: "This declared defect has no test in the plan.",
-            suggestion: "Add a planned test that cites the defect in `defects` and sets `expected.outcome` to `fail`. A defect in a file this pull request touches gets the test whether or not this pull request introduced it. If an existing test already proves it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this defect's id — maintenance is proof, and a duplicate spec beside the one you edited is the mistake. Only a test closes this objection. If a service the test needs is down, write the test anyway: it is committed and runs once the service is back.",
+            suggestion: "Add a planned test that cites the defect in `defects` and sets `expected.outcome` to `fail`. A defect in a file this pull request touches gets the test whether or not this pull request introduced it. If an existing test already proves it and this run edits that test, or runs it unchanged as a VERIFY, rather than writing a new one, declare it in `maintains` with the file, what your edit changes, and this defect's id — maintenance is proof, and a duplicate spec beside the one you edited is the mistake. If something stopped this run from writing the test, answer it and set `blocker` to what stopped it.",
         },
         expectedPass: {
             message: "Every test that cites this defect expects to pass, and a test that passes today proves nothing about a defect.",
-            suggestion: "Assert what the fixed code returns and set `expected.outcome` to `fail` with `why`. Only a test that expects to fail closes this objection.",
+            suggestion: "Assert what the fixed code returns, set `expected.outcome` to `fail` with `why`, or answer in one line why a passing test is the proof.",
         },
         unknownId: {
             message: "A planned test cites a defect id that this plan does not declare.",