@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/utils/frontendSelectors.js

@@ -1,28 +1,14 @@
 /**
- * Frontend selector extraction for UI-test-maintenance discovery (Pass 3, "selector-edge").
+ * The `data-*` attributes and selector literals a frontend diff touched.
  *
- * Playwright/Cypress page objects couple to a changed component by SELECTOR — a
- * `data-testid` value or a CSS class token — not by filename or by `import`. So the
- * filename-token (pass 1) and import-edge (pass 2) promotion signals in
- * TestDiscoveryService Step 2 both miss them: a page object `table.component.ts` shares
- * no name token with the changed `CascadeFields.tsx` and does not import it — it selects
- * `.t--table-filter-columns-dropdown` at runtime.
+ * One reader now: the removal guard (SKYR-4305), which reports an element the
+ * diff deleted from a page that survives so the agent can assert it is gone.
  *
- * This module extracts the selector literals that a frontend diff added OR removed, so
- * discovery can promote any existing test/page-object whose body still references one of
- * them. Both sides of a rename are captured deliberately: a page object that has NOT been
- * updated still contains the OLD value, so matching the removed literal is what surfaces
- * the test that needs maintenance.
- *
- * This is the frontend analog of importerHop's `extractChangedSymbols` (backend type
- * names) — kept in its own frontend-scoped module rather than in the backend-resource
- * importerHop, per the codebase convention of keeping domain vocabularies local.
+ * This module also used to lift every selector literal a diff added or removed,
+ * so discovery could promote a page object whose body referenced one. That was
+ * the server deciding which existing tests a change touches — the external
+ * tests are loaded uncut up to the discovery cap now, and the agent reads them.
  */
-// Bound the extracted set so a large diff can't produce an unbounded match list. The
-// downstream promotion is separately capped by MAX_UI_PROMOTED, so this is a belt on the
-// literal set itself. Exported so the caller can detect + log when a single file's
-// extraction is truncated by this cap.
-export const MAX_CHANGED_SELECTORS = 80;
 // Utility / design-token CSS classes (Tailwind/Bootstrap-style) are ALSO multi-hyphen kebab
 // tokens, but they are shared *styling* vocabulary, not component identity — matching them
 // floods Pass 3, because snapshot files (`__snapshots__/*.snap`) serialize `className`
