@codyswann/lisa 2.349.0 → 2.350.0

package/expo/copy-overwrite/scripts/bdd/baseline.mjs

@@ -91,17 +91,59 @@ export function loadBaseline(root, revision) {
 export function checkRatchet({ baseContract, contract, labels }) {
   const before = baseContract?.coverageFloor ?? {};
   const after = contract.coverageFloor ?? {};
+  // A head value that is not a finite number is treated as a REMOVAL, never
+  // as "unchanged". Quoting a floor as "19" would otherwise make the
+  // comparison `"19" < 19` false, recording no drop, while the report treats
+  // the same value as no floor at all — a one-character, single-file edit
+  // that disables enforcement and produces no defect. That is precisely what
+  // the ratchet exists to prevent, so an unusable value fails closed.
   const drops = Object.keys(before)
-    .filter(platform => typeof before[platform] === "number")
-    .filter(platform => (after[platform] ?? -Infinity) < before[platform])
+    .filter(platform => isUsableFloor(before[platform]))
+    .filter(
+      platform =>
+        !isUsableFloor(after[platform]) || after[platform] < before[platform]
+    )
     .map(platform => ({
       platform,
       from: before[platform],
-      to: typeof after[platform] === "number" ? after[platform] : null,
+      to: isUsableFloor(after[platform]) ? after[platform] : null,
+      malformed:
+        after[platform] !== undefined && !isUsableFloor(after[platform]),
     }));
   return drops.flatMap(drop => ratchetDefects(drop, contract, labels));
 }
 
+/**
+ * Whether a raw `coverageFloor` entry is a usable floor.
+ *
+ * Mirrors `classifyFloor` in report.mjs; a unit test asserts the two agree,
+ * because a disagreement is exactly the gap a quoted value slipped through.
+ * @param {unknown} value - The raw entry.
+ * @returns {boolean} True when it is a finite number in 0..100.
+ */
+export function isUsableFloor(value) {
+  return (
+    typeof value === "number" &&
+    Number.isFinite(value) &&
+    value >= 0 &&
+    value <= 100
+  );
+}
+
+/**
+ * Describe one observed reduction for the operator.
+ * @param {object} drop - The observed reduction.
+ * @returns {string} A one-line description.
+ */
+function describeDrop(drop) {
+  if (drop.malformed) {
+    return `coverageFloor.${drop.platform} is no longer a number (was ${drop.from}); a non-numeric floor disables enforcement, so it counts as a removal`;
+  }
+  return drop.to === null
+    ? `coverageFloor.${drop.platform} was removed (was ${drop.from})`
+    : `coverageFloor.${drop.platform} lowered ${drop.from} → ${drop.to}`;
+}
+
 /**
  * Defects for one attempted floor reduction.
  * @param {object} drop - The observed reduction.
@@ -110,10 +152,7 @@ export function checkRatchet({ baseContract, contract, labels }) {
  * @returns {object[]} Defects found.
  */
 function ratchetDefects(drop, contract, labels) {
-  const what =
-    drop.to === null
-      ? `coverageFloor.${drop.platform} was removed (was ${drop.from})`
-      : `coverageFloor.${drop.platform} lowered ${drop.from} → ${drop.to}`;
+  const what = describeDrop(drop);
   const record = (contract.coverageFloorBaseline ?? []).find(
     entry =>
       entry.platform === drop.platform &&

package/expo/copy-overwrite/scripts/bdd/parse.mjs

@@ -139,6 +139,9 @@ export function parseFeatureSource(source, file, platforms) {
   const scenarios = [];
   const lines = source.split(/\r?\n/);
   let feature = null;
+  let featureTags = [];
+  let featureIdTags = [];
+  let featureLine = 0;
   let pending = [];
   let current = null;
   for (let index = 0; index < lines.length; index += 1) {
@@ -151,6 +154,15 @@ export function parseFeatureSource(source, file, platforms) {
     const featureMatch = /^Feature:\s*(.+)$/.exec(trimmed);
     if (featureMatch) {
       feature = featureMatch[1].trim();
+      // Gherkin inherits Feature-level tags down to every scenario in the
+      // file. Dropping them made an inherited @web or @ratified-* read as
+      // missing, so a conforming feature file failed on defects it did not
+      // have. Scenario IDs are deliberately NOT inherited — a feature-level
+      // @BDD-* would hand every scenario the same ID, which is a duplicate,
+      // so it is reported instead.
+      featureTags = pending.filter(tag => !ID_PATTERN.test(tag));
+      featureIdTags = pending.filter(tag => ID_PATTERN.test(tag));
+      featureLine = index + 1;
       pending = [];
       current = null;
       continue;
@@ -159,14 +171,22 @@ export function parseFeatureSource(source, file, platforms) {
       trimmed
     );
     if (scenarioMatch) {
-      const grouped = categorize(pending, platforms);
+      // Inherited tags come first so a scenario's own tags read last, and
+      // duplicates are collapsed: a scenario repeating an inherited @web must
+      // not look like it declared the platform twice.
+      const effective = [...new Set([...featureTags, ...pending])];
+      const grouped = categorize(effective, platforms);
       current = {
         id: grouped.ids[0] ?? null,
         name: scenarioMatch[1].trim(),
         feature: feature ?? "Unknown feature",
         file,
         line: index + 1,
-        tags: [...pending],
+        tags: effective,
+        ownTags: [...pending],
+        inheritedTags: [...featureTags],
+        featureIdTags,
+        featureLine,
         ...grouped,
         required: grouped.lifecycle.length === 0,
         primarySteps: [],

package/expo/copy-overwrite/scripts/bdd/render.mjs

@@ -17,10 +17,24 @@
  * @returns {string} Cell text.
  */
 const fmt = value =>
-  value.total === 0
+  value.total === 0 || value.percentage === null
     ? "n/a (no obligations)"
     : `${value.covered}/${value.total} (${value.percentage.toFixed(1)}%)`;
 
+/**
+ * Make author-supplied text safe inside a Markdown table cell.
+ *
+ * Waiver reasons and scenario titles are repo data. A single `|` ends the
+ * cell early and shifts every column after it, so the Ticket and Expires
+ * columns silently misreport — in a generated file nobody re-reads.
+ * @param {unknown} text - Arbitrary cell content.
+ * @returns {string} Text safe to interpolate into a table row.
+ */
+const cell = text =>
+  String(text ?? "")
+    .replace(/\|/g, "\\|")
+    .replace(/\r?\n/g, " ");
+
 /**
  * Render the per-platform traceability table.
  * @param {object} report - The coverage report.
@@ -28,7 +42,7 @@ const fmt = value =>
  */
 function platformTable(report) {
   const rows = Object.entries(report.traceability.byPlatform)
-    .map(([platform, value]) => `| ${platform} | ${fmt(value)} |`)
+    .map(([platform, value]) => `| ${cell(platform)} | ${fmt(value)} |`)
     .join("\n");
   return `| Platform | Obligations with mapped automation |\n|---|---:|\n${rows}\n| **Overall** | **${fmt(report.traceability.overall)}** |`;
 }
@@ -47,7 +61,7 @@ function executionSection(report) {
   const sources = execution.sources
     .map(
       source =>
-        `- \`${source.runner}\` run \`${source.runId ?? "unidentified"}\` (${source.resultCount} results, completed ${source.completedAt ?? "unknown"})`
+        `- \`${cell(source.runner)}\` run \`${cell(source.runId ?? "unidentified")}\` (${source.resultCount} results, completed ${cell(source.completedAt ?? "unknown")})`
     )
     .join("\n");
   return `| Mapped tests | Executed | Passed | Failed | Skipped | Not run |\n|---:|---:|---:|---:|---:|---:|\n| ${execution.mappedTests} | ${execution.executed} | ${execution.passed} | ${execution.failed} | ${execution.skipped} | ${execution.notRun} |\n\nSources:\n\n${sources}`;
@@ -63,12 +77,25 @@ function waiverTable(report) {
     report.waived.entries
       .map(
         entry =>
-          `| ${entry.scenario} | ${entry.platforms.join(", ")} | ${entry.runner ?? "—"} | ${entry.owner ?? "**unowned**"} | ${entry.reason ?? "—"} | ${entry.ticket ?? "**none**"} | ${entry.expiresAt ?? "**never**"} |`
+          `| ${cell(entry.scenario)} | ${cell(entry.platforms.join(", "))} | ${cell(entry.runner ?? "—")} | ${cell(entry.owner ?? "**unowned**")} | ${cell(entry.reason ?? "—")} | ${cell(entry.ticket ?? "**none**")} | ${cell(entry.expiresAt ?? "**never**")} |`
       )
       .join("\n") || "| — | — | — | — | None | — | — |";
   return `| Scenario | Platforms | Runner | Owner | Reason | Ticket | Expires |\n|---|---|---|---|---|---|---|\n${rows}`;
 }
 
+/**
+ * Render one platform's committed floor.
+ *
+ * An unusable value is called out as invalid rather than shown as absent —
+ * "no floor here" and "somebody broke the floor" need different reactions.
+ * @param {object} value - One platform's floor evaluation.
+ * @returns {string} Cell text.
+ */
+function floorCell(value) {
+  if (value.state === "invalid") return "**invalid**";
+  return value.floor === null ? "**unset**" : `${value.floor}%`;
+}
+
 /**
  * Render the floor ratchet table.
  * @param {object} report - The coverage report.
@@ -78,7 +105,7 @@ function floorTable(report) {
   const rows = Object.entries(report.floor.byPlatform)
     .map(
       ([platform, value]) =>
-        `| ${platform} | ${value.floor === null ? "**unset**" : `${value.floor}%`} | ${value.actual}% | ${value.ok ? "ok" : "**below floor**"} |`
+        `| ${cell(platform)} | ${floorCell(value)} | ${value.actual === null ? "n/a" : `${value.actual}%`} | ${value.ok ? "ok" : "**below floor**"} |`
     )
     .join("\n");
   return `| Platform | Committed floor | Current | Status |\n|---|---:|---:|---|\n${rows}`;
@@ -107,10 +134,10 @@ function gapSections(report) {
       const rows = [...entries.entries()]
         .map(
           ([id, value]) =>
-            `| ${id} | ${value.name} | ${value.platforms.sort().join(", ")} |`
+            `| ${cell(id)} | ${cell(value.name)} | ${cell(value.platforms.sort().join(", "))} |`
         )
         .join("\n");
-      return `### ${feature}\n\n| Scenario | Behavior with no mapped proof | Platforms |\n|---|---|---|\n${rows}`;
+      return `### ${cell(feature)}\n\n| Scenario | Behavior with no mapped proof | Platforms |\n|---|---|---|\n${rows}`;
     });
   return (
     sections.join("\n\n") ||

package/expo/copy-overwrite/scripts/bdd/report.mjs

@@ -22,11 +22,13 @@ import {
   trackerUrl,
 } from "./contract.mjs";
 
-const percentage = (covered, total) =>
-  total === 0 ? 100 : (covered / total) * 100;
-
 /**
  * Summarize a subset of obligations against the covered set.
+ *
+ * An empty denominator reports `percentage: null`, never 100. "Nothing was
+ * required here" and "everything required here is covered" are different
+ * claims, and printing the second for the first is how a platform with no
+ * obligations comes to look fully covered.
  * @param {readonly object[]} subset - Obligations to count.
  * @param {ReadonlySet<string>} coveredKeys - Keys with an aligned mapping.
  * @returns {object} Covered/total/percentage.
@@ -36,7 +38,10 @@ function summarize(subset, coveredKeys) {
   return {
     covered,
     total: subset.length,
-    percentage: Number(percentage(covered, subset.length).toFixed(1)),
+    percentage:
+      subset.length === 0
+        ? null
+        : Number(((covered / subset.length) * 100).toFixed(1)),
   };
 }
 
@@ -59,16 +64,55 @@ function declaredObligations(scenarios, platformRunners) {
     );
 }
 
+/**
+ * Precedence when the same test reports more than once.
+ *
+ * Retries and sharded runs legitimately report a test twice. Last-write-wins
+ * would let a `passed` retry bury the `failed` attempt that preceded it, and
+ * the whole point of the execution block is that it cannot understate
+ * failures. Higher wins.
+ */
+const STATUS_PRECEDENCE = Object.freeze({
+  failed: 3,
+  skipped: 2,
+  passed: 1,
+});
+
+/**
+ * Rank a result status, treating anything unrecognized as the most severe.
+ *
+ * Unknown is ranked ABOVE failed on purpose: a status this gate does not
+ * understand must never be silently outranked by a `passed` from another
+ * shard (allowlist, never denylist).
+ * @param {string|undefined} status - A supplied result status.
+ * @returns {number} Its precedence.
+ */
+function statusRank(status) {
+  return STATUS_PRECEDENCE[status] ?? 4;
+}
+
 /**
  * Index supplied execution results by runner, file, and evidence.
+ *
+ * Exported so the matrix joins results exactly as the burndown does; two
+ * private copies of this rule would eventually disagree about whether a test
+ * failed.
  * @param {readonly object[]} runs - Parsed execution-result documents.
  * @returns {Map<string, object>} Lookup keyed by `runner|file|evidence`.
  */
-function indexResults(runs) {
+export function indexResults(runs) {
   const index = new Map();
   for (const run of runs) {
     for (const result of run.results ?? []) {
-      index.set(`${run.runner}|${result.file}|${result.evidence}`, {
+      const key = `${run.runner}|${result.file}|${result.evidence}`;
+      const existing = index.get(key);
+      if (
+        existing &&
+        statusRank(existing.status) >= statusRank(result.status)
+      ) {
+        continue;
+      }
+      index.set(key, {
         ...result,
         runner: run.runner,
         runId: run.runId ?? null,
@@ -152,36 +196,78 @@ function distinctTests(mappings) {
   );
 }
 
+/**
+ * A declared floor value, or the reason it is not usable.
+ *
+ * Only a finite number in 0..100 is a floor. Anything else — a quoted
+ * `"19"`, a null, a NaN — is `invalid`, NOT "no floor": treating a bad value
+ * as absent is what let a one-character edit remove a platform from
+ * enforcement while producing no defect at all.
+ * @param {unknown} declared - The raw `coverageFloor` entry.
+ * @returns {{state: string, value: number|null}} The classified floor.
+ */
+function classifyFloor(declared) {
+  if (declared === undefined) return { state: "unset", value: null };
+  if (typeof declared !== "number" || !Number.isFinite(declared)) {
+    return { state: "invalid", value: null };
+  }
+  if (declared < 0 || declared > 100) return { state: "invalid", value: null };
+  return { state: "declared", value: declared };
+}
+
 /**
  * Evaluate the committed coverage floor per platform.
  * @param {object} contract - Parsed coverage map.
  * @param {object} byPlatform - Traceability summary per platform.
  * @param {ReadonlySet<string>} platforms - Declared platform vocabulary.
- * @returns {object} Floor evaluation, including which platforms declared none.
+ * @returns {object} Floor evaluation, naming unset and invalid platforms.
  */
 export function evaluateFloor(contract, byPlatform, platforms) {
   const floors = contract.coverageFloor ?? {};
   const entries = [...platforms].sort().map(platform => {
-    const declared = floors[platform];
-    const actual = byPlatform[platform]?.percentage ?? 100;
+    const declared = classifyFloor(floors[platform]);
+    // A platform with no obligations reports `null`, not 100. It cannot clear
+    // a positive floor by having nothing to measure.
+    const actual = byPlatform[platform]?.percentage ?? null;
     return [
       platform,
       {
-        floor: typeof declared === "number" ? declared : null,
+        floor: declared.value,
+        state: declared.state,
         actual,
-        ok: typeof declared !== "number" || actual + 1e-9 >= declared,
+        ok: isFloorMet(declared, actual),
       },
     ];
   });
   return {
     byPlatform: Object.fromEntries(entries),
     unset: entries
-      .filter(([, value]) => value.floor === null)
+      .filter(([, value]) => value.state === "unset")
+      .map(([name]) => name),
+    invalid: entries
+      .filter(([, value]) => value.state === "invalid")
       .map(([name]) => name),
     ok: entries.every(([, value]) => value.ok),
   };
 }
 
+/**
+ * Whether a platform clears its floor.
+ *
+ * An invalid floor is never "met" — a bad value must fail rather than quietly
+ * disable enforcement. An unset floor has nothing to clear here; the enforced
+ * mode reports its absence separately.
+ * @param {{state: string, value: number|null}} declared - The classified floor.
+ * @param {number|null} actual - Measured percentage, or null when there are no obligations.
+ * @returns {boolean} Whether the floor is satisfied.
+ */
+function isFloorMet(declared, actual) {
+  if (declared.state === "invalid") return false;
+  if (declared.state === "unset") return true;
+  if (actual === null) return declared.value === 0;
+  return actual + 1e-9 >= declared.value;
+}
+
 /**
  * Collect every tracker reference declared across the contract.
  * @param {readonly object[]} scenarios - Parsed scenarios.
@@ -218,7 +304,13 @@ export function buildTrackerIndex(scenarios, trackers) {
  * @param {object} input - Scenarios, contract, execution runs, and platforms.
  * @returns {object} The report envelope.
  */
-export function buildReport({ scenarios, contract, runs, platforms }) {
+export function buildReport({
+  scenarios,
+  contract,
+  runs,
+  platforms,
+  unresolved = new Set(),
+}) {
   const platformRunners = runnersByPlatform(contract.runnerPlatforms);
   const declared = declaredObligations(scenarios, platformRunners);
   const waivedKeys = new Set(
@@ -227,7 +319,7 @@ export function buildReport({ scenarios, contract, runs, platforms }) {
     )
   );
   const obligations = declared.filter(item => !waivedKeys.has(item.key));
-  const coveredKeys = coverageKeys(scenarios, contract);
+  const coveredKeys = coverageKeys(scenarios, contract, unresolved);
   const byPlatform = Object.fromEntries(
     [...platforms].sort().map(platform => [
       platform,
@@ -242,7 +334,7 @@ export function buildReport({ scenarios, contract, runs, platforms }) {
     asOf: contract.asOf ?? null,
     scenarios: countScenarios(scenarios),
     traceability: {
-      note: "Obligations whose aligned automation is mapped and whose evidence string still resolves. This is TRACEABILITY coverage, not execution coverage and not a pass rate.",
+      note: "Obligations whose aligned automation is mapped AND whose evidence string still resolves — a mapping whose test was renamed or deleted stops counting here immediately, even in bootstrap where the matching defect is only a warning. This is TRACEABILITY coverage, not execution coverage and not a pass rate.",
       overall: summarize(obligations, coveredKeys),
       byPlatform,
       byRunner: byRunnerSummary(contract, obligations, coveredKeys),
@@ -267,12 +359,19 @@ export function buildReport({ scenarios, contract, runs, platforms }) {
 }
 
 /**
- * Every scenario-platform key an existing mapping covers.
+ * Every scenario-platform key a mapping covers AND still proves.
+ *
+ * A mapping whose evidence string no longer resolves is excluded here, not
+ * merely reported. In bootstrap that defect is only a warning, so counting it
+ * as covered would let the headline keep claiming coverage the repo does not
+ * have — the precise "the manifest was lying" failure this gate exists to
+ * surface.
  * @param {readonly object[]} scenarios - Parsed scenarios.
  * @param {object} contract - Parsed coverage map.
+ * @param {ReadonlySet<string>} unresolved - Keys whose evidence no longer resolves.
  * @returns {Set<string>} Covered keys.
  */
-function coverageKeys(scenarios, contract) {
+function coverageKeys(scenarios, contract, unresolved) {
   const required = new Set(
     scenarios.filter(scenario => scenario.required).map(scenario => scenario.id)
   );
@@ -280,7 +379,8 @@ function coverageKeys(scenarios, contract) {
   for (const mapping of contract.mappings ?? []) {
     if (!required.has(mapping.scenario)) continue;
     for (const platform of mapping.platforms ?? []) {
-      covered.add(`${mapping.scenario}:${platform}`);
+      const key = `${mapping.scenario}:${platform}`;
+      if (!unresolved.has(key)) covered.add(key);
     }
   }
   return covered;

package/expo/copy-overwrite/scripts/bdd/validate.mjs

@@ -64,9 +64,29 @@ export function validateScenarios(scenarios, platforms) {
       );
     }
     defects.push(...missingSteps(scenario, at));
+    defects.push(...featureLevelId(scenario));
     if (scenario.id) defects.push(...recordId(scenario, at, seen));
   }
-  return defects;
+  return [...new Map(defects.map(item => [item.message, item])).values()];
+}
+
+/**
+ * Reject a `@BDD-*` id placed on the Feature rather than a Scenario.
+ *
+ * Gherkin would inherit it into every scenario in the file, handing them all
+ * the same identity. IDs are per-behavior, so this is always a mistake — and
+ * inheriting it silently would produce a pile of duplicate-ID defects that
+ * never name the real cause.
+ * @param {object} scenario - Parsed scenario.
+ * @returns {object[]} Defects found.
+ */
+function featureLevelId(scenario) {
+  return (scenario.featureIdTags ?? []).map(tag =>
+    defect(
+      "scenario-id",
+      `${scenario.file}:${scenario.featureLine} declares @${tag} on the Feature; a scenario ID identifies one behavior and is never inherited`
+    )
+  );
 }
 
 /**
@@ -166,7 +186,12 @@ function orphanReason(reference, { keys, repos, defaultRepo }) {
  * @param {object} input - Root, scenarios, and the parsed contract.
  * @returns {object[]} Defects found.
  */
-export function validateMappings({ root, scenarios, contract }) {
+export function validateMappings({
+  root,
+  scenarios,
+  contract,
+  cache = new Map(),
+}) {
   const byId = new Map(scenarios.map(scenario => [scenario.id, scenario]));
   const platformRunners = runnersByPlatform(contract.runnerPlatforms);
   const defects = [];
@@ -188,7 +213,7 @@ export function validateMappings({ root, scenarios, contract }) {
     }
     defects.push(...mappingDuplicates(mapping, at, seen));
     defects.push(...mappingPlatforms(mapping, scenario, platformRunners, at));
-    defects.push(...mappingEvidence(root, mapping, at));
+    defects.push(...mappingEvidence(root, mapping, at, cache));
   }
   return defects;
 }
@@ -250,33 +275,81 @@ function mappingPlatforms(mapping, scenario, platformRunners, at) {
 }
 
 /**
- * Prove the mapped file still contains the exact evidence string.
+ * Whether a mapping's evidence string still resolves inside the repo.
  *
- * This is what makes a mapping falsifiable rather than an assertion: rename
- * or delete the test and the map breaks loudly instead of leaving a scenario
- * silently unguarded.
+ * The single source of truth for "does this mapping still prove anything",
+ * shared by the defect check and by the coverage count. Two separate answers
+ * to that question is how a stale mapping comes to fail validation while
+ * still counting as covered.
  * @param {string} root - Repo root.
  * @param {object} mapping - Raw mapping entry.
- * @param {string} at - Location label.
- * @returns {object[]} Defects found.
+ * @param {Map<string, string>} [cache] - Optional file-content cache.
+ * @returns {{ok: boolean, code?: string, detail?: string}} The verdict.
  */
-function mappingEvidence(root, mapping, at) {
+export function evidenceResolves(root, mapping, cache = new Map()) {
   if (typeof mapping.evidence !== "string" || mapping.evidence.length === 0) {
-    return [defect("mapping-evidence", `${at}: declares no evidence string`)];
+    return {
+      ok: false,
+      code: "mapping-evidence",
+      detail: "declares no evidence string",
+    };
   }
   const resolved = resolveInsideRepo(root, mapping.file);
   if (!resolved.path) {
-    return [
-      defect("mapping-file", `${at}: ${mapping.file} — ${resolved.error}`),
-    ];
+    return {
+      ok: false,
+      code: "mapping-file",
+      detail: `${mapping.file} — ${resolved.error}`,
+    };
   }
-  if (!fs.readFileSync(resolved.path, "utf8").includes(mapping.evidence)) {
-    return [
-      defect(
-        "mapping-evidence",
-        `${at}: ${mapping.file} no longer contains ${JSON.stringify(mapping.evidence)}`
-      ),
-    ];
+  if (!cache.has(resolved.path)) {
+    cache.set(resolved.path, fs.readFileSync(resolved.path, "utf8"));
   }
-  return [];
+  if (!cache.get(resolved.path).includes(mapping.evidence)) {
+    return {
+      ok: false,
+      code: "mapping-evidence",
+      detail: `${mapping.file} no longer contains ${JSON.stringify(mapping.evidence)}`,
+    };
+  }
+  return { ok: true };
+}
+
+/**
+ * The scenario-platform keys whose mapping no longer proves anything.
+ *
+ * Coverage is counted from mappings that PASS this check, so a mapping whose
+ * test was renamed stops counting the moment it stops resolving — including
+ * in bootstrap, where the matching defect is only a warning. Otherwise the
+ * headline would keep claiming coverage the repo does not have, which is
+ * exactly the "manifest was lying" failure this gate exists to surface.
+ * @param {object} input - Root, contract, and an optional file cache.
+ * @returns {Set<string>} Keys that must not be counted as covered.
+ */
+export function unresolvedEvidenceKeys({ root, contract, cache = new Map() }) {
+  const broken = new Set();
+  for (const mapping of contract.mappings ?? []) {
+    if (evidenceResolves(root, mapping, cache).ok) continue;
+    for (const platform of mapping.platforms ?? []) {
+      broken.add(`${mapping.scenario}:${platform}`);
+    }
+  }
+  return broken;
+}
+
+/**
+ * Prove the mapped file still contains the exact evidence string.
+ *
+ * This is what makes a mapping falsifiable rather than an assertion: rename
+ * or delete the test and the map breaks loudly instead of leaving a scenario
+ * silently unguarded.
+ * @param {string} root - Repo root.
+ * @param {object} mapping - Raw mapping entry.
+ * @param {string} at - Location label.
+ * @param {Map<string, string>} cache - File-content cache.
+ * @returns {object[]} Defects found.
+ */
+function mappingEvidence(root, mapping, at, cache) {
+  const verdict = evidenceResolves(root, mapping, cache);
+  return verdict.ok ? [] : [defect(verdict.code, `${at}: ${verdict.detail}`)];
 }

package/expo/copy-overwrite/scripts/bdd-matrix.mjs

@@ -22,6 +22,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { declaredPlatforms, trackerUrl } from "./bdd/contract.mjs";
 import { loadScenarios } from "./bdd/parse.mjs";
+import { indexResults } from "./bdd/report.mjs";
 import { loadExecutionResults } from "./check-bdd-coverage.mjs";
 
 const PACKAGE_ROOT = path.resolve(
@@ -46,37 +47,6 @@ function mappingsByScenario(contract) {
   return index;
 }
 
-/**
- * Index execution results by runner, file, and evidence.
- * @param {readonly object[]} runs - Parsed execution-result documents.
- * @returns {Map<string, object>} Lookup keyed by `runner|file|evidence`.
- */
-function resultsIndex(runs) {
-  const index = new Map();
-  for (const run of runs) {
-    for (const result of run.results ?? []) {
-      index.set(`${run.runner}|${result.file}|${result.evidence}`, result);
-    }
-  }
-  return index;
-}
-
-/**
- * Every `SCENARIO:platform` a waiver removes from the denominator.
- *
- * The matrix must know about waivers or it contradicts the burndown: a
- * waived obligation is not an uncovered one, it is a dated IOU.
- * @param {object} contract - Parsed coverage map.
- * @returns {Set<string>} Waived keys.
- */
-function waivedKeys(contract) {
-  return new Set(
-    (contract.platformWaivers ?? []).flatMap(waiver =>
-      (waiver.platforms ?? []).map(platform => `${waiver.scenario}:${platform}`)
-    )
-  );
-}
-
 /**
  * Render one scenario's mapped-automation cell for one runner.
  * @param {readonly string[]} required - Platforms the scenario demands this runner cover.
@@ -152,7 +122,10 @@ export function renderMatrix(root, resultFiles) {
   const platforms = declaredPlatforms(contract.runnerPlatforms);
   const scenarios = loadScenarios(root, platforms);
   const execution = loadExecutionResults(root, resultFiles);
-  const results = resultsIndex(execution.runs);
+  // Shared with the burndown so the two can never disagree about whether a
+  // test failed — including the retry precedence that keeps a `failed`
+  // attempt from being buried by a later `passed`.
+  const results = indexResults(execution.runs);
   const byScenario = mappingsByScenario(contract);
   const waived = waivedKeys(contract);
   const runners = Object.keys(contract.runnerPlatforms ?? {}).sort();