@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

package/src/lib/mutation/snapshot.js

@@ -1,65 +0,0 @@
-import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-
-export const md5Of = (bytes) => createHash('md5').update(bytes).digest('hex');
-export const md5OfFile = (abs) => md5Of(readFileSync(abs));
-
-/**
- * Copies of the original bytes, kept outside the working tree, plus a journal
- * that survives the process: a run killed halfway is undone by the next
- * `--restore` from the journal alone.
- */
-export function openSnapshot({ dir, root, files, runId }) {
-  mkdirSync(dir, { recursive: true });
-  const entries = files.map((file, index) => {
-    const abs = join(root, file);
-    const bytes = readFileSync(abs);
-    const backup = join(dir, `${index}.bak`);
-    writeFileSync(backup, bytes);
-    return { file, md5: md5Of(bytes), backup, created: false };
-  });
-  const snapshot = { runId, root, dir, entries, generated: [], state: 'open' };
-  writeJournal(snapshot);
-  return snapshot;
-}
-
-export function trackGenerated(snapshot, file) {
-  if (!snapshot.generated.includes(file)) snapshot.generated.push(file);
-  writeJournal(snapshot);
-}
-
-export function writeJournal(snapshot) {
-  writeFileSync(join(snapshot.dir, 'journal.json'), JSON.stringify(snapshot, null, 2));
-}
-
-export function readJournal(dir) {
-  const path = join(dir, 'journal.json');
-  return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : null;
-}
-
-/**
- * Writes the original bytes back — a fresh write, so the file is NEWER than
- * any binary built from a mutant. Restoring the old mtime would let the build
- * consider the mutant binary up to date and never recompile the source.
- */
-export function restoreSnapshot(snapshot, { rewrite = true } = {}) {
-  const report = [];
-  for (const entry of snapshot.entries) {
-    const abs = join(snapshot.root, entry.file);
-    const before = existsSync(abs) ? md5OfFile(abs) : null;
-    if (rewrite || before !== entry.md5) {
-      mkdirSync(dirname(abs), { recursive: true });
-      writeFileSync(abs, readFileSync(entry.backup));
-    }
-    const after = md5OfFile(abs);
-    report.push({ file: entry.file, md5Original: entry.md5, md5Before: before, md5After: after, ok: after === entry.md5 });
-  }
-  for (const file of snapshot.generated) {
-    const abs = join(snapshot.root, file);
-    if (existsSync(abs)) unlinkSync(abs);
-  }
-  snapshot.state = report.every((r) => r.ok) ? 'restored' : 'restore-failed';
-  writeJournal(snapshot);
-  return report;
-}

package/src/lib/mutation/subset.js

