@polymorphism-tech/morph-spec 9.1.0 → 9.2.0

package/src/dashboard/vite.config.js

@@ -1,24 +1,24 @@
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-import tailwindcss from '@tailwindcss/vite';
-import morphDataPlugin from './vite-plugin-morph-data.js';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const frameworkDir = resolve(__dirname, '..', '..', 'framework');
-const projectDir = process.env.MORPH_PROJECT_DIR || process.cwd();
-
-export default defineConfig({
-  root: __dirname,
-  plugins: [
-    react(),
-    tailwindcss(),
-    morphDataPlugin(frameworkDir, projectDir),
-  ],
-  server: {
-    port: 3200,
-  },
-});
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import morphDataPlugin from './vite-plugin-morph-data.js';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const frameworkDir = resolve(__dirname, '..', '..', 'framework');
+const projectDir = process.env.MORPH_PROJECT_DIR || process.cwd();
+
+export default defineConfig({
+  root: __dirname,
+  plugins: [
+    react(),
+    tailwindcss(),
+    morphDataPlugin(frameworkDir, projectDir),
+  ],
+  server: {
+    port: 3200,
+  },
+});

package/src/lib/ci/workflow-scaffold.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync } from 'fs';
 import { join, posix, relative, resolve } from 'path';
 import { PACKAGE_LOCATIONS } from '../detectors/index.js';
 import { CI_ARTIFACT, CI_RESULT_FILE } from './github-ci.js';
+import { discoverDotnetSolution } from '../tasks/test-runner.js';
 
 const LOCKFILES = [
   ['package-lock.json', 'npm ci'],
@@ -50,6 +51,16 @@ function dotnetSetup(root, config) {
   ];
 }
 
