@skyramp/mcp 0.4.1-rc.1 → 0.4.1

package/build/recommendation/verifierContracts.js

@@ -88,8 +88,16 @@ export const EXISTING_COVERAGE_CONTRACT = {
             message: "This planned test names an existing test file that is not in the checkout.",
             suggestion: "Name the file repository-relative, spelled as the analysis lists it. Drop the entry if it names a test you did not read — naming none is an answer too.",
         },
+        maintainedTestMissing: {
+            message: "`maintains` names an existing test file that is not in the checkout.",
+            suggestion: "Name the file repository-relative, spelled as the analysis lists it. A maintenance entry is what makes its changes count as covered, so it has to name a file this run can edit.",
+        },
+        maintainedUnknownChange: {
+            message: "A `maintains` entry cites a change id that this plan does not declare.",
+            suggestion: "Spell the change's `id` exactly as your own `changes` list gives it — the match is exact apart from surrounding space. Declare the change if it is missing.",
+        },
     },
-    suggestion: "Which existing tests did you read on this change, and how does this planned test differ from them?",
+    suggestion: "Which existing tests did you read on this change, how does this planned test differ from them, and which changes does the maintenance you are doing cover?",
 };
 export const EXPECTED_OUTCOME_CONTRACT = {
     id: "expectedOutcome",
@@ -141,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 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.",
+            suggestion: "Plan a test that exercises it. If an existing test already covers it and this run edits that test 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.",
@@ -253,14 +261,22 @@ export const EXPECTED_VALUE_SOURCED_CONTRACT = {
         // 34414643135 objected to five cases whose values that rule decides.
         quoteMissing: {
             message: "This case reads its value from the pull request, and its change does not quote the sentence that states the rule.",
-            suggestion: "Put the sentence from the title or description on the change as `quote`, as written there. Derive this case's value from that rule; the value itself need not appear in the pull request.",
+            suggestion: "Put the sentence from the title or description on the change as `quote`, as written there. If that sentence states the rule and not the number, put the rule in `derived` and leave `expectedValue` out.",
+        },
+        // The other half of the same reading. Run 34434835959 declared
+        // `expectedValue: 159.998` from `pr-description` on a change whose quote states
+        // how a percentage discount works and writes no number; the agent computed 10%
+        // of a subtotal it had seen and attributed the result to the description.
+        valueNotQuoted: {
+            message: "This case reads its value from the pull request, and the pull request does not state this value.",
+            suggestion: "Quote the sentence that states it, or, if the pull request states a rule, put the rule in `derived` and leave `expectedValue` out; the test computes the value from what it sent.",
         },
         // A test that expects to fail asserts what the code does not return today, so
         // some source outside the code states that value. Run 34406282133 declared such
         // tests and put `expectedValue` on no case at all.
         failWithoutValue: {
             message: "This test expects to fail, and no case on the changes it cites states the value it must assert.",
-            suggestion: "Put the value the code does not return today on the case this test sends, as `expectedValue`, and name where you read it. If no source states the value, answer with what the test asserts instead and where that comes from.",
+            suggestion: "Put the value the code does not return today on the case this test sends, as `expectedValue`, and name where you read it. If the source states a rule rather than a number, put the rule in `derived` instead. If no source states either, answer with what the test asserts instead and where that comes from.",
         },
     },
     suggestion: "Where does the correct value for this case come from?",

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

@@ -1,4 +1,14 @@
 import { Verifier } from "../types.js";
+/** 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 declare function renderCase(declared: {
+    param: string;
+    value?: unknown;
+    absent?: true;
+    expect: string;
+}): string;
 /** The completeness check, over three surfaces: every declared behaviour, every
  *  mutated route, and every changed file needs a test in the plan. More is
  *  welcome, fewer is the objection. ONE RULE for the file half, no classification

package/build/recommendation/verifiers/coverage.js

@@ -1,5 +1,6 @@
 import { allChangedFiles } from "../types.js";
-import { LOCKFILE, NOT_A_ROUTE_FILE, NOT_SOURCE_DIR } from "./endpointGrounded.js";
+import { canonicalJson } from "../../utils/canonicalJson.js";
+import { escapesRepo, LOCKFILE, NOT_A_ROUTE_FILE, NOT_SOURCE_DIR } from "./endpointGrounded.js";
 import { isTestPath } from "../../utils/testFileClassification.js";
 import { normalizeCitedPath } from "./citedPath.js";
 import { COVERAGE_CONTRACT, fillPlaceholders } from "../verifierContracts.js";
@@ -37,9 +38,31 @@ function citedFiles(plannedTests) {
     }
     return cited;
 }
-/** The behaviour ids some planned test cites, trimmed. */
-function citedBehaviors(plannedTests) {
+/** 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
+ *  maintenance decision, since that objection closes with a `blocker` alone and
+ *  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
+ *  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) {
     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;
+        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))
@@ -58,7 +81,7 @@ function citedBehaviors(plannedTests) {
  *
  *  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) {
+function claimObjections(registration, ctx) {
     const changes = Array.isArray(registration.changes) ? registration.changes : [];
     const plannedTests = registration.plannedTests ?? [];
     const objections = [];
@@ -79,7 +102,8 @@ function claimObjections(registration) {
         if (id)
             declared.add(id);
     }
-    const cited = citedBehaviors(plannedTests);
+    const maintains = Array.isArray(registration.maintains) ? registration.maintains : [];
+    const cited = citedBehaviors(plannedTests, maintains, (file) => !!file && !escapesRepo(file) && ctx.citedFileExists(file));
     const seen = new Set();
     for (const change of changes) {
         const id = String(change?.id ?? "").trim();
@@ -207,28 +231,100 @@ function sameValue(sent, declared) {
         return false;
     if (declared === null)
         return sent === null;
+    // A list or an object compares WHOLE, and only against another one. `String` made
+    // every structure a scalar: `String(["alpha","beta"])` is `"alpha,beta"`, so a
+    // case declaring that string was answered by a list no entry of which sends it,
+    // and `String([])` is `""`, so an empty list answered `tags=""`. An entry of the
+    // list is still a scalar of its own and still answers a scalar case.
+    const sentIsStructure = sent !== null && typeof sent === "object";
+    const declaredIsStructure = typeof declared === "object";
+    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);
+    }
     const sentNumber = asNumber(sent);
     const declaredNumber = asNumber(declared);
     if (sentNumber !== undefined && declaredNumber !== undefined)
         return sentNumber === declaredNumber;
     return String(sent) === String(declared);
 }
-/** Every value of one parameter a step sends, wherever it carries it: the query
- *  string written into the path, the `queryParams` object, or the top level of the
- *  request body. Nothing reads deeper into a body — a constrained input is a field
- *  of the request, not a field nested inside one. */
+/** The path a case's `param` names, as segments. Numeric segments drop: a plan
+ *  writes `items.0` for "the line items", not for the first one only. */
+function fieldPath(param) {
+    const segments = param
+        .split(/[.[\]]/)
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0 && !/^\d+$/.test(segment));
+    return segments.length > 0 ? segments : [param];
+}
+/** Every value at `rest`, below a key that already matched the path's first
+ *  segment. Only arrays are transparent between segments, so `billing.postcode` is
+ *  not sent by `billing.shipping.postcode`. A matched array yields the array AND
+ *  its entries, because `String(["beta"]) === "beta"` matched a one-item list only.
+ *
+ *  `open` holds the objects on the way down to this one, so a payload that points
+ *  back at itself ends rather than recurses. It is the way down and not every
+ *  object seen, because one object reached twice by two different routes is two
+ *  values the payload really sends. */
+function valuesAt(value, rest, open) {
+    if (rest.length === 0)
+        return [value, ...(Array.isArray(value) ? value : [])];
+    if (value === null || typeof value !== "object" || open.has(value))
+        return [];
+    open.add(value);
+    const found = Array.isArray(value)
+        ? value.flatMap((entry) => valuesAt(entry, rest, open))
+        : (() => {
+            const [head, ...next] = rest;
+            const fields = value;
+            return head in fields ? valuesAt(fields[head], next, open) : [];
+        })();
+    open.delete(value);
+    return found;
+}
+/** Every value carried at `path`, anywhere inside one payload. Only the FIRST
+ *  segment is found at any depth, which is what makes `quantity` find
+ *  `items.0.quantity`; the rest of the path is matched by `valuesAt`. */
+function valuesUnder(payload, path, open = new Set()) {
+    // A body that points back at itself ends the walk; how deeply a real body nests
+    // is the payload's business, and a depth cap here read a valid one as sending
+    // nothing.
+    if (payload === null || typeof payload !== "object" || open.has(payload))
+        return [];
+    open.add(payload);
+    const found = [];
+    if (Array.isArray(payload)) {
+        for (const entry of payload)
+            found.push(...valuesUnder(entry, path, open));
+    }
+    else {
+        for (const [key, value] of Object.entries(payload)) {
+            if (key === path[0])
+                found.push(...valuesAt(value, path.slice(1), open));
+            // The same head, deeper: this is the any-depth half of the search.
+            found.push(...valuesUnder(value, path, open));
+        }
+    }
+    open.delete(payload);
+    return found;
+}
+/** Every value of one parameter a step sends: the query string, the `queryParams`
+ *  object, or anywhere inside the request body. */
 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("?");
     if (query)
         found.push(...new URLSearchParams(query).getAll(param));
-    for (const carrier of [step?.queryParams, step?.requestBody]) {
-        if (carrier && typeof carrier === "object" && !Array.isArray(carrier)) {
-            const fields = carrier;
-            if (param in fields)
-                found.push(fields[param]);
-        }
+    const queryParams = step?.queryParams;
+    if (queryParams && typeof queryParams === "object" && !Array.isArray(queryParams)) {
+        const fields = queryParams;
+        if (param in fields)
+            found.push(fields[param]);
     }
+    found.push(...valuesUnder(step?.requestBody, fieldPath(param)));
     return found;
 }
 /** The parameter name that names the request's verb rather than one of its inputs. */
@@ -316,6 +412,15 @@ function sendsInPath(step, slot, value) {
     }
     return sameValue(segments[slot.index], value);
 }
