@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

package/src/commands/validation/mutate.js

@@ -1,263 +0,0 @@
-import chalk from 'chalk';
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { discoverDotnetBuildTargets } from '../../lib/tasks/test-runner.js';
-import { dotnetTestMode } from '../../lib/mutation/dotnet-introspection.js';
-import { dotnetBuildCommands } from '../../lib/mutation/commands.js';
-import { resolveTestNodes } from '../../lib/tasks/test-nodes.js';
-import { changedPathsAgainst, detectDefaultBranch, getHeadSha } from '../../lib/git/default-branch.js';
-import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
-import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
-import { resolveGitCommonDir } from '../../../framework/hooks/shared/git-paths.js';
-import { BACKSLASH_TOKEN, ManifestError } from '../../lib/mutation/manifest.js';
-import { groupByNode, loadPlan } from '../../lib/mutation/plan.js';
-import { dotnetSubset, jsSubset, mutatedTypesOf, testFilesCiting, testProjectDirsOf } from '../../lib/mutation/subset.js';
-import { isFinished } from '../../dashboard/scanner/feature-status.js';
-import { dotnetAdapter, genericAdapter, spawnExec } from '../../lib/mutation/adapters.js';
-import { noSubsetReason, runMutation } from '../../lib/mutation/runner.js';
-import { renderSection, summarize } from '../../lib/mutation/report.js';
-import { readJournal, restoreSnapshot } from '../../lib/mutation/snapshot.js';
-
-const EXIT = { ok: 0, failed: 1, usage: 2, busy: 3, unsafe: 4 };
-const KEEP_RUNS = 2;
-const DEFAULT_JOBS = 2;
-
-// One heavy slot per worker: the first waits, the others are taken only if free now,
-// so a busy machine degrades to sequential instead of queueing.
-export function workerGate({ root, feature, jobs }) {
-  const config = readHeavyConfig(root);
-  const gates = [createHeavyGate({ projectPath: root, label: 'mutate', feature, config })];
-  const quiet = { ...config, waitTimeoutSec: 0, warnings: [] };
-  for (let i = 1; i < jobs; i++) {
-    const { MORPH_HEAVY_LEASE: _inherited, ...env } = process.env;
-    gates.push(createHeavyGate({ projectPath: root, label: 'mutate', feature, config: quiet, env }));
-  }
-  let acquired = 0;
-  return {
-    get jobs() { return acquired; },
-    enter(node) {
-      gates[0].enter(node);
-      acquired = 1;
-      for (const gate of gates.slice(1)) {
-        try { gate.enter(node); acquired += 1; } catch (err) {
-          if (!(err instanceof HeavyBusyError)) throw err;
-          break;
-        }
-      }
-    },
-    release() {
-      for (const gate of [...gates].reverse()) gate.release();
-      acquired = 0;
-    },
-  };
-}
-
-const gitOut = (cwd, args) => execFileSync('git', args, { cwd, stdio: 'pipe', encoding: 'utf8', windowsHide: true });
-
-function workRoot(root) {
-  const common = resolveGitCommonDir(root);
-  return common ? join(common, 'morph-spec', 'mutation') : join(root, '.morph', 'tmp', 'mutation');
-}
-
-function pruneOldRuns(base, keep) {
-  if (!existsSync(base)) return;
-  const runs = readdirSync(base).sort();
-  for (const name of runs.slice(0, Math.max(0, runs.length - keep))) {
-    const done = ['g0', 'g1', 'g2', 'g3'].every((g) => {
-      const journal = readJournal(join(base, name, g, 'snapshot'));
-      return journal === null || journal.state === 'restored';
-    });
-    if (done) rmSync(join(base, name), { recursive: true, force: true });
-  }
-}
-
-function fail(message, code) {
-  console.error(chalk.red(message));
-  process.exitCode = code;
-  return null;
-}
-
-export function restoreLatest(root, out = console) {
-  const base = workRoot(root);
-  if (!existsSync(base)) { out.log('nada a restaurar: nenhuma rodada de mutação registrada'); return []; }
-  const restored = [];
-  for (const run of readdirSync(base).sort()) {
-    for (const group of readdirSync(join(base, run))) {
-      const journal = readJournal(join(base, run, group, 'snapshot'));
-      if (!journal || journal.state === 'restored') continue;
-      const report = restoreSnapshot(journal);
-      restored.push({ run, group, files: report });
-      out.log(`${run}/${group}: ${report.every((r) => r.ok) ? 'restaurado' : 'FALHOU'} — ${report.map((r) => `${r.file} ${r.ok ? 'ok' : 'md5 diverge'}`).join(', ')}`);
-    }
-  }
-  if (restored.length === 0) out.log('nada a restaurar: toda rodada registrada já foi restaurada');
-  return restored;
-}
-
-function testDirsOf(node, root, { projectsOnly = false } = {}) {
-  const cwd = resolve(root, node.cwd || '.');
-  const targets = discoverDotnetBuildTargets(node, cwd);
-  return testProjectDirsOf(root, projectsOnly ? targets.filter((t) => !/\.slnx?$/i.test(t)) : targets, cwd);
-}
-
-function subsetFor({ node, group, root }) {
-  const mutatedFiles = group.regions.map((r) => r.file);
-  if (node.runner === 'dotnet') {
-    const base = detectDefaultBranch(root);
-    const changed = base ? changedPathsAgainst(base, root) : [];
-    return dotnetSubset({ root, testProjectDirs: testDirsOf(node, root), mutatedFiles, changed });
-  }
-  return jsSubset({ runner: node.runner, command: node.command, root, mutatedFiles });
-}
-
-function e2eManualProtocol(feature, node) {
-  const f = feature ?? '<feature>';
-  const round = `eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f} && morph-spec heavy run -- ${node.command}`;
-  return 'mutate só recompila localmente, e a suíte que alcança esse código testa o container do compose: o mutante sairia sobrevivente em falso. ' +
-    `Prove à mão pelo nó "${node.id}", cada passo numa linha só e encadeado por \`&&\` (nunca \`;\`: um passo que falha não pode deixar a suíte rodar sobre o código original; ` +
-    'e o env da feature se perde entre chamadas de Bash): ' +
-    `(1) base verde antes do 1º mutante: \`${round}\`; ` +
-    `(2) por mutante: edite a linha && \`${round}\`; ` +
-    `(3) restaure, confirme com \`git diff --quiet -- <arquivo>\` e suba a stack de novo (\`eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f}\`). ` +
-    'Registre cada mutante em 4-review (expect, resultado, teste que o matou).';
-}
-
-// A .cs file belongs to every dotnet suite, by runner, not by project reference: a unit suite
-// "owns" code only an e2e suite executes. With an e2e node declared, a unit suite with no test
-// naming a type of the mutated file is not evidence, so the run is refused.
-function uncitedUnderE2e({ root, groups, nodes }) {
-  const e2e = nodes.filter((n) => n.e2e);
-  if (e2e.length === 0) return [];
-  const e2eDirs = new Set(e2e.filter((n) => n.runner === 'dotnet').flatMap((n) => testDirsOf(n, root)));
-  const uncited = [];
-  for (const { node, regions } of groups.filter((g) => g.node.runner === 'dotnet')) {
-    const direct = new Set(testDirsOf(node, root, { projectsOnly: true }));
-    const dirs = testDirsOf(node, root).filter((d) => direct.has(d) || !e2eDirs.has(d));
-    for (const region of regions) {
-      const types = mutatedTypesOf(root, [region.file]);
-      if (testFilesCiting({ root, testProjectDirs: dirs, types, exclude: [region.file] }).length === 0) uncited.push({ region, node, types, e2e });
-    }
-  }
-  return uncited;
-}
-
-function soleActiveFeature(root) {
-  const dir = join(root, '.morph', 'features');
-  let names;
-  try { names = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name); } catch { return null; }
-  const active = names.filter((name) => {
-    try { return !isFinished(JSON.parse(readFileSync(join(dir, name, 'feature.json'), 'utf8'))); } catch { return false; }
-  });
-  return active.length === 1 ? active[0] : null;
-}
-
-export async function mutateCommand(featureArg, options = {}) {
-  const root = resolve(options.cwd ?? process.cwd());
-  if (options.restore) { restoreLatest(root); return null; }
-
-  const feature = featureArg ?? soleActiveFeature(root);
-  if (!feature && !options.plan) return fail('sem feature: passe <feature> (nenhuma, ou mais de uma, em andamento) ou o manifesto por --plan.', EXIT.usage);
-  const planPath = resolve(root, options.plan ?? join('.morph', 'features', feature, '4-review', 'mutants.json'));
-  if (!existsSync(planPath)) return fail(`manifesto não encontrado: ${planPath}\nEscreva-o com a ferramenta Write, se você a tem; só com Bash, heredoc de delimitador entre aspas simples, com a barra invertida do código como ${BACKSLASH_TOKEN} — formato em .morph/framework/CLI.md, seção "### mutate".`, EXIT.usage);
-
-  let regions;
-  try {
-    regions = loadPlan({ root, planPath });
-  } catch (err) {
-    if (err instanceof ManifestError) return fail(err.message, EXIT.usage);
-    if (err instanceof SyntaxError) return fail(`${err.message}\nSe o manifesto tem barra invertida, o transporte do Bash pode tê-la alterado: escreva cada uma como ${BACKSLASH_TOKEN}, que a ferramenta expande.`, EXIT.usage);
-    throw err;
-  }
-
-  const { nodes } = resolveTestNodes(root);
-  const { groups, orphans, stackOnly } = groupByNode(regions, nodes, root);
-  if (orphans.length > 0) {
-    return fail(`nenhuma suíte declarada roda: ${orphans.map((o) => `${o.id} (${o.file})`).join(', ')}\nDeclare o nó em project.tests[] (.morph/config/config.json).`, EXIT.usage);
-  }
-  if (stackOnly.length > 0) {
-    const named = stackOnly.map(({ region, node }) => `${region.id} (${region.file}) → nó "${node.id}"`).join(', ');
-    return fail(`só uma suíte e2e: true cobre: ${named}\nProve a guarda por um teste de unidade, ou: ${e2eManualProtocol(feature, stackOnly[0].node)}`, EXIT.usage);
-  }
-  const mtp = groups.find((g) => g.node.runner === 'dotnet' && dotnetTestMode(resolve(root, g.node.cwd || '.')) === 'mtp');
-  if (mtp) return fail(`a suíte "${mtp.node.id}" roda no Microsoft.Testing.Platform (global.json): o TRX do VSTest, de onde o veredito e o motivo saem, não existe nela. Suporte a MTP ainda não há — rode a mutação com a suíte inteira à mão.`, EXIT.usage);
-  const uncompilable = groups.find((g) => g.node.runner === 'dotnet' && dotnetBuildCommands(g.node, root).length === 0);
-  if (uncompilable) return fail(`a suíte "${uncompilable.node.id}" não deixa descobrir o que compilar: o comando não nomeia .sln/.slnx/.csproj e o diretório alvo não tem uma única solution (ou um único projeto). Sem isso, todo mutante rodaria sobre o binário antigo e sairia "sobrevivente". Nomeie a solution no comando ou declare o campo build no nó (config.json, project.tests[]).`, EXIT.usage);
-  const preDecided = groups.find((g) => g.node.status);
-  if (preDecided) return fail(`a suíte "${preDecided.node.id}" já vem decidida como ${preDecided.node.status}: ${preDecided.node.reason ?? ''}`, EXIT.usage);
-  const uncited = uncitedUnderE2e({ root, groups, nodes });
-  if (uncited.length > 0) {
-    const named = uncited.map(({ region, node, types }) => `${region.id} (${region.file}; tipos: ${types.join(', ') || 'nenhum legível'}) → nenhum teste da suíte "${node.id}" os cita`).join('\n');
-    const e2eIds = uncited[0].e2e.map((n) => `"${n.id}"`).join(', ');
-    return fail(`${named}\nNó e2e: true declarado: ${e2eIds}. ${e2eManualProtocol(feature, uncited[0].e2e[0])}`, EXIT.usage);
-  }
-
-  const subsets = groups.map((group) => subsetFor({ node: group.node, group, root }));
-  const noSubset = subsets.findIndex((s) => !s.usable);
-  if (noSubset >= 0) {
-    return fail(`suíte "${groups[noSubset].node.id}": ${noSubsetReason(subsets[noSubset].reason)}.`, EXIT.usage);
-  }
-
-  if (!options.allowDirty) {
-    const dirty = gitOut(root, ['status', '--porcelain', '--', ...new Set(regions.map((r) => r.file))]).trim();
-    if (dirty) return fail(`há alteração não commitada nos arquivos a mutar:\n${dirty}\nCommite o fix ANTES de mutar (ou use --allow-dirty sabendo que o snapshot é o único caminho de volta).`, EXIT.usage);
-  }
-
-  const runId = `mut-${Date.now().toString(36)}`;
-  const base = workRoot(root);
-  pruneOldRuns(base, KEEP_RUNS);
-  const git = { porcelain: () => gitOut(root, ['status', '--porcelain', '--', '.', ':(exclude).morph']), head: () => getHeadSha(root) };
-  const jobs = Math.max(1, Number.isInteger(options.jobs) ? options.jobs : DEFAULT_JOBS);
-  const gate = workerGate({ root, feature: feature ?? null, jobs });
-  const exec = options.exec ?? spawnExec;
-
-  const merged = { wallMs: 0, mutants: [], timings: [], restore: { files: [], ok: true, treeClean: true }, binary: { proof: 'unavailable', projects: [] }, baseline: {}, method: { schemata: 0, rebuild: 0, subset: {} } };
-  try {
-    for (const [index, group] of groups.entries()) {
-      const workDir = join(base, runId, `g${index}`);
-      mkdirSync(workDir, { recursive: true });
-      const subset = subsets[index];
-      const timeoutMs = options.timeoutMs ?? group.node.timeoutMs ?? 900_000;
-      const make = group.node.runner === 'dotnet' ? dotnetAdapter : genericAdapter;
-      const adapter = make({ node: group.node, root, workDir, exec, subset, timeoutMs });
-      const result = await runMutation({ root, node: group.node, regions: group.regions, workDir, runId, exec, adapter, gate, git, options: { timeoutMs, jobs }, log: (m) => options.json || console.error(chalk.gray(m)) });
-      merged.mutants.push(...result.mutants);
-      merged.timings.push(...result.timings);
-      merged.wallMs += result.wallMs;
-      merged.restore.files.push(...result.restore.files);
-      merged.restore.ok &&= result.restore.ok;
-      merged.restore.treeClean &&= result.restore.treeClean;
-      merged.restore.porcelainAfter = result.restore.porcelainAfter;
-      if (result.binary.proof !== 'unavailable') merged.binary = ['mismatch', 'unlocated'].includes(merged.binary.proof) ? merged.binary : result.binary;
-      merged.baseline = { ...merged.baseline, ...Object.fromEntries(Object.entries(result.baseline).filter(([, v]) => v)) };
-      merged.method.schemata += result.method.schemata;
-      merged.method.rebuild += result.method.rebuild;
-      merged.method.subset = result.method.subset;
-      merged.method.jobs = Math.max(merged.method.jobs ?? 1, result.method.jobs);
-    }
-  } catch (err) {
-    if (err instanceof HeavyBusyError) return fail(`suíte não rodou: ${err.message}. A fila já esperou o prazo dela: não repita em laço — registre a mutação como não executada (morph-spec heavy status).`, EXIT.busy);
-    if (err.code === 'baseline-build-failed') return fail(`${err.message}\n${String(err.output ?? '').split('\n').slice(-12).join('\n')}`, EXIT.failed);
-    throw err;
-  }
-
-  const order = new Map(regions.map((r, i) => [r.id, i]));
-  merged.mutants.sort((a, b) => order.get(a.id) - order.get(b.id));
-  const section = renderSection(merged, { head: git.head(), date: new Date().toISOString().slice(0, 10), subset: subsets[0] ?? null });
-  const outRel = options.out ?? (feature ? join('.morph', 'features', feature, '4-review', 'mutation-section.md') : null);
-  const outPath = outRel ? resolve(root, outRel) : null;
-  if (outPath) {
-    mkdirSync(join(outPath, '..'), { recursive: true });
-    writeFileSync(outPath, section);
-  }
-
-  const tally = summarize(merged);
-  if (options.json) console.log(JSON.stringify({ ...merged, tally, section: outPath }, null, 2));
-  else {
-    console.log(section);
-    console.log(chalk.gray(outPath ? `seção gravada em ${outPath}` : 'seção não gravada: sem feature nem --out'));
-    console.log(`${chalk.green(`${tally.killed} mortos`)} · ${tally.survived ? chalk.yellow(`${tally.survived} sobreviveram`) : '0 sobreviveram'} · ${tally['build-error']} não compilaram · ${tally.inconclusive} inconclusivos`);
-  }
-  if (!merged.restore.ok || ['mismatch', 'unlocated'].includes(merged.binary.proof) || !merged.restore.treeClean) process.exitCode = EXIT.unsafe;
-  return { ...merged, tally, section: outPath };
-}

