@polymorphism-tech/morph-spec 9.0.0 → 9.2.0

package/src/lib/installers/templates-reconcile.js

@@ -1,67 +1,13 @@
-/**
- * templates-reconcile.js — reconcile a pre-existing `.morph/framework/templates/`
- * copy against the project's prior recorded morph-spec version.
- *
- * Shared by BOTH install paths that can encounter this directory:
- *   - `morph-spec update` (src/commands/project/update.js) — always knows the
- *     project's prior version (`checkProjectOutdated().current`, read from
- *     `.morph/.morphversion` BEFORE this run overwrites it).
- *   - `morph-spec init`/`setup-infra` (src/scripts/setup-infra.js) — the SAME
- *     source (`getProjectMorphVersion()`, the function `checkProjectOutdated`
- *     itself calls), read at the same point in the run (before its own write
- *     of `.morph/.morphversion`), when it's available — e.g. a repair run
- *     over an already-initialized project. Falls back to a plain warning when
- *     it isn't (a project with no recorded version has nothing here for this
- *     function to reconcile against safely).
- */
-
 import { existsSync } from 'fs';
 import { compareVersions } from '../../utils/version-checker.js';
 import { realEffects } from './effects.js';
 
-/**
- * Last CLI version whose `update`/`setup-infra` still wrote
- * `.morph/framework/templates/` unconditionally, before Task 2 of the R3
- * perf plan removed that copy. Used as the decision boundary in
- * `reconcileLegacyTemplatesCopy` below — see its doc comment for why a
- * version check is used instead of diffing file content.
- */
+// Last CLI version whose install still copied `.morph/framework/templates/` unconditionally.
 export const LAST_VERSION_THAT_COPIED_TEMPLATES = '8.17.0';
 
-/**
- * Reconcile a pre-existing `.morph/framework/templates/` copy now that
- * neither install path unconditionally writes it anymore (Task 2, R3 perf
- * plan — resolution falls back to the npm package's own framework/templates/,
- * see template-registry.js / architecture-scanner.js's layered resolver).
- *
- * Decided from the project's PRIOR recorded CLI version (before THIS run
- * writes a new one), not by diffing content against the package. A content
- * diff can't tell "stale copy from an older CLI version" apart from
- * "deliberate user override" — and staleness is the dominant case for
- * anyone who actually runs `update`/`setup-infra` again, since template
- * content does change between releases. The version boundary is unambiguous
- * instead:
- *
- *   - No local copy → nothing to do.
- *   - Prior version is unrecorded, OR <= LAST_VERSION_THAT_COPIED_TEMPLATES
- *     → the copy could ONLY have been put there by the OLD installer:
- *     `.morph/framework/**` is Edit-denied to the agent (MORPH_DENY in
- *     hooks-installer.js — "installer-managed, immutable at runtime"),
- *     the directory is gitignored, and every install/update before this fix
- *     unconditionally wiped + recopied it. There is no path by which a
- *     project on an old version could have a genuine override sitting
- *     here. Safe to delete unconditionally — it is dead weight, not data.
- *   - Prior version > LAST_VERSION_THAT_COPIED_TEMPLATES → this install path
- *     has never written this directory for this project. Anything found
- *     here was placed deliberately (by the user or other tooling) — this is
- *     the forward-looking override use case the layered resolver exists
- *     for. Preserve untouched, unconditionally, with no diffing.
- *
- * @param {string} templatesDest - .morph/framework/templates (may not exist)
- * @param {string|null} priorProjectVersion - project's recorded morph-spec
- *   version BEFORE this run (e.g. `checkProjectOutdated().current`)
- * @returns {'absent'|'removed-legacy'|'preserved-override'}
- */
+// Decided by the PRIOR recorded version, not by diffing: a diff can't tell a stale copy from an override.
+// Unrecorded or <= the boundary → only the old installer could have written it, delete.
+// Newer → placed deliberately, preserve.
 export function reconcileLegacyTemplatesCopy(templatesDest, priorProjectVersion, fx = realEffects()) {
   if (!existsSync(templatesDest)) return 'absent';
 
@@ -74,8 +20,7 @@ export function reconcileLegacyTemplatesCopy(templatesDest, priorProjectVersion,
     fx.remove(templatesDest);
     return 'removed-legacy';
   } catch {
-    // Couldn't remove — don't risk a half-broken state; leave it and let
-    // the layered resolver's override-first check pick it up as before.
+    // Couldn't remove: leave it; the resolver's override-first check picks it up.
     return 'preserved-override';
   }
 }