@@ -1,109 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
-import { csharpClasses } from './dotnet-introspection.js';
-import { relatedCommand } from './commands.js';
-
-const SKIP_DIRS = new Set(['bin', 'obj', 'node_modules', '.git', 'worktrees', 'TestResults']);
-const SAFE_CLASS = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const MIN_TYPE_LENGTH = 4;
-
-const posix = (p) => p.replace(/\\/g, '/');
-
-function walkCs(dir, out = []) {
-  let entries = [];
-  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
-  for (const e of entries) {
-    if (e.isDirectory()) {
-      if (!SKIP_DIRS.has(e.name)) walkCs(join(dir, e.name), out);
-    } else if (e.name.endsWith('.cs')) {
-      out.push(join(dir, e.name));
-    }
-  }
-  return out;
-}
-
-const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-export function mutatedTypesOf(root, files) {
-  const types = new Set();
-  for (const file of files) {
-    for (const t of csharpClasses(resolve(root, file)).types) if (t.length >= MIN_TYPE_LENGTH) types.add(t);
-  }
-  return [...types];
-}
-
-const mentionOf = (types) => (types.length > 0 ? new RegExp(`\\b(?:${types.map(escapeRe).join('|')})\\b`) : null);
-
-/** Test files (a test attribute in the code) under `testProjectDirs` naming one of `types` as a whole word. */
-export function testFilesCiting({ root, testProjectDirs, types, exclude = [] }) {
-  const mention = mentionOf(types);
-  if (mention === null) return [];
-  const skip = new Set(exclude.map(posix));
-  const found = [];
-  for (const dir of testProjectDirs) {
-    for (const abs of walkCs(resolve(root, dir))) {
-      const rel = posix(relative(root, abs));
-      if (skip.has(rel)) continue;
-      const info = csharpClasses(abs);
-      if (info.scannable && info.hasTestAttribute && mention.test(readFileSync(abs, 'utf8'))) found.push(rel);
-    }
-  }
-  return found.sort();
-}
-
-/** Chosen by the tool, never the verifier: test files the feature changed or that name a mutated type. */
-export function dotnetSubset({ root, testProjectDirs, mutatedFiles, changed = [] }) {
-  const changedSet = new Set(changed.map(posix));
-  const mention = mentionOf(mutatedTypesOf(root, mutatedFiles));
-
-  const byChange = new Set();
-  const byMention = new Set();
-  const classes = new Set();
-  for (const dir of testProjectDirs) {
-    for (const abs of walkCs(resolve(root, dir))) {
-      const info = csharpClasses(abs);
-      if (!info.scannable || !info.hasTestAttribute || info.names.length === 0) continue;
-      const rel = posix(relative(root, abs));
-      const viaChange = changedSet.has(rel);
-      const viaMention = !viaChange && mention !== null && mention.test(readFileSync(abs, 'utf8'));
-      if (!viaChange && !viaMention) continue;
-      (viaChange ? byChange : byMention).add(rel);
-      for (const name of info.names) classes.add(name);
-    }
-  }
-  const unsafe = [...classes].find((c) => !SAFE_CLASS.test(c));
-  if (unsafe) return { usable: false, reason: `nome de classe "${unsafe}" não é seguro num filtro` };
-  if (classes.size === 0) return { usable: false, reason: 'nenhum arquivo de teste alterado pela feature nem citando os tipos mutados' };
-  return {
-    usable: true,
-    classes: [...classes].sort(),
-    filter: [...classes].sort().map((c) => `FullyQualifiedName~${c}`).join('|'),
-    files: { changed: [...byChange].sort(), mentions: [...byMention].sort() },
-  };
-}
-
-export function jsSubset({ runner, command, root, mutatedFiles }) {
-  const files = mutatedFiles.filter((f) => existsSync(resolve(root, f)) && statSync(resolve(root, f)).isFile());
-  const cmd = relatedCommand(runner, command, files);
-  if (cmd === null) return { usable: false, reason: `runner "${runner}" sem seleção por arquivo relacionado neste formato de comando` };
-  return { usable: true, command: cmd, files: { related: files } };
-}
-
-const SLN_PROJECT = /^Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+\.csproj)"/gim;
-const SLNX_PROJECT = /<Project\b[^>]*\bPath="([^"]+\.csproj)"/gi;
-
-function solutionProjects(solutionAbs) {
-  let text;
-  try { text = readFileSync(solutionAbs, 'utf8'); } catch { return []; }
-  const pattern = /\.slnx$/i.test(solutionAbs) ? SLNX_PROJECT : SLN_PROJECT;
-  return [...text.matchAll(pattern)].map((m) => resolve(dirname(solutionAbs), posix(m[1])));
-}
-
-/** A solution stands for every project it lists; one that lists none yields no directory. */
-export function testProjectDirsOf(root, targets, cwd = root) {
-  const projects = targets.flatMap((t) => {
-    const abs = resolve(cwd, t);
-    return /\.slnx?$/i.test(t) ? solutionProjects(abs) : [abs];
-  });
-  return [...new Set(projects.map((p) => posix(relative(root, dirname(p)))))];
-}

package/src/lib/mutation/trx.js