package/src/commands/validation/scout-check.js

@@ -1,28 +0,0 @@
-import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import { resolve } from 'path';
-import { checkScoutMap, resolveScoutRoot } from '../../lib/scout/scout-check.js';
-
-export function scoutCheckCommand(mapPath, options = {}) {
-  const file = resolve(mapPath);
-  if (!existsSync(file)) {
-    if (options.json) console.log(JSON.stringify({ ok: false, error: 'map-not-found', map: file }));
-    else console.error(chalk.red(`scout-check: mapa não encontrado: ${file}`));
-    process.exit(2);
-  }
-  const result = { map: file, ...checkScoutMap(readFileSync(file, 'utf8'), { root: resolveScoutRoot(options.root) }) };
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (result.ok) {
-    console.log(chalk.green(`✓ scout-check: ${result.citations.length} citações conferidas contra ${result.root}`));
-  } else {
-    console.log(chalk.red(`✗ scout-check: ${result.failures.length} falha(s) em ${file} (raiz ${result.root})`));
-    for (const f of result.failures) {
-      const where = f.line ? `L${f.line}` : '—';
-      console.log(`  ${where} ${chalk.yellow(f.kind)} ${f.citation ?? ''} ${f.detail}`);
-    }
-    console.log(chalk.gray('  Mapa reprovado: descarte e re-despache o scout UMA vez com estas falhas no prompt (MORPH.md §6).'));
-  }
-  process.exit(result.ok ? 0 : 1);
-}

