@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/src/lib/validators/contracts/contract-compliance-validator.js

@@ -9,13 +9,13 @@ export async function validateContracts(projectPath, featureName, options = {})
 
   const skipped = (message) => ({ status: 'ok', errors: 0, warnings: 0, issues: [], coverage: null, message });
 
-  if (!existsSync(contractsPath)) return skipped('No spec.md found — skipping');
+  if (!existsSync(contractsPath)) return skipped('No plan.md found — skipping');
 
   const contractsContent = readFileSync(contractsPath, 'utf-8');
   const contracts = parseContracts(contractsContent);
 
   if (contracts.interfaces.length === 0 && contracts.records.length === 0 && contracts.enums.length === 0) {
-    return skipped('spec.md declares no interfaces/records/enums — skipping');
+    return skipped('plan.md declares no interfaces/records/enums — skipping');
   }
 
   // Find all .cs files in the project (excluding .morph outputs, bin, obj)

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

@@ -3,11 +3,11 @@
  *
  * A terceira camada do ciclo de reuso:
  *
- *   PROSA (morph-plan, personas)  ──►  ARTEFATO (`reuse` em tasks.json)
+ *   PROSA (morph-plan, personas)  ──►  ARTEFATO (seção de reuso do plano)
  *   ──►  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
+ * Prosa sozinha não segura — a skill de planejamento já mandava 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:
@@ -19,9 +19,9 @@
  *      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.
+ *   4. Veredito `CRIAR` declarado na tabela de reuso do plano rebaixa o
+ *      achado a aviso: a decisão foi tomada no gate do plano, 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).
  *
@@ -34,13 +34,13 @@ 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;
@@ -154,7 +154,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.`,
     });
@@ -167,9 +167,7 @@ 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.
+ * Vereditos de reuso do plano: a tabela `## Reuso` que o plan-check extraiu.
  *
  * @param {string} projectPath
  * @param {string} featureName
@@ -178,24 +176,13 @@ export function findDuplicateSymbols(declarations, existing, opts = {}) {
 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;
 }
@@ -204,9 +191,8 @@ export function readReuseVerdicts(projectPath, featureName) {
  * 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.
+ * enxerga: os `arquivos:` das fatias são o contrato do plano e sobrevivem ao
+ * commit; `git status` pega o que o plano não previu. Sem git, sem drama.
  *
  * @param {string} projectPath
  * @param {string} featureName
@@ -214,19 +200,10 @@ export function readReuseVerdicts(projectPath, featureName) {
  */
 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 {
@@ -247,7 +224,7 @@ export function collectChangedFiles(projectPath, featureName) {
       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];

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

@@ -1,89 +1,69 @@
 /**
  * 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`?
+ * cited under `**Arquivos:**` in the slice reports (`3-implement/reports/F{n}.md`)
+ * belong to some slice of the plan (its `arquivos:`, as extracted by plan-check)?
  *
- * 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.
+ * It catches the reports and the plan DISAGREEING: a file the implementation
+ * says it touched that no slice declared. A file absent from both documents
+ * is invisible to it by construction — that drift is the reuse/contract
+ * reviewer's job.
  *
- * 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: `status` is only ever 'pass' | 'warn' | 'skip'.
+ * `runVerify()` keeps this result OUTSIDE `nodes` so it can never flip the
+ * overall build/tests/validators/e2e status.
  *
- * 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.
+ * Fail-open throughout: no slice report, no extracted plan or a parse error
+ * all degrade to `{ status: 'skip' }`.
  *
  * @module traceability-check
  */
 
 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;
+/**
+ * An `**Arquivos:**` marker and what follows it: the rest of its own line
+ * (inline list) plus any `- ` bullet lines right below.
+ */
+const FILES_BLOCK_RE = /\*\*Arquivos:\*\*([^\r\n]*)\r?\n?((?:^[ \t]*-[ \t].*\r?\n?)*)/gm;
 
-/** Backtick-quoted spans within a bullet line. */
+/** Backtick-quoted spans within a 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:
+ * Extract the set of file paths cited under every `**Arquivos:**` marker of a
+ * slice report, applying a conservative decomposition of the shorthand real
+ * reports 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
+ *     whether or not it contains a `/`.
+ *   - A line with several comma-separated spans: 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.
+ *     no `/` is ambiguous shorthand and is skipped rather than guessed —
+ *     false negatives are acceptable for advisory tooling, false positives
+ *     are not.
+ *   - Any span containing `{`/`}` (brace expansion) is skipped.
  *   - Any span ending in `/` is a directory reference, not a file — skipped.
  *
- * @param {string} recapText
+ * @param {string} reportText
  * @returns {string[]} de-duplicated, normalized (forward-slash) candidate paths
  */
-export function extractCitedFiles(recapText) {
+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 +72,90 @@ 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.
- */
+/** Backslashes to forward slashes, strip a leading `./`. */
 export function normalizePath(p) {
   return String(p).replace(/\\/g, '/').replace(/^\.\//, '');
 }
 
 /**
- * Union of `outputs` across every `done` task in tasks.json, normalized.
+ * Union of the `arquivos:` of every slice of the plan, 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)
+ * @returns {string[]|null} null when the plan has no readable extraction
  */
-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;
+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.
+ * A cited file is covered if some slice names it exactly, or names a
+ * directory (an entry ending in `/`) that the cited file falls under.
  *
  * @param {string} file
- * @param {string[]} outputs
+ * @param {string[]} declared
  * @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;
 }
 
+function readOrNull(path) {
+  try {
+    return existsSync(path) ? readFileSync(path, 'utf8') : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
- * Run the recap-vs-outputs traceability check for a feature.
+ * Run the reports-vs-slices 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;
-  try {
-    recapPath = getAbsoluteOutputPath(projectPath, featureName, 'recap');
-  } catch {
-    return { status: 'skip', warnings: [], reason: 'unknown feature', citedCount: 0 };
-  }
-
-  if (!existsSync(recapPath)) {
-    return { status: 'skip', warnings: [], reason: 'no recap.md', citedCount: 0 };
+  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,
   };
 }