@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/src/lib/validators/reuse/reuse-validator.js

@@ -1,32 +1,6 @@
-/**
- * Reuse Validator — símbolo novo cujo nome já existe no codebase.
- *
- * A terceira camada do ciclo de reuso:
- *
- *   PROSA (morph-plan, personas)  ──►  ARTEFATO (`reuse` em tasks.json)
- *   ──►  COBRANÇA (este arquivo)
- *
- * Prosa sozinha não segura — `morph-brainstorming/SKILL.md:39` já manda olhar
- * o que existe, e o ProspectPRO redefiniu `SimpleBuilding` em cinco arquivos da
- * MESMA pasta assim mesmo: só a verificação em código segura o ciclo.
- *
- * Regras, na ordem em que reduzem ruído:
- *
- *   1. Só tipo (class/record/interface/enum/struct/type) — não função nem
- *      variável. É a categoria que o grafo casa com confiança.
- *   2. Só MESMA LINGUAGEM. Contrato espelhado entre C# e TS (110 casos no
- *      ProspectPRO) é o escopo F da proposta: exige gerar tipos do contrato,
- *      não se resolve por aviso, e fica FORA daqui de propósito.
- *   3. Mesma feature = achado (`error`); feature diferente = aviso
- *      (`warning`), porque VSA prescreve DTO homônimo entre slices.
- *   4. Veredito `CRIAR` declarado no plano (tasks.json `reuse`) rebaixa o
- *      achado a aviso: a decisão foi tomada no Gate 2, com justificativa em
- *      `why`. O validador cobra a decisão AUSENTE, não a decisão tomada.
- *
- * Sem grafo o validador não roda (ADR-002: ausência de grafo nunca bloqueia).
- *
- * @module reuse-validator
- */
+// Só tipos, só mesma linguagem (contrato espelhado C#↔TS não se resolve por aviso).
+// Mesma feature = error; outra feature = warning (VSA admite DTO homônimo entre slices).
+// Veredito CRIAR no plano rebaixa a warning: cobra-se a decisão AUSENTE, não a tomada.
 
 import { existsSync, readFileSync } from 'fs';
 import { execFileSync } from 'child_process';
@@ -34,34 +8,23 @@ import { join, isAbsolute } from 'path';
 
 import { loadGraph } from '../../graph/graph-loader.js';
 import { languageOf } from '../../graph/sanitize.js';
-import { getAbsoluteOutputPath } from '../../../core/paths/output-schema.js';
 import {
   featureOf,
   isIdiomaticLocalName,
   isScannableFile,
   scanDeclarations,
 } from './symbol-scanner.js';
+import { readPlanChecks } from '../../plan/checks.js';
 
-/** Quantos locais citar por achado antes de resumir com "(+N)". */
 const MAX_CITED = 4;
 