package/src/lib/generators/handoff-generator.js

@@ -1,172 +0,0 @@
-// Derived only from committed sources, so it is regenerated, never hand-edited or merged.
-// Every section is fail-open.
-
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { ensureCommonExclude } from '../../../framework/hooks/shared/git-exclude.js';
-import { derivePhaseForFeature, getPendingGates } from '../../../framework/hooks/shared/state-reader.js';
-import { sliceProgress, readySlices } from '../../../framework/hooks/shared/slice-progress.js';
-import { formatNext } from '../../../framework/hooks/shared/next-step.js';
-import { nextStepFor } from '../next-step.js';
-
-const POINTER_CANDIDATES = [
-  ['2-plan/plan.md', 'plano: problema, cenários com prova, decisões e fatias'],
-  ['2-plan/checks.json', 'cenários e fatias extraídos pelo plan-check'],
-  ['1-design/design-system.md', 'design system da feature'],
-  ['3-implement/reports', 'relatórios das fatias (**Arquivos:**/**Standards:**): o registro da implementação'],
-  ['4-review/verifier.md', 'verificador do Gate 3: cada cenário provado'],
-  ['4-review/reviewer.md', 'revisor do Gate 3: escopo, arquitetura, regressão'],
-  ['4-review/security.md', 'segurança do Gate 3 (só com caminho sensível)'],
-];
-
-function readJson(path) {
-  return JSON.parse(readFileSync(path, 'utf8').replace(/^/, ''));
-}
-
-function decisionTitles(featureDir, limit = 5) {
-  try {
-    const path = join(featureDir, '2-plan', 'checks.json');
-    if (!existsSync(path)) return [];
-    const adrs = readJson(path).adrs;
-    if (!Array.isArray(adrs)) return [];
-    return adrs.map((a) => `${a.id} — ${a.title}`).slice(-limit);
-  } catch {
-    return [];
-  }
-}
-
-function readWorktreeEnv(cwd) {
-  try {
-    const path = join(cwd, '.morph', 'worktree.env');
-    if (!existsSync(path)) return null;
-    const content = readFileSync(path, 'utf8');
-    const get = (key) => content.match(new RegExp(`^${key}=(.+)$`, 'm'))?.[1] || null;
-    const port = get('PORT');
-    return port ? { port, range: get('MORPH_PORT_RANGE') } : null;
-  } catch {
-    return null;
-  }
-}
-
-function nextLine(featureName, cwd) {
-  const fallback = `Rode \`morph-spec next ${featureName}\`.`;
-  try {
-    const next = nextStepFor(featureName, cwd);
-    return next ? formatNext(next) : fallback;
-  } catch {
-    return fallback;
-  }
-}
-
-// `opts.worktree` overrides `feature.worktree`: that field is root-owned and stripped from branch-local
-// copies, so a handoff built inside a worktree would otherwise say "no worktree registered".
-export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
-  const featureDir = join(cwd, '.morph', 'features', featureName);
-  if (!existsSync(join(featureDir, 'feature.json'))) return null;
-
-  let feature;
-  try {
-    feature = readJson(join(featureDir, 'feature.json'));
-  } catch {
-    return null;
-  }
-
-  let phase = 'plan';
-  let pendingGates = [];
-  try {
-    phase = derivePhaseForFeature(featureName, cwd) || 'plan';
-    pendingGates = getPendingGates(featureName, cwd) || [];
-  } catch {}
-
-  const generatedAt = new Date().toISOString();
-  const slices = sliceProgress(featureDir);
-  const env = readWorktreeEnv(cwd);
-  const decisions = decisionTitles(featureDir);
-  const worktree = opts.worktree !== undefined ? opts.worktree : (feature.worktree || null);
-
-  const gates = feature.approvals || feature.approvalGates || {};
-  const gateLine = Object.entries(gates)
-    .map(([name, g]) => (g?.approved ? `${name} ✔${g.approvedBy ? ` (${g.approvedBy})` : ''}` : `${name} pendente`))
-    .join(' · ') || '—';
-
-  const relFeatureDir = `.morph/features/${featureName}`;
-  const pointers = POINTER_CANDIDATES
-    .filter(([rel]) => existsSync(join(featureDir, rel)))
-    .map(([rel, why], i) => `${i + 1}. \`${relFeatureDir}/${rel}\` — ${why}`);
-
-  const lines = [
-    `# Handoff — ${featureName}`,
-    '',
-    `> Documento derivado, gerado em ${generatedAt} por \`morph-spec handoff\`.`,
-    '> Regenere com o comando — nunca edite à mão. Aponta para os arquivos da',
-    '> feature em vez de copiá-los: leia os ponteiros, não confie em resumo velho.',
-    '',
-    '## Identidade',
-    '',
-    `- Feature: **${featureName}** (${feature.workType || 'feature'}) · fase: **${phase}** · status: ${feature.status || '—'}`,
-    worktree?.path
-      ? `- Local: worktree \`${worktree.path}\` · branch \`${worktree.branch || `morph/${featureName}`}\``
-      : '- Local: raiz primária (sem worktree registrado)',
-    env
-      ? `- Ambiente: PORT ${env.port}${env.range ? ` (bloco ${env.range})` : ''} — fonte \`.morph/worktree.env\`; suba dev servers SEMPRE nessas portas`
-      : null,
-    '',
-    '## Estado',
-    '',
-    `- Gates: ${gateLine}`,
-    slices
-      ? `- Fatias: ${slices.done}/${slices.total} feitas${slices.partial ? ` · ${slices.partial} parcial(is)` : ''}${slices.blocked ? ` · ${slices.blocked} bloqueada(s)` : ''} · prontas agora: ${readySlices(slices).map((s) => `**${s.id}** "${s.title}"`).join(', ') || 'nenhuma'}`
-      : '- Fatias: sem checks.json ainda (rode plan-check)',
-    pendingGates.length ? `- Gates pendentes: ${pendingGates.join(', ')}` : null,
-    '',
-    '## Leia nesta ordem (ponteiros — nada copiado)',
-    '',
-    ...(pointers.length ? pointers : ['1. (nenhum artefato ainda — feature recém-criada)']),
-    decisions.length ? '' : null,
-    decisions.length ? `Últimas decisões: ${decisions.map((d) => `"${d}"`).join(' · ')}` : null,
-    '',
-    '## Próxima ação',
-    '',
-    nextLine(featureName, cwd),
-    '',
-    '## Retomar',
-    '',
-    worktree?.path ? `- \`cd ${worktree.path}\` e abra o Claude Code (uma instância por worktree).` : '- Abra o Claude Code na raiz do projeto.',
-    `- Visão da frota: \`morph-spec fleet\` · status: \`morph-spec status ${featureName}\``,
-    '',
-  ].filter((l) => l !== null);
-
-  return {
-    markdown: `${lines.join('\n')}`,
-    meta: {
-      generatedAt,
-      phase,
-      slicesDone: slices?.done ?? 0,
-      slicesTotal: slices?.total ?? 0,
-    },
-  };
-}
-
-/** Marks the exclude block this generator owns in `.git/info/exclude`. */
-const HANDOFF_EXCLUDE_MARKER = '# morph-spec: derived handoff docs (managed — see handoff-generator)';
-const HANDOFF_EXCLUDE_PATTERN = '/.morph/**/handoff.md';
-
-// Never committed: left visible it lands in the `git status` the finish gates read. The common-dir
-// exclude hides it in every worktree; `**` also covers a feature folder after `archive` moves it.
-function ensureHandoffExcluded(cwd) {
-  ensureCommonExclude(cwd, [HANDOFF_EXCLUDE_PATTERN], HANDOFF_EXCLUDE_MARKER);
-}
-
-/** The written path, or null when the feature does not exist (nothing is created). */
-export function writeHandoff(featureName, cwd = process.cwd(), opts = {}) {
-  const result = buildHandoff(featureName, cwd, opts);
-  if (!result) return null;
-  const path = join(cwd, '.morph', 'features', featureName, 'handoff.md');
-  try {
-    ensureHandoffExcluded(cwd);
-    writeFileSync(path, result.markdown, 'utf8');
-    return path;
-  } catch {
-    return null;
-  }
-}

