@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

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

@@ -2,7 +2,7 @@
  * Verify Runner — deterministic build+tests+validators+e2e cadence.
  *
  * v8 adds a DETERMINISTIC verification node that runs BEFORE the LLM judge
- * in the per-task loop: build + tests + validators (code, free) first; the
+ * in the implement loop: build + tests + validators (code, free) first; the
  * LLM judge is only invoked once verify passes. This is a BINARY gate
  * (pass/fail per node).
  *
@@ -15,7 +15,6 @@
  *   - runBuildCheck()  from framework/hooks/shared/build-check.js
  *   - runTestSuite()      from src/lib/tasks/test-runner.js (one node)
  *   - resolveTestNodes()  from src/lib/tasks/test-nodes.js (the LIST of suites)
- *   - applyTaskScope()    from src/lib/tasks/test-scope.js (the task-scoped cut, #87)
  *   - runValidation()  from ./validation-runner.js
  *   - runE2eCheck()    from framework/hooks/shared/e2e-check.js
  *
@@ -26,16 +25,15 @@ import { execFileSync } from 'child_process';
 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 { runBuildCheck, getBuildSteps, isDotnetStack } from '../../../framework/hooks/shared/build-check.js';
+import { composeProjectName, runE2eCheck } from '../../../framework/hooks/shared/e2e-check.js';
 import { buildComposeEnv } from '../e2e/compose-env.js';
 import {
-  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, isZeroTestRun, mtpSummaryTotals,
+  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, discoverDotnetSolution,
 } from '../tasks/test-runner.js';
 import {
   resolveTestNodes, parseTestFilter, nodeMatchesFilter, recordTestBaselines, morphConfigPath,
 } from '../tasks/test-nodes.js';
-import { applyTaskScope } from '../tasks/test-scope.js';
 import { runLinuxSuite, checkLinuxPreconditions } from '../tasks/linux-runner.js';
 import {
   EVAL_RUNNER, evalPreflight, evalNodeEnv, readEvalSummary, evalScenarioCount,
@@ -44,7 +42,6 @@ import {
 } from '../tasks/eval-node.js';
 import { runValidation } from './validation-runner.js';
 import { checkOutputsTraceability } from './traceability-check.js';
-import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { createHeavyGate } from '../heavy/gate.js';
 
 /** Default build timeout — dotnet cold build is slow; 30s (the Stop-hook default) is too short. */
@@ -56,14 +53,6 @@ const VALIDATOR_FEEDBACK_LIMIT = 10;
 /** Number of trailing output lines kept for feedback/reporting. */
 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 — '
-  + 'nada prova que algum teste rodou (desconhecido nunca vira verde)';
-
 /**
  * The caller asked for something impossible — not a red verification, a wrong
  * invocation. The distinction is the exit code: `verify` answers 1 for "the
@@ -82,11 +71,10 @@ export class VerifyUsageError extends Error {
 }
 
 /**
- * Run the deterministic verify cadence for a feature (or a single task within it).
+ * Run the deterministic verify cadence for a feature.
  *
  * @param {string} projectPath - Project root directory
  * @param {string} featureName - Feature name
- * @param {string|null} [taskId] - Task ID for task-scoped verify, or null/undefined for feature scope
  * @param {Object} [options]
  * @param {number} [options.timeout] - Timeout in ms for the build AND tests nodes
  *   (default: 120000 for build; for tests, see resolveTestTimeout())
@@ -99,8 +87,6 @@ export class VerifyUsageError extends Error {
  * @param {boolean} [options.linux] - Run the test nodes inside a Linux container, on a COPY
  *   of the tree (see linux-runner.js for why a bind mount would prove nothing)
  * @param {string} [options.linuxImage] - Image override for --linux
- * @param {boolean} [options.full] - Task scope only: switch the recorte off and run every
- *   node whole (#87). A documented no-op at feature scope, which never narrows anything.
  * @param {Function} [options._runBuildCheck] - Injectable override for runBuildCheck (testing)
  * @param {Function} [options._runTestSuite] - Injectable override for runTestSuite (testing)
  * @param {Function} [options._runValidation] - Injectable override for runValidation (testing)
@@ -110,16 +96,16 @@ export class VerifyUsageError extends Error {
  * @returns {Promise<Object>} Aggregated verify result — see module docs for shape
  * @throws {HeavyBusyError} when no heavy slot (or RAM) freed within `heavy.waitTimeoutSec`
  */
-export async function runVerify(projectPath, featureName, taskId, options = {}) {
+export async function runVerify(projectPath, featureName, options = {}) {
   const gate = options._heavyGate ?? createHeavyGate({ projectPath, feature: featureName });
   try {
-    return await runVerifyGated(projectPath, featureName, taskId, options, gate);
+    return await runVerifyGated(projectPath, featureName, options, gate);
   } finally {
     gate.release();
   }
 }
 
-async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
+async function runVerifyGated(projectPath, featureName, options, gate) {
   const {
     timeout = DEFAULT_BUILD_TIMEOUT,
     skipTests = false,
@@ -130,7 +116,6 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
     refreshCache = false,
     linux = false,
     linuxImage = null,
-    full = false,
     _runLinuxSuite = runLinuxSuite,
     _exec = undefined,
     _runBuildCheck = runBuildCheck,
@@ -156,18 +141,13 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
     );
   }
 
-  // The task is read ONCE: its group picks the e2e applicability and, with its
-  // outputs, the test scope. One reader of tasks.json for verify, so the two
-  // can never disagree about the task.
-  const task = taskId ? readTask(projectPath, featureName, taskId) : null;
-
   // `--record-baseline` is judged in the same breath, and for the same reason:
   // discovering that there is nowhere to write AFTER running the whole fleet
   // would charge the user a full suite for a usage error. `config.json` is
   // never created here — this repository deliberately has none, and inventing
   // one would break `doctor --full`.
   if (recordBaseline) {
-    const problem = baselineTargetProblem(projectPath, testPlan, { skipTests, taskId });
+    const problem = baselineTargetProblem(projectPath, testPlan, { skipTests });
     if (problem) throw new VerifyUsageError(problem);
   }
 
@@ -206,16 +186,6 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
     }
   }
 
-  // #87: at task scope the task's group picks the nodes and its outputs narrow
-  // the command inside each; test-scope.js DECIDES, this runner executes. The
-  // scoping happens ONCE, here, before runTestsNode, so the host loop and the
-  // `--linux` container receive the SAME scoped nodes (the container script is
-  // written from `node.command`) and preDecideRun/judgeRun stay the single copy
-  // of each rule for both. `--filter` was judged above on the ORIGINAL ids: a
-  // typo is a typo whatever the task. Feature scope gets the nodes back
-  // unchanged, because Gate 3 always runs every suite, whole.
-  const scoped = applyTaskScope({ projectPath, nodes: testPlan.nodes, task, taskId, filter, full });
-
   const nodes = {};
   const feedback = [];
 
@@ -229,27 +199,24 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
   // default down would silently outrank config.project.testTimeoutMs and the
   // per-project scaling (see resolveTestTimeout()).
   const explicitTimeout = Number.isFinite(options.timeout) ? options.timeout : undefined;
+  const stackNodes = [];
   nodes.tests = await runTestsNode({
     projectPath,
-    testPlan: { ...testPlan, nodes: scoped.nodes },
+    testPlan,
     filter,
     skipTests,
     buildNode: nodes.build,
     timeout: explicitTimeout,
-    taskId,
     refreshCache,
     linux,
     linuxImage,
     gate,
+    stackNodes,
     _runTestSuite,
     _runLinuxSuite,
     _exec,
   });
-  // How the nodes were chosen, for whoever reads --json. It lives on the rollup
-  // and nowhere else: nodeStatuses() (verify.js) persists status strings only,
-  // so no part of the selection ever reaches feature.json.
-  nodes.tests.scope = scoped.summary;
-  appendTestsFeedback(feedback, nodes.tests);
+  if (stackNodes.length === 0) appendTestsFeedback(feedback, nodes.tests);
 
   // 3. validators — ALWAYS runs, even on a red build (free static feedback).
   nodes.validators = await runValidatorsNode({ projectPath, featureName, _runValidation });
@@ -258,28 +225,30 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
   // 4. e2e — the only node that runs the application. Like tests, it is not
   // invoked at all on a red build: a stack that cannot compile cannot come up,
   // and the docker output would bury the actual compile error.
-  nodes.e2e = await runE2eNode({
+  const e2e = await runE2eNode({
     projectPath,
     featureName,
-    taskId,
-    task,
     skipE2e,
     freshE2e,
     buildNode: nodes.build,
     gate,
     _runE2eCheck,
   });
+  nodes.e2e = e2e.node;
   appendE2eFeedback(feedback, nodes.e2e);
 
-  // 5. traceability — advisory-only, feature-scope only (see traceability-check.js
-  // for the recap-vs-outputs disagreement it flags, and what it deliberately
-  // cannot catch). Lives OUTSIDE `nodes` on purpose: `status` below is computed
-  // from `nodes` alone, so this can never flip build/tests/validators/e2e green
-  // to red — recap/outputs disagreement is a rastreabilidade signal, not a
-  // correctness gate.
-  const traceability = taskId
-    ? { status: 'skip', warnings: [], reason: 'task-scoped verify does not run traceability', citedCount: 0 }
-    : _checkOutputsTraceability(projectPath, featureName);
+  // `e2e: true` suites need the stack the e2e node just brought up (and left up).
+  if (stackNodes.length > 0) {
+    nodes.tests = await runStackTestNodes({
+      projectPath, testsNode: nodes.tests, stackNodes, e2eNode: nodes.e2e, stackEnv: e2e.stackEnv,
+      timeout: explicitTimeout, gate, _runTestSuite,
+    });
+    appendTestsFeedback(feedback, nodes.tests);
+  }
+
+  // Fora de `nodes` de propósito: o status sai só dos nós, então a divergência
+  // relatório × fatias (aviso de rastreabilidade) nunca vira vermelho de correção.
+  const traceability = _checkOutputsTraceability(projectPath, featureName);
 
   const status = Object.values(nodes).some((n) => n.status === 'fail') ? 'fail' : 'pass';
 
@@ -293,8 +262,6 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
   return {
     version: 1,
     feature: featureName,
-    task: taskId || null,
-    scope: taskId ? 'task' : 'feature',
     stack,
     status,
     nodes,
@@ -308,12 +275,29 @@ async function runVerifyGated(projectPath, featureName, taskId, options, gate) {
 // Build node
 // ============================================================================
 
-async function runBuildNode({ projectPath, stack, paths = {}, timeout, skipBuild, gate, _runBuildCheck }) {
+/**
+ * A root `dotnet build` with no solution at the root fails MSB1003: build the
+ * repository's single solution instead, or say which candidates and which key decide.
+ */
+export function resolveDotnetBuild(projectPath, stack, paths = {}) {
+  if (!stack || !isDotnetStack(stack.toLowerCase()) || paths.backendPath) return { paths, hint: null };
+  const { target, candidates } = discoverDotnetSolution(projectPath);
+  if (target === '.') return { paths, hint: null };
+  if (target) return { paths: { ...paths, backendTarget: target }, hint: null };
+  const found = candidates.length ? `candidatos: ${candidates.join(', ')}` : 'nenhum encontrado abaixo dela';
+  return {
+    paths,
+    hint: `nenhum .sln/.slnx/.csproj na raiz (${found}): declare project.backendPath em .morph/config/config.json com a pasta da solução, relativa à raiz`,
+  };
+}
+
+async function runBuildNode({ projectPath, stack, paths: declaredPaths = {}, timeout, skipBuild, gate, _runBuildCheck }) {
   if (skipBuild) {
     return { status: 'skip', command: null, durationMs: 0, reason: 'requested', output: '' };
   }
 
-  const steps = getBuildSteps(stack, { cwd: projectPath, frontendPath: paths.frontendPath, backendPath: paths.backendPath });
+  const { paths, hint } = resolveDotnetBuild(projectPath, stack, declaredPaths);
+  const steps = getBuildSteps(stack, { cwd: projectPath, frontendPath: paths.frontendPath, backendPath: paths.backendPath, backendTarget: paths.backendTarget });
   if (steps.length === 0) {
     const reason = stack ? `no build command for stack "${stack}"` : 'no stack configured';
     return { status: 'skip', command: null, durationMs: 0, reason, output: '' };
@@ -330,7 +314,7 @@ async function runBuildNode({ projectPath, stack, paths = {}, timeout, skipBuild
     command,
     durationMs,
     reason: result.status === 'skip' ? 'no build command for stack' : null,
-    output: result.output || '',
+    output: [result.output, result.status === 'fail' ? hint : null].filter(Boolean).join('\n'),
   };
 }
 
@@ -363,8 +347,8 @@ function appendBuildFeedback(feedback, buildNode) {
  *   `source`, `environment` (null outside a container) and `runs[]`.
  */
 async function runTestsNode({
-  projectPath, testPlan, filter, skipTests, buildNode, timeout, taskId, refreshCache = false,
-  linux = false, linuxImage = null, gate, _runTestSuite, _runLinuxSuite = runLinuxSuite, _exec,
+  projectPath, testPlan, filter, skipTests, buildNode, timeout, refreshCache = false,
+  linux = false, linuxImage = null, gate, stackNodes = [], _runTestSuite, _runLinuxSuite = runLinuxSuite, _exec,
 }) {
   const { nodes, source } = testPlan;
   // Kept readable for whoever only prints the string — the same join the
@@ -384,28 +368,49 @@ async function runTestsNode({
 
   if (linux) {
     const { runs, environment } = await runNodesInLinux({
-      projectPath, nodes, filter, taskId, timeout, linuxImage, gate, _runLinuxSuite, _exec,
+      projectPath, nodes, filter, timeout, linuxImage, gate, _runLinuxSuite, _exec,
     });
     return rollUpTestRuns(runs, { command, source, environment });
   }
 
   const runs = [];
   for (const node of nodes) {
+    if (node.e2e && !preDecideRun({ node, filter, projectPath, refreshCache })) {
+      stackNodes.push(node);
+      runs.push(emptyRunEntry(node));
+      continue;
+    }
     runs.push(await runOneTestNode({
-      projectPath, node, filter, taskId, timeout, refreshCache, gate, _runTestSuite,
+      projectPath, node, filter, timeout, refreshCache, gate, _runTestSuite,
     }));
   }
 
   return rollUpTestRuns(runs, { command, source });
 }
 
+// No stack, no run: the skip carries the e2e verdict as reason AND warning, so the
+// suite never disappears behind a green rollup.
+async function runStackTestNodes({ projectPath, testsNode, stackNodes, e2eNode, stackEnv, timeout, gate, _runTestSuite }) {
+  const byId = new Map(stackNodes.map((node) => [node.id, node]));
+  const runs = [];
+  for (const run of testsNode.runs) {
+    const node = byId.get(run.id);
+    if (!node) { runs.push(run); continue; }
+    if (e2eNode.status !== 'pass') {
+      const reason = `a stack do e2e não está de pé (e2e: ${e2eNode.status}${e2eNode.reason ? ` — ${e2eNode.reason}` : ''}): nó e2e: true não roda sem ela`;
+      runs.push({ ...run, reason, warnings: [reason] });
+      continue;
+    }
+    runs.push(await runOneTestNode({ projectPath, node, filter: null, timeout, gate, env: stackEnv, _runTestSuite }));
+  }
+  return rollUpTestRuns(runs, { command: testsNode.command, source: testsNode.source, environment: testsNode.environment });
+}
+
 /**
  * Run the executable nodes inside ONE Linux container and judge them with the
  * SAME rules the local path uses.
  *
- * The pre-decisions (invalid config, `--filter`, a node outside the task
- * scope, an e2e node at task scope)
- * happen HERE, before the container exists: a node that must not run must not
+ * The pre-decisions (invalid config, `--filter`, the eval pre-flight) happen HERE, before the container exists: a node that must not run must not
  * be written into the container script either, or the flag would quietly run
  * what the user filtered out. What the container returns — an exit code and an
  * output — is then handed to `judgeRun()`, the same function the host path
@@ -415,12 +420,12 @@ async function runTestsNode({
  * bind mount: see linux-runner.js. That is the whole reason this path exists.
  */
 async function runNodesInLinux({
-  projectPath, nodes, filter, taskId, timeout, linuxImage, gate, _runLinuxSuite, _exec,
+  projectPath, nodes, filter, timeout, linuxImage, gate, _runLinuxSuite, _exec,
 }) {
   const decided = new Map();
   const toRun = [];
   for (const node of nodes) {
-    const pre = preDecideRun({ node, filter, taskId, projectPath });
+    const pre = preDecideRun({ node, filter, projectPath });
     if (pre) decided.set(node.id, pre);
     else toRun.push(node);
   }
@@ -471,9 +476,9 @@ async function runNodesInLinux({
  * from the report is the defect this whole feature exists to close.
  */
 async function runOneTestNode({
-  projectPath, node, filter, taskId, timeout, refreshCache = false, gate, _runTestSuite,
+  projectPath, node, filter, timeout, refreshCache = false, gate, env = null, _runTestSuite,
 }) {
-  const decided = preDecideRun({ node, filter, taskId, projectPath, refreshCache });
+  const decided = preDecideRun({ node, filter, projectPath, refreshCache });
   if (decided) return decided;
 
   // The eval channel: the CLI DICTATES where the cache, the dataset and the
@@ -491,8 +496,9 @@ async function runOneTestNode({
 
   gate.enter('tests');
   const start = Date.now();
+  const childEnv = env || evalChannel ? { ...(env || {}), ...(evalChannel?.env || {}) } : null;
   const result = await _runTestSuite(projectPath, {
-    timeout, node, ...(evalChannel ? { env: evalChannel.env } : {}),
+    timeout, node, ...(childEnv ? { env: childEnv } : {}),
   });
   const entry = judgeRun({ node, result, durationMs: Date.now() - start });
   if (!evalChannel) return entry;
@@ -572,11 +578,6 @@ function emptyRunEntry(node) {
     reason: null,
     warnings: [],
     output: '',
-    // What the task-scope recorte did to this node (#87): `command` above is
-    // what actually ran, `selection.declaredCommand` what was declared. null at
-    // feature scope, where applyTaskScope leaves the key ABSENT; absent is read
-    // as null here so no reader has to tell the two apart.
-    selection: node.selection ?? null,
   };
 }
 
@@ -589,7 +590,7 @@ function emptyRunEntry(node) {
  * two copies of this ordering is how a filtered node ends up invisible in one
  * of them.
  */
-function preDecideRun({ node, filter, taskId, projectPath = '.', refreshCache = false }) {
+function preDecideRun({ node, filter, projectPath = '.', refreshCache = false }) {
   const entry = emptyRunEntry(node);
 
   // The resolver already decided: invalid config (fail-closed, D4) or an
@@ -606,26 +607,12 @@ function preDecideRun({ node, filter, taskId, projectPath = '.', refreshCache =
     return { ...entry, reason: `filtered out (--filter ${filter.raw})` };
   }
 
-  // The task's group scoped this node out (#87). AFTER the filter on purpose:
-  // a node the user filtered out reports the filter, never a scope it was not
-  // judged by. BEFORE the e2e and eval checks: a node outside the task scope
-  // has nothing left to decide.
-  if (node.selection?.mode === 'out-of-scope') {
-    return { ...entry, reason: node.selection.reason };
-  }
-
-  if (node.e2e && taskId) {
-    return { ...entry, reason: 'e2e node runs at feature scope only' };
-  }
-
   // The eval pre-flight lives HERE, beside the other pre-decisions, so the host
   // loop and the `--linux` path refuse for the same reason with the same words.
   // Its three cache verdicts are FAILURES, never skips: a skip over an unusable
-  // cache is a green gate above a verification that never happened. The only
-  // skip it produces is scope — an eval suite does not pay for itself inside the
-  // per-task loop, and the result Gate 3 reads is the feature-scoped one.
+  // cache is a green gate above a verification that never happened.
   if (node.runner === EVAL_RUNNER) {
-    const pre = evalPreflight(projectPath, node, { taskId, refresh: refreshCache });
+    const pre = evalPreflight(projectPath, node, { refresh: refreshCache });
     if (pre.status) return { ...entry, status: pre.status, reason: pre.reason };
   }
 
@@ -668,12 +655,6 @@ function judgeRun({ node, result, durationMs }) {
   const parsed = parseTestCount(result.output, node.runner);
   const count = parsed ? parsed.total : null;
 
-  // A narrowed run is PARTIAL by construction (#87): it has a verdict of its
-  // own, and the count rule below never sees it.
-  if (entry.selection?.mode === 'narrowed') {
-    return judgeNarrowedRun({ entry, node, result, durationMs, count });
-  }
-
   // 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
@@ -707,68 +688,6 @@ function judgeRun({ node, result, durationMs }) {
   };
 }
 
-/**
- * The verdict of a NARROWED run (#87): what `judgeRun` hands over instead of
- * its count rule. Reached from the host loop and from `--linux` alike, because
- * both go through `judgeRun`.
- *
- * Two things change, and both follow from "partial by construction":
- *
- *   - NO `compareTestCount`. `expectedCount` is the WHOLE suite's baseline: a
- *     recorte running 12 of 3.082 is not a drop, and a superset selection
- *     running more than the baseline is not a rise. Either comparison would
- *     report something about the suite that this run never measured.
- *   - a pass needs PROOF that tests ran. A filter that matches nothing exits 0
- *     under VSTest, and "zero tests, all green" is exactly the verdict issue #87
- *     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` 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: 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.
- */
-function judgeNarrowedRun({ entry, node, result, durationMs, count }) {
-  const tail = tailLines(result.output, OUTPUT_TAIL_LINES);
-  const base = { ...entry, durationMs, count, warnings: [] };
-  const red = (reason) => ({ ...base, status: 'fail', reason, output: tail ? `${reason}\n${tail}` : reason });
-  const green = () => ({ ...base, status: 'pass', reason: result.reason ?? null, output: '' });
-  const ranTests = Number.isInteger(count) && count > 0;
-
-  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);
-  }
-
-  if (!ranTests && isZeroTestRun(result.output, node.runner, result.exitCode)) {
-    return red(`narrowed-zero-tests (${node.runner}, exit ${result.exitCode ?? 'desconhecido'}): o recorte executou 0 testes`);
-  }
-
-  return { ...base, status: 'fail', reason: result.reason ?? null, output: tail };
-}
-
 /**
  * Aggregate the per-node runs into the single node `verify` publishes.
  *
@@ -898,22 +817,12 @@ function refreshCacheProblem(projectPath, testPlan, filter, { skipTests }) {
  * never created — the framework repository has none on purpose (creating it
  * breaks `doctor --full`), so the honest answer is a named usage error.
  *
- * A TASK id is refused first (#87): at task scope the runner narrows the nodes
- * AND the commands, so what it measures is a recorte, while `expectedCount` is
- * the whole fleet's number. `recordTestBaselines` refuses a measurement that
- * carries a selection (the second barrier), but paying for the recorte to
- * learn that is the ordering this function exists to prevent.
- *
  * @param {string} projectPath
  * @param {{ nodes: Array, source: string }} testPlan
- * @param {{ skipTests: boolean, taskId?: string|null }} opts
+ * @param {{ skipTests: boolean }} opts
  * @returns {string|null}
  */
-function baselineTargetProblem(projectPath, testPlan, { skipTests, taskId = null }) {
-  if (taskId) {
-    return `--record-baseline é manutenção da frota: rode sem {task} (recebeu "${taskId}") — `
-      + 'no escopo de task o verify recorta nós e testes, e baseline de recorte não é baseline';
-  }
+function baselineTargetProblem(projectPath, testPlan, { skipTests }) {
   if (skipTests) {
     return '--record-baseline com --skip-tests não mede nada — uma baseline vem de uma execução, não de uma omissão';
   }
@@ -957,12 +866,7 @@ function recordBaselineFrom(projectPath, testsNode) {
     );
   }
 
-  // The selection travels with the count so the WRITER can refuse a recorte
-  // (#87) — the second barrier behind baselineTargetProblem's usage error.
-  return recordTestBaselines(
-    projectPath,
-    runs.map((r) => ({ id: r.id, count: r.count, selection: r.selection ?? null }))
-  );
+  return recordTestBaselines(projectPath, runs.map((r) => ({ id: r.id, count: r.count })));
 }
 
 // ============================================================================
@@ -1035,53 +939,60 @@ function appendValidatorsFeedback(feedback, validatorsNode) {
 // E2E node
 // ============================================================================
 
-async function runE2eNode({ projectPath, featureName, taskId, task = null, skipE2e, freshE2e, buildNode, gate, _runE2eCheck }) {
+async function runE2eNode({ projectPath, featureName, skipE2e, freshE2e, buildNode, gate, _runE2eCheck }) {
   if (buildNode.status === 'fail') {
     return {
-      status: 'skip',
-      command: null,
-      durationMs: 0,
-      reason: 'build failed — the stack could not come up anyway',
-      output: '',
+      node: {
+        status: 'skip',
+        command: null,
+        durationMs: 0,
+        reason: 'build failed — the stack could not come up anyway',
+        output: '',
+      },
+      stackEnv: null,
     };
   }
 
   const config = readConfig(projectPath);
-  const taskGroup = task?.group ?? null;
   const gitCommonDir = resolveGitCommonDir(projectPath);
+  // The port block matters MORE here than in `e2e up`: this is the path that
+  // runs in the loop, and two worktrees verifying at once would otherwise get
+  // distinct container names and then collide on host port 3000 — a red gate
+  // over an infrastructure clash instead of a defect.
+  const env = buildComposeEnv({ cwd: projectPath, config, featureName, gitCommonDir });
 
   const start = Date.now();
   const result = _runE2eCheck(projectPath, {
     config,
     featureName,
-    taskGroup,
-    scope: taskId ? 'task' : 'feature',
     gitCommonDir,
-    // The port block matters MORE here than in `e2e up`: this is the path that
-    // runs in the loop, and two worktrees verifying at once would otherwise get
-    // distinct container names and then collide on host port 3000 — a red gate
-    // over an infrastructure clash instead of a defect.
-    env: buildComposeEnv({ cwd: projectPath, config, featureName, gitCommonDir }),
+    env,
     skipRequested: skipE2e,
     forceFresh: freshE2e,
     beforeHeavy: () => gate.enter('e2e'),
+    countSpecs: (output) => parseTestCount(output, 'playwright')?.total ?? null,
     // The stack stays up between verifies on purpose: cold-starting a .NET
-    // container per task is the difference between a usable loop and one
+    // container per verify is the difference between a usable loop and one
     // nobody runs. `morph-spec e2e down` (and `finish`) tear it down.
     keepUp: true,
   });
   const durationMs = Date.now() - start;
 
   return {
-    status: result.status,
-    command: result.command ?? null,
-    durationMs,
-    reason: result.reason ?? null,
-    output: result.output || '',
-    // Non-fatal findings (e.g. a compose with fixed ports at the ROOT, where
-    // nothing collides yet). Surfaced so the same compose does not fail
-    // unannounced the day the feature moves into a worktree.
-    warnings: Array.isArray(result.warnings) ? result.warnings : [],
+    node: {
+      status: result.status,
+      command: result.command ?? null,
+      durationMs,
+      reason: result.reason ?? null,
+      output: result.output || '',
+      // Specs Playwright counted in this run; null = no specs ran or unreadable summary.
+      count: Number.isInteger(result.count) ? result.count : null,
+      // Non-fatal findings (e.g. a compose with fixed ports at the ROOT, where
+      // nothing collides yet). Surfaced so the same compose does not fail
+      // unannounced the day the feature moves into a worktree.
+      warnings: Array.isArray(result.warnings) ? result.warnings : [],
+    },
+    stackEnv: { COMPOSE_PROJECT_NAME: composeProjectName(featureName), ...env },
   };
 }
 
@@ -1096,34 +1007,6 @@ function appendE2eFeedback(feedback, e2eNode) {
   }
 }
 
-/**
- * The task as verify needs it, or null when tasks.json or the task is missing.
- *
- * The ONE reader of tasks.json for verify: the group picks the e2e
- * applicability, group + outputs pick the test scope, and the command uses the
- * null to refuse an unknown task id.
- *
- * @param {string} projectPath
- * @param {string} featureName
- * @param {string} taskId
- * @returns {{ group: string|null, outputs: string[] }|null}
- */
-export function readTask(projectPath, featureName, taskId) {
-  try {
-    const tasksPath = getAbsoluteOutputPath(projectPath, featureName, 'tasks');
-    if (!existsSync(tasksPath)) return null;
-    const tasksJson = JSON.parse(readFileSync(tasksPath, 'utf8'));
-    const task = (tasksJson.tasks || []).find((t) => t.id === taskId);
-    if (!task) return null;
-    return {
-      group: task.group ?? null,
-      outputs: Array.isArray(task.outputs) ? task.outputs : [],
-    };
-  } catch {
-    return null;
-  }
-}
-
 // ============================================================================
 // Shared helpers
 // ============================================================================

package/src/lib/worktree/docker-audit.js

@@ -74,8 +74,7 @@ function resolveGitCommonDir(cwd) {
  * treating those as different paths would make every stack look foreign.
  *
  * Exported as the ONE copy of that rule: `doctor.js` compares a declared test
- * node `cwd` with a discovered `package.json` folder through it (#87 F5), and
- * `test-scope.js` takes only the CASE of a canonical path through it (#87 N3).
+ * node `cwd` with a discovered `package.json` folder through it.
  */
 export const samePathCase = process.platform === 'win32' ? (s) => s.toLowerCase() : (s) => s;
 const norm = (p) => samePathCase(resolve(String(p)).replace(/\\/g, '/'));