+/** Whether a step writes the declared value as one of its own path segments. The
+ *  fallback for a plan that spells every route concretely, so no slot exists. Only
+ *  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)
+        return false;
+    return pathSegments(step).some((segment) => sameValue(segment.trim(), value));
+}
 /** Whether a step's verb is the declared value. A rejected method is the input. */
 function sendsAsMethod(step, value) {
     const method = String(step?.method ?? "").trim();
@@ -332,8 +437,11 @@ function omittedBy(step, param) {
         return false;
     return omits.some((named) => String(named ?? "").trim() === param);
 }
-/** One declared case as the objection spells it. */
-function renderCase(declared) {
+/** 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) {
     const param = String(declared.param).trim();
     const sent = declared.absent === true ? "absent" : `=${JSON.stringify(declared.value)}`;
     return `${param}${declared.absent === true ? " " : ""}${sent} (${declared.expect})`;
@@ -381,6 +489,7 @@ function caseObjections(registration) {
             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 param = String(declared?.param ?? "").trim();
             if (!param)
@@ -389,9 +498,14 @@ function caseObjections(registration) {
                 return !citingSteps.some((step) => omittedBy(step, param));
             const slots = pathSlotsFor(citingSteps, cases, 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;
             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)));
+                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
         // answer that addressed two of them and closed: run 34167252679 answered
@@ -405,7 +519,13 @@ function caseObjections(registration) {
                 objectionId: `coverage:cases:${id}:${rendered}`,
                 verifier: "coverage",
                 message: fillPlaceholders(COVERAGE_CONTRACT.objections.cases.message, { missing: rendered }),
-                evidence: `${citing.map((plannedTest) => plannedTest.plannedTestId).join(", ")} cite ${id}; no step of theirs sends ${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.
+                    (ID_PARAM.test(String(declared?.param ?? "").trim()) &&
+                        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,
             });
         }
@@ -416,8 +536,10 @@ function caseObjections(registration) {
  *  sends the same spelling, so `{memberUserId}` in a case is that record and a
  *  literal is a value the plan chose. */
 const PLACEHOLDER_VALUE = /^\{[A-Za-z][A-Za-z0-9]*\}$/;
-/** A parameter that names a record by id, by its own name. */
-const ID_PARAM = /id$/i;
+/** A parameter that names a record by id, by its own name: `id` itself, `id` after
+ *  a separator, or `Id`/`ID` starting a word. `/id$/i` also read `paid`, `valid` and
+ *  `fluid` as record ids, which let `valid=5` take its value from `/orders/5`. */
+const ID_PARAM = /(?:^|[_\-.])[Ii][Dd]$|[a-z0-9](?:Id|ID)$/;
 function isPlaceholderValue(value) {
     return typeof value === "string" && PLACEHOLDER_VALUE.test(value.trim());
 }
@@ -578,7 +700,7 @@ export const coverage = {
     name: "coverage",
     run(registration, ctx) {
         const objections = [
-            ...claimObjections(registration),
+            ...claimObjections(registration, ctx),
             ...stateTestObjections(registration),
             ...caseObjections(registration),
             ...rejectObjections(registration),

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

@@ -4,8 +4,30 @@ import { Plan } from "../registerPlan.js";
 export interface DeliveredTest {
     plannedTestId: string;
 }
+/** One maintenance row that LEFT COVERAGE BEHIND, as the report publishes it. The
+ *  caller filters by action: a row this check is handed is one whose edit a later
+ *  run can still rely on, so a no-op assessment and a deleted test never reach it.
+ *  Both fields are absolute paths. */
+export interface MaintainedTest {
+    testFilePath?: string;
+    /** Where the edit landed when that is not the spec — a page object it delegates
+     *  its selectors to. Counted, so a spec maintained through its POM still joins. */
+    pomFile?: string;
+}
 /** Verifier 5, post-execution half. Both directions on one pass: a report entry
  *  that was in no plan, and a planned planned test that never shipped. The two lists
  *  join on `plannedTestId` exactly — never a name, an endpoint or a similarity
  *  score. Objections go to the report: the tests already exist. */
 export declare function checkDeliveredMatchesPlan(plan: Plan, delivered: DeliveredTest[]): Objection[];
+/** The maintenance mirror of "planned but not delivered". A `maintains` entry is
+ *  what makes its changes count as covered, and until this ran nothing downstream
+ *  checked the file was edited at all: the plan claimed it, `coverage` credited it,
+ *  and the report published it, three records that never met.
+ *
+ *  Matched with `testFileMatches`, which keeps the directories: the plan names a file
+ *  repository-relative and a row names it absolutely, so the row's path has to END at
+ *  the claimed one on a segment boundary. Basename alone would let an edit to
+ *  `tests/admin/navbar.spec.ts` answer for `tests/store/navbar.spec.ts`. Answerable,
+ *  unlike `coverage:change:` — an edit that landed somewhere the rows do not name is
+ *  a real case, and the answer says where. */
+export declare function checkMaintenanceDelivered(plan: Plan, maintained: MaintainedTest[]): Objection[];

package/build/recommendation/verifiers/deliveredMatchesPlan.js

@@ -1,3 +1,4 @@
+import { testFileMatches } from "../../utils/utils.js";
 /** Verifier 5, post-execution half. Both directions on one pass: a report entry
  *  that was in no plan, and a planned planned test that never shipped. The two lists
  *  join on `plannedTestId` exactly — never a name, an endpoint or a similarity
@@ -31,3 +32,45 @@ export function checkDeliveredMatchesPlan(plan, delivered) {
     }
     return objections;
 }
+/** The maintenance mirror of "planned but not delivered". A `maintains` entry is
+ *  what makes its changes count as covered, and until this ran nothing downstream
+ *  checked the file was edited at all: the plan claimed it, `coverage` credited it,
+ *  and the report published it, three records that never met.
+ *
+ *  Matched with `testFileMatches`, which keeps the directories: the plan names a file
+ *  repository-relative and a row names it absolutely, so the row's path has to END at
+ *  the claimed one on a segment boundary. Basename alone would let an edit to
+ *  `tests/admin/navbar.spec.ts` answer for `tests/store/navbar.spec.ts`. Answerable,
+ *  unlike `coverage:change:` — an edit that landed somewhere the rows do not name is
+ *  a real case, and the answer says where. */
+export function checkMaintenanceDelivered(plan, maintained) {
+    const claimed = Array.isArray(plan?.maintains) ? plan.maintains : [];
+    if (claimed.length === 0)
+        return [];
+    const text = (value) => (typeof value === "string" ? value.trim() : "");
+    const editedPaths = [];
+    for (const row of Array.isArray(maintained) ? maintained : []) {
+        for (const full of [text(row?.testFilePath), text(row?.pomFile)])
+            if (full)
+                editedPaths.push(full);
+    }
+    const objections = [];
+    const seen = new Set();
+    for (const entry of claimed) {
+        const file = text(entry?.file);
+        if (!file || editedPaths.some((full) => testFileMatches(full, file)))
+            continue;
+        const objectionId = `deliveredMatchesPlan:maintains:${file}`;
+        if (seen.has(objectionId))
+            continue;
+        seen.add(objectionId);
+        objections.push({
+            objectionId,
+            verifier: "deliveredMatchesPlan",
+            message: "The plan says this existing test covers a change, and no maintenance row says it was edited.",
+            evidence: `plan maintains ${file}; the maintenance rows that changed a file name ${editedPaths.length > 0 ? editedPaths.join(", ") : "no file"}`,
+            suggestion: "The maintenance rows come from the triage, not from this call, so this is not a field to fill in here: make the edit on the file you claimed and let the maintenance step record it, or drop the entry from `maintains` and register the plan again — coverage counted the change because the plan said you were editing that test. If the test already covered the change and needed no edit, or the edit landed somewhere the rows do not name, say which as the answer.",
+        });
+    }
+    return objections;
+}

package/build/recommendation/verifiers/existingCoverage.js

@@ -42,6 +42,59 @@ export const existingCoverage = {
                 suggestion: EXISTING_COVERAGE_CONTRACT.objections.citedTestMissing.suggestion,
             });
         }
+        // `maintains` is what makes a change covered by an edited test count in
+        // `coverage`, so the same file check applies to it, plus the change ids it
+        // cites: an id no `changes` entry declares would credit coverage for nothing.
+        const maintains = Array.isArray(registration?.maintains) ? registration.maintains : [];
+        const declaredChanges = new Set((Array.isArray(registration?.changes) ? registration.changes : [])
+            .map((change) => String(change?.id ?? "").trim())
+            .filter(Boolean));
+        // Gathered per file BEFORE any objection is pushed: the schema allows two
+        // entries naming the same file, the objection id is keyed on the file so the
+        // agent answers a file once, and keying alone dropped the second entry's ids.
+        const missingByFile = new Map();
+        const unknownByFile = new Map();
+        for (const entry of maintains) {
+            const file = String(entry?.file ?? "").trim();
+            const key = file || "unnamed";
+            const missing = !file
+                ? "an entry names no file"
+                : escapesRepo(file)
+                    ? `${file} (points outside the repository)`
+                    : !ctx.citedFileExists(file)
+                        ? `${file} (not found)`
+                        : "";
+            if (missing && !missingByFile.has(key))
+                missingByFile.set(key, missing);
+            const ids = Array.isArray(entry?.changes) ? entry.changes : [];
+            for (const raw of ids) {
+                const id = String(raw ?? "").trim();
+                if (!id || declaredChanges.has(id))
+                    continue;
+                const unknown = unknownByFile.get(key) ?? [];
+                if (!unknown.includes(id))
+                    unknown.push(id);
+                unknownByFile.set(key, unknown);
+            }
+        }
+        for (const [key, missing] of missingByFile) {
+            objections.push({
+                objectionId: `existingCoverage:maintains:${key}`,
+                verifier: "existingCoverage",
+                message: EXISTING_COVERAGE_CONTRACT.objections.maintainedTestMissing.message,
+                evidence: `maintained test not in the checkout: ${missing}`,
+                suggestion: EXISTING_COVERAGE_CONTRACT.objections.maintainedTestMissing.suggestion,
+            });
+        }
+        for (const [key, unknown] of unknownByFile) {
+            objections.push({
+                objectionId: `existingCoverage:maintains:unknownChange:${key}`,
+                verifier: "existingCoverage",
+                message: EXISTING_COVERAGE_CONTRACT.objections.maintainedUnknownChange.message,
+                evidence: `${key === "unnamed" ? "an unnamed entry" : key} cites ${unknown.map((id) => `"${id}"`).join(", ")}; this plan declares ${[...declaredChanges].map((id) => `"${id}"`).join(", ") || "no changes"}`,
+                suggestion: EXISTING_COVERAGE_CONTRACT.objections.maintainedUnknownChange.suggestion,
+            });
+        }
         return objections;
     },
 };