@polymorphism-tech/morph-spec 10.1.1 → 10.2.0

package/src/lib/plan/critique.js

@@ -1,8 +1,21 @@
 import { existsSync, readFileSync } from 'fs';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { featureGeneratesMedia } from './media.js';
 
 export const CRITIQUE_EXEMPT_WORK_TYPES = ['chore', 'hotfix'];
 
+const SMALL_PLAN_MAX_CHECKS = 3;
+const SMALL_PLAN_PROOFS = ['teste', 'leitura'];
+
+/** A plan this size has little for a fresh reader to catch; a rung or a proof outside the code does. */
+export function isSmallPlan(checks, planText = '') {
+  const scenarios = checks?.checks ?? [];
+  return scenarios.length > 0
+    && scenarios.length <= SMALL_PLAN_MAX_CHECKS
+    && scenarios.every((scenario) => SMALL_PLAN_PROOFS.includes(scenario.proof) && !scenario.rung)
+    && !featureGeneratesMedia(planText);
+}
+
 const PLAN_HASH_RE = /^\*\*Plan-Hash:\*\*\s*`?([0-9a-f]{64})`?\s*$/m;
 const APPLIED_RE = /^\*\*Aplicado-em:\*\*\s*`?([0-9a-f]{64})`?\s*$/gm;
 
@@ -21,8 +34,15 @@ export function readPlanCritique(cwd, featureName, { workType, planChecks }) {
   if (CRITIQUE_EXEMPT_WORK_TYPES.includes(workType)) return 'exempt';
   const currentHash = planChecks?.status === 'fresh' ? planChecks.checks?.planHash : null;
   if (!currentHash) return null;
+  if (isSmallPlan(planChecks.checks, readText(getAbsoluteOutputPath(cwd, featureName, 'plan')) ?? '')) return 'exempt';
   const path = getAbsoluteOutputPath(cwd, featureName, 'planCritique');
-  let text = null;
-  try { text = existsSync(path) ? readFileSync(path, 'utf8') : null; } catch { text = null; }
-  return critiqueStatus(text, currentHash);
+  return critiqueStatus(readText(path), currentHash);
+}
+
+function readText(path) {
+  try {
+    return existsSync(path) ? readFileSync(path, 'utf8') : null;
+  } catch {
+    return null;
+  }
 }

package/src/lib/review-confirmation.js