package/src/lib/mutation/adapters.js

@@ -1,79 +0,0 @@
-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 { parseTrx } from './trx.js';
-import { stripAnsi } from '../tasks/test-runner.js';
-
-const MAX_CAPTURE = 16 * 1024 * 1024;
-
-export function spawnExec(command, { cwd, env, timeoutMs }) {
-  return new Promise((done) => {
-    const start = Date.now();
-    let stdout = '';
-    let stderr = '';
-    let timedOut = false;
-    const child = spawn(command, { cwd, env, shell: true, windowsHide: true });
-    child.stdout.setEncoding('utf8');
-    child.stderr.setEncoding('utf8');
-    child.stdout.on('data', (chunk) => { if (stdout.length < MAX_CAPTURE) stdout += chunk; });
-    child.stderr.on('data', (chunk) => { if (stderr.length < MAX_CAPTURE) stderr += chunk; });
-    const timer = setTimeout(() => { timedOut = true; child.kill(); }, timeoutMs);
-    const finish = (status) => { clearTimeout(timer); done({ status, stdout, stderr, durationMs: Date.now() - start, timedOut }); };
-    child.on('error', (err) => { stderr += String(err.message); finish(null); });
-    child.on('close', (status) => finish(status));
-  });
-}
-
-const FAIL_LINE = /^\s*(?:FAIL|✗|×|✖|not ok)\b|AssertionError|Error:|Expected/i;
-
-function genericFailures(output) {
-  const lines = stripAnsi(output).split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-  const first = lines.findIndex((l) => FAIL_LINE.test(l));
-  if (first === -1) return lines.slice(-3).map((l) => ({ name: l, message: '' }));
-  return [{ name: lines[first], message: lines.slice(first + 1, first + 3).join(' ⏎ ') }];
-}
-
-export function dotnetAdapter({ node, root, workDir, exec, subset, timeoutMs }) {
-  const cwd = resolve(root, node.cwd || '.');
-  const trxDir = join(workDir, 'trx');
-  mkdirSync(trxDir, { recursive: true });
-  const base = withoutBuild(node.command);
-  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(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})` };
-    }
-    const t = parseTrx(readFileSync(trxPath, 'utf8'));
-    if (!t.parsed || t.aborted > 0 || /abort/i.test(t.runOutcome ?? '')) {
-      return { outcome: 'crash', executed: t.executed, total: t.total, failed: t.failed, failedTests: t.failedTests, durationMs: r.durationMs, note: 'a rodada foi abortada (testhost caiu ou estourou o tempo)' };
-    }
-    return { outcome: t.failed > 0 ? 'red' : 'green', executed: t.executed, total: t.total, failed: t.failed, failedTests: t.failedTests, durationMs: r.durationMs };
-  };
-  return {
-    kind: 'dotnet',
-    hasSubset: Boolean(subset?.usable),
-    buildCommands: dotnetBuildCommands(node, root),
-    cwd,
-    runTests,
-  };
-}
-
-export function genericAdapter({ node, root, exec, subset, timeoutMs }) {
-  const cwd = resolve(root, node.cwd || '.');
-  return {
-    kind: node.runner,
-    hasSubset: Boolean(subset?.usable),
-    buildCommands: [],
-    cwd,
-    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}`);
-      return { outcome: 'red', executed: null, total: null, failed: failedTests.length, failedTests, durationMs: r.durationMs };
-    },
-  };
-}