@@ -53,71 +39,246 @@ function isDistinctiveSelector(token, trusted) {
     return hasBEM || (hyphens >= 2 && !COMMON_CSS_SELECTOR_TOKENS.test(token));
 }
 /**
- * Extract selector literals added or removed in a single file's diff slice.
- *
- * Two complementary passes over the changed (`+`/`-`) lines, excluding the `+++`/`---`
- * file headers:
- *   1. Explicit test-facing attribute/API values: `data-testid` / `data-test` /
- *      `data-test-id` / `data-cy` / `data-qa` attribute values and `getByTestId(...)`
- *      arguments (trusted — accepts camelCase or single-delimiter ids).
- *   2. Distinctive kebab / BEM class tokens anywhere on the line (>= 2 hyphens or `--`),
- *      which catches CSS-class-based coupling (`t--table-filter-columns-dropdown`,
- *      `ads-button--primary`).
+ * The test-facing selector grammar, shared by every extractor in this module so the
+ * two cannot drift: `data-testid` / `data-test` / `data-test-id` / `data-cy` / `data-qa`
+ * attribute values (string literals only) and `getByTestId(...)` arguments.
+ * Case-insensitive on purpose: JSX authors write `data-testId` (demoshop) and the
+ * browser lowercases attribute names, so `getByTestId` matches either spelling.
+ */
+const TESTID_ATTR_RE = /\b(data-(?:test-?id|test|cy|qa))\b\s*=\s*\{?\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/gi;
+const GET_BY_TEST_ID_RE = /getByTestId\(\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/gi;
+/**
+ * Any other `data-*` attribute with a static string value (`data-section="session-id-debug"`).
+ * Untrusted: the value must pass the stricter distinctiveness rule, and attributes that carry
+ * component STATE rather than identity are excluded — they flip at runtime, so "absent" is
+ * meaningless for them.
+ */
+const GENERIC_DATA_ATTR_RE = /\b(data-[a-z][a-z0-9]*(?:-[a-z0-9]+)*)\s*=\s*\{?\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/gi;
+const STATE_DATA_ATTRS = new Set([
+    "data-state", "data-theme", "data-orientation", "data-side", "data-align", "data-value",
+    "data-index", "data-slot", "data-disabled", "data-checked", "data-active", "data-open",
+    "data-loading", "data-size", "data-variant", "data-selected", "data-highlighted",
+    "data-focus", "data-hover", "data-pressed", "data-expanded", "data-placeholder", "data-status",
+]);
+/**
+ * Identifying `data-*` attributes on one source line: the trusted test-facing set (any
+ * casing), `getByTestId(...)` arguments (attributed to `data-testid`), and any other
+ * static `data-*` whose value is distinctive and whose attribute is not a state carrier.
+ */
+function attributesOnLine(line) {
+    const out = [];
+    const seen = new Set();
+    const push = (attribute, value) => {
+        const key = `${attribute}=${value}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push({ attribute, value });
+        }
+    };
+    let m;
+    TESTID_ATTR_RE.lastIndex = 0;
+    while ((m = TESTID_ATTR_RE.exec(line)) !== null) {
+        if (isDistinctiveSelector(m[2], true))
+            push(m[1].toLowerCase(), m[2]);
+    }
+    GET_BY_TEST_ID_RE.lastIndex = 0;
+    while ((m = GET_BY_TEST_ID_RE.exec(line)) !== null) {
+        if (isDistinctiveSelector(m[1], true))
+            push("data-testid", m[1]);
+    }
+    GENERIC_DATA_ATTR_RE.lastIndex = 0;
+    while ((m = GENERIC_DATA_ATTR_RE.exec(line)) !== null) {
+        const attribute = m[1].toLowerCase();
+        if (STATE_DATA_ATTRS.has(attribute))
+            continue;
+        if (seen.has(`${attribute}=${m[2]}`))
+            continue; // already captured by the trusted pass
+        if (isDistinctiveSelector(m[2], false))
+            push(attribute, m[2]);
+    }
+    return out;
+}
+/**
+ * Tag name of the JSX/HTML element a diff line opens, or "" — also "" for a comment
+ * line (`//`, `/*`, `*`, `{/*`, `<!--`), whose `<div …>` is text, not an element.
  */
-export function extractChangedSelectors(fileDiff) {
+function openingTagOf(line) {
+    const t = line.trim();
+    if (/^(?:\/\/|\/\*|\*|\{\s*\/\*|<!--)/.test(t))
+        return "";
+    return /<\s*([A-Za-z][\w.-]*)/.exec(t)?.[1]?.toLowerCase() ?? "";
+}
+/** Identifying attribute VALUES that appear on `+` lines of a diff (any number of files). */
+export function extractAddedAttributeValues(diff) {
     const out = new Set();
-    // Require a quote immediately before the value so only string LITERALS are captured —
-    // `data-testid="x"`, `data-testid={'x'}`, `data-testid={`x`}`. This deliberately skips
-    // non-literal expressions like `data-testid={someVar}`, which would otherwise inject a
-    // variable name into the selector set and cause noisy promotion matches.
-    // Require a quote/backtick on BOTH sides so only FULLY-literal values are captured —
-    // `data-testid="x"`, `data-testid={'x'}`, `data-testid={`x`}`. The closing delimiter
-    // deliberately rejects interpolated template literals (`data-testid={`members-${id}`}`),
-    // which would otherwise leak a partial prefix (`members-`) into the selector set.
-    const ATTR = /\bdata-(?:test-?id|test|cy|qa)\b\s*=\s*\{?\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/g;
-    const GET_BY_TEST_ID = /getByTestId\(\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/g;
-    const KEBAB = /[a-z][a-z0-9]*(?:-{1,2}[a-z0-9]+)+/g;
-    // BEM base whose modifier is composed DYNAMICALLY, so no concrete class literal exists
-    // in the diff to grep: `ads-button--${kind}`, "ads-button--" + kind, clsx(base && `x--${y}`).
-    // Match a kebab base + `--` followed by a NON-alphanumeric (interpolation `$`, quote,
-    // paren, whitespace) and capture the `<base>--` prefix. The page objects' concrete
-    // modifier classes (ads-button--primary, ads-button--secondary) all start with that
-    // prefix, so a substring match on it promotes them — the shared/design-system component
-    // case a static-literal scan (KEBAB) misses. (A STATIC modifier like `foo--bar` is left
-    // to KEBAB, which captures the whole class.)
-    const BEM_DYNAMIC = /([a-z][a-z0-9]*(?:-[a-z0-9]+)+--)(?![a-z0-9])/g;
-    for (const raw of fileDiff.split("\n")) {
-        if (!(raw.startsWith("+") || raw.startsWith("-")))
+    for (const raw of diff.split("\n")) {
+        if (!raw.startsWith("+") || raw.startsWith("+++"))
             continue;
-        if (raw.startsWith("+++") || raw.startsWith("---"))
+        for (const a of attributesOnLine(raw.slice(1)))
+            out.add(a.value);
+    }
+    return [...out];
+}
+/**
+ * Identifying `data-*` attributes one file's diff REMOVED: literals on `-` lines, minus the
+ * cases where the element still renders somewhere:
+ *
+ *   - **moved / extracted** — the same value appears on a `+` line of this file or, via
+ *     `addedValuesElsewhere`, anywhere else in the diff (a component extracted into a new
+ *     file is the common shape);
+ *   - **not an element** — a `-` line counts only when it opens a JSX/HTML tag or is a
+ *     wrapped attribute line of a tag opened above it, on a changed or an unchanged
+ *     line (the tag is carried until the `>` that closes it; a `>` inside a quoted
+ *     value, a `{…}` expression or an `=>` arrow is content and does not close it). A deleted comment, docs snippet, story arg or page-object
+ *     `getByTestId(...)` call that merely mentions the attribute is not an element
+ *     removal — the element itself may well survive on an unchanged context line;
+ *   - **renamed** — a rename cannot be told apart by literal identity (old and new
+ *     value differ by definition), so it is paired structurally: within the same hunk,
+ *     each removed ELEMENT is paired with AT MOST ONE added element that opens the same
+ *     tag, carries a NEW identifying attribute, and keeps every other attribute NAME
+ *     the removed element set on its changed lines (a rename may add attributes or
+ *     edit their values, never drop one). With the tag kept on a context line, the
+ *     changed lines are exactly the attributes that differ, so an in-place rename
+ *     compares only what it touched while an in-place replacement that drops the old
+ *     element's handlers does not pair. An element whose changed lines carry nothing
+ *     but the identifier pairs by tag alone: a relabelled rename (`clear-state` →
+ *     `reset-session`, "Clear State" → "Reset Session") and a same-shape replacement
+ *     are the same diff, and the tie goes to rename — a guard on a retired identifier
+ *     passes vacuously, and the agent still reads the diff for what the list lacks. A paired added element is consumed, so one addition
+ *     suppresses one removal, not every removal in the hunk. SKYR-4339: pairing by tag
+ *     alone consumed a genuinely removed `<a href="#">` with a genuinely added
+ *     `<a href="https://…">` in the same hunk (judgement eval RG03), so the guard was
+ *     never listed.
+ *
+ * Feeds `uiContext.removedElements` (SKYR-4305) — the grounding for a removal guard
+ * (`toBeHidden()` on `getByTestId(value)` for `data-testid`, on
+ * `locator('[<attribute>="<value>"]')` for any other `data-*`).
+ */
+export function extractRemovedAttributes(fileDiff, addedValuesElsewhere = []) {
+    const addedAnywhere = new Set(addedValuesElsewhere);
+    for (const v of extractAddedAttributeValues(fileDiff))
+        addedAnywhere.add(v);
+    // Split into hunks so rename pairing stays local.
+    const hunks = [];
+    for (const raw of fileDiff.split("\n")) {
+        if (raw.startsWith("@@")) {
+            hunks.push([]);
             continue;
-        const line = raw.slice(1);
-        for (const re of [ATTR, GET_BY_TEST_ID]) {
-            re.lastIndex = 0;
-            let m;
-            while ((m = re.exec(line)) !== null) {
-                if (isDistinctiveSelector(m[1], true))
-                    out.add(m[1]);
-                if (out.size >= MAX_CHANGED_SELECTORS)
-                    return [...out];
-            }
         }
-        KEBAB.lastIndex = 0;
-        let k;
-        while ((k = KEBAB.exec(line)) !== null) {
-            if (isDistinctiveSelector(k[0], false))
-                out.add(k[0]);
-            if (out.size >= MAX_CHANGED_SELECTORS)
-                return [...out];
+        if (hunks.length === 0)
+            hunks.push([]);
+        hunks[hunks.length - 1].push(raw);
+    }
+    // Names of the attributes an element's changed lines set (`name=` at attribute
+    // position: line start or after whitespace, so `=>`, `a=b` inside a handler body and
+    // `id=` inside a regex do not count), minus the identifying data-* attributes. Names,
+    // not values: a rename may edit or reformat a neighbouring attribute, never drop one.
+    const otherAttrNames = (text, ids) => {
+        const out = new Set();
+        const re = /(?:^|\s)([A-Za-z][\w:.-]*)=/g;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const name = m[1].toLowerCase();
+            if (ids.some((a) => name === a.attribute))
+                continue;
+            out.add(name);
         }
-        BEM_DYNAMIC.lastIndex = 0;
-        let b;
-        while ((b = BEM_DYNAMIC.exec(line)) !== null) {
-            if (isDistinctiveSelector(b[1], false))
-                out.add(b[1]);
-            if (out.size >= MAX_CHANGED_SELECTORS)
-                return [...out];
+        return out;
+    };
+    // Does this line close the opening tag? A `>` inside a quoted value, inside a `{…}`
+    // expression (`onClick={() => x}`) or as part of `=>` is content, not the tag end.
+    const closesOpeningTag = (line) => {
+        let t = line.replace(/"[^"]*"|'[^']*'|`[^`]*`/g, '""').replace(/=>/g, "");
+        for (let prev = ""; prev !== t;) {
+            prev = t;
+            t = t.replace(/\{[^{}]*\}/g, "");
+        }
+        return t.includes(">");
+    };
+    const out = [];
+    const seen = new Set();
+    for (const hunk of hunks) {
+        // Group changed lines into elements per side: an element starts on the line that
+        // opens its tag and carries on until the `>` that closes the opening tag, so a
+        // wrapped attribute line (`-  data-testid="x"`) belongs to the tag opened above it,
+        // and a later comment or unrelated line in the hunk does not inherit it.
+        // The tag may also be opened on an unchanged context line (`<a` kept, attributes
+        // edited underneath): then each side's changed lines form an element of that tag,
+        // until the context `>` that closes it.
+        const removed = [];
+        const added = [];
+        let curMinus = null;
+        let curPlus = null;
+        let contextTag = "";
+        for (const raw of hunk) {
+            if (raw.startsWith("+++") || raw.startsWith("---"))
+                continue;
+            if (!(raw.startsWith("+") || raw.startsWith("-"))) {
+                const line = raw.startsWith(" ") ? raw.slice(1) : raw;
+                const tag = openingTagOf(line);
+                if (tag) {
+                    contextTag = tag;
+                    curMinus = null;
+                    curPlus = null;
+                }
+                if (closesOpeningTag(line)) {
+                    contextTag = "";
+                    curMinus = null;
+                    curPlus = null;
+                }
+                continue;
+            }
+            const line = raw.slice(1);
+            const minus = raw.startsWith("-");
+            const ownTag = openingTagOf(line);
+            let cur = minus ? curMinus : curPlus;
+            if (ownTag) {
+                cur = { tag: ownTag, text: "", ids: [], consumed: false };
+                (minus ? removed : added).push(cur);
+            }
+            else if (!cur && contextTag) {
+                cur = { tag: contextTag, text: "", ids: [], consumed: false };
+                (minus ? removed : added).push(cur);
+            }
+            if (cur) {
+                cur.text += `${line}\n`;
+                cur.ids.push(...attributesOnLine(line));
+            }
+            // Only an element (a tag opened on this line or carried from above) can be a
+            // removed element; a bare mention in a comment / docs / page object is not.
+            if (closesOpeningTag(line))
+                cur = null;
+            if (minus)
+                curMinus = cur;
+            else
+                curPlus = cur;
+        }
+        const candidates = added.filter((a) => a.ids.length > 0);
+        for (const r of removed) {
+            if (r.ids.length === 0)
+                continue;
+            const rNames = otherAttrNames(r.text, r.ids);
+            const partner = candidates.find((a) => {
+                if (a.consumed || a.tag !== r.tag)
+                    return false;
+                const aNames = otherAttrNames(a.text, a.ids);
+                for (const name of rNames)
+                    if (!aNames.has(name))
+                        return false;
+                return true;
+            });
+            if (partner) {
+                partner.consumed = true;
+                continue;
+            }
+            for (const a of r.ids) {
+                const key = `${a.attribute}=${a.value}`;
+                if (!addedAnywhere.has(a.value) && !seen.has(key)) {
+                    seen.add(key);
+                    out.push(a);
+                }
+            }
         }
     }
-    return [...out];
+    return out;
 }

package/build/utils/pathMatching.d.ts

@@ -5,10 +5,8 @@
  * are both true even though the paths name different resources. These
  * helpers require the match to land on a "/" (or path-end) boundary.
  *
- * Lives in its own module, independent of `routeParsers.ts` and
- * `importerHop.ts`, so callers in either direction (`planRanker.ts` imports
- * `routeParsers.ts`; `scenarioDrafting.ts` imports `importerHop.ts`, which
- * imports `routeParsers.ts`) can both use it without risking an import cycle.
+ * Lives in its own module so any caller can use it without risking an import
+ * cycle through whichever module owns the route predicates.
  */
 /**
  * Returns true when `a` starts with `b` at a path-segment boundary.

package/build/utils/pathMatching.js

@@ -5,10 +5,8 @@
  * are both true even though the paths name different resources. These
  * helpers require the match to land on a "/" (or path-end) boundary.
  *
- * Lives in its own module, independent of `routeParsers.ts` and
- * `importerHop.ts`, so callers in either direction (`planRanker.ts` imports
- * `routeParsers.ts`; `scenarioDrafting.ts` imports `importerHop.ts`, which
- * imports `routeParsers.ts`) can both use it without risking an import cycle.
+ * Lives in its own module so any caller can use it without risking an import
+ * cycle through whichever module owns the route predicates.
  */
 /**
  * Returns true when `a` starts with `b` at a path-segment boundary.

package/build/utils/planMatchKeys.d.ts

@@ -1,22 +1,19 @@
 /**
- * SKYR-3879 Path B — shared match-key computation for the register-plan
- * checkpoint. `computeMatchKeys` runs ONCE, at approval time (inside
- * registerTestPlanTool / the analyze_changes pre-seed), so the two
- * consumers — planGuard (generation-tool hard gate) and submitReportTool
- * (report cross-check) — only ever do a Set/array membership check, never
- * re-derive normalization logic against a live candidate.
+ * Shared match-key computation for the generation-tool plan gate. The generation
+ * tools are called with a scenario name and an endpoint, never a `plannedTestId`,
+ * so this joins a call back to a plan planned test; the report compares ids.
  *
  * Two kinds of key:
  *  - `name:<slug>`               — normalized scenarioName, for multi-step
- *    candidates (batch-scenario / integration) where the agent's own name is
+ *    planned tests (batch-scenario / integration) where the agent's own name is
  *    the natural join key.
  *  - `ep:<testType>:<METHOD>:<path>` — one per step, for single-endpoint
  *    matching (contract tests, or a fallback when names drift between
  *    register and generate).
  */
-import { DraftedScenario } from "../types/RepositoryAnalysis.js";
-import { ApprovedPlanItem, Candidate } from "../types/Recommendation.js";
-/** Query shape built from a generation-tool call or a submitted report entry. */
+import { PlanScenario } from "../types/RepositoryAnalysis.js";
+import type { PlannedTest } from "../recommendation/types.js";
+/** Query shape built from a generation-tool call or a reported test entry. */
 export interface PlanMatchQuery {
     scenarioName?: string;
     testType?: string;
@@ -25,51 +22,45 @@ export interface PlanMatchQuery {
 }
 /** Lowercase, collapse non-alphanumeric runs to '-', trim leading/trailing '-'. */
 export declare function slugifyName(name: string | undefined): string;
+export declare function isParamSegment(segment: string): boolean;
+export declare function isOpaqueIdSegment(segment: string): boolean;
 /**
- * Normalize a path so param/id segments collapse: `{brace}`, `:colon`,
- * `[bracket]` params in any of routeParsers.ts's syntaxes, plus numeric,
- * UUID, and long-hex id VALUES, all become `:p`. Delegates to
- * routeParsers.ts's `isParamSegment`/`isOpaqueIdSegment` (SKYR-4214 task 5)
- * rather than a second inline copy — this module previously had its own
- * looser hex rule (`/^[0-9a-fA-F-]{16,}$/`, accepting `-`) and no
- * bracket-syntax rule at all, so a Next.js `[id]` segment never collapsed
- * and kept a match key from matching its `{id}`-spelled counterpart (the
- * SKYR-4123 failure mode: a generated test's key stops matching its plan
- * item). The characterization test in
- * `pathSegmentClassification.characterization.test.ts` confirms every
- * previously-agreeing input (UUID, numeric, 16+/24-char hex) still
- * collapses to `:p` after this change — safe within one run because the
- * register-time key and the generation-time query are computed by the same
- * build; a plan file is never persisted across builds. Mirrors
- * discriminators.ts's normalizePath (duplicated rather than imported —
- * that function verifies discriminator claims against a diff, a different
- * concern from plan matching, and keeping them independent avoids coupling
- * this module's stability to phase 1's internal helper).
+ * Normalize a path so param and id segments collapse to `:p`.
+ *
+ * The two predicates above are the only rule for it — an earlier inline copy had
+ * no bracket rule, so a Next.js `[id]` stopped matching its `{id}` spelling.
  */
 export declare function normalizeMatchPath(rawPath: string | undefined): string;
-/** Name key (if a name exists) plus one endpoint key per step. */
-export declare function computeMatchKeys(scenario: DraftedScenario): string[];
-/** Build the persisted plan item from a ranked Candidate. */
-export declare function buildApprovedPlanItem(candidate: Candidate): ApprovedPlanItem;
+/** Name key (if a name exists) plus one endpoint key per step. BOTH kinds carry
+ *  the planned test's test type, or a contract call matches an integration-only
+ *  planned test sharing its name. A slug holds no `:`. */
+export declare function computeMatchKeys(scenario: PlanScenario): string[];
 /**
- * True when `query` matches at least one of `items`' matchKeys:
- *  - by scenarioName slug (`name:<slug>`), or
+ * True when `query` matches `keys`:
+ *  - by testType + scenarioName slug (`name:<testType>:<slug>`), or
  *  - by testType + path (`ep:<testType>:*:<path>`), method-exact when
  *    `query.method` is given, method-agnostic (any method) otherwise — the
  *    contract tool's `method: ""` ("test all methods") case. Path comparison
  *    tolerates a base-path prefix on either side (see normalizedPathsMatch).
+ * The planned test's test type gates BOTH channels: gating the endpoint channel
+ * alone let a contract call pass against an integration-only planned test of the
+ * same name. Where the query carries an endpoint the name match must agree on it
+ * too, since `slugifyName` folds case and every run of non-alphanumerics.
  */
-export declare function matchesApprovedItem(items: ApprovedPlanItem[], query: PlanMatchQuery): boolean;
+export declare function matchesMatchKeys(keys: string[], query: PlanMatchQuery): boolean;
 /**
- * True when `query` is admissible under the approved plan: it matches a
- * GENERATE item, or it matches an ADDITIONAL item while the plan has at least
- * one GENERATE item. ADDITIONAL is strictly a backfill pool for failed
- * GENERATE items — on a zero-budget plan (`generate: []`, e.g. maxGenerate=0
- * for a config-only PR) there is nothing to backfill, so ADDITIONAL must not
- * admit generation. Shared by planGuard and submitReportTool so the gate and
- * the report cross-check can never disagree on admissibility.
+ * The planned tests whose scenarioName and testType match but whose planned steps
+ * name no endpoint the query addresses — the near miss a boolean cannot report,
+ * where the real disagreement is one step's path spelling. Empty when the query
+ * names no path.
  */
-export declare function matchesApprovedPlan(plan: {
-    generate: ApprovedPlanItem[];
-    additional: ApprovedPlanItem[];
-}, query: PlanMatchQuery): boolean;
+export declare function nameMatchedEndpointMismatches(plannedTests: PlannedTest[], query: PlanMatchQuery): PlannedTest[];
+/** The planned tests whose scenarioName matches but whose testType does not — the
+ *  plan holds this scenario and the call asked a different generator for it, so
+ *  "not in the plan" is the wrong thing to say. Empty when the query names no
+ *  type, since `nameAgrees` then matches on the name alone. */
+export declare function nameMatchedTypeMismatches(plannedTests: PlannedTest[], query: PlanMatchQuery): PlannedTest[];
+/** True when `query` matches at least one planned test of the registered plan.
+ *  The keys are computed per call rather than stored with the plan, so there is
+ *  one description of a planned test and no second shape to drift from it. */
+export declare function matchesPlanCandidates(plannedTests: PlannedTest[], query: PlanMatchQuery): boolean;