@polymorphism-tech/morph-spec 8.36.0 → 8.37.0

package/src/commands/validation/verify.js

@@ -188,6 +188,12 @@ function evalsStatusOf(result) {
   return 'skip';
 }
 
+/**
+ * The options that make a FEATURE-scope run partial, each with the `reason` it
+ * reports when it keeps the stamp from being written — first match wins.
+ */
+const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'], ['skipBuild', 'skip-build']];
+
 /**
  * `morph-spec verify <feature> [task]` — the deterministic code-before-judge
  * gate: build + tests + validators, BEFORE the LLM eval. See verify-runner.js
@@ -270,16 +276,23 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   // run is narrowed to a subset of nodes, but the stamp it would write carries
   // `scope: 'feature'` — the one scope risk-detector.js trusts unconditionally.
   // A partial run must not stand in for the proof a gate asks for, same as
-  // `--record-baseline` above. Task-scope `--filter` is unaffected: that stamp
-  // already says `scope: 'task:{id}'`, and `taskVerifications` never claimed
-  // to cover more than the task in the first place. Checked AFTER `--no-persist`
-  // (via the `!options.noPersist` guard) so an explicit `--no-persist` keeps its
-  // own reason instead of being reported as 'filtered' — the flags are both
-  // "don't write", but decidePersistence() already owns the former's reason.
+  // `--record-baseline` above. `--skip-tests` and `--skip-build` are the same
+  // partial run through another door (#113): a skipped node never reddens the
+  // rollup, so the stamp said `pass` over a suite (or a build) that never ran,
+  // and no gate rule reads a skipped `tests`/`build`. Task scope is unaffected:
+  // that stamp already says `scope: 'task:{id}'` (which pauses the ship gate on
+  // its own), and `taskVerifications` never claimed to cover more than the
+  // task. Checked AFTER `--no-persist` (via the `!options.noPersist` guard) so
+  // an explicit `--no-persist` keeps its own reason instead of being reported
+  // as one of these — the flags are all "don't write", but decidePersistence()
+  // already owns the former's reason.
+  const partialFeatureRun = (!options.noPersist && !taskId)
+    ? PARTIAL_RUN_FLAGS.find(([flag]) => options[flag])?.[1] ?? null
+    : null;
   const { persist, reason } = options.recordBaseline
     ? { persist: false, reason: 'record-baseline' }
-    : (!options.noPersist && !taskId && options.filter)
-      ? { persist: false, reason: 'filtered' }
+    : partialFeatureRun
+      ? { persist: false, reason: partialFeatureRun }
       : decidePersistence({ cwd: process.cwd(), featureName, noPersist: options.noPersist });
 
   let compact = null;

package/src/lib/tasks/dotnet-test-introspection.js

@@ -224,28 +224,142 @@ export function dotnetTestMode(absCwd) {
   }
 }
 
+/** Read on EVERY level from the project's folder up (bindingMsbuildFiles). */
+const DIRECTORY_FILES = ['Directory.Build.props', 'Directory.Build.targets', 'Directory.Build.rsp', 'Directory.Packages.props'];
+
 /**
- * Does an MSBuild file that binds this project — the csproj, or any
- * `Directory.Build.props/.targets` up to the project root — match `pattern`?
- * `<Import Project=…>` is not followed (deferred). It errs wide: a false positive
- * costs a whole run, a false negative a red (or a green) that no test earned.
+ * The MSBuild files that bind a project, as far as this module reads them: the csproj,
+ * the `<csproj>.user` Microsoft.Common.targets imports beside it, and every
+ * DIRECTORY_FILES walking up to the FILESYSTEM root — MSBuild's lookup does not stop at
+ * the repository, and a Directory.Build.targets above it binds the project just the same
+ * (#114 review F3). Every level is read, not only the first file MSBuild would import:
+ * that errs wide. Not read: an `<Import Project=…>` (floorOverride refuses a csproj that
+ * has one), a NuGet package's `build/*.targets`, the SDK's own imports.
  */
