@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/recommendation/verifiers/expectedValueSourced.js

@@ -1,9 +1,9 @@
-import { allChangedFiles } from "../types.js";
+import { allChangedFiles, } from "../types.js";
 import { changedPathSet, normalizeCitedPath } from "./citedPath.js";
 import { EXPECTED_VALUE_SOURCED_CONTRACT as CONTRACT } from "../verifierContracts.js";
 import { appearsIn, searchable } from "../pullRequestText.js";
 import { escapeRegExp } from "../../utils/regex.js";
-import { renderCase } from "./coverage.js";
+import { renderTestCase } from "./coverage.js";
 function readSource(raw) {
     const source = typeof raw === "string" ? raw.trim() : "";
     if (source.length === 0)
@@ -16,7 +16,10 @@ function readSource(raw) {
     if (!named)
         return { kind: "none", file: "" };
     const kind = named[1].toLowerCase();
-    const cited = named[2].split(/[#\u00a7]/)[0].replace(/(?::\d+)+(?:-\d+)?$/, "").trim();
+    const cited = named[2]
+        .split(/[#\u00a7]/)[0]
+        .replace(/(?::\d+)+(?:-\d+)?$/, "")
+        .trim();
     // `spec:` with nothing after it names no file, so there is nothing to check and
     // nothing to trust either. A path that IS written and still normalises away is a
     // named source, and it is named wrongly.
@@ -27,8 +30,8 @@ function readSource(raw) {
 }
 /** One case's address, for the evidence line. A case has no id of its own, so it
  *  is named the way the agent wrote it. */
-function caseLabel(change, entry) {
-    return `${String(change?.id ?? "?")}:${String(entry?.param ?? "?")}`;
+function testCaseLabel(change, entry) {
+    return `${String(change.id ?? "?")}:${String(entry.param ?? "?")}`;
 }
 /** Every number the pull request writes, as a number. One value has many
  *  spellings — `1e21`, `1e+21`, `1E21`, the digits in full — and matching the
@@ -94,7 +97,7 @@ function statesTheValue(prText, value) {
         return true;
     return statedNumbers(prText).includes(value);
 }
-const text = (value) => (typeof value === "string" ? value.trim() : "");
+const text = (value) => typeof value === "string" ? value.trim() : "";
 /** Verifier 10. A case that states what the response must carry says where that
  *  value came from, and the value did not come from the code under test.
  *
@@ -111,48 +114,52 @@ export const expectedValueSourced = {
     name: "expectedValueSourced",
     run(registration, ctx) {
         const objections = [];
-        // The plan comes off disk, so both arrays hold their declared type only on the
-        // validated path. A throw here reaches the agent as `:crashed` and hides
-        // whatever real objection this pass would have raised.
         // A `convention:` is trusted BECAUSE the pull request did not change it. Comparing
         // against the run's own changed files is the only way to hold it to that.
         const changed = changedPathSet(allChangedFiles(ctx), true);
-        const readable = typeof ctx?.citedFileExists === "function" ? ctx.citedFileExists : undefined;
-        const prText = searchable(ctx?.pullRequest ?? { title: "", description: "" });
+        const prText = searchable(ctx.pullRequest);
         const raised = new Set();
-        const changes = Array.isArray(registration.changes) ? registration.changes : [];
+        const changes = registration.changes;
         for (const change of changes) {
-            const changeId = String(change?.id ?? "?");
-            const cases = Array.isArray(change?.cases) ? change.cases : [];
-            cases.forEach((entry, index) => {
-                // `undefined` is "this case states no expected value"; `null` is a stated
+            const changeId = String(change.id ?? "?");
+            const testCases = change.testCases ?? [];
+            testCases.forEach((entry, index) => {
+                // `undefined` is "this test case states no expected value"; `null` is a stated
                 // expectation that the field comes back null, which needs a source like
                 // any other value.
-                // A case states an expectation either as a value or as the rule behind one,
+                // A test case states an expectation either as a value or as the rule behind one,
                 // and BOTH are read from somewhere: crediting `derived` without reading its
                 // `expectedFrom` let a rule "read" off the running app satisfy the check
                 // this verifier exists to be.
-                if (!entry || (entry.expectedValue === undefined && text(entry.derived).length === 0))
+                if (!entry ||
+                    (entry.expectedValue === undefined &&
+                        text(entry.derived).length === 0))
                     return;
-                const label = caseLabel(change, entry);
-                const where = `${label} (source "${String(entry.expectedFrom ?? "")}")`;
+                const label = testCaseLabel(change, entry);
+                const where = `${label} (source "${entry.expectedFrom ?? ""}")`;
                 const source = readSource(entry.expectedFrom);
-                // One objection per CASE. A single objection listing three cases took one
+                // One objection per TEST CASE. A single objection listing three of them took one
                 // answer that addressed two of them and closed, and the id an answer is
-                // carried forward by must therefore name the case as well as the change.
-                const param = String(entry?.param ?? "").trim() || `case-${index + 1}`;
-                // The CASE, not its parameter. Two bound cases on one parameter each invent
+                // carried forward by must therefore name the test case as well as the change.
+                // `names a case with no \`param\` by its position` omits the field.
+                const param = String(entry.param ?? "").trim() || `case-${index + 1}`;
+                // The TEST CASE, not its parameter. Two bound test cases on one parameter each invent
                 // their own value, and keying on the parameter published one of them and
                 // carried its answer to the other. The rendering is the case's content, so
-                // it is the same string whatever order the cases arrive in — the identity
-                // `coverage:cases` already uses.
-                const caseId = renderCase({ param, value: entry.value, absent: entry.absent, expect: String(entry.expect ?? "") });
+                // it is the same string whatever order the test cases arrive in — the identity
+                // `coverage:testCases` already uses.
+                const testCaseId = renderTestCase({
+                    param,
+                    value: entry.value,
+                    absent: entry.absent,
+                    expect: String(entry.expect ?? ""),
+                });
                 const raise = (kind, objection, evidence) => {
-                    if (raised.has(`${kind}:${changeId}:${caseId}`))
+                    if (raised.has(`${kind}:${changeId}:${testCaseId}`))
                         return;
-                    raised.add(`${kind}:${changeId}:${caseId}`);
+                    raised.add(`${kind}:${changeId}:${testCaseId}`);
                     objections.push({
-                        objectionId: `expectedValueSourced:${kind}:${changeId}:${caseId}`,
+                        objectionId: `expectedValueSourced:${kind}:${changeId}:${testCaseId}`,
                         verifier: "expectedValueSourced",
                         message: objection.message,
                         evidence,
@@ -178,9 +185,9 @@ export const expectedValueSourced = {
                     // Two readings, and the quote settles which one applies. A rule the pull
                     // request states decides values it never writes — "over 60 is rejected"
                     // states no 61, and demanding the value itself objected to five correct
-                    // cases in run 34414643135 — so a case whose source states a rule puts
+                    // test cases in run 34414643135 — so one whose source states a rule puts
                     // that rule in `derived` and declares no number.
-                    const quote = String(change?.quote ?? "").trim();
+                    const quote = String(change.quote ?? "").trim();
                     if (quote.length === 0) {
                         raise("noQuote", CONTRACT.objections.quoteMissing, `${label} reads its value from the pull request; change ${changeId} states no \`quote\``);
                     }
@@ -190,7 +197,9 @@ export const expectedValueSourced = {
                     else if (!statesTheValue(prText, entry.expectedValue)) {
                         // `derived` is the case saying it pins NO number, so a case that still
                         // carries one is not excused by it: the number is what has to be stated.
-                        raise("valueNotQuoted", CONTRACT.objections.valueNotQuoted, `${label} reads ${JSON.stringify(entry.expectedValue)} from the pull request, which writes no such value${text(entry.derived) ? " — and `derived` does not stand in for a value the case still declares" : ""}`);
+                        raise("valueNotQuoted", CONTRACT.objections.valueNotQuoted, `${label} reads ${JSON.stringify(entry.expectedValue)} from the pull request, which writes no such value${text(entry.derived)
+                            ? " — and `derived` does not stand in for a value the case still declares"
+                            : ""}`);
                     }
                 }
                 else if (!source.file) {
@@ -201,7 +210,7 @@ export const expectedValueSourced = {
                     // DELETED is not a spelling problem, it is the rule this check exists for.
                     raise("changedConvention", CONTRACT.objections.changedConvention, `convention cited in a file this pull request changed: ${where}`);
                 }
-                else if (readable && !readable(source.file)) {
+                else if (!ctx.citedFileExists(source.file)) {
                     // A named source nothing opens is a source in name only.
                     raise("unreadable", CONTRACT.objections.unreadableSource, `source file not in the checkout: ${where}`);
                 }
@@ -209,34 +218,36 @@ export const expectedValueSourced = {
         }
         // A test that expects to fail asserts what the code does not return today, so a
         // source outside the code has to state that value, and a case has to carry it.
-        const plannedTests = Array.isArray(registration?.plannedTests) ? registration.plannedTests : [];
+        const plannedTests = registration.plannedTests;
         for (const plannedTest of plannedTests) {
-            if (plannedTest?.declarations?.expected?.outcome !== "fail")
+            if (plannedTest.declarations.expected?.outcome !== "fail")
                 continue;
             // A test that calls nothing sends no case, so it has no case to state a value
             // on. That is the plan-only lane, whose ui tests declare a page and no steps.
-            if (!Array.isArray(plannedTest?.scenario?.steps) || plannedTest.scenario.steps.length === 0)
+            if (plannedTest.scenario.steps.length === 0)
                 continue;
-            const citedIds = (Array.isArray(plannedTest?.declarations?.changes) ? plannedTest.declarations.changes : [])
-                .map((changeId) => (typeof changeId === "string" ? changeId.trim() : ""))
+            const citedIds = (plannedTest.declarations.changes ?? [])
+                .map((changeId) => typeof changeId === "string" ? changeId.trim() : "")
                 .filter((changeId) => changeId.length > 0);
             // An id no change carries is the coverage check's finding, not this one.
-            const cited = changes.filter((change) => citedIds.includes(String(change?.id ?? "").trim()));
+            const cited = changes.filter((change) => citedIds.includes(String(change.id ?? "").trim()));
             if (cited.length === 0)
                 continue;
             // `derived` counts: it states the rule the value follows from, which is a
             // stated value in every sense except that no number is written down.
-            const statesAValue = cited.some((change) => (Array.isArray(change?.cases) ? change.cases : []).some((entry) => entry && (entry.expectedValue !== undefined || text(entry.derived).length > 0)));
+            const statesAValue = cited.some((change) => (change.testCases ?? []).some((entry) => entry &&
+                (entry.expectedValue !== undefined ||
+                    text(entry.derived).length > 0)));
             if (statesAValue)
                 continue;
-            const plannedTestId = String(plannedTest?.plannedTestId ?? "").trim();
+            const plannedTestId = String(plannedTest.plannedTestId ?? "").trim();
             objections.push({
                 objectionId: `expectedValueSourced:noValue:${plannedTestId || "plan"}`,
                 verifier: "expectedValueSourced",
                 ...(plannedTestId ? { plannedTestId } : {}),
                 message: CONTRACT.objections.failWithoutValue.message,
                 evidence: `planned test ${plannedTestId || "(unnamed)"} expects to fail and cites ${cited
-                    .map((change) => String(change?.id ?? "?"))
+                    .map((change) => String(change.id ?? "?"))
                     .join(", ")}; no case on those changes states an \`expectedValue\` or a \`derived\` rule`,
                 suggestion: CONTRACT.objections.failWithoutValue.suggestion,
             });

package/build/recommendation/verifiers/issueTraceability.d.ts

@@ -42,6 +42,11 @@ export interface TraceabilityLane {
  *  list, so an unjoined id would let a report invent a defect and trace every bug
  *  through it.
  *
+ *  A declared `defectId` also counts when a `maintains` entry names it and plan time
+ *  accepted that entry — the same claim a planned test makes. See
+ *  {@link maintainedDefects} for how that acceptance is read.
+ *  `deliveredMatchesPlan:maintains:` checks separately that the edit landed.
+ *
  *  A declared `defectId` also counts when the agent answered `defects:untested:<id>`
  *  at plan time (or closed it with a blocker). The plan-time verifier asked why no
  *  test proves that defect and the agent said; asking again here is the same

package/build/recommendation/verifiers/issueTraceability.js

@@ -1,3 +1,4 @@
+import { maintainedFileObjectionId } from "./existingCoverage.js";
 const NORMAL_LANE = { planOnly: false };
 /** An id as the plan spells it: trimmed, and exact otherwise. */
 function idKey(raw) {
@@ -25,7 +26,9 @@ function expectsToFail(plannedTest) {
 /** How many characters of an issue's description the objection quotes. */
 const QUOTE_LENGTH = 80;
 function quote(description) {
-    const text = String(description ?? "").trim().replace(/\s+/g, " ");
+    const text = String(description ?? "")
+        .trim()
+        .replace(/\s+/g, " ");
     return text.length > QUOTE_LENGTH ? `${text.slice(0, QUOTE_LENGTH)}…` : text;
 }
 /** The plan-time `defects:untested:<id>` objection, as the plan-time verifier ids it. */
@@ -52,6 +55,43 @@ function answeredUntested(plan) {
     }
     return ids;
 }
+/** The declared defect ids a `maintains` entry proves, as plan time judged them.
+ *  Report time has no VerifyContext, so it reads plan time's own verdict on the
+ *  entry's file, `existingCoverage:maintains:<file>`, rather than resolving the path
+ *  again. Every objection bucket is read: an ANSWER to a file-not-found objection
+ *  does not make the file resolve.
+ *
+ *  NOT keyed on `defects:untested:<id>`, which is suppressed whenever a planned test
+ *  cites the same defect, so its absence would read as "accepted".
+ *
+ *  Read defensively: the plan comes off disk. */
+function maintainedDefects(plan) {
+    const judged = new Set();
+    for (const bucket of [
+        plan?.openObjections,
+        plan?.answeredObjections,
+        plan?.unverifiedCloses,
+    ]) {
+        for (const entry of Array.isArray(bucket) ? bucket : []) {
+            const objectionId = idKey(entry?.objectionId ??
+                entry?.objection
+                    ?.objectionId);
+            if (objectionId)
+                judged.add(objectionId);
+        }
+    }
+    const ids = new Set();
+    for (const entry of Array.isArray(plan?.maintains) ? plan.maintains : []) {
+        if (judged.has(maintainedFileObjectionId(entry?.file)))
+            continue;
+        for (const raw of Array.isArray(entry?.defects) ? entry.defects : []) {
+            const id = idKey(raw);
+            if (id)
+                ids.add(id);
+        }
+    }
+    return ids;
+}
 /** Where the defect sits, as the objection quotes it. */
 function locate(defect) {
     const file = String(defect?.file ?? "").trim() || "no file";
@@ -78,13 +118,20 @@ function locate(defect) {
  *  list, so an unjoined id would let a report invent a defect and trace every bug
  *  through it.
  *
+ *  A declared `defectId` also counts when a `maintains` entry names it and plan time
+ *  accepted that entry — the same claim a planned test makes. See
+ *  {@link maintainedDefects} for how that acceptance is read.
+ *  `deliveredMatchesPlan:maintains:` checks separately that the edit landed.
+ *
  *  A declared `defectId` also counts when the agent answered `defects:untested:<id>`
  *  at plan time (or closed it with a blocker). The plan-time verifier asked why no
  *  test proves that defect and the agent said; asking again here is the same
  *  question twice, and the answer is already published with the plan. */
 export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LANE) {
     const shipped = new Set(delivered.map((test) => idKey(test?.plannedTestId)).filter(Boolean));
-    const plannedTests = Array.isArray(plan?.plannedTests) ? plan.plannedTests : [];
+    const plannedTests = Array.isArray(plan?.plannedTests)
+        ? plan.plannedTests
+        : [];
     // The join that gives a delivered test its expected outcome. First entry wins:
     // a repeated id is the plan's own duplicate, and the checks that own it are the
     // plan-time ones.
@@ -95,7 +142,8 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
             plannedById.set(id, plannedTest);
     }
     // In the plan-only lane a planned test stands where a delivered one would.
-    const inHand = (plannedTestId) => shipped.has(plannedTestId) || (lane.planOnly && plannedById.has(plannedTestId));
+    const inHand = (plannedTestId) => shipped.has(plannedTestId) ||
+        (lane.planOnly && plannedById.has(plannedTestId));
     const proves = (plannedTestId) => inHand(plannedTestId) && expectsToFail(plannedById.get(plannedTestId));
     /** Why this id proves nothing, in the words the objection uses. */
     const gap = (plannedTestId) => {
@@ -126,17 +174,24 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
         }
     }
     const answered = answeredUntested(plan);
+    const maintained = maintainedDefects(plan);
     const objections = [];
     issues.forEach((issue, index) => {
-        if (String(issue?.category ?? "").trim().toLowerCase() !== "bug")
+        if (String(issue?.category ?? "")
+            .trim()
+            .toLowerCase() !== "bug")
             return;
         const plannedTestId = idKey(issue?.plannedTestId);
         if (plannedTestId && proves(plannedTestId))
             return;
         const defectId = idKey(issue?.defectId);
         const declaredDefect = defectId.length > 0 && known.has(defectId);
-        if (declaredDefect && ((provenBy.get(defectId) ?? []).length > 0 || answered.has(defectId)))
+        if (declaredDefect &&
+            ((provenBy.get(defectId) ?? []).length > 0 ||
+                maintained.has(defectId) ||
+                answered.has(defectId))) {
             return;
+        }
         const named = [];
         if (plannedTestId)
             named.push(gap(plannedTestId));
@@ -149,7 +204,7 @@ export function checkIssueTraceability(plan, delivered, issues, lane = NORMAL_LA
                 named.push(`defectId "${defectId}" is cited by no ${word} test that expects to fail: ${(citedWeakly.get(defectId) ?? []).join(", ")} cite it and the plan declares each as expecting to pass`);
             }
             else {
-                named.push(`defectId "${defectId}" is cited by no ${word} test that expects to fail and no plan-time answer closed ${UNTESTED_PREFIX}${defectId}`);
+                named.push(`defectId "${defectId}" is cited by no ${word} test that expects to fail, no accepted \`maintains\` entry proves it — an entry naming a file that is not in the checkout is refused — and no plan-time answer closed ${UNTESTED_PREFIX}${defectId}`);
             }
         }
         const where = String(issue?.sourceFile ?? "").trim() || "no sourceFile";
@@ -175,7 +230,9 @@ export function checkDefectsReported(plan, issues) {
     // Configuration Errors section — a defect parked there is one the reader never
     // meets under Issues Found, and it would close this check all the same.
     const reported = new Set(issues
-        .filter((issue) => String(issue?.category ?? "").trim().toLowerCase() === "bug")
+        .filter((issue) => String(issue?.category ?? "")
+        .trim()
+        .toLowerCase() === "bug")
         .map((issue) => idKey(issue?.defectId))
         .filter(Boolean));
     const objections = [];

package/build/recommendation/verifiers/removedElementGuarded.js

@@ -1,4 +1,4 @@
-import { REMOVED_ELEMENT_GUARDED_CONTRACT, fillPlaceholders } from "../verifierContracts.js";
+import { REMOVED_ELEMENT_GUARDED_CONTRACT, fillPlaceholders, } from "../verifierContracts.js";
 import { escapeRegExp } from "../../utils/regex.js";
 /** Verifier 9. Every element the diff removed needs a planned test that says it is
  *  gone.
@@ -19,11 +19,10 @@ import { escapeRegExp } from "../../utils/regex.js";
  *  rather than accuses. `data-*` only, all the extractor reads; a renamed `aria-label`
  *  is the prompt's to catch. */
 const { missing: MISSING, retired: RETIRED } = REMOVED_ELEMENT_GUARDED_CONTRACT.objections;
-const text = (value) => (typeof value === "string" ? value.trim() : "");
+const text = (value) => typeof value === "string" ? value.trim() : "";
 function declaresElement(plannedTest, value) {
-    const declared = plannedTest?.declarations;
-    const items = Array.isArray(declared?.elements?.items) ? declared.elements.items : [];
-    return items.some((item) => text(item?.testId) === value || text(item?.stableId) === value);
+    const items = plannedTest.declarations.elements?.items ?? [];
+    return items.some((item) => text(item.testId) === value || text(item.stableId) === value);
 }
 /** How a plan names an element. `testId` is the one field that carries the value
  *  for a `data-testid`; a guard on `data-cy` or `data-qa` reaches the plan with
@@ -31,7 +30,10 @@ function declaresElement(plannedTest, value) {
 function namesElement(plannedTest, value) {
     if (declaresElement(plannedTest, value))
         return true;
-    return [text(plannedTest?.declarations?.asserts), text(plannedTest?.plannedTestId)].some((prose) => prose.includes(value));
+    return [
+        String(plannedTest.declarations.asserts ?? "").trim(),
+        String(plannedTest.plannedTestId ?? "").trim(),
+    ].some((prose) => prose.includes(value));
 }
 /** Whole-identifier match. This case objects on a hit, so `includes` would raise
  *  `nav-clear` against a test about `nav-clear-state-banner`. */
@@ -43,7 +45,7 @@ function mentionsIdentifier(prose, value) {
 function retiredIdentifierNamedBy(plannedTest, value) {
     if (declaresElement(plannedTest, value))
         return true;
-    return mentionsIdentifier(text(plannedTest?.declarations?.asserts), value);
+    return mentionsIdentifier(String(plannedTest.declarations.asserts ?? "").trim(), value);
 }
 /** `attribute=value` identifies an element across the run, so the objection id is
  *  the same string on every registration whatever order the list arrives in. */
@@ -74,7 +76,9 @@ export const removedElementGuarded = {
             objections.push({
                 objectionId,
                 verifier: "removedElementGuarded",
-                message: fillPlaceholders(MISSING.message, { element: `${attribute}="${value}"` }),
+                message: fillPlaceholders(MISSING.message, {
+                    element: `${attribute}="${value}"`,
+                }),
                 evidence: `removed from ${text(element?.file) || "a changed frontend file"}; no planned test names ${value}`,
                 suggestion: MISSING.suggestion,
             });
@@ -82,7 +86,9 @@ export const removedElementGuarded = {
         // Also removed somewhere means removed, whatever one hunk's pairing made of it.
         // Keyed the way the rest of the contract keys an element: `data-cy="legacy"` going
         // away says nothing about `data-testid="legacy"` being renamed.
-        const removedKeys = new Set(removed.map((element) => `${text(element?.attribute)}=${text(element?.value)}`).filter((key) => key !== "="));
+        const removedKeys = new Set(removed
+            .map((element) => `${text(element?.attribute)}=${text(element?.value)}`)
+            .filter((key) => key !== "="));
         for (const element of retired) {
             const value = text(element?.value);
             const attribute = text(element?.attribute);
@@ -91,7 +97,7 @@ export const removedElementGuarded = {
             for (const plannedTest of plannedTests) {
                 if (!retiredIdentifierNamedBy(plannedTest, value))
                     continue;
-                const plannedTestId = text(plannedTest?.plannedTestId);
+                const plannedTestId = String(plannedTest.plannedTestId ?? "").trim();
                 const objectionId = retiredObjectionIdFor(element, plannedTestId);
                 if (seen.has(objectionId))
                     continue;
@@ -100,7 +106,9 @@ export const removedElementGuarded = {
                     objectionId,
                     verifier: "removedElementGuarded",
                     ...(plannedTestId ? { plannedTestId } : {}),
-                    message: fillPlaceholders(RETIRED.message, { element: `${attribute}="${value}"` }),
+                    message: fillPlaceholders(RETIRED.message, {
+                        element: `${attribute}="${value}"`,
+                    }),
                     evidence: `${text(element?.file) || "a changed frontend file"} pairs ${value} with a new identifier on the same element, which reads as a rename; planned test ${plannedTestId || "(unnamed)"} names ${value}`,
                     suggestion: RETIRED.suggestion,
                 });

package/build/recommendation/verifiers/reportedCategory.js

@@ -45,8 +45,12 @@ export function checkRequirementConflictReported(plan, delivered, issues) {
     const conflicts = delivered.filter((test) => normalizeCategory(plannedCategory(plan, test)) === "requirement_conflict");
     if (conflicts.length === 0)
         return [];
-    const severities = issues.map((issue) => String(issue?.severity ?? "").trim().toLowerCase());
-    const isAtFloor = (issue) => REQUIREMENT_CONFLICT_FLOOR.includes(String(issue?.severity ?? "").trim().toLowerCase());
+    const severities = issues.map((issue) => String(issue?.severity ?? "")
+        .trim()
+        .toLowerCase());
+    const isAtFloor = (issue) => REQUIREMENT_CONFLICT_FLOOR.includes(String(issue?.severity ?? "")
+        .trim()
+        .toLowerCase());
     const atFloor = issues.filter(isAtFloor);
     if (atFloor.length === 0) {
         const named = conflicts.map((test) => test.fileName).join(", ");
@@ -67,8 +71,9 @@ export function checkRequirementConflictReported(plan, delivered, issues) {
     // report whose issues name no planned test keeps the run-level answer above.
     if (!issues.some((issue) => String(issue?.plannedTestId ?? "").trim().length > 0))
         return [];
-    const unnamed = conflicts.filter((test) => !atFloor.some((issue) => String(issue?.plannedTestId ?? "").trim() === String(test.plannedTestId ?? "").trim()
-        && String(test.plannedTestId ?? "").trim().length > 0));
+    const unnamed = conflicts.filter((test) => !atFloor.some((issue) => String(issue?.plannedTestId ?? "").trim() ===
+        String(test.plannedTestId ?? "").trim() &&
+        String(test.plannedTestId ?? "").trim().length > 0));
     if (unnamed.length === 0)
         return [];
     return [

package/build/recommendation/verifiers/requirementSourced.js

@@ -1,5 +1,5 @@
 import { normalizeCategory } from "../../types/TestRecommendation.js";
-import { REQUIREMENT_SOURCED_CONTRACT, fillPlaceholders } from "../verifierContracts.js";
+import { REQUIREMENT_SOURCED_CONTRACT, fillPlaceholders, } from "../verifierContracts.js";
 import { normalizeCitedPath } from "./citedPath.js";
 import { appearsIn, searchable } from "../pullRequestText.js";
 /** Verifier 10. A change names where the agent read it, and the server reads the
@@ -19,8 +19,12 @@ import { appearsIn, searchable } from "../pullRequestText.js";
 const { unsourced: UNSOURCED, unreadable: UNREADABLE, fromDiff: FROM_DIFF, noChange: NO_CHANGE, notNamed: NOT_NAMED, emptyPullRequest: EMPTY_PULL_REQUEST, notQuoted: NOT_QUOTED, unquoted: UNQUOTED, } = REQUIREMENT_SOURCED_CONTRACT.objections;
 const CONFLICT_CATEGORY = "requirement_conflict";
 function readSource(raw) {
-    const none = (kind) => ({ kind, file: "", citedAs: "" });
-    const source = typeof raw === "string" ? raw.trim() : "";
+    const none = (kind) => ({
+        kind,
+        file: "",
+        citedAs: "",
+    });
+    const source = raw.trim();
     if (source.length === 0)
         return none("unknown");
     if (/^(pr-title|pr-description)$/i.test(source))
@@ -41,24 +45,24 @@ function readSource(raw) {
 }
 /** A source that stands for a requirement: the pull request, or a requirements file. */
 const statesARequirement = (source) => source.kind === "pullRequest" || source.kind === "spec";
-const text = (value) => (typeof value === "string" ? value.trim() : "");
-const list = (value) => (Array.isArray(value) ? value : []);
 export const requirementSourced = {
     name: "requirementSourced",
     run(registration, ctx) {
-        const changes = list(registration?.changes);
-        const plannedTests = list(registration?.plannedTests);
+        const changes = registration.changes;
+        const plannedTests = registration.plannedTests;
         const objections = [];
         const sourceById = new Map();
         const quoteById = new Map();
         const pullRequestText = searchable(ctx.pullRequest);
         for (const change of changes) {
-            const changeId = text(change?.id) || "(unnamed)";
-            const written = text(change?.source);
+            const id = String(change.id ?? "").trim();
+            const changeId = id || "(unnamed)";
+            // `objects when a change states no source` sends `source: undefined`.
+            const written = typeof change.source === "string" ? change.source.trim() : "";
             const source = readSource(written);
-            if (text(change?.id)) {
-                sourceById.set(text(change.id), source);
-                quoteById.set(text(change.id), typeof change?.quote === "string" ? change.quote : undefined);
+            if (id) {
+                sourceById.set(id, source);
+                quoteById.set(id, typeof change.quote === "string" ? change.quote : undefined);
             }
             if (source.kind === "unknown") {
                 objections.push({
@@ -76,7 +80,9 @@ export const requirementSourced = {
                 objections.push({
                     objectionId: `requirementSourced:emptyPullRequest:${changeId}`,
                     verifier: "requirementSourced",
-                    message: fillPlaceholders(EMPTY_PULL_REQUEST.message, { change: changeId }),
+                    message: fillPlaceholders(EMPTY_PULL_REQUEST.message, {
+                        change: changeId,
+                    }),
                     evidence: `change ${changeId} states source \`${written}\`; this run rendered its prompt with no title and no description`,
                     suggestion: EMPTY_PULL_REQUEST.suggestion,
                 });
@@ -84,11 +90,14 @@ export const requirementSourced = {
             }
             if (source.kind !== "spec")
                 continue;
-            if (typeof ctx?.citedFileExists === "function" && !ctx.citedFileExists(source.file)) {
+            if (!ctx.citedFileExists(source.file)) {
                 objections.push({
                     objectionId: `requirementSourced:unreadable:${changeId}`,
                     verifier: "requirementSourced",
-                    message: fillPlaceholders(UNREADABLE.message, { change: changeId, source: written }),
+                    message: fillPlaceholders(UNREADABLE.message, {
+                        change: changeId,
+                        source: written,
+                    }),
                     evidence: `change ${changeId} states source \`${written}\`; ${source.file} is not a file in the run's repositories`,
                     suggestion: UNREADABLE.suggestion,
                 });
@@ -96,25 +105,29 @@ export const requirementSourced = {
             }
             // A requirements file the pull request never names is a file the agent found by
             // looking through the repository, which is not reading a requirement.
-            if (appearsIn(pullRequestText, source.file) || appearsIn(pullRequestText, source.citedAs))
+            if (appearsIn(pullRequestText, source.file) ||
+                appearsIn(pullRequestText, source.citedAs))
                 continue;
             objections.push({
                 objectionId: `requirementSourced:notNamed:${changeId}`,
                 verifier: "requirementSourced",
-                message: fillPlaceholders(NOT_NAMED.message, { change: changeId, source: written }),
+                message: fillPlaceholders(NOT_NAMED.message, {
+                    change: changeId,
+                    source: written,
+                }),
                 evidence: `change ${changeId} states source \`${written}\`; neither the title nor the description names ${source.file}`,
                 suggestion: NOT_NAMED.suggestion,
             });
         }
         for (const plannedTest of plannedTests) {
-            if (normalizeCategory(plannedTest?.scenario?.category) !== CONFLICT_CATEGORY)
+            if (normalizeCategory(plannedTest.scenario.category) !== CONFLICT_CATEGORY)
                 continue;
-            const plannedTestId = text(plannedTest?.plannedTestId);
+            const plannedTestId = String(plannedTest.plannedTestId ?? "").trim();
             const named = plannedTestId ? { plannedTestId } : {};
             // An id no change carries names nothing, so it says no more than citing
             // nothing does. Both leave the requirement with no stated origin.
-            const cited = list(plannedTest?.declarations?.changes)
-                .map((changeId) => text(changeId))
+            const cited = (plannedTest.declarations.changes ?? [])
+                .map((changeId) => String(changeId ?? "").trim())
                 .filter((changeId) => sourceById.has(changeId));
             if (cited.length === 0) {
                 objections.push({

package/build/recommendation/verifiers/screenRoute.js

@@ -27,14 +27,16 @@ function fills(pattern, path) {
  *  a route path on a lane where no host serves the app and an absolute url when
  *  one does; both name the same page. */
 function urlPath(raw) {
-    const value = String(raw ?? "").trim();
+    const value = raw.trim();
     if (!value)
         return "";
     try {
         return new URL(value).pathname.replace(/\/+$/, "") || "/";
     }
     catch {
-        return value.startsWith("/") ? value.split(/[?#]/)[0].replace(/\/+$/, "") || "/" : "";
+        return value.startsWith("/")
+            ? value.split(/[?#]/)[0].replace(/\/+$/, "") || "/"
+            : "";
     }
 }
 function field(value) {
@@ -44,12 +46,12 @@ function field(value) {
  *  for it. A resolver that throws or answers with the wrong type is treated as
  *  one that cannot speak: a scan is best-effort, and its failure is not evidence
  *  about the plan. */
-function routesFor(ctx, file) {
-    if (typeof ctx?.routesRenderingFile !== "function")
-        return undefined;
+function routesFor(ctx, file, repository) {
     try {
-        const routes = ctx.routesRenderingFile(file);
-        return Array.isArray(routes) ? routes.map(field).filter(Boolean) : undefined;
+        const routes = ctx.routesRenderingFile(file, repository);
+        return Array.isArray(routes)
+            ? routes.map(field).filter(Boolean)
+            : undefined;
     }
     catch {
         return undefined;
@@ -73,7 +75,7 @@ export const screenRoute = {
         for (const plannedTest of registration.plannedTests ?? []) {
             if (!isUIPlannedTest(plannedTest))
                 continue;
-            const elements = plannedTest.declarations?.elements;
+            const elements = plannedTest.declarations.elements;
             const url = field(elements && typeof elements === "object" ? elements.pageUrl : "");
             // `uiElementGrounded:pagecontext` already objects to an empty pageUrl.
             if (!url)
@@ -84,10 +86,13 @@ export const screenRoute = {
             // `screenEvidence.file` names the file that renders the screen; on a mixed
             // PR that is not the file the test is about. `changedFile` is the fallback,
             // and `changedFile:notStated` already objects when neither is stated.
-            const screen = field(plannedTest.declarations?.screenEvidence?.file) || field(plannedTest.declarations?.changedFile);
+            const screen = field(plannedTest.declarations.screenEvidence?.file) ||
+                field(plannedTest.declarations.changedFile);
             if (!screen)
                 continue;
-            const routes = routesFor(ctx, screen);
+            // The test's OWN repository: its file is checked against the routes of the
+            // repository it names, not of whichever one holds a file of that name.
+            const routes = routesFor(ctx, screen, plannedTest.repository);
             // The resolver does not know this file. Not a fact about the plan.
             if (routes === undefined)
                 continue;