@@ -1,50 +0,0 @@
-const ENTITIES = { '&lt;': '<', '&gt;': '>', '&amp;': '&', '&quot;': '"', '&apos;': "'" };
-
-export function decodeXml(text) {
-  return text
-    .replace(/&(?:lt|gt|amp|quot|apos);/g, (m) => ENTITIES[m])
-    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
-    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec)));
-}
-
-const attr = (attrs, name) => new RegExp(`\\b${name}="([^"]*)"`).exec(attrs)?.[1] ?? null;
-const count = (attrs, name) => Number(attr(attrs, name) ?? 0);
-
-/**
- * What a VSTest TRX says about a run: the counters, and for every failed test
- * its name and the FIRST message line — the literal reason a mutation report
- * quotes. Linear over the text: a full suite writes several MB.
- */
-export function parseTrx(xml) {
-  const counters = /<Counters\b([^>]*)\/?>/.exec(xml)?.[1] ?? null;
-  const summary = /<ResultSummary\b([^>]*)>/.exec(xml)?.[1] ?? '';
-  const failedTests = [];
-  const tag = /<UnitTestResult\b([^>]*?)(\/?)>/g;
-  for (let m = tag.exec(xml); m; m = tag.exec(xml)) {
-    if (attr(m[1], 'outcome') !== 'Failed') continue;
-    let message = '';
-    if (m[2] !== '/') {
-      const close = xml.indexOf('</UnitTestResult>', tag.lastIndex);
-      const body = xml.slice(tag.lastIndex, close === -1 ? undefined : close);
-      const raw = /<Message>([\s\S]*?)<\/Message>/.exec(body)?.[1] ?? '';
-      message = decodeXml(raw.replace(/^<!\[CDATA\[|\]\]>$/g, '')).trim();
-    }
-    failedTests.push({ name: decodeXml(attr(m[1], 'testName') ?? '?'), message });
-  }
-  return {
-    parsed: counters !== null,
-    total: counters ? count(counters, 'total') : 0,
-    executed: counters ? count(counters, 'executed') : 0,
-    passed: counters ? count(counters, 'passed') : 0,
-    failed: counters ? count(counters, 'failed') : failedTests.length,
-    aborted: counters ? count(counters, 'aborted') + count(counters, 'timeout') : 0,
-    runOutcome: attr(summary, 'outcome'),
-    failedTests,
-  };
-}
-
-
-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(' ⏎ ');
-  return lines.length > width ? `${lines.slice(0, width)}…` : lines;
-}

package/src/lib/scout/scout-check.js