package/src/lib/mutation/adapters.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import { dotnetBuildCommands, withFilter, withTrx, withoutBuild } from './commands.js';
-import { methodOf, parseTrx } from './trx.js';
+import { parseTrx } from './trx.js';
 import { stripAnsi } from '../tasks/test-runner.js';
 
 const MAX_CAPTURE = 16 * 1024 * 1024;
@@ -39,14 +39,10 @@ export function dotnetAdapter({ node, root, workDir, exec, subset, timeoutMs })
   const trxDir = join(workDir, 'trx');
   mkdirSync(trxDir, { recursive: true });
   const base = withoutBuild(node.command);
-  const filterOf = { subset: () => subset.filter, names: (filter) => filter };
-  const commandFor = (scope, label, filter) => withTrx(
-    scope === 'full' ? base : withFilter(base, filterOf[scope](filter)),
-    { dir: trxDir, name: `${label}.trx` },
-  );
-  const runTests = async ({ scope, label, env, filter }) => {
+  const commandFor = (label) => withTrx(withFilter(base, subset.filter), { dir: trxDir, name: `${label}.trx` });
+  const runTests = async ({ label, env }) => {
     const trxPath = join(trxDir, `${label}.trx`);
-    const r = await exec(commandFor(scope, label, filter), { cwd, env, timeoutMs, label });
+    const r = await exec(commandFor(label), { cwd, env, timeoutMs, label });
     if (!existsSync(trxPath)) {
       return { outcome: 'crash', executed: null, total: null, failed: 0, failedTests: [], durationMs: r.durationMs, note: r.timedOut ? `timeout de ${timeoutMs} ms` : `sem TRX (exit ${r.status})` };
     }
@@ -62,12 +58,6 @@ export function dotnetAdapter({ node, root, workDir, exec, subset, timeoutMs })
     buildCommands: dotnetBuildCommands(node, root),
     cwd,
     runTests,
-    reproduce: ({ names, label, env }) => runTests({
-      scope: 'names',
-      label,
-      env,
-      filter: [...new Set(names.map(methodOf))].map((n) => `FullyQualifiedName~${n}`).join('|'),
-    }),
   };
 }
 