+// The verify build node runs `dotnet build --no-restore` (right on a warm tree): a fresh checkout restores first,
+// against the same target the build node resolves.
+function dotnetRestore(root, config) {
+  if (!usesDotnet(root, config)) return [];
+  const backend = config?.project?.backendPath;
+  if (typeof backend === 'string') return step('dotnet restore', backend, 'dotnet restore');
+  const { target } = discoverDotnetSolution(root);
+  return step('dotnet restore', '.', target && target !== '.' ? `dotnet restore "${target}"` : 'dotnet restore');
+}
+
 const step = (name, dir, run) => [
   `      - name: ${name}`,
   ...(dir === '.' ? [] : [`        working-directory: ${posix.normalize(dir)}`]),
@@ -94,6 +105,7 @@ export function renderCiWorkflow(root, config) {
     lines.push(...step(`install (${pkg.dir})`, pkg.dir, pkg.install));
     if (pkg.playwright) lines.push(...step(`playwright browsers (${pkg.dir})`, pkg.dir, 'npx playwright install --with-deps chromium'));
   }
+  lines.push(...dotnetRestore(root, config));
   lines.push(
     '      - name: morph-spec verify',
     '        shell: bash',

package/src/lib/e2e/applicability.js

@@ -0,0 +1,37 @@
+import { basename } from 'path';
+import { readPlanChecks } from '../plan/checks.js';
+import { changedPathsAgainst, detectDefaultBranch } from '../git/default-branch.js';
+import { resolveComposeFile } from '../../../framework/hooks/shared/e2e-check.js';
+import { E2E_SPEC_LOCATIONS } from '../../../framework/hooks/shared/frontend-locations.js';
+
+export const E2E_NOT_APPLICABLE = 'not applicable: no `prova: e2e` scenario and the diff touches no UI, e2e spec or container file';
+
+const UI_FILE = /\.(tsx|jsx|vue|svelte|astro|css|scss|sass|less|html)$/i;
+const RUNTIME_FILE = /(^|\/)(dockerfile[^/]*|\.dockerignore|(docker-)?compose[^/]*\.ya?ml|playwright\.config\.[cm]?[jt]s)$/i;
+const E2E_DIR = /(^|\/)e2e\//i;
+const KNOWN_PACKAGE_DIRS = E2E_SPEC_LOCATIONS.filter((dir) => dir !== '.');
+
+function packageDirsOf(config) {
+  const declared = [config?.project?.frontendPath, ...(config?.project?.tests ?? []).filter((n) => n?.runner !== 'dotnet').map((n) => n?.cwd)];
+  const extra = declared.filter((d) => typeof d === 'string').map((d) => d.replace(/\\/g, '/').replace(/^\.\/|\/$/g, '')).filter((d) => d && d !== '.');
+  return [...KNOWN_PACKAGE_DIRS, ...extra];
+}
+
+const touchesRuntime = (file, composeFile, packageDirs) => UI_FILE.test(file)
+  || RUNTIME_FILE.test(file)
+  || E2E_DIR.test(file)
+  || (composeFile && basename(file) === basename(composeFile))
+  || packageDirs.some((dir) => file === dir || file.startsWith(`${dir}/`));
+
+/** Unknown (no git, no base, empty diff) is applicable: the e2e only stands down on evidence. */
+export function e2eApplicability(projectPath, featureName, config) {
+  const { checks } = readPlanChecks(projectPath, featureName);
+  if (checks?.checks?.some((c) => c.proof === 'e2e')) return { applicable: true, reason: 'prova: e2e' };
+  const base = detectDefaultBranch(projectPath);
+  const changed = base ? changedPathsAgainst(base, projectPath).filter((f) => !f.startsWith('.morph/')) : [];
+  if (changed.length === 0) return { applicable: true, reason: 'diff unknown' };
+  const composeFile = resolveComposeFile(projectPath, config);
+  const packageDirs = packageDirsOf(config);
+  const hit = changed.find((f) => touchesRuntime(f, composeFile, packageDirs));
+  return hit ? { applicable: true, reason: hit } : { applicable: false, reason: E2E_NOT_APPLICABLE };
+}

package/src/lib/mutation/adapters.js

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

package/src/lib/mutation/runner.js

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

package/src/lib/mutation/trx.js

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

package/src/lib/plan/checks.js

@@ -3,8 +3,9 @@ import { existsSync, readFileSync } from 'fs';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { frozenBody } from '../../../framework/hooks/shared/errata.js';
 import { readAgentsJson } from '../specs/screen-checklist.js';
+import { getFeature } from '../../../framework/hooks/shared/state-reader.js';
 import { findArtifactTerms } from './artifact-vocabulary.js';
-import { PROOF_KINDS, REUSE_VERDICTS, ADR_SCOPES, SECTIONS, CONFLICTS_HEADING } from './plan-parser.js';
+import { PROOF_KINDS, RISK_KINDS, REUSE_VERDICTS, ADR_SCOPES, SECTIONS, CONFLICTS_HEADING } from './plan-parser.js';
 
 export const CHECKS_VERSION = 1;
 export const MAX_SLICE_FILES = 8;
@@ -83,7 +84,19 @@ export function parallelGroups(slices) {
   return groups;
 }
 
-export function validatePlan(plan, { personas = null, surfaces = null } = {}) {
+// A frozen body already extracted under older rules cannot gain a `risco:` line, so it is not demanded.
+export function planRuleOptions(cwd, featureName) {
+  return {
+    workType: getFeature(featureName, cwd)?.workType ?? null,
+    riskRules: readPlanChecks(cwd, featureName).status !== 'fresh',
+  };
+}
+
+const foldRisk = (s) => s.normalize('NFD').replace(/\p{M}/gu, '').replace(/`/g, '').toLowerCase().trim();
+const RISK_BY_FOLD = new Map(RISK_KINDS.map((r) => [foldRisk(r), r]));
+const REGRESSION_WORK_TYPES = ['bug', 'hotfix'];
+
+export function validatePlan(plan, { personas = null, surfaces = null, workType = null, riskRules = true } = {}) {
   const errors = [];
   const warnings = [];
   const at = (line) => (line ? ` (linha ${line})` : '');
@@ -114,12 +127,26 @@ export function validatePlan(plan, { personas = null, surfaces = null } = {}) {
     } else if (!PROOF_KINDS.includes(c.proof.toLowerCase())) {
       errors.push(`${c.id}: prova "${c.proof}" fora de ${PROOF_KINDS.join(' | ')}${at(c.line)}`);
     }
+    const proof = c.proof?.toLowerCase();
+    const risk = c.risk === null ? null : RISK_BY_FOLD.get(foldRisk(c.risk)) ?? false;
+    if (risk === false) {
+      errors.push(`${c.id}: risco "${c.risk}" fora de ${RISK_KINDS.join(' | ')}${at(c.line)}`);
+    } else if (riskRules && proof === 'teste' && risk === null) {
+      errors.push(`${c.id}: "prova: teste" sem "risco:" (${RISK_KINDS.join(' | ')}) — sem risco, a prova é "leitura" ou "e2e"${at(c.line)}`);
+    } else if (risk && proof === 'leitura') {
+      warnings.push(`${c.id}: risco "${risk}" provado só por leitura${at(c.line)}`);
+    }
     const terms = findArtifactTerms(c.text);
     if (terms.length > 0 && !c.artifactWhy) {
       errors.push(`${c.id} descreve artefato ("${terms.join(', ')}") sem "> Por que artefato:" — reescreva como efeito observável ou justifique${at(c.line)}`);
     }
   }
 
+  const isRegression = (c) => ['teste', 'e2e'].includes(c.proof?.toLowerCase()) && c.risk !== null && RISK_BY_FOLD.get(foldRisk(c.risk)) === 'regressão';
+  if (riskRules && REGRESSION_WORK_TYPES.includes(workType) && plan.scenarios.length > 0 && !plan.scenarios.some(isRegression)) {
+    errors.push(`${workType} sem cenário de regressão — o sintoma do bug real vira um Cn com "prova: teste" e "risco: regressão"`);
+  }
+
   const scenarioIds = new Set(plan.scenarios.map((c) => c.id));
   const sliceIds = new Set(plan.slices.map((s) => s.id));
   const covered = new Set();

package/src/lib/plan/plan-parser.js

@@ -2,7 +2,8 @@ import { tableCells, isTableLine, SEPARATOR_ROW_RE } from '../specs/gfm-table.js
 import { ARTIFACT_MARKER_RE } from './artifact-vocabulary.js';
 import { markdownLines } from '../../../framework/hooks/shared/errata.js';
 
-export const PROOF_KINDS = ['teste', 'e2e', 'eval', 'manual'];
+export const PROOF_KINDS = ['teste', 'e2e', 'eval', 'manual', 'leitura'];
+export const RISK_KINDS = ['regra', 'dinheiro', 'contrato', 'concorrência', 'dado', 'regressão'];
 export const REUSE_VERDICTS = ['REUSAR', 'ESTENDER', 'CRIAR'];
 export const ADR_SCOPES = ['feature', 'projeto'];
 
@@ -36,6 +37,7 @@ const SCENARIO_RE = new RegExp(String.raw`^[-*]\s+\*\*(C\d+)\*\*${DASH}(.+)$`);
 const ADR_RE = new RegExp(String.raw`^###\s+(ADR-\d+)${DASH}(.+?)\s*$`);
 const SLICE_RE = new RegExp(String.raw`^###\s+(F\d+)${DASH}(.+?)\s*$`);
 const PROOF_RE = /^\s*prova\s*:\s*(.*?)\s*$/i;
+const RISK_RE = /^\s*risco\s*:\s*(.*?)\s*$/i;
 const WHY_RE = new RegExp(String.raw`^\s*>\s*` + ARTIFACT_MARKER_RE.source + String.raw`\s*(.*?)\s*$`, 'i');
 const SCOPE_RE = /^\s*\*\*Alcance:\*\*\s*(.*?)\s*$/i;
 const SLICE_LINE_RE = /^\s*[-*]\s+([\p{L}]+)\s*:\s*(.*?)\s*$/u;
@@ -69,7 +71,7 @@ function parseScenarios(lines) {
     if (line.fenced) { current = null; continue; }
     const m = SCENARIO_RE.exec(line.raw);
     if (m) {
-      current = { id: m[1], text: m[2].trim(), proof: null, artifactWhy: null, line: line.n };
+      current = { id: m[1], text: m[2].trim(), proof: null, risk: null, artifactWhy: null, line: line.n };
       scenarios.push(current);
       continue;
     }
@@ -79,6 +81,8 @@ function parseScenarios(lines) {
     if (why) { current.artifactWhy = why[1] || ''; continue; }
     const proof = PROOF_RE.exec(line.raw);
     if (proof && current.proof === null) { current.proof = proof[1]; continue; }
+    const risk = RISK_RE.exec(line.raw);
+    if (risk && current.risk === null) { current.risk = risk[1]; continue; }
     if (/^\s*>/.test(line.raw)) continue;
     current.text = `${current.text} ${line.raw.trim()}`;
   }

package/src/lib/review-reports.js

@@ -27,10 +27,11 @@ const CHECKS_SECTION_RE = sectionRe('Checks');
 const MEDIA_SECTION_RE = /^##\s+M[íi]dia\s+gerada\s*$/m;
 const SCREEN_CHECKLIST_SECTION_RE = sectionRe('Checklist\\s+de\\s+tela');
 
-/** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. */
+/** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. Chore: só o revisor (review leve). */
 export function requiredReviewRoles({ workType, securityRequired = false } = {}) {
   if (workType === 'hotfix') return ['verifier'];
-  return securityRequired ? ['verifier', 'reviewer', 'security'] : ['verifier', 'reviewer'];
+  const base = workType === 'chore' ? ['reviewer'] : ['verifier', 'reviewer'];
+  return securityRequired ? [...base, 'security'] : base;
 }
 
 function sectionBodies(text, re) {
@@ -172,7 +173,9 @@ export function reviewSignal(reports, { required, checkIds }) {
         superseded: r.superseded,
       };
   }
-  out.checks = checkIds === null
+  out.checks = !required.includes('verifier')
+    ? { status: 'not-required', missing: [], notProven: [] }
+    : checkIds === null
     ? { status: 'no-checks', missing: [], notProven: [] }
     : { status: 'ok', total: checkIds.length, ...checksCoverage(checkIds, reports.verifier.checks) };
   return out;

package/src/lib/risk-detector.js

@@ -11,6 +11,7 @@ const E2E_SKIP_PATTERNS = [
   [/docker is not available/i, 'environment'],
   [/^requested$/i, 'requested'],
   [/does not containerize/i, 'project'],
+  [/^not applicable:/i, 'not-applicable'],
 ];
 
 // `unknown` (razão vazia) pausa de propósito: dispensa sem motivo é o no-op silencioso que a regra elimina.
@@ -99,6 +100,7 @@ export function reviewPause(signal) {
     if (r.verdict !== 'SHIP') return `veredito do ${role} é ${r.verdict}`;
   }
   const checks = signal?.checks;
+  if (checks?.status === 'not-required') return null;
   if (!checks || checks.status !== 'ok') {
     return 'sem `2-plan/checks.json` legível — a cobertura dos cenários pelo verificador não é conferível';
   }

package/src/lib/tests-audit/audit.js

@@ -0,0 +1,96 @@
+import { execFileSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { basename, join } from 'path';
+import { isTestPath } from '../graph/sanitize.js';
+
+export const PROSE_MIN_HITS = 3;
+export const FAMILY_MIN_SIZE = 4;
+
+const TEST_FILE = /\.(cs|[cm]?[jt]sx?)$/i;
+const CS_CASE = /\[\s*\w*(Fact|Theory)\b/g;
+const JS_CASE = /^\s*(?:it|test)(?:\.each\s*\([\s\S]*?\))?\s*\(\s*['"`]/gm;
+const READS_DOC = /(ReadAll\w*|readFileSync)\s*\([^)]*\.(md|txt)\b/;
+const PROSE_ASSERT = /(?:Assert\.(?:Contains|DoesNotContain)\(\s*"|\.(?:toContain|toMatch)\(\s*['"`])([^"'`]{20,})/g;
+const CONSTANT_ASSERT = /Assert\.Equal\(\s*"[^"]*"\s*,\s*[A-Z]\w*(?:\.[A-Z]\w*)+\s*\)|expect\(\s*[A-Z][A-Z0-9_]+(?:\.[A-Z0-9_]+)*\s*\)\.toBe\(\s*['"`]/g;
+const CS_METHOD = /\[\s*\w*Fact\b[^\]]*\][\s\S]*?(?:void|Task)\s+(\w+)\s*\(/g;
+const LAYER = /^(\w+?)(Handler|Endpoints?|EndpointIntegration|Integration)Tests$/;
+
+function trackedTestFiles(root) {
+  try {
+    return execFileSync('git', ['ls-files', '-z'], { cwd: root, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 256 * 1024 * 1024 })
+      .toString().split('\0').filter((f) => f && TEST_FILE.test(f) && isTestPath(f));
+  } catch {
+    return null;
+  }
+}
+
+const lineOf = (text, index) => text.slice(0, index).split('\n').length;
+const countOf = (text, re) => (text.match(re) ?? []).length;
+
+function factFamilies(text) {
+  const byStem = new Map();
+  for (const m of text.matchAll(CS_METHOD)) {
+    const name = m[1];
+    const cut = name.lastIndexOf('_');
+    if (cut <= 0) continue;
+    const stem = name.slice(0, cut);
+    byStem.set(stem, [...(byStem.get(stem) ?? []), name]);
+  }
+  return [...byStem].filter(([, names]) => names.length >= FAMILY_MIN_SIZE).map(([stem, names]) => ({ stem, size: names.length }));
+}
+
+/** Read-only heuristics over the tracked test files: candidates to delete or merge, never verdicts. */
+export function auditTests(root) {
+  const files = trackedTestFiles(root);
+  if (files === null) return { ok: false, reason: 'git ls-files não respondeu — a auditoria lê só arquivos rastreados' };
+
+  const perFile = [];
+  const prose = [];
+  const constants = [];
+  const families = [];
+  const layers = new Map();
+  for (const file of files) {
+    let text;
+    try { text = readFileSync(join(root, file), 'utf8'); } catch { continue; }
+    const cases = /\.cs$/i.test(file) ? countOf(text, CS_CASE) : countOf(text, JS_CASE);
+    if (cases === 0) continue;
+    perFile.push({ file, cases });
+
+    const proseHits = [...text.matchAll(PROSE_ASSERT)].filter((m) => /\s/.test(m[1]));
+    if (READS_DOC.test(text) || proseHits.length >= PROSE_MIN_HITS) {
+      prose.push({ file, readsDoc: READS_DOC.test(text), literalAsserts: proseHits.length });
+    }
+    for (const m of text.matchAll(CONSTANT_ASSERT)) constants.push({ file, line: lineOf(text, m.index) });
+    for (const family of factFamilies(text)) families.push({ file, ...family });
+
+    const layer = LAYER.exec(basename(file).replace(/\.\w+$/, ''));
+    if (layer) layers.set(layer[1], [...(layers.get(layer[1]) ?? []), file]);
+  }
+
+  perFile.sort((a, b) => b.cases - a.cases);
+  return {
+    ok: true,
+    files: perFile.length,
+    cases: perFile.reduce((n, f) => n + f.cases, 0),
+    largest: perFile.slice(0, 10),
+    prose,
+    constants,
+    families,
+    layers: [...layers].filter(([, f]) => f.length > 1).map(([subject, f]) => ({ subject, files: f })),
+  };
+}
+
+export function renderTestsAudit(result) {
+  if (!result.ok) return `tests audit: ${result.reason}`;
+  const out = [`${result.cases} casos em ${result.files} arquivos de teste`, ''];
+  const section = (title, rows) => {
+    if (rows.length === 0) return;
+    out.push(`${title} (${rows.length})`, ...rows.map((r) => `  ${r}`), '');
+  };
+  section('Maiores arquivos', result.largest.map((f) => `${f.cases}  ${f.file}`));
+  section('Fixam texto ou leem doc — candidatos a apagar', result.prose.map((p) => `${p.file}${p.readsDoc ? ' (lê .md/.txt)' : ''}${p.literalAsserts ? ` — ${p.literalAsserts} asserts de frase` : ''}`));
+  section('Constante contra o próprio literal — candidatos a apagar', result.constants.map((c) => `${c.file}:${c.line}`));
+  section(`Famílias de [Fact] (≥ ${FAMILY_MIN_SIZE} com o mesmo prefixo) — candidatas a [Theory]`, result.families.map((f) => `${f.file} — ${f.stem}_* ×${f.size}`));
+  section('Mesmo assunto em mais de uma camada — mantenha a mais barata que morde', result.layers.map((l) => `${l.subject}: ${l.files.join(', ')}`));
+  return out.join('\n').trimEnd();
+}

package/src/lib/validators/code-budget/code-budget-validator.js

@@ -9,7 +9,7 @@ import { isTestFile } from '../reuse/symbol-scanner.js';
 import { isGenerated, isProjectSource } from '../../../../framework/hooks/shared/source-files.js';
 import { citesProcess, commentLines } from '../../../../framework/hooks/shared/comment-scanner.js';
 
-export const MAX_TEST_RATIO = 1.5;
+export const MAX_TEST_RATIO = 1;
 
 /** Abaixo disto a razão não é julgada: a regressão de um bug de 2 linhas cabe aqui. */
 export const MIN_TEST_LINES = 40;