-function msbuildDeclares(csprojAbs, rootAbs, pattern) {
-  const files = [csprojAbs];
-  for (let dir = dirname(csprojAbs); isInside(dir, rootAbs); dir = dirname(dir)) {
-    files.push(join(dir, 'Directory.Build.props'), join(dir, 'Directory.Build.targets'));
-    if (dirname(dir) === dir) break;
+function bindingMsbuildFiles(csprojAbs) {
+  const files = [csprojAbs, `${csprojAbs}.user`];
+  for (let dir = dirname(csprojAbs); ; dir = dirname(dir)) {
+    files.push(...DIRECTORY_FILES.map((name) => join(dir, name)));
+    if (dirname(dir) === dir) return files;
   }
-  return files.some((p) => pattern.test(readText(p) ?? ''));
+}
+
+/**
+ * Does an MSBuild file that binds this project (bindingMsbuildFiles) match `pattern`?
+ * It errs wide: a false positive costs a whole run, a false negative a red (or a
+ * green) that no test earned.
+ */
+function msbuildDeclares(csprojAbs, pattern) {
+  return bindingMsbuildFiles(csprojAbs).some((p) => pattern.test(readText(p) ?? ''));
 }
 
 /**
  * The project imposes `--minimum-expected-tests` on every run: in the MSBuild
  * property (attributes such as `Condition=` allowed), or in a `*testconfig.json`
- * beside the csproj. Measured: the CLI cannot override it, so a green recorte exits 9.
+ * beside the csproj. Measured: the CLI flag cannot override it, so a green recorte
+ * exits 9 — unless floorOverride can lower it (#114).
+ */
+export function imposesMinimumExpected(csprojAbs) {
+  return msbuildDeclares(csprojAbs, FLOOR_PROPERTY) || testconfigDeclares(csprojAbs, /minimum-?expected-?tests/i);
+}
+
+const ARGS_NAME = 'TestingPlatformCommandLineArguments';
+const ARGS_ELEMENT = /<TestingPlatformCommandLineArguments\b([^>]*)>([^<]*)<\/TestingPlatformCommandLineArguments\s*>/gi;
+const ARGS_OPENING = /<TestingPlatformCommandLineArguments\b/gi;
+/** Named anywhere: an element, a `$(…)` read, a `-p:` in a Directory.Build.rsp. */
+const ARGS_MENTION = /TestingPlatformCommandLineArguments/i;
+const IMPORT_ELEMENT = /<Import\b/i;
+/**
+ * A tag — or a comment, CDATA section, declaration or processing instruction, which
+ * enclosingElements skips. An attribute value may hold `>` (`Condition="'$(A)' > '1'"`),
+ * so a quoted value is consumed whole.
+ */
+const XML_TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<[!?][^>]*>|<(\/?)([A-Za-z_][\w.:-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
+/**
+ * What a value cannot carry and still be re-passed as ONE double-quoted `-p:`
+ * argument meaning the same thing: MSBuild expansion and escapes (`$ @ %`), its
+ * property separators (`; ,`), an XML entity (`&`), and shell quoting (`" ' \` \ !`).
+ */
+const UNSAFE_IN_PROPERTY = /[$@%;,&"'`\\!]/;
+/** Read after ASCII whitespace is collapsed: a no-break space between flag and number matches nothing (review F7). */
+const FLOOR_ARGUMENT = /(^| )--minimum-expected-tests \d+(?= |$)/;
+
+/**
+ * The elements enclosing the opening tag of `name`, outermost first — or null when the
+ * tags do not balance. Fails SAFE: a document it cannot walk is null, and the node runs
+ * whole.
+ */
+function enclosingElements(text, name) {
+  const stack = [];
+  let enclosing = null;
+  for (const [, closing, tag, attributes, selfClosing] of text.matchAll(XML_TOKEN)) {
+    if (tag === undefined) continue;
+    if (closing) {
+      if (stack.pop()?.tag.toLowerCase() !== tag.toLowerCase()) return null;
+      continue;
+    }
+    if (tag.toLowerCase() === name.toLowerCase()) enclosing = [...stack];
+    if (!selfClosing) stack.push({ tag, attributes });
+  }
+  return stack.length === 0 ? enclosing : null;
+}
+
+/**
+ * The element is set on EVERY evaluation, by nothing but itself: its parent is a
+ * `<PropertyGroup>` with no attribute, directly under `<Project>` — never a `<Target>`, a
+ * `<Choose>/<When>`, an `<ItemDefinitionGroup>` or a conditional group (#114 review F1:
+ * the element's OWN attributes were the only ones read, and a false `Condition` on its
+ * group got the value injected into a run MSBuild would never give it). `<Project>` does
+ * not mark it `TreatAsLocalProperty` (the csproj would beat the global `-p:` and a green
+ * recorte exit 9, review F5), and the csproj imports nothing that could append to it.
+ */
+function setUnconditionally(text) {
+  if (IMPORT_ELEMENT.test(text)) return false;
+  const enclosing = enclosingElements(text, ARGS_NAME);
+  if (enclosing?.length !== 2) return false;
+  const [project, group] = enclosing;
+  return /^Project$/i.test(project.tag) && !/TreatAsLocalProperty/i.test(project.attributes)
+    && /^PropertyGroup$/i.test(group.tag) && group.attributes.trim() === '';
+}
+
+/**
+ * The value for `-p:TestingPlatformCommandLineArguments=` that lowers the project's
+ * floor to 1 and keeps every other argument (#114) — or null, and the node runs whole.
+ *
+ * Measured (test/fixtures/test-output/): the CLI flag does NOT override the project's
+ * floor — a green recorte still exits 9 —, the global MSBuild property does — green
+ * exits 0, zero tests still exit 8 — and it replaces the value WHOLE, so the rest is
+ * re-passed verbatim (mtp-minimum-expected-override-multiarg.txt). No rebuild: six
+ * runs alternating with and without it kept the test DLL's mtime, ~3 s each.
+ *
+ * So the value has to be exactly the one MSBuild would use, read from ONE place:
+ *   - ONE `<TestingPlatformCommandLineArguments>` in the csproj itself, set on every
+ *     evaluation (setUnconditionally) — no attribute of its own, no second opening
+ *     (another element, or one in an XML comment: the count is over the raw text);
+ *   - the property named in no other file that binds the project (bindingMsbuildFiles:
+ *     the `.user` file, Directory.Build.* up to the filesystem root) — one could append
+ *     to it or replace it;
+ *   - no floor in a `*testconfig.json` beside it (`-p:` does not reach that file);
+ *   - exactly one literal `--minimum-expected-tests N`, and nothing UNSAFE_IN_PROPERTY.
+ * Out of reach: a NuGet package's build targets appending to the property. The override
+ * drops that argument during the recorte, and one like xunit.v3's `--explicit` changes
+ * WHICH tests run — a limit framework/docs/CLI.md states.
+ *
+ * @returns {string|null}
  */
-export function imposesMinimumExpected(csprojAbs, rootAbs) {
-  return msbuildDeclares(csprojAbs, rootAbs, FLOOR_PROPERTY) || testconfigDeclares(csprojAbs, /minimum-?expected-?tests/i);
+export function floorOverride(csprojAbs) {
+  const text = readText(csprojAbs);
+  if (text === null) return null;
+  const elements = [...text.matchAll(ARGS_ELEMENT)];
+  if (elements.length !== 1 || (text.match(ARGS_OPENING) ?? []).length !== 1) return null;
+  const [, attributes, raw] = elements[0];
+  if (attributes.trim() !== '' || !setUnconditionally(text)) return null;
+  if (bindingMsbuildFiles(csprojAbs).slice(1).some((p) => ARGS_MENTION.test(readText(p) ?? ''))) return null;
+  if (testconfigDeclares(csprojAbs, /minimum-?expected-?tests/i)) return null;
+  const value = raw.replace(/[ \t\r\n]+/g, ' ').trim();
+  if (UNSAFE_IN_PROPERTY.test(value)) return null;
+  if ((value.match(/--minimum-expected-tests/g) ?? []).length !== 1 || !FLOOR_ARGUMENT.test(value)) return null;
+  return value.replace(FLOOR_ARGUMENT, '$1--minimum-expected-tests 1');
 }
 
 /**
@@ -253,12 +367,13 @@ export function imposesMinimumExpected(csprojAbs, rootAbs) {
  * the `TESTINGPLATFORM_EXITCODE_IGNORE` variable named anywhere in an MSBuild file that
  * binds the project — inside `<TestingPlatformCommandLineArguments>` or in a property
  * it references through `$(…)` — or either one in a `*testconfig.json` beside the csproj.
- * Under MTP a narrowed run's proof that tests ran is exit 0 (zero tests exit 8);
- * with 8 ignored, zero tests exit 0 and the proof is gone — the final review of
+ * Under MTP a narrowed run's proof that tests ran is the summary's count and — when
+ * the summary is not readable (#115: pt-BR and en-US are) — exit 0 (zero tests exit
+ * 8); with 8 ignored, zero tests exit 0 and that proof is gone — the final review of
  * branch B probed it end to end. Errs wide, like the floor.
  */
-export function ignoresExitCode(csprojAbs, rootAbs) {
-  return msbuildDeclares(csprojAbs, rootAbs, IGNORE_EXIT_MARKER)
+export function ignoresExitCode(csprojAbs) {
+  return msbuildDeclares(csprojAbs, IGNORE_EXIT_MARKER)
     || testconfigDeclares(csprojAbs, /ignore-?exit-?code|exit-?code-?ignore|TESTINGPLATFORM_EXITCODE_IGNORE/i);
 }
 
@@ -271,8 +386,8 @@ function testconfigDeclares(csprojAbs, pattern) {
 }
 
 /** The project declares `<VSTestTestCaseFilter>` — an appended `--filter` would silently REPLACE it. */
-export function declaresCaseFilter(csprojAbs, rootAbs) {
-  return msbuildDeclares(csprojAbs, rootAbs, CASE_FILTER_PROPERTY);
+export function declaresCaseFilter(csprojAbs) {
+  return msbuildDeclares(csprojAbs, CASE_FILTER_PROPERTY);
 }
 
 const lineEnd = (text, i) => { const e = text.indexOf('\n', i); return e < 0 ? text.length : e; };

package/src/lib/tasks/eval-node.js

@@ -389,9 +389,9 @@ export function readEvalSummary(path) {
 /**
  * How many scenarios an eval run evaluated.
  *
- * The summary wins when it is readable; otherwise the caller falls back to the
- * `dotnet` extractor, because an eval IS `dotnet test`. **No new extractor is
- * invented**, and an unreadable summary yields null, never 0.
+ * The ONLY source of an eval node's count. The `dotnet` extractor reads the same
+ * run but counts xunit cases — another unit (#110) — so an unreadable summary
+ * yields null: UNKNOWN, never 0, and never the extractor's number.
  *
  * @param {object|null} summary
  * @returns {number|null}

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

@@ -411,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;
 /**
- * Sum every `Total:`/`Aprovado:`/`Com falha:` summary `dotnet test` printed.
+ * 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 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');
@@ -532,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,

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

@@ -31,8 +31,8 @@ import { canonicalPath, extractCsprojTargets, isInside } from './test-runner.js'
 import { normalizePath } from '../validators/traceability-check.js';
 import { samePathCase } from '../worktree/docker-audit.js';
 import {
-  csharpClasses, declaresCaseFilter, dotnetTestMode, dotnetTestProjectOf, ignoresExitCode, imposesMinimumExpected,
-  isDotnetSource, isDotnetTestProject, nearestCsprojOf, nearestProjectOf, readsLikeTestSource,
+  csharpClasses, declaresCaseFilter, dotnetTestMode, dotnetTestProjectOf, floorOverride, ignoresExitCode,
+  imposesMinimumExpected, isDotnetSource, isDotnetTestProject, nearestCsprojOf, nearestProjectOf, readsLikeTestSource,
 } from './dotnet-test-introspection.js';
 
 // Part of this module's API (task B3); implemented beside the rest of the .NET introspection.
@@ -66,8 +66,9 @@ export { dotnetTestMode, classNamesOf } from './dotnet-test-introspection.js';
  *   unless narrowed.
  * @property {'count'|'mtp-exit-8'|null} zeroGuard - How a narrowed run proves tests
  *   ran: `count` = only a parsed count > 0 proves it (VSTest exits 0 on an empty
- *   filter; vitest/jest print a string); `mtp-exit-8` = MTP exits 8 on zero tests,
- *   so exit 0 is proof. null unless narrowed.
+ *   filter; vitest/jest print a string); `mtp-exit-8` = a parsed count > 0 proves it
+ *   (the MTP summary, pt-BR/en-US, #115) and, with no readable summary, exit 0 does —
+ *   MTP exits 8 on zero tests. A parsed 0 is red under both. null unless narrowed.
  */
 
 const NO_TEST_FILE = 'no test file from task outputs in this node — running it whole';
@@ -75,17 +76,26 @@ const SHAPE = 'command shape not recognised for narrowing — running it whole';
 /**
  * Measured (test/fixtures/test-output/mtp-minimum-expected-cli-override-ignored.txt):
  * `--minimum-expected-tests 1` on the CLI does NOT override the project's floor —
- * a green narrowed run still exits 9. So a project that imposes it runs whole
+ * a green narrowed run still exits 9. The global `-p:` property does, and since
+ * #114 a floor floorOverride can re-pass is lowered to 1 for the recorte; every
+ * other floor (VSTest, set elsewhere or conditionally) runs whole with this reason
  * rather than produce a red that no test caused. Wording pinned by the plan.
  */
 const MIN_EXPECTED = 'projeto impõe --minimum-expected-tests; recorte desligado';
+/** #114 review F6: `-p:` is global to ONE `dotnet test`, so it would replace the arguments of EVERY project the link runs. */
+const FLOOR_SHARED = 'a link runs several test projects and one has a floor — its -p: would replace the others\' arguments too; running it whole';
+/** #114 review F2: the recorte's `-p:` comes last, and the last one wins — the command's own value would be gone. */
+const COMMAND_SETS_ARGS = 'command sets TestingPlatformCommandLineArguments itself — the recorte\'s -p: would replace that value; running it whole';
 const FILTER_TAKEN = 'command already carries a test filter — a second one would replace it; running it whole';
 const CASE_FILTER = 'project declares <VSTestTestCaseFilter> — an appended --filter would replace it; running it whole';
 /**
- * Final review F3: under MTP a narrowed run's proof that tests ran is exit 0 (zero
- * tests exit 8). Whatever makes MTP ignore an exit code takes that proof away —
- * zero tests then exit 0 — so the node runs whole. The COMMAND is read by
- * FLOOR_OR_IGNORE; these two are the project (ignoresExitCode) and the environment.
+ * Final review F3: under MTP, when the summary is NOT readable (a locale other than
+ * pt-BR/en-US, #115), a narrowed run's proof that tests ran is exit 0 (zero tests
+ * exit 8). Whatever makes MTP ignore an exit code takes that proof away — zero tests
+ * then exit 0 — so the node runs whole, readable summary or not: this is decided
+ * BEFORE the run, which is when nobody knows yet whether its summary will read.
+ * The COMMAND is read by FLOOR_OR_IGNORE; these two are the project
+ * (ignoresExitCode) and the environment.
  */
 const IGNORE_EXIT_PROJECT = 'project makes MTP ignore an exit code (--ignore-exit-code / TESTINGPLATFORM_EXITCODE_IGNORE in its MSBuild files or testconfig) — exit 0 would no longer prove that tests ran; running it whole';
 const IGNORE_EXIT_ENV = 'TESTINGPLATFORM_EXITCODE_IGNORE is set in the environment — MTP may exit 0 on zero tests, so exit 0 would no longer prove that tests ran; running it whole';
@@ -319,13 +329,29 @@ function narrowDotnet(command, owned, cwdAbs, rootAbs) {
   if (mode === null) return whole('global.json unreadable — cannot tell VSTest from MTP; running it whole');
 
   const files = owned.map((abs) => ({ abs, inside: isInside(abs, cwdAbs), ...dotnetTestProjectOf(abs, rootAbs), ...csharpClasses(abs) }));
-  // The PROJECT binds the run, in either mode: a floor exits 9 on a green
-  // recorte (MTP, or MTP through the VSTest bridge), and a declared case filter
-  // is REPLACED by an appended --filter (`Category!=Eval` silently gone).
+  // The PROJECT binds the run, in either mode. A floor exits 9 on a green
+  // recorte: under MTP it is lowered to 1 by a `-p:` that re-passes the rest of
+  // the value when floorOverride can read it from ONE place (#114); otherwise —
+  // VSTest (the MTP bridge, not measured), a floor set elsewhere or conditionally
+  // — the node runs whole. A declared case filter is REPLACED by an appended
+  // --filter (`Category!=Eval` silently gone).
   const projects = [...new Set(files.map((f) => f.csproj))];
-  if (projects.some((p) => imposesMinimumExpected(p, rootAbs))) return whole(MIN_EXPECTED);
-  if (projects.some((p) => ignoresExitCode(p, rootAbs))) return whole(IGNORE_EXIT_PROJECT);
-  if (projects.some((p) => declaresCaseFilter(p, rootAbs))) return whole(CASE_FILTER);
+  const floors = new Map();
+  for (const project of projects.filter((p) => imposesMinimumExpected(p))) {
+    const value = mode === 'mtp' ? floorOverride(project) : null;
+    if (value === null) return whole(MIN_EXPECTED);
+    if (links.some((l) => /TestingPlatformCommandLineArguments/i.test(l))) return whole(COMMAND_SETS_ARGS);
+    floors.set(project, value);
+  }
+  // `-p:` is global to ONE `dotnet test` invocation: it lowers the floor of the project
+  // it was read from and REPLACES the arguments of every other project the link runs.
+  const floorArg = (owners, projectCount) => {
+    const value = owners.map((c) => floors.get(c)).find((v) => v !== undefined);
+    if (value === undefined) return '';
+    return projectCount === 1 ? ` "-p:TestingPlatformCommandLineArguments=${value}"` : null;
+  };
+  if (projects.some((p) => ignoresExitCode(p))) return whole(IGNORE_EXIT_PROJECT);
+  if (projects.some((p) => declaresCaseFilter(p))) return whole(CASE_FILTER);
   if (mode === 'mtp') {
     const other = files.find((f) => !MTP_FRAMEWORKS.has(f.framework));
     if (other) return whole(`MTP test project uses a framework with no known class filter (${other.framework ?? 'unknown'}) — running it whole`);
@@ -367,7 +393,11 @@ function narrowDotnet(command, owned, cwdAbs, rootAbs) {
     if (targets.length > 0) {
       const mine = files.filter((f) => targets.some((t) => samePath(t, f.csproj)));
       const classes = classesOf(mine);
-      if (classes.length > 0) out.push(`${link} ${selectorArgs(mode, mine[0].framework, classes)}`);
+      if (classes.length > 0) {
+        const floor = floorArg([...new Set(mine.map((f) => f.csproj))], targets.length);
+        if (floor === null) return whole(FLOOR_SHARED);
+        out.push(`${link} ${selectorArgs(mode, mine[0].framework, classes)}${floor}`);
+      }
       continue; // a link whose project owns none of the files is dropped
     }
     const flags = retargetFlags(link, mode, cwdAbs);
@@ -380,7 +410,7 @@ function narrowDotnet(command, owned, cwdAbs, rootAbs) {
       const mine = files.filter((f) => f.csproj === csproj && f.inside);
       const classes = classesOf(mine);
       const target = mode === 'mtp' ? `--project "${rel}"` : `"${rel}"`;
-      if (classes.length > 0) out.push(`dotnet test ${target}${flags} ${selectorArgs(mode, mine[0].framework, classes)}`);
+      if (classes.length > 0) out.push(`dotnet test ${target}${flags} ${selectorArgs(mode, mine[0].framework, classes)}${floorArg([csproj], 1)}`);
     }
   }
   if (out.length === 0) {

package/src/lib/validators/verify-runner.js

@@ -24,14 +24,14 @@
  */
 
 import { execFileSync } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, rmSync } from 'fs';
 import { join, resolve } from 'path';
 
 import { runBuildCheck, getBuildSteps } from '../../../framework/hooks/shared/build-check.js';
 import { runE2eCheck } from '../../../framework/hooks/shared/e2e-check.js';
 import { buildComposeEnv } from '../e2e/compose-env.js';
 import {
-  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, isZeroTestRun,
+  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, isZeroTestRun, mtpSummaryTotals,
 } from '../tasks/test-runner.js';
 import {
   resolveTestNodes, parseTestFilter, nodeMatchesFilter, recordTestBaselines, morphConfigPath,
@@ -56,6 +56,7 @@ const OUTPUT_TAIL_LINES = 20;
 
 /** A narrowed run that proved ZERO tests ran (#87) — wording pinned by the plan. */
 const NARROWED_ZERO_TESTS = 'narrowed-zero-tests: o recorte executou 0 testes';
+const NARROWED_ZERO_TESTS_LINK = 'narrowed-zero-tests: um link do recorte executou 0 testes (bloco MTP com total: 0)';
 
 /** A narrowed run that exited green with no count anyone could read (#87): null is UNKNOWN, and unknown is never green. */
 const NARROWED_COUNT_UNKNOWN = 'narrowed-count-unknown: o recorte saiu verde sem contagem legível — '
@@ -469,14 +470,27 @@ async function runOneTestNode({
   const evalChannel = node.runner === EVAL_RUNNER
     ? evalNodeEnv(node, projectPath, { refresh: refreshCache })
     : null;
+  // The summary path is fixed per node id and pid, and nothing else removes the
+  // file: one left there by an earlier run (an earlier verify in the same
+  // process, a recycled pid) was read as THIS run's, handing a harness that
+  // wrote nothing the old scenario count — and hiding an empty run behind it.
+  if (evalChannel) discardFile(evalChannel.summaryPath);
 
   const start = Date.now();
   const result = await _runTestSuite(projectPath, {
     timeout, node, ...(evalChannel ? { env: evalChannel.env } : {}),
   });
   const entry = judgeRun({ node, result, durationMs: Date.now() - start });
+  if (!evalChannel) return entry;
 
-  return evalChannel ? judgeEvalRun(entry, node, evalChannel.summaryPath) : entry;
+  const judged = judgeEvalRun(entry, node, evalChannel.summaryPath);
+  discardFile(evalChannel.summaryPath);
+  return judged;
+}
+
+/** Remove a scratch file the CLI owns; a file that is not there (or will not go) changes nothing. */
+function discardFile(path) {
+  try { rmSync(path, { force: true }); } catch { /* best effort — the next run removes it first */ }
 }
 
 /**
@@ -484,10 +498,12 @@ async function runOneTestNode({
  * code said.
  *
  * Two things the exit code cannot see:
- *   - the scenario COUNT, which is what `expectedCount` is compared against.
- *     The summary wins when readable; otherwise the `dotnet` extractor's number
- *     stands, because an eval IS `dotnet test`. **null stays UNKNOWN, never 0** —
- *     an unreadable summary must not manufacture a count drop;
+ *   - the scenario COUNT, which is what `expectedCount` is compared against and
+ *     what `--record-baseline` writes. Read ONLY from the summary: the `dotnet`
+ *     extractor counts xunit cases, another unit — compared with (or recorded as)
+ *     a scenario baseline it failed green runs as drops (#110, #117 review). No
+ *     readable summary → **null, UNKNOWN, never 0** — an unreadable summary must
+ *     not manufacture a count drop;
  *   - a suite that evaluated ZERO scenarios and exited 0. Nothing failed, because
  *     nothing ran: the guardrail-inert shape this repository has already paid to
  *     learn to detect.
@@ -499,8 +515,7 @@ function judgeEvalRun(entry, node, summaryPath) {
   const cold = evalColdCacheWarning(summary);
   if (cold) warnings.push(cold);
 
-  const fromSummary = evalScenarioCount(summary);
-  const count = fromSummary ?? entry.count;
+  const count = evalScenarioCount(summary);
   const verdict = compareTestCount(count, node.expectedCount);
   if (verdict.warning) warnings.push(verdict.warning);
 
@@ -645,7 +660,12 @@ function judgeRun({ node, result, durationMs }) {
     return judgeNarrowedRun({ entry, node, result, durationMs, count });
   }
 
-  const verdict = compareTestCount(count, node.expectedCount);
+  // An eval node's unit is the SCENARIO (#110 part 2): its baseline is the
+  // summary's scenario count, and `judgeEvalRun` is the one that compares it.
+  // Comparing here too, with the extractor's count of xunit cases, failed a
+  // 24/24 run as "esperado 24, executado 2" — and `judgeEvalRun` only turns a
+  // pass into a fail, never the reverse.
+  const verdict = compareTestCount(count, node.runner === EVAL_RUNNER ? null : node.expectedCount);
   const warnings = verdict.warning ? [verdict.warning] : [];
 
   // A drop is the one count verdict that fails a node by itself: tests that
@@ -689,16 +709,24 @@ function judgeRun({ node, result, durationMs }) {
  *     must never buy. What counts as proof is the selection's `zeroGuard`
  *     (test-scope.js):
  *       `count`      only a parsed count > 0. **null is UNKNOWN, never green**;
- *       `mtp-exit-8` MTP exits 8 on zero tests, so exit 0 IS the proof.
- *     A parsed 0 is refused under either guard: it is positive evidence.
+ *       `mtp-exit-8` a parsed count > 0 proves it (the MTP summary is read in
+ *                    pt-BR and en-US, #115); with no readable summary (another
+ *                    locale), exit 0 does — MTP exits 8 on zero tests.
+ *     A parsed 0 is refused under either guard: it is positive evidence. It is
+ *     also what closes limit (f): with exit 8 IGNORED, MTP exits 0 over a
+ *     summary that says `total: 0` (measured, mtp-ignore-exit-code-8-zero-tests.txt).
+ *     In a narrowed `&&` chain the SUM would hide that link behind another's
+ *     count, so under `mtp-exit-8` every MTP block is checked on its own — MTP
+ *     prints one block per invocation (measured), and a `total: 0` block is red.
  *
  * A FAILED run is renamed `narrowed-zero-tests (…)` only when it carries the
  * runner's zero-test signature AND no count proves tests ran. A multi-project
  * VSTest output may print "No test matches…" for one project while another
  * ran and failed; that failure is the lead, never a zero. Anything else,
- * exit 9 included, keeps the executor's own raw reason: projects that impose
- * `--minimum-expected-tests` are never narrowed, so a 9 here is not ours to
- * reinterpret.
+ * exit 9 included, keeps the executor's own raw reason: a project that imposes
+ * `--minimum-expected-tests` is narrowed only with its floor lowered to 1 by
+ * `-p:` (#114, test-scope.js), where a run with tests cannot exit 9 — so a 9
+ * here is not ours to reinterpret.
  *
  * Every red leads its output with the verdict, like a timeout does: the
  * feedback line reads `output` before `reason`, and a tail alone would bury it.
@@ -712,6 +740,9 @@ function judgeNarrowedRun({ entry, node, result, durationMs, count }) {
 
   if (result.passed) {
     if (count === 0) return red(NARROWED_ZERO_TESTS);
+    if (entry.selection.zeroGuard === 'mtp-exit-8' && mtpSummaryTotals(result.output).includes(0)) {
+      return red(NARROWED_ZERO_TESTS_LINK);
+    }
     if (ranTests) return green();
     if (entry.selection.zeroGuard === 'mtp-exit-8' && result.exitCode === 0) return green();
     return red(NARROWED_COUNT_UNKNOWN);