@@ -78,9 +68,8 @@ export function genericAdapter({ node, root, exec, subset, timeoutMs }) {
     hasSubset: Boolean(subset?.usable),
     buildCommands: [],
     cwd,
-    async runTests({ scope, label, env }) {
-      const command = scope === 'subset' ? subset.command : node.command;
-      const r = await exec(command, { cwd, env, timeoutMs, label });
+    async runTests({ label, env }) {
+      const r = await exec(subset.command, { cwd, env, timeoutMs, label });
       if (r.timedOut) return { outcome: 'crash', executed: null, total: null, failed: 0, failedTests: [], durationMs: r.durationMs, note: `timeout de ${timeoutMs} ms` };
       if (r.status === 0) return { outcome: 'green', executed: null, total: null, failed: 0, failedTests: [], durationMs: r.durationMs };
       const failedTests = genericFailures(`${r.stdout}\n${r.stderr}`);

package/src/lib/mutation/dotnet-introspection.js

@@ -1,10 +1,3 @@
-/**
- * .NET introspection the targeted mutation (`morph-spec mutate`) needs: which
- * project owns a file, which test mode the SDK picks, and which types a C# file
- * declares — read FAIL-SAFE (see csharpClasses).
- *
- * Pure: reads files, never spawns a process.
- */
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 
@@ -13,54 +6,21 @@ import { jsoncToJson } from '../../../framework/hooks/shared/comment-stripper.js
 
 const MTP_RUNNER = 'Microsoft.Testing.Platform';
 const TYPE_HEADER = /\b(?:class|struct|record|interface)\b/;
-/** A C# identifier's first character: a letter, an Nl letter (`Ⅱ`), `_`, `@` (verbatim) or `\` (a unicode escape). */
+// `@` = verbatim identifier, `\` = unicode escape.
 const NAME_START = '[\\p{L}\\p{Nl}_@\\\\]';
-/**
- * TRIPWIRE: every type-declaration keyword wherever it sits — applied to the RAW
- * text (nothing blanked) and to the blanked code alike, with NO context rule:
- * round 5 showed that any exclusion decided by what precedes the keyword (the
- * `:` of a generic constraint, a `where T :` shape) can be forged by a comment in
- * the raw text or by string content a cut exposes in the code. `record class`/
- * `record struct` count once. What follows the keyword, after optional whitespace,
- * is a name start (NAME_START), a comment or preprocessor line standing between
- * the keyword and its name (`class/**\/BTests` is legal), OR a quote — a quote is
- * what the RAW text shows where the blanked code shows the spaces of a string the
- * keyword is followed by (`"; class " : " Fake"` exposed as code): every keyword
- * the code counts is a keyword the raw text counts, by offset.
- * A constraint keyword is therefore counted too whenever a name-shaped token
- * follows it (`where T : class where U : …`, `: class // note`): it is not named,
- * so the file is unscannable. `class,` / `class\n{` / `class?` are not counted at all.
- */
+// TRIPWIRE with NO context rule: any exclusion based on what precedes the keyword can be
+// forged by a comment or exposed string. The quote in the lookahead makes every keyword
+// the blanked code counts also counted in the raw text, at the same offset.
 const TYPE_KEYWORD = new RegExp(`\\b(?:record\\s+(?:class|struct)|class|record|struct|interface)\\b(?=\\s*(?:${NAME_START}|["']|\\/[/*]|#))`, 'gu');
-/** A type declaration the scanner can NAME: after `; { } ]`, a newline or the file start; attributes; modifiers; a NAME_START name. */
 const TYPE_DECL = new RegExp(`(?:^|[;{}\\]\\n])[ \\t]*(?:\\[[^\\]\\n]*\\][ \\t]*)*(?:(?:public|internal|private|protected|sealed|static|partial|abstract|unsafe|file|new|readonly|ref)\\s+)*(record\\s+(?:class|struct)|class|record|struct|interface)\\s+(${NAME_START}[^\\s:<({;,=]*)`, 'gu');
 const IDENT = '[\\p{L}_][\\p{L}\\p{N}_]*';
 const QUALIFIER = `(?:${IDENT}\\s*(?:\\.|::)\\s*)*`;
-/** An attribute's optional arguments: one nested level of parentheses, no `]`. */
 const ATTRIBUTE_ARGS = '(?:\\((?:[^()\\]]|\\([^()\\]]*\\))*\\))?';
-/** Any other attribute of the same section: a name, optionally with arguments. */
 const OTHER_ATTRIBUTE = `${QUALIFIER}${IDENT}\\s*${ATTRIBUTE_ARGS}`;
 const TEST_ATTRIBUTE_NAME = '(?:Fact|Theory|Test|TestMethod|DataTestMethod|TestCase|TestCaseSource)(?:Attribute)?';
-/**
- * A test attribute, read on the BLANKED code of a test-project file (hasTestAttribute):
- * a WHOLE name — `Fact`, `Theory`, `Test`, `TestMethod`, `DataTestMethod`, `TestCase`,
- * `TestCaseSource`, optionally `…Attribute` and qualified (`Xunit.Fact`) — inside an
- * attribute section that CLOSES as one: `[` where a declaration may start (line start,
- * after `;` `{` `}` `]` or a `*\/`), an optional target, other attributes before it
- * separated by `,`, the test name with its optional arguments, any further attributes,
- * then the `]` — followed by a declaration start (`[`, a name, a comment, a directive)
- * or the end of the input.
- *
- * A false POSITIVE is the unsafe direction here: a helper taken for a test file
- * narrows the subset to its own name, and the tests that USE the helper never run. The final review of branch B found
- * exactly that with the old prefix match (`, TestContext` / `, Factory` / `, TheoryData`
- * after any `,`), and its re-review (N1) with a test name merely FOLLOWED by `(` or `,`:
- * a C# 12 collection laid out with `[` alone on its line (`[\n    Env.Dev,\n    Env.Test,\n];`,
- * a row `[Env.Test, Env.Dev],`, `[\n    Test("a"),\n];`). Requiring the section to close
- * rejects all three; what still matches is stated in csharpClasses. A false NEGATIVE
- * only leaves a test file out of a selection (a custom attribute such as `[SkippableFact]`, a test
- * attribute after an argument holding `]`).
- */
+// A false POSITIVE is the unsafe side (a helper taken for a test file hides the tests that
+// use it), so the whole name must sit in an attribute section that CLOSES: a C# 12
+// collection such as `[\n Env.Test,\n];` must not match. Residual cases: csharpClasses.
 export const CS_TEST_ATTRIBUTE = new RegExp(
   '(?:^|[;{}\\]]|\\*\\/)[ \\t]*\\['
   + `\\s*(?:${IDENT}\\s*:(?!:)\\s*)?`
@@ -71,22 +31,12 @@ export const CS_TEST_ATTRIBUTE = new RegExp(
   'mu',
 );
 
-/**
- * File text with a leading UTF-8 BOM stripped (VS and `charset=utf-8-bom` write
- * one) and every C# new-line character mapped 1:1 to `\n` — CR, NEL (U+0085),
- * LS (U+2028), PS (U+2029): JS `\s` excludes NEL, so `class<NEL>Name` was
- * invisible to both regexes (compiled and discovered by xunit); a CR-only file had
- * no line ends at all. U+001A (Ctrl-Z) is mapped 1:1 to a space: Roslyn reads it
- * as whitespace and JS `\s` does not, so `class<SUB>Name` hid a declaration the
- * same way (B3 carry-over: compiled, green while skipping the class). Length is kept (CRLF becomes `\n\n`). null when unreadable.
- */
+// Roslyn reads CR/NEL/LS/PS as new-lines and U+001A as whitespace; JS `\s` misses NEL
+// and U+001A, which hid `class<NEL>Name`. Mapped 1:1 so offsets stay aligned with the code.
 const readText = (path) => {
   try { return readFileSync(path, 'utf8').replace(/\x1A/g, ' ').replace(/^\uFEFF/, '').replace(/[\r\u0085\u2028\u2029]/g, '\n'); } catch { return null; }
 };
 
-/** Which test framework a csproj references, by package (or MSBuild SDK) name. */
-
-/** Nearest file matching `projectName` walking up from a file's directory, inside the root; null when none. */
 function nearestProjectFile(fileAbs, rootAbs, projectName) {
   for (let dir = dirname(fileAbs); isInside(dir, rootAbs); dir = dirname(dir)) {
     let names = [];
@@ -97,32 +47,20 @@ function nearestProjectFile(fileAbs, rootAbs, projectName) {
   return null;
 }
 
-/**
- * The project — `.csproj`, `.fsproj` or `.vbproj` — nearest to ANY file walking
- * up, or null inside the root. Asked about the .NET sources the C# scan cannot
- * read (a bUnit `.razor`, an F# `.fs`).
- */
 export function nearestProjectOf(fileAbs, rootAbs) {
   return nearestProjectFile(fileAbs, rootAbs, /\.(?:cs|fs|vb)proj$/i);
 }
 
-/** .NET sources the C# scan cannot read: Razor (`.razor`, `.cshtml`), F# (`.fs`, `.fsi`, `.fsx`), VB (`.vb`). */
 const NON_CSHARP_SOURCE = /\.(?:razor|cshtml|fs|fsi|fsx|vb)$/i;
 
-/** A .NET source other than C#: no type scan, hence no class selector, for it. */
+/** No type scan, hence no class selector, for these. */
 export const isNonCSharpSource = (path) => NON_CSHARP_SOURCE.test(String(path));
 
-/** Any .NET source a project compiles — C# or one of the others. */
 export const isDotnetSource = (path) => /\.cs$/i.test(String(path)) || isNonCSharpSource(path);
 
 /**
- * `.NET` test mode for a cwd: nearest `global.json` walking UP (as the SDK
- * resolves it — from the CWD, never from the `.sln` argument), read as JSONC.
- *
- * @param {string} absCwd
- * @returns {'mtp'|'vstest'|null} `mtp` when `test.runner` is Microsoft.Testing.Platform;
- *   `vstest` when readable without it (or absent: the SDK default); null when a
- *   global.json exists but cannot be read — never a guess.
+ * Nearest global.json walking up from the CWD, as the SDK resolves it (never from the
+ * `.sln` argument). null when one exists but cannot be read — never a guess.
  */
 export function dotnetTestMode(absCwd) {
   for (let dir = resolve(absCwd); ; dir = dirname(dir)) {
@@ -141,7 +79,6 @@ export function dotnetTestMode(absCwd) {
 
 const lineEnd = (text, i) => { const e = text.indexOf('\n', i); return e < 0 ? text.length : e; };
 
-/** End (exclusive) of a regular string or char literal opened at `start`; -1 if the line ends first. */
 function closeOnLine(text, start, quote) {
   for (let j = start + 1; j < text.length && text[j] !== '\n'; j++) {
     if (text[j] === '\\') j++;
@@ -150,11 +87,8 @@ function closeOnLine(text, start, quote) {
   return -1;
 }
 
-/**
- * Does an interpolated literal's content end inside a hole? A `"` inside a hole
- * (`$"{d["k"]}"`) ends the literal as the scanner reads it, so what it took for
- * the literal stops with the hole still open. `{{`/`}}` outside a hole are escapes.
- */
+// A `"` inside a hole (`$"{d["k"]}"`) ends the literal as the scanner reads it,
+// leaving the hole open. `{{`/`}}` outside a hole are escapes.
 function holeLeftOpen(content) {
   let depth = 0;
   for (let k = 0; k < content.length; k++) {
@@ -167,26 +101,9 @@ function holeLeftOpen(content) {
 }
 
 /**
- * C# source with every comment, preprocessor line and string/char literal
- * blanked — newlines and length kept — or null when the file cannot be read this way:
- * - a literal or comment never ends;
- * - an interpolated `$"…"`/`$@"…"`/`@$"…"` literal is cut by a quote inside a hole
- *   (its content ends with the hole open). Blanking the part before the cut would
- *   leave the rest of the hole as "code", with braces that can cancel out.
- *
- * Raw strings (`"""…"""`, 3+ quotes, with or without `$`/`$$`) end at the same run
- * of quotes; a quote inside a raw interpolation hole is NOT checked. Verbatim `@"…"`
- * ends at a lone `"`. Regular and char literals cannot cross a line.
- *
- * This is a heuristic lexer and it CAN misread (known: `holeLeftOpen` counts the
- * braces of a char literal such as `'}'`, so `$"{(c == '}' ? "a" : "/*")}"` is cut
- * at the inner quote and `"/*"` becomes code). Nothing relies on the
- * blanking being right: csharpClasses compares the declarations it names against
- * the type keywords of the RAW text, and any declaration a misread hides makes the
- * file unscannable.
- *
- * @param {string} text
- * @returns {string|null}
+ * Comments, preprocessor lines and literals blanked, length and newlines kept; null when
+ * a literal never ends or an interpolation hole is cut. A heuristic lexer that CAN misread:
+ * csharpClasses never trusts it alone (it checks against the raw text).
  */
 export function blankCSharpLiterals(text) {
   const out = text.split('');
@@ -232,7 +149,6 @@ export function blankCSharpLiterals(text) {
   return out.join('');
 }
 
-/** Type-keyword tokens in a text (raw or blanked) — every one; no context rule (see TYPE_KEYWORD). */
 const typeKeywordCount = (text) => [...text.matchAll(TYPE_KEYWORD)].length;
 
 /**
@@ -285,7 +201,7 @@ const typeKeywordCount = (text) => [...text.matchAll(TYPE_KEYWORD)].length;
  *   or a custom one (`[SkippableFact]`) is not seen: the file counts as a helper and
  *   it is left out of a selection;
  * - `hasTestAttribute` is still a heuristic, and ITS false positive is the unsafe
- *   side. Since the re-review (N1) the section must close; what still matches in a
+ *   side. The section must close; what still matches in a
  *   helper — probed — is a LIST PATTERN opening a line (or after `;` `{` `}` `]`)
  *   whose element is named exactly `Test`/`Fact`/… (qualified or not) and whose `]`
  *   is followed by a combinator: `[Env.Test] or [Env.Dev] => true`. Such a helper is
@@ -317,10 +233,8 @@ export function csharpClasses(csFileAbs) {
   // length, so the raw text at the same offsets shows the directive.
   const split = decls.find((d) => /(^|\n)[ \t]*#/.test(text.slice(d.at - d.gap, d.at)));
   if (split) return unscannable(`a preprocessor directive stands between a type keyword and the name "${split.name}"`);
-  // THE NET (R2, tightened in round 5): the raw text is the lexer-independent
-  // truth about how many type keywords the file carries. Compare it — and the
-  // blanked code — against what was actually named (see the JSDoc for why
-  // equality of counts is equality of sets).
+  // The raw text is the lexer-independent truth about how many type keywords the file
+  // carries (the JSDoc explains why equal counts mean equal sets).
   const rawKeywords = typeKeywordCount(text);
   if (rawKeywords !== decls.length) {
     return unscannable(`${rawKeywords} type keyword(s) in the file but ${decls.length} declaration(s) recognised`);

package/src/lib/mutation/runner.js

@@ -4,12 +4,13 @@ import { applyRegions, diffOf } from './manifest.js';
 import { blame, parseCompilerErrors, patchFile, switchClassName, switchSource, SWITCH_ENV } from './schemata.js';
 import { md5Of, md5OfFile, openSnapshot, restoreSnapshot, trackGenerated } from './snapshot.js';
 import { parseBuiltDlls } from './commands.js';
-import { firstLines, methodOf } from './trx.js';
+import { firstLines } from './trx.js';
 import { nearestProjectOf } from './dotnet-introspection.js';
 
 const posix = (p) => p.replace(/\\/g, '/');
 const MAX_SCHEMATA_ATTEMPTS = 3;
-const MAX_REPRODUCE = 5;
+
+export const noSubsetReason = (why) => `sem subconjunto utilizável (${why ?? 'nenhum teste da feature nem que cite os tipos mutados'}): a mutação não roda a suíte inteira — prove o cenário por leitura`;
 
 const envWithout = (env) => { const { [SWITCH_ENV]: _drop, ...rest } = env; return rest; };
 const failedNames = (result) => new Set(result.failedTests.map((t) => t.name));
@@ -123,29 +124,15 @@ export async function runMutation(input) {
       .map((name) => [name, md5OfFile(dlls.get(name))]),
   );
 
-  const run = (scope, label, env) => timed(label, () => adapter.runTests({ scope, label, env }));
-
-  const confirmKill = async (id, verdict, env) => {
-    if (!adapter.reproduce) return verdict;
-    const names = [...new Set(verdict.failures.map((f) => f.name))].slice(0, MAX_REPRODUCE);
-    const again = await timed(`${id}-reproduce`, () => adapter.reproduce({ names, label: `${id}-reproduce`, env }));
-    if (again.outcome === 'crash' || !again.executed) {
-      return { state: 'inconclusive', reason: `a falha de ${names[0]} não pôde ser confirmada na repetição (${again.note ?? 'nenhum teste executado'})` };
-    }
-    const wanted = new Set(names.map(methodOf));
-    const held = again.failedTests.filter((t) => wanted.has(methodOf(t.name)));
-    if (held.length > 0) return { ...verdict, reason: reasonOf(held) };
-    const whole = await timed(`${id}-reproduce-full`, () => adapter.runTests({ scope: 'full', label: `${id}-reproduce-full`, env }));
-    if (whole.outcome === 'crash' || !whole.executed) {
-      return { state: 'inconclusive', reason: `a falha de ${names[0]} não pôde ser confirmada na repetição (${whole.note ?? 'nenhum teste executado'})` };
-    }
-    const heldWhole = whole.failedTests.filter((t) => wanted.has(methodOf(t.name)));
-    if (heldWhole.length > 0) return { ...verdict, reason: reasonOf(heldWhole) };
-    const which = names.length === 1 ? names[0] : `${names.length} testes`;
-    return { state: 'survived', reason: `nenhum teste falhou de forma reproduzível: ${which} falhou uma vez e passou isolado e na suíte inteira repetida (instável, não prova o mutante)` };
-  };
+  const run = (label, env) => timed(label, () => adapter.runTests({ label, env }));
 
   const record = (id, patch) => Object.assign(results.get(id), patch);
+  const recordSubset = (id, result) => {
+    const verdict = judge(result, baselineSubset);
+    const base = { scope: 'subset', executed: result.executed, durationMs: result.durationMs };
+    if (verdict.state === 'killed') record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
+    else record(id, { ...base, verdict: verdict.state, reason: verdict.reason ?? '' });
+  };
   const applyOnDisk = (id) => {
     const region = byId.get(id);
     writeFileSync(join(root, region.file), applyRegions(originals.get(region.file), [region], (x) => x.replaceText).text);
@@ -154,10 +141,8 @@ export async function runMutation(input) {
   let pristine = new Map();
   let binary = { proof: 'unavailable', projects: [] };
   let baselineSubset = null;
-  let baselineFull = null;
   let subsetLive = adapter.hasSubset;
   let subsetNote = null;
-  const needFullBaseline = [];
   let restoreReport = [];
 
   try {
@@ -238,40 +223,26 @@ export async function runMutation(input) {
     if (subsetLive && (schemataIds.length > 0 || hasRebuild)) {
       const copies = schemataIds.length > 0 ? jobs : 1;
       baselineSubset = mergeBaselines(await Promise.all(Array.from({ length: copies }, (_, i) => (
-        run('subset', i === 0 ? 'baseline-subset' : `baseline-subset-${i + 1}`, envWithout(process.env))))));
+        run(i === 0 ? 'baseline-subset' : `baseline-subset-${i + 1}`, envWithout(process.env))))));
       if (baselineSubset.outcome === 'crash' || baselineSubset.executed === 0) {
         subsetLive = false;
         subsetNote = baselineSubset.executed === 0 ? 'o filtro do subconjunto não selecionou teste algum' : (baselineSubset.note ?? 'a rodada-base do subconjunto não terminou');
       }
     }
-    if (!subsetLive && schemataIds.length > 0) baselineFull = await run('full', 'baseline-full', envWithout(process.env));
-
-    const scopeOf = subsetLive ? 'subset' : 'full';
-    const scopeBaseline = () => (subsetLive ? baselineSubset : baselineFull);
     const routed = [];
-    const scopeJobs = subsetLive ? jobs : 1;
-    workerCount = schemataIds.length > 0 ? scopeJobs : 1;
-    const outcomes = new Map();
-    await pool(schemataIds, scopeJobs, async (id) => {
-      outcomes.set(id, await run(scopeOf, `${id}-${scopeOf}`, { ...process.env, [SWITCH_ENV]: id }));
-    });
-    for (const id of schemataIds) {
-      const result = outcomes.get(id);
-      const first = judge(result, scopeBaseline());
-      const verdict = first.state === 'killed' && scopeOf === 'full' ? await confirmKill(id, first, { ...process.env, [SWITCH_ENV]: id }) : first;
-      const base = { scope: scopeOf, executed: result.executed, durationMs: result.durationMs };
-      if (verdict.state === 'killed') {
-        record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
-      } else if (scopeOf === 'subset' && verdict.state === 'survived') {
-        record(id, { ...base, verdict: 'survived', reason: '' });
-      } else {
-        record(id, { ...base, verdict: null, reason: verdict.reason ?? '' });
-        routed.push({ id, needs: 'full' });
-      }
+    workerCount = subsetLive && schemataIds.length > 0 ? jobs : 1;
+    if (subsetLive) {
+      const outcomes = new Map();
+      await pool(schemataIds, jobs, async (id) => {
+        outcomes.set(id, await run(`${id}-subset`, { ...process.env, [SWITCH_ENV]: id }));
+      });
+      for (const id of schemataIds) recordSubset(id, outcomes.get(id));
+      for (const r of results.values()) if (r.mode === 'rebuild') routed.push(r.id);
+    } else {
+      for (const r of results.values()) record(r.id, { verdict: 'inconclusive', scope: null, reason: noSubsetReason(subsetNote) });
     }
-    for (const r of results.values()) if (r.mode === 'rebuild') routed.push({ id: r.id, needs: subsetLive ? 'subset' : 'full' });
 
-    for (const { id, needs } of routed) {
+    for (const id of routed) {
       applyOnDisk(id);
       try {
         if (adapter.buildCommands.length > 0) {
@@ -282,21 +253,7 @@ export async function runMutation(input) {
             continue;
           }
         }
-        if (needs === 'subset') {
-          const sub = await run('subset', `${id}-subset`, envWithout(process.env));
-          const verdict = judge(sub, baselineSubset);
-          const base = { scope: 'subset', executed: sub.executed, durationMs: sub.durationMs };
-          if (verdict.state === 'killed') record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
-          else record(id, { ...base, verdict: verdict.state, reason: verdict.reason ?? '' });
-          continue;
-        }
-        const full = await run('full', `${id}-full`, envWithout(process.env));
-        const first = judge(full, baselineFull);
-        const verdict = first.state === 'killed' ? await confirmKill(id, first, envWithout(process.env)) : first;
-        const base = { scope: 'full', executed: full.executed, durationMs: full.durationMs };
-        if (verdict.state === 'inconclusive') record(id, { ...base, verdict: 'inconclusive', reason: verdict.reason });
-        else if (verdict.state === 'survived') record(id, { ...base, verdict: 'survived', reason: verdict.reason ?? '' });
-        else { record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason }); if (!baselineFull) needFullBaseline.push({ id, full }); }
+        recordSubset(id, await run(`${id}-subset`, envWithout(process.env)));
       } finally {
         restoreSnapshot(snapshot);
       }
@@ -310,14 +267,6 @@ export async function runMutation(input) {
       binary = proveBinary({ pristine, dlls: last.dlls, restoredAt, hashes: dllHashes(last.dlls) });
     }
 
-    if (needFullBaseline.length > 0) {
-      baselineFull = await run('full', 'baseline-full', envWithout(process.env));
-      for (const { id, full } of needFullBaseline) {
-        const verdict = judge(full, baselineFull);
-        if (verdict.state === 'killed') record(id, { killers: verdict.failures.length, reason: verdict.reason });
-        else record(id, { verdict: 'survived', killers: 0, reason: '' });
-      }
-    }
   } finally {
     restoreReport = restoreSnapshot(snapshot, { rewrite: false });
     gate?.release();
@@ -338,7 +287,6 @@ export async function runMutation(input) {
     mutants,
     baseline: {
       subset: baselineSubset ? { executed: baselineSubset.executed, failed: baselineSubset.failed } : null,
-      full: baselineFull ? { executed: baselineFull.executed, failed: baselineFull.failed } : null,
     },
     binary,
     restore: {

package/src/lib/mutation/subset.js

@@ -51,10 +51,7 @@ export function testFilesCiting({ root, testProjectDirs, types, exclude = [] })
   return found.sort();
 }
 
-/**
- * The tests to run FIRST, chosen by the tool: files the feature changed, and files naming a
- * type the mutated files declare. A mutant the subset does not kill goes to the whole suite.
- */
+/** Chosen by the tool, never the verifier: test files the feature changed or that name a mutated type. */
 export function dotnetSubset({ root, testProjectDirs, mutatedFiles, changed = [] }) {
   const changedSet = new Set(changed.map(posix));
   const mention = mentionOf(mutatedTypesOf(root, mutatedFiles));

package/src/lib/mutation/trx.js

@@ -43,7 +43,6 @@ export function parseTrx(xml) {
   };
 }
 
-export const methodOf = (testName) => String(testName).replace(/\s*\(.*$/s, '').trim();
 
 export function firstLines(message, max = 2, width = 240) {
   const lines = String(message).split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(0, max).join(' ⏎ ');

package/src/lib/plan/artifact-vocabulary.js

@@ -1,33 +1,18 @@
 /** The inline justification that lets a criterion talk about an artifact on purpose. */
 export const ARTIFACT_MARKER_RE = /por\s+que\s+artefato\s*:/i;
 
-/**
- * Case-insensitive spelling of `word` inside a regex that must stay
- * case-SENSITIVE elsewhere — Node 18 has no inline `(?i:…)` modifier.
- */
+// Node 18 has no inline `(?i:…)` modifier, and the rest of the regex must stay case-sensitive.
 const anyCase = (word) => [...word].map((c) => {
   const lo = c.toLowerCase();
   const up = c.toUpperCase();
   return lo === up ? c : `[${lo}${up}]`;
 }).join('');
 
-/**
- * What follows "arquivo em" in a behavioural export criterion ("exporta o
- * arquivo em CSV", "salva o arquivo em formato aberto"): an uppercase file
- * format acronym or the word `formato`. Case-sensitive on purpose — `src`,
- * `docs` or `lib` after "arquivo em" are places, and places are artifacts.
- */
+// Case-sensitive on purpose: `src`, `docs` or `lib` after "arquivo em" are places, and places are artifacts.
 const FORMAT_TOKEN = String.raw`\s+(?:[A-Z]{2,5}(?![\p{L}\d_])|${anyCase('formato')}(?![\p{L}]))`;
 
-/**
- * Vocabulary of artifact-shaped phrasing. `term` is the label surfaced in
- * warnings and cited by the `morph-plan` skill prose — keep it stable, a
- * parity test imports it verbatim.
- *
- * Unicode lookarounds, never `\b`: in JS, `\b` does not treat accented
- * letters (é, á, ó…) as word characters, so it would false-boundary inside
- * "não" or "binário".
- */
+// `term` is cited verbatim by the `morph-plan` skill (a parity test imports it): keep it stable.
+// Unicode lookarounds, never `\b`: JS `\b` false-boundaries inside "não" or "binário".
 export const ARTIFACT_VOCABULARY = [
   { term: 'grep',                        re: /(?<![\p{L}\d_])grep(?![\p{L}\d_])/iu },
   { term: 'contém a string',             re: /cont[ée]m\s+as?\s+strings?/iu },
@@ -44,12 +29,7 @@ export const ARTIFACT_VOCABULARY = [
   { term: 'glob **/',                    re: /\*\*\/|\/\*\*/ },
 ];
 
-/**
- * Vocabulary terms matched in `text`, in vocabulary order, each at most once.
- *
- * @param {string} text
- * @returns {string[]}
- */
+/** Each term at most once, in vocabulary order. */
 export function findArtifactTerms(text) {
   const s = String(text ?? '');
   const found = [];