-/**
- * Índice "o que já existe": nome em minúsculas -> ocorrências reais do grafo.
- *
- * Só nós com `source_file` preenchido entram — nó com `source_file: ""` é stub
- * não resolvido (BCL, NuGet, pacote externo), e apontar `Task` do .NET como
- * duplicação seria ruído garantido. É o mesmo critério do `buildIndex`.
- *
- * @param {{nodes: object[]}} graph
- * @returns {Map<string, Array<{name: string, file: string, language: string, feature: string}>>}
- */
 export function buildExistingIndex(graph) {
   const index = new Map();
 
   for (const node of graph?.nodes ?? []) {
+    // `source_file` vazio é stub não resolvido (BCL, NuGet): `Task` do .NET não é duplicação.
     if (!node.source_file) continue;
-    // `_callable_class` é a marca de tipo do graphify; nós de ARQUIVO também a
-    // carregam, e se distinguem pelo label com extensão.
+    // Nós de ARQUIVO também têm `_callable_class`; distinguem-se pelo label com extensão.
     if (node._callable_class !== true) continue;
     if (/\.[a-z0-9]+$/i.test(node.label)) continue;
     if (!isScannableFile(node.source_file)) continue;
@@ -81,23 +44,10 @@ export function buildExistingIndex(graph) {
   return index;
 }
 
-/**
- * Casa as declarações desta feature contra o que já existe.
- *
- * Puro e sem I/O — é aqui que a regra mora, e é isto que o teste roda contra o
- * grafo real do ProspectPRO.
- *
- * @param {Array<{name: string, kind: string, line: number, file: string}>} declarations
- * @param {Map<string, Array<{name: string, file: string, language: string, feature: string}>>} existing
- * @param {{verdicts?: Map<string, {verdict: string, target?: string}>}} [opts]
- * @returns {Array<object>} issues, uma por símbolo duplicado
- */
 export function findDuplicateSymbols(declarations, existing, opts = {}) {
   const verdicts = opts.verdicts ?? new Map();
   const issues = [];
 
-  // Uma declaração por (nome, arquivo); o mesmo nome em N arquivos da feature
-  // vira UM achado com N locais, não N achados.
   const byName = new Map();
   for (const decl of declarations) {
     const key = decl.name.toLowerCase();
@@ -112,17 +62,10 @@ export function findDuplicateSymbols(declarations, existing, opts = {}) {
     const declaredFiles = new Set(decls.map((d) => d.file));
     const language = languageOf(decls[0].file);
 
-    // Onde mais esse nome vive: no grafo (código que já existia) e nos OUTROS
-    // arquivos desta mesma leva (código novo que o grafo ainda não viu — ele
-    // só é refeito depois do commit, e é exatamente o caso SimpleBuilding).
+    // A leva também conta: o grafo só é refeito depois do commit e ainda não viu o código novo.
     const fromGraph = (existing.get(key) ?? []).filter(
       (e) => e.language === language && !declaredFiles.has(e.file),
     );
-    // O filtro de linguagem vale AQUI TAMBÉM, não só contra o grafo: uma leva
-    // que toca `CatalogContracts.cs` e `catalog.types.ts` declara `CatalogItem`
-    // nos dois, na mesma feature `Catalog/` — e sem este filtro isso vira erro,
-    // que é precisamente o contrato espelhado C#↔TS que a proposta separa no
-    // escopo F por não se resolver com aviso. Medido no MORPH_GHLBrain.
     const fromBatch = decls
       .slice(1)
       .filter((d) => languageOf(d.file) === language)
@@ -154,7 +97,7 @@ export function findDuplicateSymbols(declarations, existing, opts = {}) {
         ? `Reuse ou estenda o tipo existente em vez de redeclarar. Confirme com ` +
           `\`morph-spec graph explain ${decls[0].name}\` (sem grafo: ` +
           `\`grep -rn "${decls[0].name}"\`) e, se a criação for mesmo necessária, ` +
-          'registre o veredito CRIAR com a justificativa em "why" no tasks[].reuse da task.'
+          'registre o veredito CRIAR com a justificativa em "why" na tabela ## Reuso do plan.md.'
         : `VSA tolera DTO homônimo entre slices — confirme que são conceitos ` +
           `diferentes e não a mesma coisa escrita duas vezes.`,
     });
@@ -166,67 +109,28 @@ export function findDuplicateSymbols(declarations, existing, opts = {}) {
   });
 }
 
-/**
- * Vereditos de reuso carimbados no plano: `tasks[].reuse[]`.
- *
- * O veredito mora só no `tasks.json`: dado estruturado, lido aqui e no Gate 2.
- *
- * @param {string} projectPath
- * @param {string} featureName
- * @returns {Map<string, {verdict: string, target?: string}>}
- */
 export function readReuseVerdicts(projectPath, featureName) {
   const verdicts = new Map();
   if (!featureName) return verdicts;
-
-  try {
-    const tasksPath = getAbsoluteOutputPath(projectPath, featureName, 'tasks');
-    if (!existsSync(tasksPath)) return verdicts;
-    const doc = JSON.parse(readFileSync(tasksPath, 'utf8').replace(/^/, ''));
-    for (const task of doc.tasks ?? []) {
-      for (const entry of task.reuse ?? []) {
-        if (!entry?.concept) continue;
-        verdicts.set(String(entry.concept).toLowerCase(), {
-          verdict: String(entry.verdict || '').toUpperCase(),
-          target: entry.target,
-        });
-      }
-    }
-  } catch {
-    // Plano ilegível não é problema deste validador — o tasks-json-guard já
-    // cobra o schema, e aqui a ausência de veredito só torna a cobrança mais
-    // rígida, nunca mais frouxa.
+  // Sem extração, nenhum veredito: a cobrança só fica mais rígida, nunca mais frouxa.
+  for (const entry of readPlanChecks(projectPath, featureName).checks?.reuse ?? []) {
+    if (!entry?.concept) continue;
+    verdicts.set(String(entry.concept).toLowerCase(), {
+      verdict: String(entry.verdict || '').toUpperCase(),
+      target: entry.target,
+    });
   }
   return verdicts;
 }
 
-/**
- * Arquivos que esta feature criou ou alterou.
- *
- * Duas fontes, unidas, porque cada uma é cega no momento em que a outra
- * enxerga: `outputs` do `tasks.json` é o contrato do framework (morph-implement
- * §8 exige listar TODO arquivo produzido) e sobrevive ao commit; `git status`
- * pega o que ainda não foi registrado numa task. Sem git, sem drama.
- *
- * @param {string} projectPath
- * @param {string} featureName
- * @returns {string[]} paths relativos ao projeto, com barra normal
- */
+// União de duas fontes cegas em momentos diferentes: `arquivos:` das fatias sobrevivem
+// ao commit; `git status` pega o que o plano não previu.
 export function collectChangedFiles(projectPath, featureName) {
   const files = new Set();
-
-  try {
-    const tasksPath = getAbsoluteOutputPath(projectPath, featureName, 'tasks');
-    if (existsSync(tasksPath)) {
-      const doc = JSON.parse(readFileSync(tasksPath, 'utf8').replace(/^/, ''));
-      for (const task of doc.tasks ?? []) {
-        for (const out of task.outputs ?? []) {
-          if (typeof out === 'string') files.add(out.replace(/\\/g, '/'));
-        }
-      }
+  for (const slice of readPlanChecks(projectPath, featureName).checks?.slices ?? []) {
+    for (const file of slice.files ?? []) {
+      if (typeof file === 'string') files.add(file.replace(/\\/g, '/'));
     }
-  } catch {
-    // tasks.json ausente/ilegível: sobra o git.
   }
 
   try {
@@ -238,32 +142,17 @@ export function collectChangedFiles(projectPath, featureName) {
     });
     for (const line of out.split(/\r?\n/)) {
       if (!line.trim()) continue;
-      // "XY path" e, em rename, "XY antigo -> novo": só o destino interessa.
-      // Os paths vêm relativos à RAIZ do repositório — que no morph-spec é a
-      // própria árvore da feature (cada worktree é a sua raiz). Se algum dia
-      // não coincidir com `projectPath`, o `existsSync` adiante descarta o
-      // path: perde-se cobertura, nunca se acusa um arquivo que não existe.
+      // Rename vem como "XY antigo -> novo": só o destino interessa.
       const path = line.slice(3).split(' -> ').pop().replace(/^"|"$/g, '');
       if (path) files.add(path.replace(/\\/g, '/'));
     }
   } catch {
-    // Fora de um repo git, ou git indisponível: o tasks.json já respondeu.
+    // Fora de um repo git, ou git indisponível: o plano já respondeu.
   }
 
   return [...files];
 }
 
-/**
- * Validador plugado no `validation-runner` (e por ele no nó `validators` do
- * `morph-spec verify`).
- *
- * @param {string} projectPath
- * @param {string} featureName
- * @param {object} [options]
- * @param {string[]} [options.changedFiles] - override da coleta (testes)
- * @param {object} [options._graph] - grafo já carregado (testes)
- * @returns {Promise<{errors: number, warnings: number, issues: object[]}>}
- */
 export async function validateReuse(projectPath, featureName = null, options = {}) {
   const result = { errors: 0, warnings: 0, issues: [] };
 
@@ -273,11 +162,9 @@ export async function validateReuse(projectPath, featureName = null, options = {
   })();
 
   if (!graph) {
-    // ADR-002: projeto sem grafo (sem Python, ou grafo ainda não construído)
-    // segue em frente. Um validador que reprovasse aqui transformaria uma
-    // dependência opcional em pré-requisito.
+    // Sem grafo segue em frente: reprovar faria de uma dependência opcional um pré-requisito.
     result._skipReason = 'sem grafo de codebase — `morph-spec graph build` habilita esta verificação';
-    // "Could not check", unlike "nothing to check": verify reports it aloud.
+    // "Não pude checar", diferente de "nada a checar": o verify relata em voz alta.
     result._skipUnavailable = true;
     return result;
   }

package/src/lib/validators/reuse/symbol-scanner.js

@@ -1,74 +1,32 @@
-/**
- * Extração determinística de declarações de tipo a partir do TEXTO do arquivo.
- *
- * Por que não ler as declarações do grafo: o grafo só é reconstruído depois de
- * um commit (o refresh em background de framework/hooks/shared/graph-refresh.js),
- * então o código que acabou de ser escrito — o caso que este validador existe
- * para pegar — ainda NÃO está nele. O grafo responde "o que já existia"; o
- * disco responde "o que esta feature acabou de declarar". Inverter os dois
- * papéis produziria um validador cego justamente na janela em que ele precisa
- * morder — ver graph-loader.js `getFreshness`.
- *
- * A varredura é por linha, com regex ancorada no início da declaração: uma
- * declaração citada dentro de uma string ou de um comentário de bloco pode
- * passar. O custo de errar é um aviso a mais, nunca um bloqueio silencioso.
- *
- * @module reuse-symbol-scanner
- */
+// Lê declarações do disco, não do grafo: o grafo só é refeito depois de um commit,
+// então o código recém-escrito (o que este validador existe para pegar) ainda não está nele.
 
 import { isTestPath, languageOf } from '../../graph/sanitize.js';
 import { isProjectSource } from '../../../../framework/hooks/shared/source-files.js';
 
-/**
- * Nomes que a convenção usa como tipo LOCAL de arquivo, não como conceito do
- * domínio. Todo componente React declara o seu `Props`; dois arquivos com
- * `interface Props` não são o mesmo conceito escrito duas vezes — são dois
- * conceitos diferentes com o nome que a convenção manda usar.
- *
- * A lista é curta de propósito e só admite nome genérico de UMA palavra: assim
- * que há qualificador de domínio (`BuildingFiltersProps`, `FilterOption`) o
- * nome volta a ser um conceito e a regra vale.
- */
+// Tipo LOCAL de arquivo por convenção (todo componente tem seu `Props`), não conceito do
+// domínio. Só nome genérico de UMA palavra: com qualificador (`FilterOption`) a regra vale.
 const IDIOMATIC_LOCAL_NAMES = new Set([
   'props', 'state', 'row', 'item', 'column', 'context', 'params', 'options',
 ]);
 
-/** Declaração de tipo em C#. `partial` é capturado para ser excluído depois. */
 const CSHARP_DECL =
   /^\s*(?:\[[^\]]*\]\s*)*(?:(?:public|internal|private|protected|sealed|abstract|static|readonly|new|file|partial)\s+)*(class|record|interface|enum|struct)\s+([A-Za-z_]\w*)/;
 
-/** Declaração de tipo em TS/JS. */
 const WEB_DECL =
   /^\s*(?:export\s+(?:default\s+)?)?(?:declare\s+)?(?:abstract\s+)?(interface|type|class|enum)\s+([A-Za-z_$][\w$]*)/;
 
-/** Linha que é claramente comentário — não vale a pena parsear. */
 const COMMENT_LINE = /^\s*(?:\/\/|\/\*|\*|<!--)/;
 
-/**
- * @param {string} sourceFile
- * @returns {boolean} arquivo de teste, pelo mesmo predicado do grafo
- */
 export function isTestFile(sourceFile) {
   return isTestPath(String(sourceFile || '').replace(/\\/g, '/'));
 }
 
-/**
- * @param {string} sourceFile
- * @returns {boolean} o arquivo entra na varredura de reuso
- */
 export function isScannableFile(sourceFile) {
   return isProjectSource(sourceFile) && !isTestFile(sourceFile);
 }
 
-/**
- * "Feature" de um path, com a mesma heurística do baseline
- * (docs/specs/code-reuse-gap/measure-duplication.mjs): o segmento após
- * `features/`/`Features/` quando existe, senão a pasta do arquivo. É o que
- * separa o achado indefensável (mesma feature) do aviso tolerado por VSA.
- *
- * @param {string} sourceFile
- * @returns {string}
- */
+/** Segmento após `features/`/`Features/`, senão a pasta do arquivo. */
 export function featureOf(sourceFile) {
   const f = String(sourceFile || '').replace(/\\/g, '/');
   const m = /(?:^|\/)(?:features|Features)\/([^/]+)/.exec(f);
@@ -76,25 +34,11 @@ export function featureOf(sourceFile) {
   return f.split('/').slice(0, -1).join('/').toLowerCase();
 }
 
-/**
- * @param {string} name
- * @returns {boolean} nome genérico que a convenção usa como tipo local
- */
 export function isIdiomaticLocalName(name) {
   return IDIOMATIC_LOCAL_NAMES.has(String(name).toLowerCase());
 }
 
-/**
- * Declarações de tipo de um arquivo.
- *
- * `partial` (C#) é reconhecido e DESCARTADO: declarar a mesma classe em dois
- * arquivos é o propósito da palavra-chave, e sinalizá-la seria um falso
- * positivo garantido em qualquer projeto .NET com código gerado.
- *
- * @param {string} content - conteúdo do arquivo
- * @param {string} sourceFile - path, usado só para decidir a linguagem
- * @returns {Array<{name: string, kind: string, line: number}>}
- */
+// `partial` (C#) é descartado: declarar a mesma classe em dois arquivos é o propósito da palavra-chave.
 export function scanDeclarations(content, sourceFile) {
   const language = languageOf(sourceFile);
   const re = language === 'dotnet' ? CSHARP_DECL : WEB_DECL;

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

@@ -1,89 +1,31 @@
-/**
- * traceability-check.js — advisory, feature-scope-only check: do the files
- * cited in recap.md's "**Files:**" bullet lists have an owning task in
- * tasks.json's `outputs`?
- *
- * This is the DETERMINISTIC half of a two-layer fix. The NLH half lives in
- * `framework/skills/core/morph-implement/SKILL.md` §7 ("outputs DEVE listar
- * TODO arquivo criado ou modificado pela task") and targets the root cause: a
- * file shipped without EVER being declared anywhere (not in outputs, not in
- * recap.md — the real-world case that motivated this module, see the finding
- * below). This module cannot catch THAT class of drift — a file absent from
- * both documents is invisible to a check that only compares the two documents
- * against each other. What it DOES catch is a narrower, complementary class:
- * recap.md and tasks.json DISAGREEING — an author cited a file in the recap's
- * prose but forgot (or a later task re-touched it without) declaring it in any
- * task's `outputs`. That disagreement is real signal even though it is not the
- * same defect the SKILL.md rule targets.
- *
- * Motivating evidence: run 2026-08-12T133732Z-vet-visit-followup-reminder —
- * `ApplicationDbContextFactory.cs` shipped in production with no owning task
- * in `outputs` AND no mention in recap.md (out of this module's reach by
- * construction). Separately, `src/VetClinic.Api/appsettings.json` and
- * `Properties/launchSettings.json` WERE cited in T1's recap `**Files:**` list
- * but never appear in any task's `outputs` — exactly the disagreement this
- * module flags.
- *
- * Advisory, never blocking: the returned `status` is only ever 'pass' | 'warn'
- * | 'skip' — never 'fail'. `runVerify()` keeps this result OUTSIDE `nodes` on
- * purpose so it can never flip the overall build/tests/validators/e2e status
- * computed from `nodes` alone (see verify-runner.js).
- *
- * Fail-open throughout: no recap.md, no tasks.json, or a parse error all
- * degrade to `{ status: 'skip' }` rather than throwing or warning about the
- * absence itself — this is rastreabilidade tooling, not a completeness gate.
- *
- * @module traceability-check
- */
+// 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 { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { join } from 'path';
+import { readPlanChecks } from '../plan/checks.js';
+import { sliceProgress, sliceReportPath } from '../../../framework/hooks/shared/slice-progress.js';
 
-/** Matches a `**Files:**` marker followed by one or more `- ` bullet lines. */
-const FILES_BLOCK_RE = /\*\*Files:\*\*[ \t]*\r?\n((?:^[ \t]*-[ \t].*\r?\n?)+)/gm;
+const FILES_BLOCK_RE = /\*\*Arquivos:\*\*([^\r\n]*)\r?\n?((?:^[ \t]*-[ \t].*\r?\n?)*)/gm;
 
-/** Backtick-quoted spans within a bullet line. */
 const BACKTICK_RE = /`([^`]+)`/g;
 
-/**
- * Extract the set of file paths cited under every "**Files:**" block in a
- * recap.md's text, applying a conservative decomposition of the natural
- * language shorthand real recaps use:
- *
- *   - A line with exactly one backtick span: that span is a candidate,
- *     whether or not it contains a `/` (a legitimate top-level file, e.g.
- *     `` `VetClinic.sln` ``, has no slash).
- *   - A line with multiple comma-separated backtick spans (e.g.
- *     `` `a/b.json`, `c.json`, `d/e.json` ``): only the FIRST span and any
- *     LATER span that itself contains `/` are candidates. A later span with
- *     no `/` is ambiguous shorthand (a bare filename implicitly relative to
- *     the first span's directory, or a suffix like `` `.Designer.cs` ``) and
- *     is skipped rather than guessed — false negatives are the acceptable
- *     failure mode for advisory tooling, false positives are not.
- *   - Any span containing `{`/`}` (brace-expansion shorthand, e.g.
- *     `` `Foo/{A,B,C}.cs` ``) is skipped entirely — decomposing it correctly
- *     would require guessing at delimiters this format doesn't standardize.
- *   - Any span ending in `/` is a directory reference, not a file — skipped.
- *
- * @param {string} recapText
- * @returns {string[]} de-duplicated, normalized (forward-slash) candidate paths
- */
-export function extractCitedFiles(recapText) {
+// 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 (!recapText) return [];
+  if (!reportText) return [];
 
   FILES_BLOCK_RE.lastIndex = 0;
   let blockMatch;
-  while ((blockMatch = FILES_BLOCK_RE.exec(recapText)) !== null) {
-    const block = blockMatch[1];
-    const lines = block.split(/\r?\n/).filter((l) => /^[ \t]*-[ \t]/.test(l));
-
-    for (const line of lines) {
+  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; // ambiguous shorthand continuation
-        if (span.includes('{') || span.includes('}')) return; // brace-expansion, too ambiguous to decompose
-        if (span.endsWith('/')) return; // directory reference, not a file
+        if (idx > 0 && !span.includes('/')) return;
+        if (span.includes('{') || span.includes('}')) return;
+        if (span.endsWith('/')) return;
         cited.add(normalizePath(span));
       });
     }
@@ -92,114 +34,70 @@ export function extractCitedFiles(recapText) {
   return [...cited];
 }
 
-/**
- * Backslashes to forward slashes, strip a leading `./`.
- *
- * Exported because `src/lib/tasks/test-scope.js` normalises the SAME thing —
- * a task's `outputs` entry — before deciding which tests a task-scoped verify
- * runs. One normaliser for `outputs`, so the traceability check and the test
- * recorte never disagree about which file a task delivered.
- */
 export function normalizePath(p) {
   return String(p).replace(/\\/g, '/').replace(/^\.\//, '');
 }
 
-/**
- * Union of `outputs` across every `done` task in tasks.json, normalized.
- *
- * @param {string} projectPath
- * @param {string} featureName
- * @returns {string[]|null} null when tasks.json is missing/unreadable/invalid
- *   (the caller treats null as "cannot judge coverage" and skips, not warns)
- */
-export function collectDoneOutputs(projectPath, featureName) {
-  let tasksPath;
-  try {
-    tasksPath = getAbsoluteOutputPath(projectPath, featureName, 'tasks');
-  } catch {
-    return null;
-  }
-  if (!existsSync(tasksPath)) return null;
-
-  let data;
-  try {
-    data = JSON.parse(readFileSync(tasksPath, 'utf8'));
-  } catch {
-    return null;
-  }
-
-  const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
-  const outputs = [];
-  for (const task of tasks) {
-    if (task?.status !== 'done') continue;
-    for (const output of task.outputs || []) {
-      if (typeof output === 'string' && output.trim()) outputs.push(normalizePath(output));
-    }
-  }
-  return outputs;
+/** 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));
 }
 
-/**
- * A cited file is covered if some done task's `outputs` names it exactly, or
- * names a directory (an entry ending in `/`) that the cited file falls under.
- *
- * @param {string} file
- * @param {string[]} outputs
- * @returns {boolean}
- */
-function isCovered(file, outputs) {
-  for (const output of outputs) {
-    if (output === file) return true;
-    if (output.endsWith('/') && file.startsWith(output)) return true;
+function isCovered(file, declared) {
+  for (const entry of declared) {
+    if (entry === file) return true;
+    if (entry.endsWith('/') && file.startsWith(entry)) return true;
   }
   return false;
 }
 
-/**
- * Run the recap-vs-outputs traceability check for a feature.
- *
- * @param {string} projectPath
- * @param {string} featureName
- * @returns {{ status: 'pass'|'warn'|'skip', warnings: string[], reason: string|null, citedCount: number }}
- */
-export function checkOutputsTraceability(projectPath, featureName) {
-  let recapPath;
+function readOrNull(path) {
   try {
-    recapPath = getAbsoluteOutputPath(projectPath, featureName, 'recap');
+    return existsSync(path) ? readFileSync(path, 'utf8') : null;
   } catch {
-    return { status: 'skip', warnings: [], reason: 'unknown feature', citedCount: 0 };
+    return null;
   }
+}
 
-  if (!existsSync(recapPath)) {
-    return { status: 'skip', warnings: [], reason: 'no recap.md', citedCount: 0 };
+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 };
   }
 
-  let recapText;
-  try {
-    recapText = readFileSync(recapPath, 'utf8');
-  } catch {
-    return { status: 'skip', warnings: [], reason: 'recap.md unreadable', 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);
+    }
   }
-
-  const cited = extractCitedFiles(recapText);
-  if (cited.length === 0) {
-    return { status: 'skip', warnings: [], reason: 'no Files: entries found in recap.md', citedCount: 0 };
+  if (citedBy.size === 0) {
+    return { status: 'skip', warnings: [], reason: 'no Arquivos: entries found in the slice reports', citedCount: 0 };
   }
 
-  const outputs = collectDoneOutputs(projectPath, featureName);
-  if (outputs === null) {
-    return { status: 'skip', warnings: [], reason: 'no tasks.json', citedCount: cited.length };
+  const declared = collectSliceFiles(projectPath, featureName);
+  if (declared === null) {
+    return { status: 'skip', warnings: [], reason: 'no checks.json', citedCount: citedBy.size };
   }
 
-  const warnings = cited
-    .filter((file) => !isCovered(file, outputs))
+  const warnings = [...citedBy.keys()]
+    .filter((file) => !isCovered(file, declared))
     .sort()
-    .map((file) => `${file} — cited in recap.md but not listed in any done task's outputs`);
+    .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: cited.length,
+    citedCount: citedBy.size,
   };
 }