@@ -1,293 +0,0 @@
-import { execFileSync } from 'child_process';
-import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
-import { join, relative, resolve } from 'path';
-import { workTreeTop } from '../../../framework/hooks/shared/git-paths.js';
-
-export const LINE_TOLERANCE = 2;
-
-const SPAN = /`([^`\n]+)`/g;
-const SPAN_CITATION = /^(.+\.[A-Za-z0-9]+):(\d+)(?:-(\d+))?$/;
-const BARE_CITATION = /(?<![\w.:\\/-])(?:[A-Za-z]:)?[\w.\\/-]*\w\.[A-Za-z0-9]+:(\d+)(?:-(\d+))?\b/g;
-const GREP_LINE = /^((?:[A-Za-z]:)?[^\s:]+\.[A-Za-z0-9]+)(?::(\d+):|-(\d+)-)(.*)$/;
-const FENCE = /^\s*(```|~~~)/;
-const HEADING = /^\s{0,3}#{1,6}\s+(.*)$/;
-const INFERENCE_HEADING = /inferid|hip[óo]tese|inferred|hypothes/i;
-const INFERENCE_MARKER = /\b(INFERIDO|hip[óo]tese)\b/i;
-const COMMAND_SPAN = /^(rg|grep|git\s+grep|morph-spec\s+graph|findstr|Select-String|sls)\b/;
-const COUNT = /(?:→|->|=>)\s*\d+|\b\d+\s+(?:ocorr[êe]ncias?|arquivos?|linhas?|hits?|resultados?|matches?|files?|lines?)\b/i;
-const PATH_SPAN = /^(?:[\w.-]*[\\/])+[\w.-]+$|^[\w.-]+\.(?:cs|csproj|fs|vb|razor|js|mjs|cjs|ts|tsx|jsx|json|md|py|go|java|sql|ya?ml|xml|props|targets|sln)$/i;
-
-const VERDICTS = [
-  /\b(?:VIVO|VIVA|MORTO|MORTA|ALIVE|DEAD)\b/,
-  /\b(?:c[óo]digo morto|dead code|unused)\b/i,
-  /\bsem (?:nenhum )?(?:consumidor|chamador|leitor|escritor|setter|uso|refer[êe]ncia|teste)s?\b/i,
-  /(?<!\b(?:execut|rod)\w*\s)\bnenhum[a]? (?:consumidor|chamador|leitor|escritor|setter|uso|refer[êe]ncia|teste|caller|call site)s?\b/i,
-  /\bningu[ée]m (?:chama|usa|l[êe]|escreve|grava|consome|referencia)\b/i,
-  /\bn[ãa]o (?:é|est[áa]) (?:usad|chamad|lid|referenciad|escrit)/i,
-  /\bnunca (?:é )?(?:usad|chamad|lid|escrit)/i,
-  /\bn[ãa]o h[áa] (?:consumidor|chamador|leitor|escritor|uso|teste|refer[êe]ncia)/i,
-  /\bno (?:callers?|consumers?|readers?|writers?|tests?|usages?)\b/i,
-];
-
-const WALK_SKIP = new Set(['node_modules', '.git', 'bin', 'obj', 'worktrees', '.worktrees']);
-
-function splitLines(text) {
-  const lines = text.replace(/^/, '').split(/\r?\n/);
-  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
-  return lines;
-}
-
-const squash = (s) => s.replace(/\s+/g, ' ').trim();
-
-function lineTokens(line) {
-  const tokens = [];
-  const masked = line.replace(SPAN, (whole, inner, index) => {
-    const cite = inner.trim().match(SPAN_CITATION);
-    if (cite) tokens.push({ index, cite: { raw: inner.trim(), path: cite[1], start: +cite[2], end: +(cite[3] ?? cite[2]) } });
-    else tokens.push({ index, quote: inner });
-    return ' '.repeat(whole.length);
-  });
-  for (const m of masked.matchAll(BARE_CITATION)) {
-    const cite = m[0].match(SPAN_CITATION);
-    if (cite) tokens.push({ index: m.index, cite: { raw: m[0], path: cite[1], start: +cite[2], end: +(cite[3] ?? cite[2]) } });
-  }
-  return tokens.sort((a, b) => a.index - b.index);
-}
-
-function citationsOf(line) {
-  const tokens = lineTokens(line);
-  const out = [];
-  tokens.forEach((t, i) => {
-    if (!t.cite) return;
-    let quote = null;
-    for (const next of tokens.slice(i + 1)) {
-      if (next.cite) break;
-      const q = next.quote.trim();
-      if (COMMAND_SPAN.test(q) || PATH_SPAN.test(q)) continue;
-      quote = next.quote;
-      break;
-    }
-    out.push({ ...t.cite, quote });
-  });
-  return out;
-}
-
-function makeFileLister(root) {
-  let files = null;
-  return () => {
-    if (files) return files;
-    try {
-      files = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], {
-        cwd: root, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true, maxBuffer: 64 * 1024 * 1024,
-      }).toString().split('\0').filter(Boolean);
-    } catch {
-      files = [];
-      const walk = (dir) => {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-          if (WALK_SKIP.has(entry.name)) continue;
-          const full = join(dir, entry.name);
-          if (entry.isDirectory()) walk(full);
-          else files.push(relative(root, full).replace(/\\/g, '/'));
-        }
-      };
-      walk(root);
-    }
-    return files;
-  };
-}
-
-const isFile = (p) => existsSync(p) && statSync(p).isFile();
-
-function resolveCitedPath(rawPath, root, listFiles) {
-  const p = rawPath.replace(/\\/g, '/').replace(/^\.\//, '');
-  if (/^[A-Za-z]:\//.test(p) || p.startsWith('/')) {
-    return isFile(p) ? { path: p } : { problem: 'missing-file' };
-  }
-  const direct = join(root, p);
-  if (isFile(direct)) return { path: direct };
-  const fold = process.platform === 'win32' ? (s) => s.toLowerCase() : (s) => s;
-  const suffix = fold(`/${p}`);
-  const candidates = listFiles().filter((f) => fold(`/${f}`).endsWith(suffix));
-  if (candidates.length === 1) return { path: join(root, candidates[0]) };
-  if (candidates.length > 1) return { problem: 'ambiguous-path', candidates };
-  return { problem: 'missing-file' };
-}
-
-function quoteAppears(quote, lines, start, end) {
-  const from = Math.max(0, start - 1 - LINE_TOLERANCE);
-  const to = Math.min(lines.length, end + LINE_TOLERANCE);
-  const window = squash(lines.slice(from, to).join(' '));
-  let at = 0;
-  for (const fragment of quote.split(/\.\.\.|…/).map(squash).filter(Boolean)) {
-    const found = window.indexOf(fragment, at);
-    if (found === -1) return false;
-    at = found + fragment.length;
-  }
-  return true;
-}
-
-function auditCitation(cite, root, listFiles, readCache) {
-  const where = resolveCitedPath(cite.path, root, listFiles);
-  if (where.problem === 'ambiguous-path') {
-    return { kind: 'ambiguous-path', detail: `${where.candidates.length} arquivos casam: ${where.candidates.slice(0, 5).join(', ')}` };
-  }
-  if (where.problem) return { kind: 'missing-file', detail: `${cite.path} não existe sob ${root}` };
-  if (!readCache.has(where.path)) readCache.set(where.path, splitLines(readFileSync(where.path, 'utf8')));
-  const lines = readCache.get(where.path);
-  cite.resolved = where.path;
-  if (cite.start < 1 || cite.end < cite.start || cite.end > lines.length) {
-    return { kind: 'line-out-of-range', detail: `o arquivo tem ${lines.length} linhas` };
-  }
-  const quotes = cite.quote != null ? [cite.quote] : cite.fence;
-  if (!quotes) {
-    return cite.listing ? null : { kind: 'missing-quote', detail: 'a citação não traz o trecho literal em crase depois dela' };
-  }
-  const missing = quotes.find((q) => !quoteAppears(q, lines, cite.start, cite.end));
-  if (missing != null) {
-    return {
-      kind: 'quote-mismatch',
-      detail: `trecho ausente nas linhas ${Math.max(1, cite.start - LINE_TOLERANCE)}-${Math.min(lines.length, cite.end + LINE_TOLERANCE)}; linha ${cite.start}: ${squash(lines[cite.start - 1])}`,
-    };
-  }
-  cite.verified = true;
-  return null;
-}
-
-const asMention = (line) => line.replace(SPAN, ' ').replace(/"[^"\n]*"|“[^”\n]*”/g, ' ');
-
-const isVerdict = (line) =>
-  VERDICTS[0].test(line.replace(SPAN, ' ')) || VERDICTS.slice(1).some((re) => re.test(asMention(line)));
-
-const hasSearchCommand = (line) => [...line.matchAll(SPAN)].some((m) => COMMAND_SPAN.test(m[1].trim()));
-
-function underSearchCommand(lines, i) {
-  for (let j = i - 1; j >= 0; j--) {
-    if (hasSearchCommand(lines[j])) return true;
-    if (HEADING.test(lines[j])) return false;
-  }
-  return false;
-}
-
-function auditVerdict(line, evidence, inInference) {
-  if (!inInference && !INFERENCE_MARKER.test(line)) {
-    return { kind: 'verdict-outside-inference', detail: 'veredito de ausência/vida fora da seção de hipóteses (Inferido)' };
-  }
-  const spans = [...evidence.matchAll(SPAN)].map((m) => m[1].trim());
-  if (!spans.some((s) => COMMAND_SPAN.test(s))) {
-    return { kind: 'verdict-without-command', detail: 'hipótese de ausência/vida sem o comando de busca usado, em crase' };
-  }
-  if (!COUNT.test(evidence)) return { kind: 'verdict-without-count', detail: 'hipótese de ausência/vida sem a contagem bruta do comando' };
-  return null;
-}
-
-function fenceAfter(lines, i) {
-  let j = i + 1;
-  while (j < lines.length && lines[j].trim() === '') j++;
-  if (j >= lines.length || !FENCE.test(lines[j])) return null;
-  const body = [];
-  for (let k = j + 1; k < lines.length && !FENCE.test(lines[k]); k++) {
-    const text = lines[k].replace(/^\s*:?\d+[:\s]\s*/, '').trim();
-    if (text) body.push(text);
-  }
-  return body.length ? body : null;
-}
-
-const indentOf = (line) => line.match(/^\s*/)[0].length;
-const BULLET = /^\s*([-*+]|\d+[.)])\s/;
-
-function itemStart(lines, i) {
-  let start = i;
-  for (let j = i - 1; j >= 0 && lines[j].trim() !== '' && !HEADING.test(lines[j]); j--) {
-    if (BULLET.test(lines[j]) && indentOf(lines[j]) < indentOf(lines[start])) start = j;
-  }
-  return start;
-}
-
-function continuationEnd(lines, i) {
-  const indent = indentOf(lines[i]);
-  let j = i + 1;
-  while (j < lines.length && lines[j].trim() !== '' && !HEADING.test(lines[j]) && !FENCE.test(lines[j])) {
-    if (indentOf(lines[j]) <= indent && BULLET.test(lines[j])) break;
-    j++;
-  }
-  return j;
-}
-
-export function resolveScoutRoot(root, cwd = process.cwd()) {
-  return root ? resolve(cwd, root) : (workTreeTop(cwd) ?? cwd);
-}
-
-export function checkScoutMap(text, { root }) {
-  const lines = splitLines(text);
-  const listFiles = makeFileLister(root);
-  const readCache = new Map();
-  const failures = [];
-  const citations = [];
-  let verdicts = 0;
-  let inFence = false;
-  let inferenceLevel = null;
-  let subsectionStart = null;
-
-  const audit = (cite, lineNo) => {
-    citations.push(cite);
-    const problem = auditCitation(cite, root, listFiles, readCache);
-    if (problem) failures.push({ line: lineNo, citation: cite.raw, cite, ...problem });
-  };
-  const subsectionText = (from) => {
-    let to = from + 1;
-    while (to < lines.length && !HEADING.test(lines[to])) to++;
-    return lines.slice(from, to).join('\n');
-  };
-
-  lines.forEach((line, i) => {
-    const lineNo = i + 1;
-    if (FENCE.test(line)) { inFence = !inFence; return; }
-    if (inFence) {
-      const grep = line.trim().match(GREP_LINE);
-      if (grep) {
-        const n = +(grep[2] ?? grep[3]);
-        audit({ raw: `${grep[1]}:${n}`, path: grep[1], start: n, end: n, quote: grep[4].trim() || null }, lineNo);
-      }
-      return;
-    }
-    const heading = line.match(HEADING);
-    if (heading) {
-      const level = line.trim().match(/^#+/)[0].length;
-      if (INFERENCE_HEADING.test(heading[1])) { inferenceLevel = level; subsectionStart = null; }
-      else if (inferenceLevel != null && level > inferenceLevel) subsectionStart = i;
-      else { inferenceLevel = null; subsectionStart = null; }
-    }
-
-    const cites = citationsOf(line);
-    const residue = cites.reduce((rest, c) => rest.split(c.raw).join(' '), line)
-      .replace(/[`*_|>()[\]\-+:;,.—–\s]|\d+[.)]/g, '');
-    for (const cite of cites) {
-      if (cite.quote == null) {
-        cite.fence = fenceAfter(lines, i);
-        cite.listing = residue === '' && underSearchCommand(lines, i);
-      }
-      audit(cite, lineNo);
-    }
-
-    if (!isVerdict(line)) return;
-    verdicts++;
-    const evidence = subsectionStart != null
-      ? subsectionText(subsectionStart)
-      : lines.slice(itemStart(lines, i), continuationEnd(lines, itemStart(lines, i))).join('\n');
-    const verdict = auditVerdict(line, evidence, inferenceLevel != null);
-    if (verdict) failures.push({ line: lineNo, text: squash(line), ...verdict });
-  });
-
-  const covered = (c) => citations.some((v) => v.verified && v.resolved === c.resolved && v.start <= c.start && c.end <= v.end);
-  const kept = failures.filter((f) => !(f.kind === 'missing-quote' && covered(f.cite)));
-  if (citations.length === 0) {
-    kept.push({ line: null, kind: 'no-citations', detail: 'o mapa não cita nenhum arquivo:linha — nada nele é verificável' });
-  }
-  return {
-    ok: kept.length === 0,
-    root,
-    citations: citations.map(({ raw, resolved, quote }) => ({ raw, resolved: resolved ?? null, quote })),
-    verdicts,
-    failures: kept.map(({ cite, ...f }) => f),
-  };
-}

package/src/lib/validators/traceability-check.js

@@ -1,103 +0,0 @@
-// Advisory: status is only 'pass' | 'warn' | 'skip', and runVerify() keeps it outside
-// `nodes` so it never flips the verify rollup.
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { readPlanChecks } from '../plan/checks.js';
-import { sliceProgress, sliceReportPath } from '../../../framework/hooks/shared/slice-progress.js';
-
-const FILES_BLOCK_RE = /\*\*Arquivos:\*\*([^\r\n]*)\r?\n?((?:^[ \t]*-[ \t].*\r?\n?)*)/gm;
-
-const BACKTICK_RE = /`([^`]+)`/g;
-
-// A later span without `/` is ambiguous shorthand and is skipped, not guessed: false
-// negatives are acceptable for advisory tooling, false positives are not.
-export function extractCitedFiles(reportText) {
-  const cited = new Set();
-  if (!reportText) return [];
-
-  FILES_BLOCK_RE.lastIndex = 0;
-  let blockMatch;
-  while ((blockMatch = FILES_BLOCK_RE.exec(reportText)) !== null) {
-    const bullets = blockMatch[2].split(/\r?\n/).filter((l) => /^[ \t]*-[ \t]/.test(l));
-    for (const line of [blockMatch[1], ...bullets]) {
-      const spans = [...line.matchAll(BACKTICK_RE)].map((m) => m[1].trim()).filter(Boolean);
-      spans.forEach((span, idx) => {
-        if (idx > 0 && !span.includes('/')) return;
-        if (span.includes('{') || span.includes('}')) return;
-        if (span.endsWith('/')) return;
-        cited.add(normalizePath(span));
-      });
-    }
-  }
-
-  return [...cited];
-}
-
-export function normalizePath(p) {
-  return String(p).replace(/\\/g, '/').replace(/^\.\//, '');
-}
-
-/** null when the plan has no readable extraction. */
-export function collectSliceFiles(projectPath, featureName) {
-  const checks = readPlanChecks(projectPath, featureName).checks;
-  if (!checks) return null;
-  return checks.slices.flatMap((slice) => (slice.files ?? [])
-    .filter((f) => typeof f === 'string' && f.trim())
-    .map(normalizePath));
-}
-
-function isCovered(file, declared) {
-  for (const entry of declared) {
-    if (entry === file) return true;
-    if (entry.endsWith('/') && file.startsWith(entry)) return true;
-  }
-  return false;
-}
-
-function readOrNull(path) {
-  try {
-    return existsSync(path) ? readFileSync(path, 'utf8') : null;
-  } catch {
-    return null;
-  }
-}
-
-export function checkOutputsTraceability(projectPath, featureName) {
-  const featureDir = join(projectPath, '.morph', 'features', featureName);
-  const progress = sliceProgress(featureDir);
-  const reports = (progress?.slices ?? [])
-    .map((slice) => ({ id: slice.id, text: readOrNull(sliceReportPath(featureDir, slice.id)) }))
-    .filter((r) => r.text !== null);
-  if (reports.length === 0) {
-    return { status: 'skip', warnings: [], reason: 'no slice reports', citedCount: 0 };
-  }
-
-  const citedBy = new Map();
-  for (const { id, text } of reports) {
-    for (const file of extractCitedFiles(text)) {
-      if (!citedBy.has(file)) citedBy.set(file, []);
-      citedBy.get(file).push(id);
-    }
-  }
-  if (citedBy.size === 0) {
-    return { status: 'skip', warnings: [], reason: 'no Arquivos: entries found in the slice reports', citedCount: 0 };
-  }
-
-  const declared = collectSliceFiles(projectPath, featureName);
-  if (declared === null) {
-    return { status: 'skip', warnings: [], reason: 'no checks.json', citedCount: citedBy.size };
-  }
-
-  const warnings = [...citedBy.keys()]
-    .filter((file) => !isCovered(file, declared))
-    .sort()
-    .map((file) => `${file} — cited in reports/${citedBy.get(file).join(', ')} but declared in no slice's arquivos:`);
-
-  return {
-    status: warnings.length > 0 ? 'warn' : 'pass',
-    warnings,
-    reason: null,
-    citedCount: citedBy.size,
-  };
-}