package/src/lib/mutation/commands.js

@@ -1,61 +0,0 @@
-import { resolve } from 'node:path';
-import { discoverDotnetBuildTargets, dotnetBuildCommandFor } from '../tasks/test-runner.js';
-
-const FILTER = /--filter(?:[ =:])(?:"([^"]*)"|'([^']*)'|(\S+))/;
-const quote = (s) => `"${String(s).replace(/"/g, '\\"')}"`;
-
-export function declaredFilter(command) {
-  const m = FILTER.exec(command);
-  return m ? (m[1] ?? m[2] ?? m[3]) : null;
-}
-
-export function withFilter(command, expression) {
-  const declared = declaredFilter(command);
-  if (declared === null) return `${command} --filter ${quote(expression)}`;
-  return command.replace(FILTER, () => `--filter ${quote(`(${declared})&(${expression})`)}`);
-}
-
-export function withTrx(command, { dir, name }) {
-  return `${command} --results-directory ${quote(dir)} --logger ${quote(`trx;LogFileName=${name}`)}`;
-}
-
-export function withoutBuild(command) {
-  return /(?:^|\s)--no-build(?:\s|$)/.test(command) ? command : `${command} --no-build`;
-}
-
-const CONFIGURATION = /(?:^|\s)(?:-c|--configuration)[ =:]?(?:"([^"]*)"|(\S+))/;
-const VERBOSITY = /\s(?:-v|--verbosity)[ =:]?\S+/g;
-
-/**
- * The verify's build command per target. The test command's `-c` follows it, and
- * verbosity is minimal: at `quiet` the `Project -> dll` line the binary proof reads is gone.
- */
-export function dotnetBuildCommands(node, projectPath) {
-  const configuration = CONFIGURATION.exec(node.command ?? '');
-  const flag = configuration ? ` -c ${configuration[1] ?? configuration[2]}` : '';
-  return discoverDotnetBuildTargets(node, resolve(projectPath || '.', node.cwd || '.'))
-    .map((target) => dotnetBuildCommandFor(target, projectPath))
-    .filter(Boolean)
-    .map((command) => `${command.replace(VERBOSITY, '')} -v m${flag}`);
-}
-
-const BUILT = /^\s*(?<project>\S.*?) -> (?<dll>.+\.dll)\s*$/gm;
-
-export function parseBuiltDlls(output) {
-  const dlls = new Map();
-  for (const m of String(output).matchAll(BUILT)) dlls.set(m.groups.project, m.groups.dll.trim());
-  return dlls;
-}
-
-const VITEST_RUN = /(vitest(?:\.mjs|\.js)?)\s+run\b/;
-
-export function relatedCommand(runner, command, files) {
-  const list = files.map(quote).join(' ');
-  if (runner === 'vitest' && VITEST_RUN.test(command)) {
-    return `${command.replace(/\s+run\b/, ' related')} ${list} --run`;
-  }
-  if (runner === 'jest' && /\bjest\b/.test(command) && !/[;&|]/.test(command)) {
-    return `${command} --findRelatedTests ${list}`;
-  }
-  return null;
-}