@@ -0,0 +1,67 @@
+import { execFileSync } from 'child_process';
+import { basename } from 'path';
+import { treeMovedSince } from './git/evidence-staleness.js';
+import { isTestOnly, securityReviewFor } from './risk-detector.js';
+
+function resolveCommit(cwd, ref) {
+  try {
+    return execFileSync('git', ['rev-parse', '--verify', `${ref}^{commit}`], { cwd, stdio: 'pipe' }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function changedBetween(cwd, from, to) {
+  try {
+    return execFileSync('git', ['diff', '--name-only', '--no-renames', from, to, '--', '.', ':(exclude).morph'], { cwd, stdio: 'pipe' })
+      .toString().split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+function citedByBlockers(reports) {
+  return Object.values(reports)
+    .flatMap((report) => report.rounds ?? [])
+    .flatMap((round) => round.blockers ?? [])
+    .map((blocker) => `${blocker.where} ${blocker.evidence}`)
+    .join('\n');
+}
+
+const openedBlockers = (report) => (report.rounds ?? []).some((round) => (round.blockers ?? []).length > 0);
+const isCleanShip = (report) => report.verdict === 'SHIP' && (report.blockers ?? []).length === 0;
+
+function deltaIsNarrow(role, delta, cited) {
+  if (delta === null) return false;
+  if (role === 'security') return !securityReviewFor(delta).required;
+  return delta.every((file) => isTestOnly(file) || cited.includes(file) || cited.includes(basename(file)));
+}
+
+/**
+ * After a fix, a role that shipped clean need not return when the delta stays inside what the
+ * blockers named (security: when it touches no sensitive path). `moved` lists the roles behind
+ * `head`; `skippable` says it holds; `confirmed` says a role that opened blockers re-judged `head`,
+ * without which nothing is skippable at approval.
+ */
+export function reviewConfirmation(cwd, reports, head) {
+  const cited = citedByBlockers(reports);
+  const moved = [];
+  let confirmed = false;
+
+  for (const [role, report] of Object.entries(reports)) {
+    if (report.status === 'missing' || !report.reviewedSha) continue;
+    const reviewed = resolveCommit(cwd, report.reviewedSha);
+    if (!reviewed) continue;
+    if (!treeMovedSince(cwd, reviewed, head)) {
+      if (openedBlockers(report)) confirmed = true;
+      continue;
+    }
+    moved.push({
+      role,
+      reviewed,
+      skippable: isCleanShip(report) && deltaIsNarrow(role, changedBetween(cwd, reviewed, head), cited),
+    });
+  }
+
+  return { moved, confirmed };
+}

package/src/lib/review-reports.js

@@ -32,6 +32,7 @@ const SCREEN_CHECKLIST_SECTION_RE = sectionRe('Checklist\\s+de\\s+tela');
 
 /** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. Chore: só o revisor (review leve). */
 export function requiredReviewRoles({ workType, securityRequired = false } = {}) {
+  // Sem `security` mesmo em caminho sensível: o humano assina todo hotfix.
   if (workType === 'hotfix') return ['verifier'];
   const base = workType === 'chore' ? ['reviewer'] : ['verifier', 'reviewer'];
   return securityRequired ? [...base, 'security'] : base;

package/src/lib/risk-detector.js

@@ -83,7 +83,7 @@ export function reviewPause(signal) {
            + ' auto-avaliação de quem implementou não decide o ship';
     }
     if (r.status === 'partial') {
-      return `\`${file}\` está PARCIAL — retome o mesmo agente por SendMessage; parcial não é veredito`;
+      return `\`${file}\` está PARCIAL — despache o mesmo papel de novo dizendo o que já está no relatório; parcial não é veredito`;
     }
     if (r.status !== 'ok') {
       return `\`${file}\` sem \`**Verdict:** SHIP|FIX\` — o relatório não seguiu o contrato`;
@@ -144,7 +144,7 @@ export function verifierModelFor({ promptModelTouched = false, generatesMedia =
 
 // Teste e artefato de teste não são superfície de ataque: `e2e/login.spec.ts` não pede a persona security.
 const E2E_DIR_RE = /(^|\/)e2e\//;
-const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
+export const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
 
 export function securityReviewFor(changedFiles = []) {
   const risky = changedFiles

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

@@ -83,6 +83,7 @@ function makeNode(partial) {
     runner,
     expectedCount: keepsBaseline(runner) ? partial.expectedCount ?? null : null,
     timeoutMs: partial.timeoutMs ?? null,
+    parallel: partial.parallel ?? false,
     build: partial.build ?? [],
     e2e: partial.e2e ?? false,
     linuxImage: partial.linuxImage ?? null,
@@ -133,6 +134,9 @@ function firstProblem(raw, projectPath) {
   if (raw.timeoutMs !== undefined && !(Number.isInteger(raw.timeoutMs) && raw.timeoutMs > 0)) {
     return 'timeoutMs must be an integer > 0';
   }
+  if (raw.parallel !== undefined && typeof raw.parallel !== 'boolean') {
+    return 'parallel must be a boolean';
+  }
   if (raw.build !== undefined && (!Array.isArray(raw.build) || raw.build.some((b) => typeof b !== 'string'))) {
     return 'build must be an array of strings';
   }
@@ -208,6 +212,7 @@ export function validateTestNodes(config, projectPath = null) {
       runner: entry.runner ?? inferRunner(entry.command),
       expectedCount: entry.expectedCount ?? null,
       timeoutMs: entry.timeoutMs ?? null,
+      parallel: entry.parallel ?? false,
       build: entry.build ?? [],
       e2e: entry.e2e ?? false,
       linuxImage: entry.linuxImage ?? null,

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

@@ -1,5 +1,5 @@
-import { execSync, execFileSync } from 'child_process';
-import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'fs';
+import { exec as execCallback, execSync, execFileSync } from 'child_process';
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
 import { join, resolve, relative, isAbsolute } from 'path';
 import { globSync } from 'glob';
 
@@ -157,6 +157,7 @@ function countCompletedRuns(output) {
 }
 
 const NO_BUILD_FLAG = /(^|\s)--no-build(\s|$)/;
+const DOTNET_COMMAND = /^\s*dotnet\s/;
 
 // `[]` is the safe answer: nothing compiled here, so a `--no-build` in the same command is refused.
 export function extractCsprojTargets(command) {
@@ -177,28 +178,6 @@ export function resolveTestBuildTargets(node) {
   return extractCsprojTargets(node.command);
 }
 
-const DOTNET_BUILDABLE = /"([^"]+\.(?:slnx?|csproj))"|'([^']+\.(?:slnx?|csproj))'|(\S+\.(?:slnx?|csproj))/gi;
-
-/**
- * What `dotnet test` compiles for this node, relative to its `cwd`: declared `build`,
- * else what the command names, else the directory's single solution/project; `[]` = undiscoverable.
- */
-export function discoverDotnetBuildTargets(node, cwd) {
-  if (node?.runner !== 'dotnet') return [];
-  if (Array.isArray(node.build) && node.build.length > 0) return node.build;
-  const command = typeof node.command === 'string' ? node.command : '';
-  const named = [...command.matchAll(DOTNET_BUILDABLE)].map((m) => m[1] ?? m[2] ?? m[3]);
-  if (named.length > 0) return [...new Set(named)];
-
-  const dirArg = command.split(/\s+/).find((token) => token && !token.startsWith('-') && token !== 'dotnet' && token !== 'test'
-    && isDirectory(join(cwd, token)));
-  const dir = dirArg ?? '.';
-  let entries;
-  try { entries = readdirSync(join(cwd, dir)); } catch { return []; }
-  const only = singleDotnetBuildable(entries);
-  return only ? [dir === '.' ? only : join(dir, only).replace(/\\/g, '/')] : [];
-}
-
 function singleDotnetBuildable(files) {
   const solutions = files.filter((f) => /\.slnx?$/i.test(f));
   const projects = files.filter((f) => /\.csproj$/i.test(f));
@@ -237,10 +216,6 @@ export function discoverDotnetSolution(root) {
   return { target: single, candidates: pool };
 }
 
-function isDirectory(path) {
-  try { return statSync(path).isDirectory(); } catch { return false; }
-}
-
 // Derived from build-check.js, the single spelling of "dotnet build". `--no-restore` is
 // dropped: a test project outside the solution may never have been restored.
 export function dotnetBuildCommandFor(target, projectPath) {
@@ -253,7 +228,7 @@ export function dotnetBuildCommandFor(target, projectPath) {
 
 // Runs only with declared `build[]` or `--no-build`: a plain `dotnet test` builds
 // itself, and pre-compiling it would double the clock of the hot path.
-function runTestPrebuild({ node, cwd, exec, timeout, projectPath }) {
+function runTestPrebuild({ node, cwd, exec, timeout, projectPath, builtTargets = new Set() }) {
   if (node.runner !== 'dotnet') return { built: false, failure: null };
 
   const declared = Array.isArray(node.build) ? node.build : [];
@@ -265,10 +240,13 @@ function runTestPrebuild({ node, cwd, exec, timeout, projectPath }) {
   const outputs = [];
 
   for (const target of targets) {
+    const key = `${cwd}\0${target}`;
+    if (builtTargets.has(key)) continue;
     const command = dotnetBuildCommandFor(target, projectPath);
     if (!command) return { built: false, failure: null };
     try {
       exec(command, { cwd, timeout, encoding: 'utf8', stdio: 'pipe' });
+      builtTargets.add(key);
     } catch (err) {
       outputs.push(`[${command}]\n${(err.stdout || '') + (err.stderr || '')}`);
       return {
@@ -511,12 +489,12 @@ export function runTestSuite(projectPath = '.', opts = {}) {
   const cwd = resolve(projectPath, node.cwd || '.');
 
   // Prebuild BEFORE judging `--no-build`: the build is what makes the flag legal.
-  const prebuild = runTestPrebuild({ node, cwd, exec, timeout, projectPath });
+  const prebuild = runTestPrebuild({ node, cwd, exec, timeout, projectPath, builtTargets: opts.builtTargets });
   if (prebuild.failure) return prebuild.failure;
 
   // `--no-build` without a build here would run a stale assembly. The command is never
   // rewritten: a silent fix would make the reported `command` a lie about what ran.
-  if (node.runner === 'dotnet' && NO_BUILD_FLAG.test(cmd) && !prebuild.built) {
+  if (DOTNET_COMMAND.test(cmd) && NO_BUILD_FLAG.test(cmd) && !prebuild.built && !opts.solutionBuilt) {
     return {
       passed: false,
       buildFailed: false,
@@ -530,18 +508,17 @@ export function runTestSuite(projectPath = '.', opts = {}) {
   // Layered OVER process.env: a child that lost PATH fails for reasons unrelated to the suite.
   const env = opts.env ? { ...process.env, ...opts.env } : undefined;
 
-  try {
-    const output = exec(cmd, {
-      cwd,
-      timeout,
-      encoding: 'utf8',
-      stdio: 'pipe',
-      // Node's 1 MiB default kills a large suite mid-run (ENOBUFS), which then reads as a red suite.
-      maxBuffer: TEST_OUTPUT_MAX_BUFFER,
-      ...(env ? { env } : {}),
-    });
-    return { passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout };
-  } catch (err) {
+  const execOptions = {
+    cwd,
+    timeout,
+    encoding: 'utf8',
+    stdio: 'pipe',
+    // Node's 1 MiB default kills a large suite mid-run (ENOBUFS), which then reads as a red suite.
+    maxBuffer: TEST_OUTPUT_MAX_BUFFER,
+    ...(env ? { env } : {}),
+  };
+  const passed = (output) => ({ passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout });
+  const failed = (err) => {
     // A spawn failure or a kill leaves both streams empty; its own error is then the only lead.
     const output = (err.stdout || '') + (err.stderr || '')
       || [err.code, err.signal, err.message].filter(Boolean).join(' ');
@@ -571,5 +548,22 @@ export function runTestSuite(projectPath = '.', opts = {}) {
       exitCode: err.status ?? 1,
       timeoutMs: timeout,
     };
+  };
+
+  if (opts.background) return runInBackground(cmd, execOptions).then(passed, failed);
+  try {
+    return passed(exec(cmd, execOptions));
+  } catch (err) {
+    return failed(err);
   }
 }
+
+// `exec` reports the exit code in `err.code`; the shared handler reads `err.status`, as from execSync.
+function runInBackground(cmd, options) {
+  return new Promise((resolvePromise, reject) => {
+    execCallback(cmd, options, (err, stdout, stderr) => {
+      if (!err) return resolvePromise(stdout);
+      return reject(Object.assign(err, { stdout, stderr, status: Number.isInteger(err.code) ? err.code : null }));
+    });
+  });
+}

package/src/lib/telemetry/telemetry-reader.js

@@ -164,8 +164,7 @@ export function aggregateTelemetry(events, opts = {}) {
   };
 }
 
-// Kept apart from aggregateTelemetry: its return shape is spread into `telemetry --json`, so new fields
-// there would leak into that contract. Bytes re-ingested is a proxy for cost, never a token count.
+// Bytes re-ingested is a proxy for cost, never a token count.
 
 function mapToObj(map) {
   const out = {};

package/src/lib/telemetry/verify-event.js

@@ -11,6 +11,11 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
     if (!node) continue;
     nodes[name] = { status: node.status, durationMs: Number.isFinite(node.durationMs) ? node.durationMs : null };
   }
+  if (nodes.tests && Array.isArray(result.nodes.tests.runs)) {
+    nodes.tests.runs = result.nodes.tests.runs.map(({ id, status, durationMs }) => ({
+      id, status: status ?? null, durationMs: Number.isFinite(durationMs) ? durationMs : null,
+    }));
+  }
   if (nodes.validators) {
     nodes.validators.ran = [...(result.nodes.validators.ran || [])];
     nodes.validators.skipped = (result.nodes.validators.skipped || [])
@@ -26,6 +31,8 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
     persisted,
     reason: persisted ? null : (reason ?? null),
     source,
+    reused: result.reused ?? [],
+    flaky: result.flaky ?? [],
     nodes,
   };
 }

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

@@ -0,0 +1,63 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+// Ignored files (`.env`, a database) are outside the fingerprint: `verify --fresh` is the way out.
+function cachePath(gitCommonDir, featureName) {
+  return join(gitCommonDir, 'morph-spec', `verify-nodes-${featureName}.json`);
+}
+
+export function readVerifyCache(gitCommonDir, featureName) {
+  try {
+    return JSON.parse(readFileSync(cachePath(gitCommonDir, featureName), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Fail-open: a cache that cannot be written costs a rerun, never a verdict. */
+export function writeVerifyCache(gitCommonDir, featureName, entry) {
+  try {
+    const path = cachePath(gitCommonDir, featureName);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(entry));
+  } catch { /* see above */ }
+}
+
+const withoutOutput = ({ output: _output, ...rest }) => rest;
+
+export function cacheEntryFrom(fingerprint, nodes) {
+  return {
+    fingerprint,
+    build: withoutOutput(nodes.build),
+    tests: (nodes.tests.runs || []).map(withoutOutput),
+    e2e: withoutOutput(nodes.e2e),
+  };
+}
+
+const NOTHING = Object.freeze({
+  build: null, tests: new Map(), e2e: null, redFirst: new Set(), retried: new Set(),
+});
+
+/**
+ * Same tree: green nodes stand, red ones run again (`retried`, to name a flake when they turn green).
+ * Tree moved: nothing stands, and last round's red suites run first (`redFirst`).
+ */
+export function planReuse(previous, fingerprint) {
+  if (!previous || !fingerprint) return NOTHING;
+  const runs = previous.tests || [];
+  const red = new Set(runs.filter((run) => run.status === 'fail').map((run) => run.id));
+
+  if (previous.fingerprint !== fingerprint) return { ...NOTHING, redFirst: red };
+
+  return {
+    build: previous.build?.status === 'pass' ? previous.build : null,
+    tests: new Map(runs.filter((run) => run.status === 'pass').map((run) => [run.id, run])),
+    e2e: previous.e2e?.status === 'pass' ? previous.e2e : null,
+    redFirst: red,
+    retried: previous.e2e?.status === 'fail' ? new Set([...red, 'e2e']) : red,
+  };
+}
+
+export function reusedEntry(entry) {
+  return { ...entry, output: '', durationMs: 0, reused: true };
+}

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

@@ -22,6 +22,9 @@ import {
 } from '../tasks/eval-node.js';
 import { runValidation } from './validation-runner.js';
 import { createHeavyGate } from '../heavy/gate.js';
+import {
+  cacheEntryFrom, planReuse, readVerifyCache, reusedEntry, writeVerifyCache,
+} from './verify-cache.js';
 
 const DEFAULT_BUILD_TIMEOUT = 1_800_000;
 
@@ -62,6 +65,8 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     refreshCache = false,
     linux = false,
     linuxImage = null,
+    fingerprint = null,
+    fresh = false,
     _runLinuxSuite = runLinuxSuite,
     _exec = undefined,
     _runBuildCheck = runBuildCheck,
@@ -117,13 +122,23 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
   const nodes = {};
   const feedback = [];
 
-  nodes.build = await runBuildNode({ projectPath, stack, paths, timeout, skipBuild, gate, _runBuildCheck });
+  // Only a complete run feeds or reads the cache: a partial one proves nothing about the nodes it left out.
+  const cacheDir = fingerprint && !filter && !skipTests && !skipBuild && !skipE2e && !recordBaseline
+    && !refreshCache && !linux && !freshE2e
+    ? resolveGitCommonDir(projectPath)
+    : null;
+  const reuse = planReuse(cacheDir && !fresh ? readVerifyCache(cacheDir, featureName) : null, fingerprint);
+
+  nodes.build = reuse.build
+    ? reusedEntry(reuse.build)
+    : await runBuildNode({ projectPath, stack, paths, timeout, skipBuild, gate, _runBuildCheck });
   appendBuildFeedback(feedback, nodes.build);
 
   // Only a TYPED --timeout reaches the tests: the build default would outrank
   // config.project.testTimeoutMs and the per-project scaling.
   const explicitTimeout = Number.isFinite(options.timeout) ? options.timeout : undefined;
   const stackNodes = [];
+  const buildFacts = { solutionBuilt: builtDotnet(nodes.build), builtTargets: new Set() };
   nodes.tests = await runTestsNode({
     projectPath,
     testPlan,
@@ -136,6 +151,8 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     linuxImage,
     gate,
     stackNodes,
+    reuse,
+    buildFacts,
     _runTestSuite,
     _runLinuxSuite,
     _exec,
@@ -145,25 +162,28 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
   nodes.validators = await runValidatorsNode({ projectPath, featureName, _runValidation });
   appendValidatorsFeedback(feedback, nodes.validators);
 
-  const e2e = await runE2eNode({
-    projectPath,
-    featureName,
-    skipE2e,
-    freshE2e,
-    buildNode: nodes.build,
-    testsNode: nodes.tests,
-    hasStackNodes: stackNodes.length > 0,
-    gate,
-    _runE2eCheck,
-    _e2eApplicability,
-  });
+  // A suite with `e2e: true` still to run needs the stack's env, which only a real run returns.
+  const e2e = reuse.e2e && stackNodes.length === 0 && nodes.tests.status !== 'fail'
+    ? { node: reusedEntry(reuse.e2e), stackEnv: null }
+    : await runE2eNode({
+      projectPath,
+      featureName,
+      skipE2e,
+      freshE2e,
+      buildNode: nodes.build,
+      testsNode: nodes.tests,
+      hasStackNodes: stackNodes.length > 0,
+      gate,
+      _runE2eCheck,
+      _e2eApplicability,
+    });
   nodes.e2e = e2e.node;
   appendE2eFeedback(feedback, nodes.e2e);
 
   if (stackNodes.length > 0) {
     nodes.tests = await runStackTestNodes({
       projectPath, testsNode: nodes.tests, stackNodes, e2eNode: nodes.e2e, stackEnv: e2e.stackEnv,
-      timeout: explicitTimeout, gate, _runTestSuite,
+      timeout: explicitTimeout, gate, buildFacts, _runTestSuite,
     });
     appendTestsFeedback(feedback, nodes.tests);
   }
@@ -180,6 +200,13 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
 
   const status = Object.values(nodes).some((n) => n.status === 'fail') ? 'fail' : 'pass';
 
+  if (cacheDir) writeVerifyCache(cacheDir, featureName, cacheEntryFrom(fingerprint, nodes));
+
+  const reused = reusedNames(nodes);
+  if (reused.length > 0) feedback.push(`[verify] aproveitado da rodada anterior na mesma árvore: ${reused.join(', ')}`);
+  const flaky = flakyNames(nodes, reuse.retried);
+  if (flaky.length > 0) feedback.push(`[verify] vermelho sem mudança de código, verde agora (instável): ${flaky.join(', ')}`);
+
   return {
     version: 1,
     feature: featureName,
@@ -187,10 +214,28 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     status,
     nodes,
     feedback,
+    reused,
+    flaky,
     ...(baseline ? { baseline } : {}),
   };
 }
 
+function reusedNames(nodes) {
+  return [
+    ...(nodes.build.reused ? ['build'] : []),
+    ...(nodes.tests.runs || []).filter((run) => run.reused).map((run) => `tests/${run.id}`),
+    ...(nodes.e2e.reused ? ['e2e'] : []),
+  ];
+}
+
+function flakyNames(nodes, retried) {
+  return [
+    ...(nodes.tests.runs || []).filter((run) => run.status === 'pass' && retried.has(run.id)).map((run) => `tests/${run.id}`),
+    ...(nodes.e2e.status === 'pass' && retried.has('e2e') ? ['e2e'] : []),
+    ...(nodes.e2e.flakySpecs || []).map((spec) => `e2e: ${spec}`),
+  ];
+}
+
 /**
  * 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.
@@ -259,7 +304,7 @@ function appendBuildFeedback(feedback, buildNode) {
 // with `status` because verify.js and the persisted stamp read `nodes.tests.status`.
 async function runTestsNode({
   projectPath, testPlan, filter, skipTests, buildNode, timeout, refreshCache = false,
-  linux = false, linuxImage = null, gate, stackNodes = [], _runTestSuite, _runLinuxSuite = runLinuxSuite, _exec,
+  linux = false, linuxImage = null, gate, stackNodes = [], reuse, buildFacts, _runTestSuite, _runLinuxSuite = runLinuxSuite, _exec,
 }) {
   const { nodes, source } = testPlan;
   const command = nodes.map((n) => n.command).filter(Boolean).join(' && ') || null;
@@ -282,24 +327,53 @@ async function runTestsNode({
     return rollUpTestRuns(runs, { command, source, environment });
   }
 
+  const declaredOrder = new Map(nodes.map((node, index) => [node.id, index]));
+  const redFirst = [...nodes].sort((a, b) => reuse.redFirst.has(b.id) - reuse.redFirst.has(a.id));
+
+  // A round chasing a red suite stays serial: it must be able to stop at the first one.
+  const together = reuse.redFirst.size > 0
+    ? []
+    : nodes.filter((node) => node.parallel && !node.e2e && !reuse.tests.has(node.id));
+  const finished = new Map(await Promise.all(together.map(async (node) => [node.id, await runOneTestNode({
+    projectPath, node, filter, timeout, refreshCache, gate, buildFacts, _runTestSuite,
+  })])));
+
   const runs = [];
-  for (const node of nodes) {
+  let stillRed = null;
+  for (const node of redFirst) {
+    if (reuse.tests.has(node.id)) {
+      runs.push(reusedEntry(reuse.tests.get(node.id)));
+      continue;
+    }
+    if (finished.has(node.id)) {
+      runs.push(finished.get(node.id));
+      continue;
+    }
+    if (stillRed) {
+      runs.push({ ...emptyRunEntry(node), reason: `adiado: ${stillRed} segue vermelho` });
+      continue;
+    }
     if (node.e2e && !preDecideRun({ node, filter, projectPath, refreshCache })) {
       stackNodes.push(node);
       runs.push(emptyRunEntry(node));
       continue;
     }
-    runs.push(await runOneTestNode({
-      projectPath, node, filter, timeout, refreshCache, gate, _runTestSuite,
-    }));
+    const run = await runOneTestNode({
+      projectPath, node, filter, timeout, refreshCache, gate, buildFacts, _runTestSuite,
+    });
+    runs.push(run);
+    if (run.status === 'fail' && reuse.redFirst.has(node.id)) stillRed = node.id;
   }
 
+  runs.sort((a, b) => declaredOrder.get(a.id) - declaredOrder.get(b.id));
   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 builtDotnet = (buildNode) => buildNode.status === 'pass' && /\bdotnet build\b/.test(buildNode.command ?? '');
+
+async function runStackTestNodes({ projectPath, testsNode, stackNodes, e2eNode, stackEnv, timeout, gate, buildFacts, _runTestSuite }) {
   const byId = new Map(stackNodes.map((node) => [node.id, node]));
   const runs = [];
   for (const run of testsNode.runs) {
@@ -310,7 +384,7 @@ async function runStackTestNodes({ projectPath, testsNode, stackNodes, e2eNode,
       runs.push({ ...run, reason, warnings: [reason] });
       continue;
     }
-    runs.push(await runOneTestNode({ projectPath, node, filter: null, timeout, gate, env: stackEnv, _runTestSuite }));
+    runs.push(await runOneTestNode({ projectPath, node, filter: null, timeout, gate, env: stackEnv, buildFacts, _runTestSuite }));
   }
   return rollUpTestRuns(runs, { command: testsNode.command, source: testsNode.source, environment: testsNode.environment });
 }
@@ -364,7 +438,7 @@ async function runNodesInLinux({
 }
 
 async function runOneTestNode({
-  projectPath, node, filter, timeout, refreshCache = false, gate, env = null, _runTestSuite,
+  projectPath, node, filter, timeout, refreshCache = false, gate, env = null, buildFacts = {}, _runTestSuite,
 }) {
   const decided = preDecideRun({ node, filter, projectPath, refreshCache });
   if (decided) return decided;
@@ -380,7 +454,7 @@ async function runOneTestNode({
   const start = Date.now();
   const childEnv = env || evalChannel ? { ...(env || {}), ...(evalChannel?.env || {}) } : null;
   const result = await _runTestSuite(projectPath, {
-    timeout, node, ...(childEnv ? { env: childEnv } : {}),
+    timeout, node, ...buildFacts, background: node.parallel === true, ...(childEnv ? { env: childEnv } : {}),
   });
   const durationMs = Date.now() - start;
   const logPath = writeFailedRunLog(projectPath, node, result);
@@ -763,6 +837,7 @@ async function runE2eNode({
       output: tailLines(result.output || '', OUTPUT_TAIL_LINES),
       count: Number.isInteger(result.count) ? result.count : null,
       warnings: Array.isArray(result.warnings) ? result.warnings : [],
+      flakySpecs: result.flakySpecs ?? [],
     },
     stackEnv: { COMPOSE_PROJECT_NAME: composeProjectName(featureName), ...env },
   };

package/src/utils/agents-installer.js

@@ -183,7 +183,7 @@ function buildFrontmatter(agent, description, knownMcpIds, maxTurns) {
     `maxTurns: ${maxTurns}`,
   ];
   if (agent.color) lines.push(`color: ${agent.color}`);
-  lines.push(`memory: project`, '');
+  lines.push('');
   return lines.join('\n');
 }
 
@@ -208,7 +208,7 @@ export const REVIEW_REPORT_CONTRACT = [
     'tabela `## Bloqueadores` (`| id | tipo | onde | evidência |`; vazia = `Nenhum.`) e `## Notas`. ' +
     'Bloqueador só com evidência e tipo; o resto é nota, e nota nunca pede rodada nova.',
   '',
-  'Numa confirmação (o orquestrador te retoma depois da correção, com o `sha` novo) acrescente ao fim uma seção nova com ' +
+  'Numa confirmação (um dispatch novo te traz depois da correção, com o `sha` novo) acrescente ao fim uma seção nova com ' +
     `\`${VERDICT_TOKEN}\` e \`${REVIEWED_SHA_TOKEN} {sha novo}\`: se você abriu bloqueadores, julgue só eles; ` +
     'se não abriu, julgue só o delta `{sha anterior}..{sha novo}` — o que a correção abriu. ' +
     'O relatório é append-only: vale o último veredito e, na `## Checks`, a última linha de cada Cn.',