@polymorphism-tech/morph-spec 8.35.1 → 8.37.0

package/src/lib/tasks/test-nodes.js

@@ -13,9 +13,14 @@
  * So the unit of verification becomes a LIST of nodes. `project.tests[]` in
  * `.morph/config/config.json` declares them; when it is absent, the four-step
  * fallback still runs and is synthesized into exactly one node. Declared beats
- * guessed (D3): deeper auto-detection would only trade one silent false
- * negative for another, and the cost of the error here is a green gate over
- * untested code.
+ * guessed (D3): a declaration — `tests[]` OR `testCommand` — still wins
+ * completely, and deeper auto-detection would only trade one silent false
+ * negative for another there. But with NOTHING declared, the guess stops
+ * being allowed to be a single answer: the old first-match fallback still
+ * picks the primary node exactly as before, and any vitest/jest suite found
+ * under a `package.json` (issue #87) is added BESIDE it, because that single
+ * guess is exactly what hid 3.082 vitest tests behind a green gate (F30) —
+ * the fallback found `.sln`, answered "dotnet test", and never looked twice.
  *
  * WHY VALIDATION IS FAIL-CLOSED HERE (D4)
  *
@@ -32,11 +37,12 @@
  */
 
 import { existsSync, readFileSync } from 'fs';
-import { join, resolve } from 'path';
+import { join, resolve, relative, sep } from 'path';
 
 import { resolveTestPlan, readMorphConfig, isInside } from './test-runner.js';
 import { EVAL_RUNNER, evalBlockProblem } from './eval-node.js';
 import { atomicWriteJson, CONFIG_FILE_NAME } from '../../core/state/state-manager.js';
+import { PACKAGE_LOCATIONS } from '../detectors/index.js';
 
 /**
  * The count extractors that exist (one per runner, see parseTestCount).
@@ -45,6 +51,41 @@ import { atomicWriteJson, CONFIG_FILE_NAME } from '../../core/state/state-manage
  */
 export const TEST_RUNNERS = ['dotnet', 'vitest', 'jest', 'node-test', 'playwright', 'none', EVAL_RUNNER];
 
+/**
+ * The task-group vocabulary a node can declare via `groups`, and that
+ * `tasks.json` entries declare via `group` (framework/schemas/tasks.schema.json
+ * `~:28`) — ONE enum, checked to agree by canary, never two that drift.
+ * Single home for B3's task-scope selection (`test-scope.js`) to import from.
+ */
+export const TASK_GROUPS = ['backend', 'frontend', 'tests', 'infra', 'docs'];
+
+/**
+ * Which group(s) a node serves when it does NOT declare `groups` itself,
+ * keyed by runner. `none` and `evals` are deliberately ABSENT — a command
+ * nobody could read (`none`) and a declared eval suite (`evals`) have no
+ * honest default group, so `effectiveGroups()` answers null for them rather
+ * than guessing one.
+ */
+export const RUNNER_DEFAULT_GROUPS = {
+  dotnet: ['backend'],
+  'node-test': ['backend'],
+  vitest: ['frontend'],
+  jest: ['frontend'],
+  playwright: ['frontend'],
+};
+
+/**
+ * Which task group(s) this node answers to: what it DECLARED, or else its
+ * runner's default. **null is "no mapping"**, never an invented guess — B3's
+ * task-scope selection reads null as "this node is unscoped, always runs".
+ *
+ * @param {import('./test-nodes.js').TestNode} node
+ * @returns {string[]|null}
+ */
+export function effectiveGroups(node) {
+  return node?.groups ?? RUNNER_DEFAULT_GROUPS[node?.runner] ?? null;
+}
+
 /**
  * A node id is what `--filter` matches and what keys `runs[]`. Lowercase and
  * dash-only so it survives a shell argument and a JSON key without quoting.
@@ -168,6 +209,11 @@ function makeNode(partial) {
     // eval node"** — distinct from an eval node with an empty block, which
     // `validateTestNodes` already refused.
     evals: partial.evals ?? null,
+    // Declared task-group(s) this node serves (§B3 task-scope selection).
+    // **null is "not declared"**, distinct from an empty array (which
+    // `firstProblem` refuses outright) — effectiveGroups() falls back to the
+    // runner's default only when this is null.
+    groups: partial.groups ?? null,
     status: partial.status ?? null,
     reason: partial.reason ?? null,
   };
@@ -250,6 +296,28 @@ function firstProblem(raw, projectPath) {
     return `evals applies only to runner "${EVAL_RUNNER}"`;
   }
 
+  if (raw.groups !== undefined) {
+    if (!Array.isArray(raw.groups)) {
+      return 'groups must be a non-empty array';
+    }
+    if (raw.groups.length === 0) {
+      return 'groups must be a non-empty array';
+    }
+    const invalid = raw.groups.filter((g) => !TASK_GROUPS.includes(g));
+    if (invalid.length > 0) {
+      return `groups must contain only ${TASK_GROUPS.join(' | ')} (invalid: ${invalid.join(', ')})`;
+    }
+    const seenGroups = new Set();
+    const duplicates = new Set();
+    for (const g of raw.groups) {
+      if (seenGroups.has(g)) duplicates.add(g);
+      seenGroups.add(g);
+    }
+    if (duplicates.size > 0) {
+      return `groups must not contain duplicates (repeated: ${[...duplicates].join(', ')})`;
+    }
+  }
+
   // The cwd checks come last because they are the expensive ones, and because
   // a node that is malformed in shape has a better error to report first.
   const cwd = typeof raw.cwd === 'string' ? raw.cwd.trim() : '.';
@@ -322,11 +390,97 @@ export function validateTestNodes(config, projectPath = null) {
       e2e: entry.e2e ?? false,
       linuxImage: entry.linuxImage ?? null,
       evals: entry.evals ?? null,
+      groups: entry.groups ?? null,
       projectCount: 1,
     });
   });
 }
 
+/** Turn a relative path into an id-safe slug matching TEST_NODE_ID_PATTERN. */
+function slugifyForId(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Guess which frontend test suites this project has, from `package.json`
+ * alone — a GUESS (issue #87), never a declaration. Only called by the
+ * fallback of `resolveTestNodes()`, and only when nothing was declared: a
+ * `package.json` that names `vitest`/`jest` in `dependencies` or
+ * `devDependencies` becomes one candidate suite, exactly the shape F30
+ * exploited when a repo had .NET AND a frontend and the first-match fallback
+ * only ever answered "dotnet test".
+ *
+ * Fail-open by construction (it IS a guess): an unreadable or malformed
+ * `package.json` is skipped silently, never a `fail` node — that fail-closed
+ * treatment is reserved for a DECLARATION (`tests[]`), which this is not.
+ *
+ * @param {string} projectPath - Project root
+ * @param {object|null} config - Parsed `.morph/config/config.json`, or null
+ * @returns {Array<{ id: string, cwd: string, runner: 'vitest'|'jest', command: string }>}
+ */
+export function discoverFrontendPackages(projectPath, config) {
+  const root = resolve(projectPath);
+  const candidates = [...PACKAGE_LOCATIONS];
+
+  const frontendPath = config?.project?.frontendPath;
+  if (typeof frontendPath === 'string' && frontendPath.trim()) {
+    const abs = resolve(root, frontendPath.trim());
+    // Outside the root is IGNORED, not refused — this is a guess reusing
+    // another guess (detectProject's own frontendPath), and neither one gets
+    // to address another tree.
+    if (isInside(abs, root)) candidates.push(frontendPath.trim());
+  }
+
+  const seenDirs = new Set();
+  const seenIds = new Set();
+  const found = [];
+
+  for (const loc of candidates) {
+    const dirAbs = resolve(root, loc);
+    if (seenDirs.has(dirAbs)) continue;
+    seenDirs.add(dirAbs);
+
+    const pkgPath = join(dirAbs, 'package.json');
+    if (!existsSync(pkgPath)) continue;
+
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    } catch {
+      continue; // unreadable/invalid — skipped silently, fail-open (it's a guess)
+    }
+
+    const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+    let runner = null;
+    let command = null;
+    if (deps.vitest) {
+      runner = 'vitest';
+      command = 'npx vitest run';
+    } else if (deps.jest) {
+      runner = 'jest';
+      command = 'npx jest --ci';
+    }
+    if (!runner) continue;
+
+    const cwd = dirAbs === root ? '.' : relative(root, dirAbs).split(sep).join('/');
+    const baseId = cwd === '.' ? runner : `${runner}-${slugifyForId(cwd)}`;
+    let id = baseId;
+    let n = 2;
+    while (seenIds.has(id)) {
+      id = `${baseId}-${n}`;
+      n += 1;
+    }
+    seenIds.add(id);
+
+    found.push({ id, cwd, runner, command });
+  }
+
+  return found;
+}
+
 /**
  * Resolve every test suite of a project, in the order the verifier must run them.
  *
@@ -372,22 +526,28 @@ export function resolveTestNodes(projectPath = '.') {
 
   const plan = resolveTestPlan(projectPath);
 
-  if (!plan.command) {
-    return {
-      nodes: [makeNode({ id: FALLBACK_NODE_ID, status: 'skip', reason: NO_SUITE_REASON })],
-      source: plan.source,
-    };
+  const nodes = [
+    plan.command
+      ? makeNode({ id: FALLBACK_NODE_ID, command: plan.command, cwd: '.', projectCount: plan.projectCount })
+      : makeNode({ id: FALLBACK_NODE_ID, status: 'skip', reason: NO_SUITE_REASON }),
+  ];
+
+  // The union (#87 PR B / F30): add discovered frontend suites BESIDE the
+  // fallback node — but only when nothing was declared. `plan.source ===
+  // 'config'` means `project.testCommand` IS a declaration (it lives inside
+  // resolveTestPlan's own step 1), and a declaration wins completely: nothing
+  // is added beside it, same as the `project.tests[]` branch above.
+  if (plan.source !== 'config') {
+    const discovered = discoverFrontendPackages(projectPath, config)
+      // The root package is already run by `npm test` when that is the
+      // fallback's own answer — adding it again would run the same suite
+      // twice under two different commands.
+      .filter((pkg) => !(pkg.cwd === '.' && plan.source === 'npm'))
+      .map((pkg) => makeNode({ id: pkg.id, command: pkg.command, cwd: pkg.cwd, runner: pkg.runner }));
+    nodes.push(...discovered);
   }
 
-  return {
-    nodes: [makeNode({
-      id: FALLBACK_NODE_ID,
-      command: plan.command,
-      cwd: '.',
-      projectCount: plan.projectCount,
-    })],
-    source: plan.source,
-  };
+  return { nodes, source: plan.source };
 }
 
 /**
@@ -425,10 +585,15 @@ export function morphConfigPath(projectPath = '.') {
  *   - a measured id that is not declared (appending a node would be inventing
  *     the declaration the command came to update);
  *   - a declared node with no measurement (a baseline recorded for part of a
- *     fleet says nothing true about the rest of it).
+ *     fleet says nothing true about the rest of it);
+ *   - a measurement carrying a task-scope `selection` (#87): narrowed, scoped
+ *     out or run whole INSIDE a task-scoped verify, it measured a recorte, and
+ *     `expectedCount` is the whole suite's number. `verify` already refuses
+ *     `--record-baseline` with a task id before the build; this is the second
+ *     barrier, at the writer, so no caller can route around it.
  *
  * @param {string} projectPath - Project root
- * @param {Array<{id: string, count: number|null}>} measurements - One per node that ran
+ * @param {Array<{id: string, count: number|null, selection?: object|null}>} measurements - One per node that ran
  * @returns {{ recorded: boolean, reason: string|null, updates: Array<{id: string, from: number|null, to: number}>, path: string }}
  */
 export function recordTestBaselines(projectPath, measurements) {
@@ -449,6 +614,11 @@ export function recordTestBaselines(projectPath, measurements) {
     return refuse('config.json não declara project.tests[] — não há entrada onde gravar a baseline');
   }
 
+  const recortes = measurements.filter((m) => m.selection != null).map((m) => m.id);
+  if (recortes.length > 0) {
+    return refuse(`medição de recorte de task em: ${recortes.join(', ')} — baseline só de execução inteira, sem {task}`);
+  }
+
   const unreadable = measurements.filter((m) => !Number.isInteger(m.count)).map((m) => m.id);
   if (unreadable.length > 0) {
     return refuse(`contagem desconhecida em: ${unreadable.join(', ')} — desconhecido nunca vira 0`);

package/src/lib/tasks/test-runner.js

@@ -170,8 +170,13 @@ function collectDotnetTestProjects(projectPath) {
  * says "not inside" for the same directory and a linked worktree leaks into
  * the test command. Only `realpathSync.native` asks the OS. Fail-open to the
  * plain resolve for a path that does not exist (yet).
+ *
+ * Exported because test-scope.js spells every task output with it (#87 F4): a
+ * mis-cased output resolves on a case-insensitive disk and was forwarded to the
+ * runner verbatim — and the `--linux` container is case-sensitive. The OS also
+ * returns the real CASE of each component, so this one call is both answers.
  */
-function canonicalPath(p) {
+export function canonicalPath(p) {
   try {
     return realpathSync.native(p);
   } catch {
@@ -406,34 +411,106 @@ function runTestPrebuild({ node, cwd, exec, timeout, projectPath }) {
 // How many tests actually ran (T4 / UC-08)
 // ============================================================================
 
+/** VSTest: one summary line per project, STARTING with the verdict. */
+const VSTEST_SUMMARY = /^\s*(?:Aprovado|Passed|Com falha|Failed|Reprovado|Erro)!/i;
+/**
+ * Microsoft.Testing.Platform: the header line, in the two locales MEASURED (pt-BR and
+ * en-US). `\S+` spans `ção` — and a mis-decoded version of it — without naming a byte.
+ */
+const MTP_SUMMARY_HEADER = /^(?:Test run summary|Resumo da execu\S+ de teste):/;
+const MTP_TOTAL = /^\s+total:\s*(\d+)\s*$/;
+const MTP_FAILED = /^\s+(?:failed|falhou):\s*(\d+)\s*$/;
+const MTP_PASSED = /^\s+(?:succeeded|conclu\S*\s+com\s+\S*xito):\s*(\d+)\s*$/;
+
+/**
+ * The indented block under an MTP summary header. It ends at the first line that
+ * starts at column 0; a block with no `total:` line yields `total: null`.
+ */
+function mtpSummaryBlock(lines, from) {
+  const block = { total: null, passed: 0, failed: 0 };
+  for (let i = from; i < lines.length && /^(?:\s|$)/.test(lines[i]); i++) {
+    const line = lines[i];
+    let m;
+    if ((m = MTP_TOTAL.exec(line))) block.total = Number(m[1]);
+    else if ((m = MTP_FAILED.exec(line))) block.failed = Number(m[1]);
+    else if ((m = MTP_PASSED.exec(line))) block.passed = Number(m[1]);
+  }
+  return block;
+}
+
 /**
- * Sum every `Total:`/`Aprovado:`/`Com falha:` summary `dotnet test` printed.
+ * Sum every summary `dotnet test` printed, in either of its two formats.
+ *
+ *   - **VSTest**: a line per project that starts with the verdict —
+ *     `Aprovado!  - Com falha: 0, Aprovado: 57, Ignorado: 1, Total: 58, …`.
+ *   - **Microsoft.Testing.Platform** (xunit.v3 4.x under `global.json`
+ *     `test.runner`, #115): the verdict does NOT start the line —
+ *     `Test run summary: Passed!` / `Resumo da execução de teste: Aprovado!` —
+ *     and the count comes in an indented block below it, with a lowercase
+ *     `total:`, `failed:`/`falhou:` and `succeeded:`/`concluído com êxito:`.
+ *     Measured in both locales (test/fixtures/test-output/mtp-*.txt). ONE block
+ *     per `dotnet test` invocation: a solution of two projects prints a single
+ *     aggregated block (mtp-solution-fail-skip.txt: `total: 6` = 4 + 2), so
+ *     blocks add up only across invocations. `total` counts skipped cases, as
+ *     VSTest's `Total:` does. Another locale is not read: UNKNOWN, never 0.
  *
  * SUM, not "the last one": a chained `a && b` command prints one summary per
- * project, and reading a single line would report half a suite as the whole of
- * it — which, against a recorded baseline, is an invented count drop.
- * `countCompletedRuns()` above counts the same lines for a different question
+ * invocation, and reading a single one would report half a suite as the whole
+ * of it — which, against a recorded baseline, is an invented count drop.
+ * `countCompletedRuns()` above counts the VSTest lines for a different question
  * (WHICH link was running when the clock died); this one reads their numbers.
  */
 function parseDotnetCount(output) {
-  const lines = output.split('\n').filter((l) => /^\s*(?:Aprovado|Passed|Com falha|Failed|Reprovado|Erro)!/i.test(l));
+  const lines = output.split('\n');
   let seen = false;
   const sum = { total: 0, passed: 0, failed: 0 };
+  const add = (total, passed, failed) => {
+    seen = true;
+    sum.total += total;
+    sum.passed += passed;
+    sum.failed += failed;
+  };
 
-  for (const line of lines) {
+  for (const line of lines.filter((l) => VSTEST_SUMMARY.test(l))) {
     const total = /\b(?:Total de testes|Total)\s*:\s*(\d+)/i.exec(line);
     if (!total) continue;
-    seen = true;
-    sum.total += Number(total[1]);
     const passed = /\b(?:Aprovado|Passed)\s*:\s*(\d+)/i.exec(line);
     const failed = /\b(?:Com falha|Failed|Reprovado)\s*:\s*(\d+)/i.exec(line);
-    sum.passed += passed ? Number(passed[1]) : 0;
-    sum.failed += failed ? Number(failed[1]) : 0;
+    add(Number(total[1]), passed ? Number(passed[1]) : 0, failed ? Number(failed[1]) : 0);
   }
 
+  lines.forEach((line, i) => {
+    if (!MTP_SUMMARY_HEADER.test(line)) return;
+    const block = mtpSummaryBlock(lines, i + 1);
+    if (block.total !== null) add(block.total, block.passed, block.failed);
+  });
+
   return seen ? sum : null;
 }
 
+/**
+ * The `total` of every MTP summary block in `output`, ANSI stripped — one per
+ * `dotnet test` invocation (measured: a solution prints ONE aggregated block).
+ * `[]` when none is readable. Read by `judgeNarrowedRun` (verify-runner.js): in a
+ * narrowed `&&` chain the SUM can be > 0 while one link ran nothing — its exit 8
+ * ignored by a path the scanner cannot read — and that link's own block says
+ * `total: 0`.
+ *
+ * @param {string|null|undefined} output
+ * @returns {number[]}
+ */
+export function mtpSummaryTotals(output) {
+  if (typeof output !== 'string' || !output) return [];
+  const lines = stripAnsi(output).split('\n');
+  const totals = [];
+  lines.forEach((line, i) => {
+    if (!MTP_SUMMARY_HEADER.test(line)) return;
+    const { total } = mtpSummaryBlock(lines, i + 1);
+    if (total !== null) totals.push(total);
+  });
+  return totals;
+}
+
 /** Last value of a `# key N` (TAP) or `ℹ key N` (spec reporter) summary line. */
 function lastSummaryValue(output, key) {
   const re = new RegExp(`^\\s*[#ℹ]\\s*${key}\\s+(\\d+)\\s*$`, 'gim');
@@ -488,6 +565,32 @@ function parseJestCount(output) {
   };
 }
 
+/**
+ * CSI (`ESC [ ... <final byte @-~>`, e.g. SGR color codes) and OSC (`ESC ] ...
+ * BEL|ESC\`, e.g. hyperlinks/terminal titles) escape sequences — the two
+ * shapes a captured terminal transcript actually carries (issue #110: a
+ * vitest summary piped through `execSync` kept its SGR bytes, and every count
+ * regex in this file is anchored on `^` / exact literals, so a color code
+ * sitting between "Tests" and the number silently defeated the whole line).
+ */
+const ANSI_PATTERN = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\))/g;
+
+/**
+ * Strip ANSI escape sequences (CSI/SGR and OSC) from captured process output.
+ *
+ * Non-string input is returned UNCHANGED, never coerced to `''` — the callers
+ * that matter (`parseTestCount`, `isZeroTestRun`) already treat a non-string
+ * output as "nothing to read" on their own; making this function opinionated
+ * about that too would be a second place for the same rule to drift.
+ *
+ * @param {string} text
+ * @returns {string} `text` with escape sequences removed; unchanged if not a string
+ */
+export function stripAnsi(text) {
+  if (typeof text !== 'string') return text;
+  return text.replace(ANSI_PATTERN, '');
+}
+
 /** Playwright: `8 passed (12.4s)` and/or `2 failed`, on their own lines. */
 function parsePlaywrightCount(output) {
   const passed = /^\s*(\d+)\s+passed\b/im.exec(output);
@@ -501,11 +604,12 @@ function parsePlaywrightCount(output) {
 /** One extractor per runner. An absent entry is an honest "I cannot read this". */
 const COUNT_EXTRACTORS = {
   dotnet: parseDotnetCount,
-  // An eval IS `dotnet test`, so it reads the same summary. No new extractor is
-  // invented here: the authoritative number for an eval node is the `scenarios`
-  // field of the fixture's summary FILE, which this function cannot see (it only
-  // gets the output). `verify-runner` prefers that file and falls back to this —
-  // and both paths keep `null` meaning UNKNOWN, never zero.
+  // An eval IS `dotnet test`, so it reads the same summary — but that number
+  // counts xunit cases, not scenarios. What an eval node is judged and recorded
+  // by is the `scenarios` field of the fixture's summary FILE, which this
+  // function cannot see: `judgeEvalRun` replaces this count with it, or with
+  // `null` (UNKNOWN, never zero) when the file is unreadable, and `judgeRun`
+  // never compares an eval node against `expectedCount` (#110).
   evals: parseDotnetCount,
   'node-test': parseNodeTestCount,
   vitest: parseVitestCount,
@@ -529,7 +633,96 @@ export function parseTestCount(output, runner) {
   if (typeof output !== 'string' || !output) return null;
   const extractor = COUNT_EXTRACTORS[runner];
   if (!extractor) return null;
-  return extractor(output);
+  // SINGLE call site: every extractor reads ANSI-stripped text, never raw
+  // bytes — a captured terminal transcript may carry SGR color codes right
+  // inside a summary line (#110) and every regex above is anchored on exact
+  // literals that a stray `\x1b[32m` would defeat.
+  return extractor(stripAnsi(output));
+}
+
+// ============================================================================
+// "Zero tests ran" signatures, per runner (#87 PR B / #110 parte 1)
+// ============================================================================
+
+/**
+ * Per-runner signal for "the run matched/executed NOTHING" — a category
+ * distinct from both a genuine `{ total: 0, ... }` summary (a suite that
+ * legitimately declares zero cases) and from a summary `parseTestCount`
+ * simply could not read (`null`, UNKNOWN). Its reader is `judgeNarrowedRun`
+ * (verify-runner.js, #87): a narrowed `verify {feature} {task}` run that FAILED
+ * with this signature, and with no count proving tests ran, is named
+ * `narrowed-zero-tests (…)` instead of an anonymous red. (A PASSED narrowed run
+ * needs its own proof there — a count > 0, or MTP's exit 0 — never this table.)
+ *
+ * Every entry was MEASURED against a real runner, not invented, and the two
+ * dotnet entries disagree with each other on purpose:
+ *
+ *   - **MTP** (`--filter-class`, this repo's own `ai-kit`, xunit.v3 4.x):
+ *     a non-matching filter exits **8** (`ZeroTests`) — reliable BY EXIT
+ *     CODE. See `test/fixtures/test-output/mtp-zero-tests.txt`.
+ *   - **VSTest** (`--filter "FullyQualifiedName~..."`, classic xunit 2.x):
+ *     a non-matching filter exits **0** — exit code CANNOT tell a zero-match
+ *     run from a green one here. Only the OUTPUT STRING can:
+ *     `test/fixtures/test-output/vstest-zero-tests.txt` (pt-BR, measured).
+ *     The en-US wording is the brief's documented string, not measured on
+ *     this pt-BR machine — kept alongside the pt-BR one because neither is
+ *     derivable from the other and the machine that runs `verify` may be in
+ *     either locale.
+ *
+ * Exit code 8 is therefore listed ONLY as a dotnet exit code, never paired
+ * with a string requirement — and exit code 9
+ * (`MinimumExpectedTestsPolicyViolation`, this repo's own
+ * `--minimum-expected-tests 275`) is deliberately ABSENT: it fires on a run
+ * that executed fewer cases than the configured floor, including a run that
+ * was entirely green (measured:
+ * `test/fixtures/test-output/mtp-filter-class-policy-violation.txt`, 10/10
+ * passed, exit 9). Folding 9 into this table would misreport a real pass as
+ * "zero tests ran".
+ */
+export const ZERO_RUN_SIGNATURES = {
+  dotnet: {
+    exitCodes: [8],
+    strings: [
+      // en-US, VSTest — documented by the brief, not measured here (pt-BR machine).
+      'No test matches the given testcase filter',
+      // pt-BR, VSTest — MEASURED, test/fixtures/test-output/vstest-zero-tests.txt.
+      'Nenhum teste corresponde ao filtro de testcase',
+    ],
+  },
+  vitest: {
+    exitCodes: [],
+    strings: ['No test files found'],
+  },
+  jest: {
+    exitCodes: [],
+    strings: ['No tests found'],
+  },
+};
+
+/**
+ * True when `output`/`exitCode` carries this runner's "zero tests ran"
+ * signature. Every other runner (`node-test`, `playwright`, `evals`, `none`,
+ * or anything not in `ZERO_RUN_SIGNATURES`) answers `false` — an absent entry
+ * is an honest "this primitive does not know that runner's zero-tests shape
+ * yet", the same doctrine `COUNT_EXTRACTORS` uses for an unknown runner.
+ *
+ * Called by `judgeNarrowedRun` (verify-runner.js) on a FAILED narrowed run, to
+ * name it `narrowed-zero-tests (…)`.
+ *
+ * @param {string|null|undefined} output - Combined stdout+stderr of the run
+ * @param {string} runner - One of TEST_RUNNERS
+ * @param {number|null|undefined} exitCode - Must be a NUMBER to match: the
+ *   exit-code check is a strict `includes`, so the string `'8'` never matches 8.
+ * @returns {boolean}
+ */
+export function isZeroTestRun(output, runner, exitCode) {
+  const signature = ZERO_RUN_SIGNATURES[runner];
+  if (!signature) return false;
+
+  if (signature.exitCodes.includes(exitCode)) return true;
+
+  const text = stripAnsi(typeof output === 'string' ? output : '');
+  return signature.strings.some((needle) => text.includes(needle));
 }
 
 /**