@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/recommendation/verifiers/coverage.js

@@ -1,8 +1,8 @@
-import { allChangedFiles } from "../types.js";
+import { allChangedFiles, } from "../types.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
-import { escapesRepo, LOCKFILE, NOT_A_ROUTE_FILE, NOT_SOURCE_DIR } from "./endpointGrounded.js";
+import { LOCKFILE, NOT_A_ROUTE_FILE, NOT_SOURCE_DIR, } from "./endpointGrounded.js";
 import { isTestPath } from "../../utils/testFileClassification.js";
-import { normalizeCitedPath } from "./citedPath.js";
+import { maintainedFileIsInItsRepository, normalizeCitedPath, } from "./citedPath.js";
 import { COVERAGE_CONTRACT, fillPlaceholders } from "../verifierContracts.js";
 import { isUIPlannedTest, stateRouteKey, subjectStep } from "../subjectStep.js";
 /** Whether a path can be product code at all, by the deny list route grounding
@@ -12,32 +12,32 @@ function couldBeProductCode(file) {
     const path = file.trim();
     if (!path)
         return false;
-    return !(isTestPath(path) || NOT_SOURCE_DIR.test(path) || LOCKFILE.test(path) || NOT_A_ROUTE_FILE.test(path));
-}
-/** Every changed file some planned test cites, in normalised spelling. THREE fields,
- *  all name-level: `changedFile`, `routes[].file` and `screenEvidence.file`
- *  — citing a changed file through any of them is being about that file. Coverage
- *  by citation reads names alone, where an anchor search needed the diff text. */
-function citedFiles(plannedTests) {
-    const cited = new Set();
+    return !(isTestPath(path) ||
+        NOT_SOURCE_DIR.test(path) ||
+        LOCKFILE.test(path) ||
+        NOT_A_ROUTE_FILE.test(path));
+}
+/** The files one planned test cites, in normalised spelling. THREE fields, all
+ *  name-level: `changedFile`, `routes[].file` and `screenEvidence.file` — citing a
+ *  changed file through any of them is being about that file. Coverage by citation
+ *  reads names alone, where an anchor search needed the diff text. */
+function citedPaths(plannedTest) {
+    const cited = [];
     const add = (value) => {
         const path = normalizeCitedPath(value);
         if (path)
-            cited.add(path);
+            cited.push(path);
     };
-    for (const plannedTest of plannedTests) {
-        add(plannedTest?.declarations?.changedFile);
-        add(plannedTest?.declarations?.screenEvidence?.file);
-        // The plan is read off disk, so this is an array only on the validated
-        // path. A throw here would reach the agent as `:crashed`, hiding the real
-        // objection instead of raising it.
-        const evidence = plannedTest?.declarations?.routes;
-        if (Array.isArray(evidence))
-            for (const entry of evidence)
-                add(entry?.file);
-    }
+    add(plannedTest.declarations.changedFile);
+    add(plannedTest.declarations.screenEvidence?.file);
+    for (const entry of plannedTest.declarations.routes ?? [])
+        add(entry.file);
     return cited;
 }
+/** Every file some planned test cites. */
+function citedFiles(plannedTests) {
+    return new Set(plannedTests.flatMap(citedPaths));
+}
 /** The behaviour ids the plan cites, trimmed — from its planned tests AND from the
  *  existing tests it maintains. A change covered by a spec this run edits is tested;
  *  counting only planned tests made `coverage:change:` unanswerable for a correct
@@ -45,34 +45,25 @@ function citedFiles(plannedTests) {
  *  nothing stopped the run.
  *
  *  A maintenance entry credits its ids only when the file it names RESOLVES in the
- *  checkout. `existingCoverage` objects about an unresolvable one, but that objection
+ *  repository the entry names. `existingCoverage` objects about an unresolvable one, but that objection
  *  takes prose, so crediting first would have handed `coverage:change:` — the one
  *  class a sentence cannot close, and the reason `BLOCKER_ONLY_PREFIX` exists — a
  *  route out through a file name nobody can open. */
