@polymorphism-tech/morph-spec 10.1.1 → 10.5.2

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

@@ -22,6 +22,10 @@ import {
 } from '../tasks/eval-node.js';
 import { runValidation } from './validation-runner.js';
 import { createHeavyGate } from '../heavy/gate.js';
+import { selectAffected } from '../verify/affected.js';
+import {
+  cacheEntryFrom, planReuse, readVerifyCache, reusedEntry, writeVerifyCache,
+} from './verify-cache.js';
 
 const DEFAULT_BUILD_TIMEOUT = 1_800_000;
 
@@ -45,12 +49,34 @@ export class VerifyUsageError extends Error {
 export async function runVerify(projectPath, featureName, options = {}) {
   const gate = options._heavyGate ?? createHeavyGate({ projectPath, feature: featureName });
   try {
-    return await runVerifyGated(projectPath, featureName, options, gate);
+    return await runVerifyGated(projectPath, featureName, applyAffectedScope(projectPath, options), gate);
   } finally {
     gate.release();
   }
 }
 
+export function withCpuShare(node, share) {
+  if (!share || node.runner !== 'vitest' || /--max-?workers/i.test(node.command ?? '')) return node;
+  return { ...node, command: `${node.command} --maxWorkers=${share}` };
+}
+
+function applyAffectedScope(projectPath, options) {
+  if (!options.affected) return options;
+  const conflict = [['filter', '--filter'], ['recordBaseline', '--record-baseline'], ['refreshCache', '--refresh-cache'], ['linux', '--linux']]
+    .find(([key]) => options[key]);
+  if (conflict) throw new VerifyUsageError(`--affected escolhe os testes sozinho; não combina com ${conflict[1]}`);
+
+  const selection = selectAffected({ projectPath, nodes: resolveTestNodes(projectPath).nodes, deps: options._affectedDeps });
+  if (selection.scope === 'full') return { ...options, escalatedBecause: selection.reason };
+  return {
+    ...options,
+    selection,
+    skipE2e: true,
+    skipBuild: options.skipBuild || selection.docsOnly,
+    skipTests: options.skipTests || selection.nodes.length === 0,
+  };
+}
+
 async function runVerifyGated(projectPath, featureName, options, gate) {
   const {
     timeout = DEFAULT_BUILD_TIMEOUT,
@@ -62,6 +88,8 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     refreshCache = false,
     linux = false,
     linuxImage = null,
+    fingerprint = null,
+    fresh = false,
     _runLinuxSuite = runLinuxSuite,
     _exec = undefined,
     _runBuildCheck = runBuildCheck,
@@ -76,7 +104,8 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
 
   // Usage errors are judged before the build: paying for a build to discover a typo
   // is the worst ordering, and a refusal after the cache was touched leaves a half-rewritten tree.
-  const testPlan = resolveTestNodes(projectPath);
+  const resolvedPlan = resolveTestNodes(projectPath);
+  const testPlan = options.selection ? { ...resolvedPlan, nodes: options.selection.nodes } : resolvedPlan;
   const filter = parseTestFilter(options.filter);
   if (filter && !testPlan.nodes.some((node) => nodeMatchesFilter(node, filter))) {
     const declared = testPlan.nodes.map((node) => node.id).join(', ') || '(none)';
@@ -116,14 +145,29 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
 
   const nodes = {};
   const feedback = [];
+  if (options.escalatedBecause) feedback.push(`[verify] rodada completa: ${options.escalatedBecause}`);
+  if (options.selection) {
+    const kept = options.selection.nodes.map((n) => n.id).join(', ') || 'nenhuma';
+    feedback.push(`[verify] rodada afetada, suítes: ${kept}; a completa roda uma vez antes da aprovação`);
+  }
 
-  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 +180,8 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     linuxImage,
     gate,
     stackNodes,
+    reuse,
+    buildFacts,
     _runTestSuite,
     _runLinuxSuite,
     _exec,
@@ -145,25 +191,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,17 +229,43 @@ 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,
     stack,
     status,
+    scope: options.selection ? 'affected' : 'full',
     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 +334,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 +357,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 +414,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 +468,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 +484,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: withCpuShare(node, gate.cpuShare), ...buildFacts, background: node.parallel === true, ...(childEnv ? { env: childEnv } : {}),
   });
   const durationMs = Date.now() - start;
   const logPath = writeFailedRunLog(projectPath, node, result);
@@ -522,7 +626,7 @@ function judgeRun({ node, result, durationMs, logPath = null }) {
   if (verdict.verdict === 'drop') warnings.push(verdict.reason);
 
   // Without a baseline, zero is the floor: a green run over no test is a suite that stopped running.
-  if (result.passed && count === 0 && node.runner !== EVAL_RUNNER && !Number.isInteger(node.expectedCount)) {
+  if (result.passed && count === 0 && !node.allowEmpty && node.runner !== EVAL_RUNNER && !Number.isInteger(node.expectedCount)) {
     return { ...entry, status: 'fail', durationMs, count, warnings, reason: 'suíte verde sem nenhum teste executado', output: '' };
   }
 
@@ -763,6 +867,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/lib/verify/affected.js

@@ -0,0 +1,141 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { changedPathsAgainst, detectDefaultBranch } from '../git/default-branch.js';
+import { resolveBaseRef } from '../git/branch-classifier.js';
+import { contractsTouched, migrationsTouched } from '../risk-detector.js';
+import { isTestFile } from '../validators/reuse/symbol-scanner.js';
+
+const MAX_TEST_CLASSES = 40;
+const INLINE_FILTER = /(^|\s)(--filter|-Filter)\s+(?:"([^"]*)"|(\S+))/i;
+const SCRIPT_IN_COMMAND = /([\w./\\-]+\.(?:ps1|sh))\b/i;
+const PS_FILTER_PARAM = /\[string\]\s*\$Filter\b(?:\s*=\s*['"]([^'"]*)['"])?/i;
+const PS_FILTER_USED = /dotnet\s+test[^\n]*\$Filter\b/i;
+const FORWARDS_ARGS = /dotnet\s+test[^\n]*("?\$@"?|\$\{@\}|@args|\$args)/i;
+const EVAL_NODE =/(^|[-_])evals?($|[-_])/i;
+const DOC_PATH =/\.(md|mdx|txt|png|jpe?g|gif|svg|webp)$/i;
+const DOTNET_SOURCE = /\.(cs|razor|cshtml)$/i;
+const SCRIPT_SOURCE = /\.(tsx?|jsx?|mjs|cjs|css|json)$/i;
+// Everything compiles or resolves through these, so the diff says nothing about what they reach.
+const WIDE_PATH = /(^|\/)(package(-lock)?\.json|pnpm-lock\.yaml|yarn\.lock|global\.json|Directory\.(Build|Packages)\.(props|targets)|tsconfig[^/]*\.json|vitest\.config\.[^/]+|[^/]+\.(csproj|sln|slnx))$/i;
+
+const defaultGit = (args, cwd) => execFileSync('git', args, { cwd, stdio: 'pipe' }).toString();
+
+function mergeBase(baseRef, cwd, git) {
+  try {
+    return git(['merge-base', 'HEAD', baseRef], cwd).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function testFilesNaming(names, cwd, git) {
+  if (names.length === 0) return [];
+  try {
+    const output = git(['grep', '-lw', ...names.flatMap((n) => ['-e', n]), '--', '*.cs'], cwd);
+    return output.split(/\r?\n/).filter((path) => path && isTestFile(path));
+  } catch {
+    // git grep exits 1 when nothing matches.
+    return [];
+  }
+}
+
+const classOf = (path) => basename(path, extname(path));
+
+const readText = (path) => {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+};
+
+/** Reads the wrapper the command calls, so a project gets the narrowing without declaring anything. */
+function scriptFilter(node, cwd, read) {
+  const script = SCRIPT_IN_COMMAND.exec(node.command ?? '')?.[1];
+  const text = script ? read(join(cwd, node.cwd ?? '.', script)) : null;
+  if (!text) return null;
+  if (PS_FILTER_USED.test(text)) {
+    const param = PS_FILTER_PARAM.exec(text);
+    if (param) return { flag: '-Filter', baseFilter: param[1] ?? null };
+  }
+  return FORWARDS_ARGS.test(text) ? { flag: '--filter' } : null;
+}
+
+function narrowDotnet(node, classes, cwd, read) {
+  const selected = classes.map((c) => `FullyQualifiedName~${c}`).join('|');
+  const inline = INLINE_FILTER.exec(node.command ?? '');
+  if (inline) {
+    const [whole, lead, flag, quoted, bare] = inline;
+    return node.command.replace(whole, `${lead}${flag} "(${quoted ?? bare})&(${selected})"`);
+  }
+  const plain = /\bdotnet\s+test\b/.test(node.command ?? '') ? { flag: '--filter' } : null;
+  const how = node.affected ?? plain ?? scriptFilter(node, cwd, read);
+  if (!how) return null;
+  const filter = how.baseFilter ? `(${how.baseFilter})&(${selected})` : selected;
+  return `${node.command} ${how.flag} "${filter}"`;
+}
+
+function selectDotnet(node, relevant, cwd, git, read) {
+  const tests = relevant.filter(isTestFile);
+  const sources = relevant.filter((p) => !isTestFile(p)).map(classOf);
+  const classes = [...new Set([...tests, ...testFilesNaming(sources, cwd, git)].map(classOf))].sort();
+  if (classes.length === 0) return { skip: true };
+  if (classes.length > MAX_TEST_CLASSES) return { wide: classes.length };
+  const command = narrowDotnet(node, classes, cwd, read);
+  // A command nothing can narrow runs whole, as it would without this.
+  return command ? { node: { ...node, command, allowEmpty: true }, classes } : { node };
+}
+
+function selectVitest(node, base) {
+  return { node: { ...node, command: `${node.command} --changed ${base} --passWithNoTests`, allowEmpty: true } };
+}
+
+function selectNode(node, { changed, base, cwd, git, read }) {
+  // A project may run its evals as a plain dotnet node: they cost money, so the name counts too.
+  if (node.e2e || node.evals || EVAL_NODE.test(node.id ?? '')) return { skip: true };
+  const prefix = node.cwd && node.cwd !== '.' ? `${node.cwd.replace(/\\/g, '/').replace(/\/$/, '')}/` : '';
+  const inside = changed.filter((p) => p.startsWith(prefix));
+  if (node.runner === 'dotnet') {
+    const relevant = inside.filter((p) => DOTNET_SOURCE.test(p));
+    return relevant.length ? selectDotnet(node, relevant, cwd, git, read) : { skip: true };
+  }
+  const relevant = inside.filter((p) => SCRIPT_SOURCE.test(p));
+  if (relevant.length === 0) return { skip: true };
+  return node.runner === 'vitest' ? selectVitest(node, base) : { node };
+}
+
+/** @returns {{ scope: 'full', reason: string } | { scope: 'affected', base: string, docsOnly: boolean, nodes: object[], skipped: string[] }} */
+export function selectAffected({ projectPath, nodes, deps = {} }) {
+  const {
+    git = defaultGit, changedPaths = changedPathsAgainst, read = readText,
+    baseRefOf = (p) => resolveBaseRef(detectDefaultBranch(p), p),
+  } = deps;
+  const baseRef = baseRefOf(projectPath);
+  const base = baseRef ? mergeBase(baseRef, projectPath, git) : null;
+  if (!base) return { scope: 'full', reason: 'sem base de comparação com a branch padrão' };
+
+  const changed = changedPaths(base, projectPath)
+    .map((p) => p.replace(/\\/g, '/'))
+    .filter((p) => !p.startsWith('.morph/'));
+
+  const migration = migrationsTouched(changed);
+  if (migration.length) return { scope: 'full', reason: `migration tocada: ${migration[0]}` };
+  const contract = contractsTouched(changed);
+  if (contract.length) return { scope: 'full', reason: `contrato tocado: ${contract[0]}` };
+  // A test project's own file reaches only tests, which the complete run still covers.
+  const wide = changed.find((p) => WIDE_PATH.test(p) && !isTestFile(p));
+  if (wide) return { scope: 'full', reason: `arquivo que alcança o projeto inteiro: ${wide}` };
+
+  const code = changed.filter((p) => !DOC_PATH.test(p));
+  const context = { changed: code, base, cwd: projectPath, git, read };
+  const selected = [];
+  const skipped = [];
+  for (const node of nodes) {
+    const choice = selectNode(node, context);
+    if (choice.wide) return { scope: 'full', reason: `código compartilhado: ${choice.wide} classes de teste alcançadas` };
+    if (choice.skip) skipped.push(node.id);
+    else selected.push(choice.node);
+  }
+  return { scope: 'affected', base, docsOnly: code.length === 0, nodes: selected, skipped };
+}

package/src/lib/verify/detached.js

@@ -0,0 +1,154 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { heavyDir } from '../../../framework/hooks/shared/heavy-holders.js';
+import { pidAlive } from '../../../framework/hooks/shared/process-alive.js';
+import { treeFingerprint } from '../git/tree-fingerprint.js';
+
+export const DETACH_STAGE_ENV = 'MORPH_VERIFY_STAGE';
+export const DETACH_RUN_ENV = 'MORPH_VERIFY_RUN';
+export const DETACH_WORKER_ENV = 'MORPH_VERIFY_WORKER_PID';
+
+const POLL_MS = 2_000;
+const MAX_RUN_MS = 3 * 60 * 60_000;
+
+export const EXIT_BUSY = 3;
+
+export function runPaths(cwd, feature, env = process.env) {
+  const id = createHash('sha1').update(`${cwd}\0${feature}`).digest('hex').slice(0, 12);
+  const base = join(heavyDir(env), `verify-${id}`);
+  return { run: `${base}.json`, exit: `${base}.exit`, out: `${base}.out`, err: `${base}.err` };
+}
+
+const readJson = (path) => {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+};
+
+const readExit = (path) => {
+  try {
+    return Number.parseInt(readFileSync(path, 'utf8'), 10);
+  } catch {
+    return null;
+  }
+};
+
+const readText = (path) => {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return '';
+  }
+};
+
+const removeRun = (paths) => {
+  for (const file of Object.values(paths)) rmSync(file, { force: true });
+};
+
+export function matchesRun(record, { key, args }) {
+  return record?.key === key && JSON.stringify(record.args) === JSON.stringify(args);
+}
+
+export function isRunning(record, paths, { isAlive = pidAlive, now = Date.now } = {}) {
+  if (!record || existsSync(paths.exit)) return false;
+  return isAlive(record.pid) && now() - record.startedAt < MAX_RUN_MS;
+}
+
+export const runFilesOf = (runFile) => ({
+  run: runFile,
+  exit: runFile.replace(/\.json$/, '.exit'),
+  out: runFile.replace(/\.json$/, '.out'),
+  err: runFile.replace(/\.json$/, '.err'),
+});
+
+function spawnStage(stage, { argv, cwd, env, paths, script, spawnFn = spawn }) {
+  mkdirSync(join(paths.run, '..'), { recursive: true });
+  const out = openSync(paths.out, 'a');
+  const err = openSync(paths.err, 'a');
+  try {
+    const child = spawnFn(process.execPath, [script, ...argv], {
+      cwd,
+      detached: true,
+      windowsHide: true,
+      stdio: ['ignore', out, err],
+      env: { ...env, [DETACH_STAGE_ENV]: stage, [DETACH_RUN_ENV]: paths.run },
+    });
+    child.unref();
+    return child;
+  } finally {
+    closeSync(out);
+    closeSync(err);
+  }
+}
+
+export function markWorkerExit(runFile, { processRef = process } = {}) {
+  const exitFile = runFilesOf(runFile).exit;
+  processRef.once('exit', (code) => {
+    try {
+      writeFileSync(exitFile, String(code ?? 1));
+    } catch {}
+  });
+}
+
+/**
+ * The launcher exists to die: killing a process tree walks parent pids, so a worker whose
+ * parent has exited is out of reach of whatever kills the session's background shell.
+ */
+export function launchWorker({ env = process.env, cwd = process.cwd(), argv, script = process.argv[1], spawnFn }) {
+  const runFile = env[DETACH_RUN_ENV];
+  const paths = runFilesOf(runFile);
+  const child = spawnStage('worker', { argv, cwd, env, paths, script, spawnFn });
+  writeFileSync(runFile, JSON.stringify({ ...readJson(runFile), pid: child.pid }));
+  spawnStage('watchdog', {
+    argv, cwd, env: { ...env, [DETACH_WORKER_ENV]: String(child.pid) }, paths, script, spawnFn,
+  });
+}
+
+export async function superviseVerify({
+  feature, args, cwd = process.cwd(), env = process.env, script = process.argv[1], log = (m) => process.stderr.write(`${m}\n`),
+  deps = {},
+}) {
+  const {
+    fingerprint = treeFingerprint, spawnFn, isAlive = pidAlive, now = Date.now, wait = sleep, pollMs = POLL_MS,
+  } = deps;
+  const paths = runPaths(cwd, feature, env);
+  const key = fingerprint(cwd);
+  let record = readJson(paths.run);
+  const liveness = { isAlive, now };
+
+  if (isRunning(record, paths, liveness) && !matchesRun(record, { key, args })) {
+    log('verify: outra rodada desta feature ainda corre, sobre outra árvore; espero ela acabar');
+    while (isRunning(record, paths, liveness)) await wait(pollMs);
+    record = null;
+  }
+
+  const attachable = matchesRun(record, { key, args }) && (isRunning(record, paths, liveness) || existsSync(paths.exit));
+  if (attachable) {
+    log(`verify: retomo a rodada destacada iniciada às ${new Date(record.startedAt).toLocaleTimeString()}`);
+  } else {
+    removeRun(paths);
+    mkdirSync(join(paths.run, '..'), { recursive: true });
+    record = { pid: null, key, args, startedAt: now() };
+    writeFileSync(paths.run, JSON.stringify(record));
+    spawnStage('launch', { argv: args, cwd, env, paths, script, spawnFn });
+  }
+
+  while (!existsSync(paths.exit)) {
+    const current = readJson(paths.run);
+    const launching = !current?.pid && now() - record.startedAt < 30_000;
+    if (!launching && !isRunning(current, paths, liveness)) break;
+    await wait(pollMs);
+  }
+
+  const exitCode = readExit(paths.exit);
+  const stdout = readText(paths.out);
+  const stderr = readText(paths.err);
+  removeRun(paths);
+  const died = exitCode === null || (exitCode === EXIT_BUSY && !stdout.trim());
+  return { exitCode: exitCode ?? EXIT_BUSY, stdout, stderr, died };
+}

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.',

package/src/utils/hooks-installer.js

@@ -6,7 +6,6 @@ import { realEffects } from '../lib/installers/effects.js';
 
 const HOOKS_VERSION = '3.17.0';
 
-const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
 
 // `Edit(path)` only: an Edit rule also covers Write, while a `Write(path)` rule
 // matches nothing and makes Claude Code warn on every session start.
@@ -195,7 +194,6 @@ export async function installClaudeHooks(targetPath, { fx = realEffects() } = {}
   const managed = settings._morph_managed || {};
   const alreadyCurrent = managed.hooks_version === HOOKS_VERSION;
 
-  removeOldDispatch(settings);
   removeMorphHooks(settings);
 
   let installed = 0;
@@ -250,8 +248,6 @@ export async function installClaudeHooks(targetPath, { fx = realEffects() } = {}
   const STALE_ALLOW = [
     'Write(.morph/features/**)',
     'Write(.morph/context/**)',
-    'Bash(morph-spec mutate:*)',
-    'Bash(npx morph-spec mutate:*)',
   ];
   settings.permissions.allow = settings.permissions.allow.filter(
     p => !MORPH_ALLOW.includes(p) && !STALE_ALLOW.includes(p)
@@ -319,22 +315,6 @@ export async function installGlobalStatusline(hooksSourceDir, globalClaudeDirOve
   return { installed: true, globalDir };
 }
 
-function removeOldDispatch(settings) {
-  if (!settings.hooks?.PostToolUse) return;
-
-  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry => {
-    if (!Array.isArray(entry.hooks)) return true;
-    return !entry.hooks.some(h =>
-      h.command === OLD_DISPATCH_COMMAND ||
-      (typeof h.command === 'string' && h.command.includes('agent-teams/dispatch.js'))
-    );
-  });
-
-  if (settings.hooks.PostToolUse.length === 0) {
-    delete settings.hooks.PostToolUse;
-  }
-}
-
 function removeMorphHooks(settings) {
   const morphPathPattern = /framework\/hooks\/claude-code\//;