-function citedBehaviors(plannedTests, maintains = [], fileResolves = () => false) {
+function citedBehaviors(plannedTests, maintains = [], entryResolves = () => false) {
     const cited = new Set();
-    for (const entry of maintains) {
-        const ids = entry?.changes;
-        if (!Array.isArray(ids))
-            continue;
-        if (!fileResolves(String(entry?.file ?? "").trim()))
-            continue;
+    const add = (ids) => {
         for (const id of ids) {
-            const trimmed = String(id ?? "").trim();
-            if (trimmed)
-                cited.add(trimmed);
-        }
-    }
-    for (const plannedTest of plannedTests) {
-        const declared = plannedTest?.declarations?.changes;
-        if (!Array.isArray(declared))
-            continue;
-        for (const id of declared) {
-            const trimmed = String(id ?? "").trim();
+            const trimmed = id.trim();
             if (trimmed)
                 cited.add(trimmed);
         }
+    };
+    for (const entry of maintains) {
+        if (entryResolves(entry))
+            add(entry.changes);
     }
+    for (const plannedTest of plannedTests)
+        add(plannedTest.declarations.changes ?? []);
     return cited;
 }
 /** Every declared behaviour needs a planned test citing it, or an answer. Coverage per
@@ -82,8 +73,8 @@ function citedBehaviors(plannedTests, maintains = [], fileResolves = () => false
  *  Checked whether or not the run has a diff: the agent declared these itself, so
  *  there is always something to hold it to. */
 function claimObjections(registration, ctx) {
-    const changes = Array.isArray(registration.changes) ? registration.changes : [];
-    const plannedTests = registration.plannedTests ?? [];
+    const changes = registration.changes;
+    const plannedTests = registration.plannedTests;
     const objections = [];
     if (changes.length === 0) {
         return [
@@ -98,15 +89,17 @@ function claimObjections(registration, ctx) {
     }
     const declared = new Set();
     for (const change of changes) {
-        const id = String(change?.id ?? "").trim();
+        const id = String(change.id ?? "").trim();
         if (id)
             declared.add(id);
     }
-    const maintains = Array.isArray(registration.maintains) ? registration.maintains : [];
-    const cited = citedBehaviors(plannedTests, maintains, (file) => !!file && !escapesRepo(file) && ctx.citedFileExists(file));
+    const maintains = Array.isArray(registration.maintains)
+        ? registration.maintains
+        : [];
+    const cited = citedBehaviors(plannedTests, maintains, (entry) => maintainedFileIsInItsRepository(entry, ctx));
     const seen = new Set();
     for (const change of changes) {
-        const id = String(change?.id ?? "").trim();
+        const id = String(change.id ?? "").trim();
         if (!id || seen.has(id))
             continue;
         seen.add(id);
@@ -116,17 +109,19 @@ function claimObjections(registration, ctx) {
             objectionId: `coverage:change:${id}`,
             verifier: "coverage",
             message: COVERAGE_CONTRACT.objections.change.message,
-            evidence: `"${String(change?.text ?? "").trim()}" (${String(change?.source ?? "").trim()}): no planned test cites behaviour ${id}.`,
+            evidence: `"${String(change.text ?? "").trim()}" (${String(change.source ?? "").trim()}): no planned test cites behaviour ${id}.`,
             suggestion: COVERAGE_CONTRACT.objections.change.suggestion,
         });
     }
     // One objection per planned test, not per id: a planned test with three unknown ids
     // has one mistake to fix, and three objections would need three answers.
     for (const plannedTest of plannedTests) {
-        const claimIds = plannedTest?.declarations?.changes;
+        const claimIds = plannedTest.declarations.changes;
         if (!Array.isArray(claimIds))
             continue;
-        const unknown = [...new Set(claimIds.map((id) => String(id ?? "").trim()))].filter((id) => id && !declared.has(id));
+        const unknown = [
+            ...new Set(claimIds.map((id) => String(id ?? "").trim())),
+        ].filter((id) => id && !declared.has(id));
         if (unknown.length === 0)
             continue;
         objections.push({
@@ -144,12 +139,17 @@ function claimObjections(registration, ctx) {
 /** The methods that write. A GET reads what is already there, so what the record
  *  held before the call decides nothing; these four run new code against a value
  *  the change did not write, which is where a latent bug sits. */
-const MUTATING_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+const MUTATING_METHODS = new Set([
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+]);
 /** Whether a planned test names the state its starting record is in. Presence is all
  *  that is checked: no two repositories describe a record's state the same way, and
  *  the test puts the record in that state itself rather than reading it from a file. */
 function declaresStartState(plannedTest) {
-    return String(plannedTest?.declarations?.startState ?? "").trim().length > 0;
+    return String(plannedTest.declarations.startState ?? "").trim().length > 0;
 }
 /** The route a planned test's test mutates, by SHAPE — `stateRouteKey`, so the id a
  *  step happened to write does not split one route in two. UI planned tests are OUT:
@@ -159,7 +159,9 @@ function mutatedRoute(plannedTest) {
     if (isUIPlannedTest(plannedTest))
         return undefined;
     const step = subjectStep(plannedTest);
-    if (!MUTATING_METHODS.has(String(step?.method ?? "").trim().toUpperCase()))
+    if (!MUTATING_METHODS.has(String(step?.method ?? "")
+        .trim()
+        .toUpperCase()))
         return undefined;
     return stateRouteKey(step);
 }
@@ -184,7 +186,7 @@ function routesTestedFromNonDefaultState(plannedTests) {
  *  half — the agent declared the mutation itself, so a run with no diff has
  *  something to hold it to. */
 function stateTestObjections(registration) {
-    const plannedTests = registration.plannedTests ?? [];
+    const plannedTests = registration.plannedTests;
     const covered = routesTestedFromNonDefaultState(plannedTests);
     const objections = [];
     const seen = new Set();
@@ -205,7 +207,7 @@ function stateTestObjections(registration) {
     }
     return objections;
 }
-// ── The declared cases ──────────────────────────────────────────────────────
+// ── The declared test cases ─────────────────────────────────────────────────
 /** One number, from a value a step sends or a case declares. A parameter is as
  *  often a string as a number, so `"100"` and `100` are one value. Anything else
  *  is no number at all: `Number("")` is 0, which would read as a value that was
@@ -241,7 +243,9 @@ function sameValue(sent, declared) {
     if (sentIsStructure || declaredIsStructure) {
         // Both sides are non-null objects by the guard above, so neither call can be
         // the `undefined` the helper returns for a value JSON renders as nothing.
-        return sentIsStructure && declaredIsStructure && canonicalJson(sent) === canonicalJson(declared);
+        return (sentIsStructure &&
+            declaredIsStructure &&
+            canonicalJson(sent) === canonicalJson(declared));
     }
     const sentNumber = asNumber(sent);
     const declaredNumber = asNumber(declared);
@@ -315,11 +319,16 @@ function valuesSent(step, param) {
     const found = [];
     // A query parameter is flat and its own name can hold a dot, so the query answers
     // the parameter as written. Only the body is read as a path.
-    const query = String(step?.path ?? "").split("?").slice(1).join("?");
+    const query = String(step?.path ?? "")
+        .split("?")
+        .slice(1)
+        .join("?");
     if (query)
         found.push(...new URLSearchParams(query).getAll(param));
     const queryParams = step?.queryParams;
-    if (queryParams && typeof queryParams === "object" && !Array.isArray(queryParams)) {
+    if (queryParams &&
+        typeof queryParams === "object" &&
+        !Array.isArray(queryParams)) {
         const fields = queryParams;
         if (param in fields)
             found.push(fields[param]);
@@ -333,7 +342,10 @@ const METHOD_PARAM = "method";
 const PLACEHOLDER_SEGMENT = /^(?:\{(.+)\}|:(.+)|\[(.+)\])$/;
 /** A step's path segments, with any query string dropped. */
 function pathSegments(step) {
-    return String(step?.path ?? "").split("?")[0].trim().split("/");
+    return String(step?.path ?? "")
+        .split("?")[0]
+        .trim()
+        .split("/");
 }
 /** The parameter a placeholder segment names, or undefined for a literal one. */
 function placeholderName(segment) {
@@ -345,7 +357,7 @@ function placeholderName(segment) {
 /** Where `param` sits in a path, according to the steps that write it as a
  *  placeholder. Only the plan says this: no route template is inferred from a
  *  concrete path, so a plan whose steps are all concrete yields no slot and its
- *  path cases read as not sent. */
+ *  path test cases read as not sent. */
 function pathSlots(steps, param) {
     const slots = [];
     for (const step of steps) {
@@ -363,9 +375,9 @@ function pathSlots(steps, param) {
  *  parameter, so its inner name counts as a name for `param` as well. The plan is
  *  still the only source: the names come from what it declares, never from a
  *  concrete path. */
-function pathSlotNames(cases, param) {
+function pathSlotNames(testCases, param) {
     const names = new Set([param]);
-    for (const declared of cases ?? []) {
+    for (const declared of testCases ?? []) {
         if (String(declared?.param ?? "").trim() !== param)
             continue;
         if (declared?.expect !== "accept" || declared?.absent === true)
@@ -395,8 +407,8 @@ function soleSlots(steps) {
     return slots;
 }
 /** Where `param` sits in a path, under any of the names it wears. */
-function pathSlotsFor(steps, cases, param) {
-    const named = pathSlotNames(cases, param).flatMap((name) => pathSlots(steps, name));
+function pathSlotsFor(steps, testCases, param) {
+    const named = pathSlotNames(testCases, param).flatMap((name) => pathSlots(steps, name));
     return ID_PARAM.test(param) ? [...named, ...soleSlots(steps)] : named;
 }
 /** Whether a step carries `value` in the segment `param` occupies. Every other
@@ -417,7 +429,9 @@ function sendsInPath(step, slot, value) {
  *  used when the parameter has no slot at all: where the plan does say where the
  *  parameter sits, the slot rule stands. */
 function sendsAsPathSegment(step, value) {
-    if (value === undefined || value === null || String(value).trim().length === 0)
+    if (value === undefined ||
+        value === null ||
+        String(value).trim().length === 0)
         return false;
     return pathSegments(step).some((segment) => sameValue(segment.trim(), value));
 }
@@ -440,18 +454,17 @@ function omittedBy(step, param) {
 /** One declared case as the objection spells it.
  *
  *  Exported: `expectedValueSourced` keys its objections on the same rendering, so
- *  two cases on one parameter are two objections there too. */
-export function renderCase(declared) {
+ *  two test cases on one parameter are two objections there too. */
+export function renderTestCase(declared) {
     const param = String(declared.param).trim();
     const sent = declared.absent === true ? "absent" : `=${JSON.stringify(declared.value)}`;
     return `${param}${declared.absent === true ? " " : ""}${sent} (${declared.expect})`;
 }
 /** Whether a planned test cites one change by id. */
 function citesChange(plannedTest, id) {
-    const declared = plannedTest?.declarations?.changes;
-    if (!Array.isArray(declared))
-        return false;
-    return declared.some((cited) => String(cited ?? "").trim() === id);
+    const declared = plannedTest.declarations.changes;
+    return (Array.isArray(declared) &&
+        declared.some((cited) => String(cited ?? "").trim() === id));
 }
 /** Every declared case needs a step of a citing test that sends it. The agent says
  *  what proves the change; the server reads whether the plan sends it. Nothing here
@@ -466,18 +479,18 @@ function citesChange(plannedTest, id) {
  *  parameter says nothing, so the omission has to be stated to be checked.
  *
  *  A case names a query parameter, a body field, a path segment, or the verb. Run
- *  34078857176 declared five cases the plan did send — two ids in a path segment,
+ *  34078857176 declared five test cases the plan did send — two ids in a path segment,
  *  two rejected methods — and drew an objection for each, because only the query
  *  string and the body were read. */
-function caseObjections(registration) {
-    const changes = Array.isArray(registration.changes) ? registration.changes : [];
-    const plannedTests = registration.plannedTests ?? [];
+function testCaseObjections(registration) {
+    const changes = registration.changes;
+    const plannedTests = registration.plannedTests;
     const objections = [];
     const seen = new Set();
     for (const change of changes) {
-        const id = String(change?.id ?? "").trim();
-        const cases = change?.cases;
-        if (!id || !Array.isArray(cases) || cases.length === 0 || seen.has(id))
+        const id = String(change.id ?? "").trim();
+        const testCases = change.testCases;
+        if (!id || !testCases || seen.has(id))
             continue;
         // A change nothing cites already draws `coverage:change:<id>`. A second
         // objection about the same gap would need a second answer for one fix.
@@ -486,39 +499,42 @@ function caseObjections(registration) {
             continue;
         seen.add(id);
         const citingSteps = citing.flatMap((plannedTest) => {
-            const steps = plannedTest?.scenario?.steps;
+            const steps = plannedTest.scenario.steps;
             return Array.isArray(steps) ? steps : [];
         });
         const writesAnyPlaceholder = citingSteps.some((step) => pathSegments(step).some((segment) => placeholderName(segment) !== undefined));
-        const missing = cases.filter((declared) => {
+        const missing = testCases.filter((declared) => {
             const param = String(declared?.param ?? "").trim();
             if (!param)
                 return false;
             if (declared.absent === true)
                 return !citingSteps.some((step) => omittedBy(step, param));
-            const slots = pathSlotsFor(citingSteps, cases, param);
+            const slots = pathSlotsFor(citingSteps, testCases, param);
             const isMethod = param.toLowerCase() === METHOD_PARAM;
             // Only for a plan that wrote NO template at all, and only for a parameter that
             // names a record. Wider than that, the URL answered everything: a `quantity=5`
             // case passed on `GET /api/v1/orders/5`.
-            const byValueInPath = slots.length === 0 && !writesAnyPlaceholder && ID_PARAM.test(param) && !isMethod;
+            const byValueInPath = slots.length === 0 &&
+                !writesAnyPlaceholder &&
+                ID_PARAM.test(param) &&
+                !isMethod;
             return !citingSteps.some((step) => valuesSent(step, param).some((sent) => sameValue(sent, declared.value)) ||
                 (isMethod && sendsAsMethod(step, declared.value)) ||
                 slots.some((slot) => sendsInPath(step, slot, declared.value)) ||
                 (byValueInPath && sendsAsPathSegment(step, declared.value)));
         });
-        // 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: run 34167252679 answered
         // patch-highlight-guards for id="abc" and id=999999, and the third case, a
         // second user's id no step ever sent, went with it. The id carries the
         // rendered case, so it is the same string on the next registration whatever
-        // order the cases arrive in, and each one needs its own answer.
+        // order the test cases arrive in, and each one needs its own answer.
         for (const declared of missing) {
-            const rendered = renderCase(declared);
+            const rendered = renderTestCase(declared);
             objections.push({
-                objectionId: `coverage:cases:${id}:${rendered}`,
+                objectionId: `coverage:testCases:${id}:${rendered}`,
                 verifier: "coverage",
-                message: fillPlaceholders(COVERAGE_CONTRACT.objections.cases.message, { missing: rendered }),
+                message: fillPlaceholders(COVERAGE_CONTRACT.objections.testCases.message, { missing: rendered }),
                 evidence: `${citing.map((plannedTest) => plannedTest.plannedTestId).join(", ")} cite ${id}; no step of theirs sends ${rendered}.` +
                     // Which spelling WOULD have matched, or the agent re-sends the same plan.
                     // Id parameters only: it asked for `{quantity}` in a route otherwise.
@@ -526,7 +542,7 @@ function caseObjections(registration) {
                         citingSteps.some((step) => sendsAsPathSegment(step, declared.value))
                         ? ` A step's path carries that value, in a segment this plan's own placeholders do not name \`${String(declared?.param ?? "").trim()}\`; write the route as a template, with \`{${String(declared?.param ?? "").trim()}}\` where it sits.`
                         : ""),
-                suggestion: COVERAGE_CONTRACT.objections.cases.suggestion,
+                suggestion: COVERAGE_CONTRACT.objections.testCases.suggestion,
             });
         }
     }
@@ -550,11 +566,13 @@ function isPlaceholderValue(value) {
 function paramsWithValuedReject(changes) {
     const rejected = new Set();
     for (const change of changes) {
-        const cases = change?.cases;
-        if (!Array.isArray(cases))
+        const testCases = change.testCases;
+        if (!testCases)
             continue;
-        for (const declared of cases) {
-            if (declared?.expect !== "reject" || declared?.absent === true || declared?.value === undefined)
+        for (const declared of testCases) {
+            if (declared?.expect !== "reject" ||
+                declared?.absent === true ||
+                declared?.value === undefined)
                 continue;
             const param = String(declared?.param ?? "").trim();
             if (param)
@@ -573,15 +591,15 @@ function paramsWithValuedReject(changes) {
  *  placeholder names a record an earlier step created, and the parameter is an id
  *  either by its name or because a citing test sends it as a path segment. */
 function rejectObjections(registration) {
-    const changes = Array.isArray(registration.changes) ? registration.changes : [];
-    const plannedTests = registration.plannedTests ?? [];
+    const changes = registration.changes;
+    const plannedTests = registration.plannedTests;
     const rejected = paramsWithValuedReject(changes);
     const objections = [];
     const seen = new Set();
     for (const change of changes) {
-        const id = String(change?.id ?? "").trim();
-        const cases = change?.cases;
-        if (!id || !Array.isArray(cases) || cases.length === 0 || seen.has(id))
+        const id = String(change.id ?? "").trim();
+        const testCases = change.testCases;
+        if (!id || !testCases || seen.has(id))
             continue;
         // A change nothing cites already draws `coverage:change:<id>`, as above.
         const citing = plannedTests.filter((plannedTest) => citesChange(plannedTest, id));
@@ -589,10 +607,10 @@ function rejectObjections(registration) {
             continue;
         seen.add(id);
         const citingSteps = citing.flatMap((plannedTest) => {
-            const steps = plannedTest?.scenario?.steps;
+            const steps = plannedTest.scenario.steps;
             return Array.isArray(steps) ? steps : [];
         });
-        const unsatisfied = cases.find((declared) => {
+        const unsatisfied = testCases.find((declared) => {
             const param = String(declared?.param ?? "").trim();
             if (!param || param.toLowerCase() === METHOD_PARAM)
                 return false;
@@ -600,7 +618,8 @@ function rejectObjections(registration) {
                 return false;
             if (!isPlaceholderValue(declared?.value))
                 return false;
-            if (!ID_PARAM.test(param) && pathSlotsFor(citingSteps, cases, param).length === 0)
+            if (!ID_PARAM.test(param) &&
+                pathSlotsFor(citingSteps, testCases, param).length === 0)
                 return false;
             return !rejected.has(param);
         });
@@ -611,7 +630,10 @@ function rejectObjections(registration) {
         objections.push({
             objectionId: `coverage:reject:${id}`,
             verifier: "coverage",
-            message: fillPlaceholders(COVERAGE_CONTRACT.objections.reject.message, { param, value }),
+            message: fillPlaceholders(COVERAGE_CONTRACT.objections.reject.message, {
+                param,
+                value,
+            }),
             evidence: `${id} declares ${param}=${value} (accept); no change in this plan declares a reject case on ${param} with a value.`,
             suggestion: fillPlaceholders(COVERAGE_CONTRACT.objections.reject.suggestion, { param }),
         });
@@ -622,15 +644,21 @@ function rejectObjections(registration) {
 /** The test types that reach each surface. An `e2e` test drives the page AND the
  *  requests behind it, so it counts for both. */
 const TEST_TYPES_FOR = {
-    api: { types: new Set(["contract", "integration", "e2e"]), kind: "contract, integration or e2e", name: "API" },
+    api: {
+        types: new Set(["contract", "integration", "e2e"]),
+        kind: "contract, integration or e2e",
+        name: "API",
+    },
     page: { types: new Set(["ui", "e2e"]), kind: "ui or e2e", name: "page" },
 };
 /** Every surface a change states, without repeats and without a name nothing maps. */
 function declaredSurfaces(change) {
-    const named = change?.surfaces;
+    const named = change.surfaces;
     if (!Array.isArray(named))
         return [];
-    return [...new Set(named.map((surface) => String(surface ?? "").trim()))].filter((surface) => surface in TEST_TYPES_FOR);
+    return [
+        ...new Set(named.map((surface) => String(surface ?? "").trim())),
+    ].filter((surface) => surface in TEST_TYPES_FOR);
 }
 /** A change on a page needs a test that opens the page, and a change on the API
  *  needs one that calls it. Run 34065056830 cited a page change from an API test
@@ -638,12 +666,12 @@ function declaredSurfaces(change) {
  *
  *  Read off the PLAN alone, like the other two halves. */
 function surfaceObjections(registration) {
-    const changes = Array.isArray(registration.changes) ? registration.changes : [];
-    const plannedTests = registration.plannedTests ?? [];
+    const changes = registration.changes;
+    const plannedTests = registration.plannedTests;
     const objections = [];
     const seen = new Set();
     for (const change of changes) {
-        const id = String(change?.id ?? "").trim();
+        const id = String(change.id ?? "").trim();
         if (!id)
             continue;
         // A change nothing cites already draws `coverage:change:<id>`. A second
@@ -656,7 +684,7 @@ function surfaceObjections(registration) {
             const objectionId = `coverage:surface:${id}:${surface}`;
             if (seen.has(objectionId))
                 continue;
-            if (citing.some((plannedTest) => types.has(String(plannedTest?.scenario?.testType ?? "").trim().toLowerCase())))
+            if (citing.some((plannedTest) => types.has(plannedTest.scenario.testType.toLowerCase())))
                 continue;
             seen.add(objectionId);
             objections.push({
@@ -672,24 +700,50 @@ function surfaceObjections(registration) {
 }
 /** One repository's changed files, and the name to attribute uncovered ones to.
  *  Keying the objection id on the path alone let two repositories that each change
- *  `src/App.tsx` share one id. A single-repository run names no repository in its
- *  ids, which is the id it produced before there was a second one. */
+ *  `src/App.tsx` share one id, so every id names its repository. */
 function repositoryPartitions(ctx) {
-    const named = Object.entries(ctx.changedFiles ?? {});
-    if (named.length < 2)
-        return [{ changedFiles: named[0]?.[1] ?? [] }];
-    return named.map(([repository, changedFiles]) => ({ repository, changedFiles: changedFiles ?? [] }));
-}
-/** The planned tests that count as covering one repository's change: those naming it,
- *  plus those naming no repository. ABSENT IS A WILDCARD, as `checkEveryDeliveredTestRan`
- *  and `collectExecutionOutcomes` read it — silence is nothing to disagree with. */
-function candidatesFor(plannedTests, repository) {
-    if (!repository)
-        return plannedTests;
-    return plannedTests.filter((plannedTest) => {
-        const named = String(plannedTest?.repository ?? "").trim();
-        return named === "" || named === repository;
-    });
+    return Object.entries(ctx.changedFiles ?? {}).map(([repository, changedFiles]) => ({
+        repository,
+        changedFiles: changedFiles ?? [],
+    }));
+}
+/** Which repositories changed each path, in normalised spelling. */
+function changedIn(partitions) {
+    const owners = new Map();
+    for (const { repository, changedFiles } of partitions) {
+        if (!repository)
+            continue;
+        for (const entry of changedFiles) {
+            const path = normalizeCitedPath(entry.path);
+            if (!path)
+                continue;
+            if (!owners.has(path))
+                owners.set(path, new Set());
+            owners.get(path)?.add(repository);
+        }
+    }
+    return owners;
+}
+/** The files some planned test cites that count for ONE repository of a
+ *  multi-repository run. A cited path counts for the repository whose diff holds
+ *  it, whatever repository the test names: a frontend test cites the backend route
+ *  file its click reaches (run 34423191795 named the frontend and cited
+ *  `routes/record.js`), and that covers the backend's change. Only when two
+ *  repositories changed the same path does the test's own name decide, which the
+ *  schema guarantees it carries. */
+function citedFilesFor(plannedTests, repository, owners) {
+    const cited = new Set();
+    for (const plannedTest of plannedTests) {
+        const named = plannedTest.repository;
+        for (const path of citedPaths(plannedTest)) {
+            const repositories = owners.get(path);
+            if (!repositories?.has(repository))
+                continue;
+            if (repositories.size === 1 || named === repository)
+                cited.add(path);
+        }
+    }
+    return cited;
 }
 /** The completeness check, over three surfaces: every declared behaviour, every
  *  mutated route, and every changed file needs a test in the plan. More is
@@ -702,21 +756,25 @@ export const coverage = {
         const objections = [
             ...claimObjections(registration, ctx),
             ...stateTestObjections(registration),
-            ...caseObjections(registration),
+            ...testCaseObjections(registration),
             ...rejectObjections(registration),
             ...surfaceObjections(registration),
         ];
         if (allChangedFiles(ctx).length === 0)
             return objections;
         const all = registration.plannedTests ?? [];
-        for (const { repository, changedFiles } of repositoryPartitions(ctx)) {
-            const cited = citedFiles(candidatesFor(all, repository));
+        const partitions = repositoryPartitions(ctx);
+        const owners = changedIn(partitions);
+        for (const { repository, changedFiles } of partitions) {
+            const cited = repository
+                ? citedFilesFor(all, repository, owners)
+                : citedFiles(all);
             const seen = new Set();
             for (const entry of changedFiles) {
                 // Compared in the normalised spelling the citations are reduced to. The
                 // objection quotes the path as `--name-status` gave it, which for a
                 // non-ASCII name is the unquoted form, not the escaped one the diff shows.
-                const file = entry?.path ?? "";
+                const file = entry.path ?? "";
                 const path = normalizeCitedPath(file);
                 if (!path || !couldBeProductCode(path) || seen.has(path))
                     continue;
@@ -724,12 +782,10 @@ export const coverage = {
                 if (cited.has(path))
                     continue;
                 objections.push({
-                    objectionId: repository
-                        ? `coverage:${repository}/${file}`
-                        : `coverage:${file}`,
+                    objectionId: `coverage:${repository}/${file}`,
                     verifier: "coverage",
                     message: COVERAGE_CONTRACT.objections.file.message,
-                    evidence: `${repository ? `${repository} ` : ""}${file}${entry?.deleted ? " (removed by this change)" : ""}: no planned test cites it in changedFile, routes or screenEvidence.`,
+                    evidence: `${repository} ${file}${entry.deleted ? " (removed by this change)" : ""}: no planned test cites it in changedFile, routes or screenEvidence.`,
                     suggestion: COVERAGE_CONTRACT.objections.file.suggestion,
                 });
             }