@polymorphism-tech/morph-spec 9.7.0 → 9.8.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/heavy/gate.js

@@ -1,7 +1,7 @@
 import { minFreeMemFor, readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 import { heavyClass } from '../../../framework/hooks/shared/heavy-command.js';
 import {
-  acquireHeavy, awaitFreeMemory, describeBusy, heavyDir, releaseHeavy, updateLease,
+  acquireHeavy, awaitFreeMemory, describeBusy, enterVerifySuite, heavyDir, isVerifySuite, releaseHeavy, updateLease,
 } from '../../../framework/hooks/shared/heavy-slots.js';
 
 export class HeavyBusyError extends Error {
@@ -33,6 +33,7 @@ export function createHeavyGate({
   let lease = null;
   let admittedGb = 0;
   let waitedMs = 0;
+  let suiteEntered = false;
   let exitHandler = null;
   let saved = null;
 
@@ -52,6 +53,7 @@ export function createHeavyGate({
     lease = null;
     restoreEnv();
     entered = false;
+    suiteEntered = false;
   };
 
   const raiseFloor = (kind) => {
@@ -65,12 +67,29 @@ export function createHeavyGate({
     admittedGb = floor;
   };
 
+  const awaitSuite = () => {
+    const result = enterVerifySuite({
+      dir: heavyDir(env),
+      lease,
+      slots: config.slots,
+      waitTimeoutMs: config.waitTimeoutSec * 1000,
+      maxHoldMs: config.maxHoldMinutes * 60_000,
+      log,
+      ...deps,
+    });
+    if (result.status === 'busy') throw new HeavyBusyError(result, config);
+    waitedMs += result.waitedMs;
+    suiteEntered = true;
+  };
+
   return {
     config,
     get waitedMs() { return waitedMs; },
 
     enter(node, kind = heavyClass(node)) {
+      const suite = isVerifySuite({ label, node });
       if (entered) {
+        if (suite && lease && !suiteEntered) awaitSuite();
         raiseFloor(kind);
         updateLease(lease, { node });
         return;
@@ -86,6 +105,7 @@ export function createHeavyGate({
           feature,
           node,
           kind,
+          suite,
           cwd: projectPath,
           minFreeMemGb,
           waitTimeoutMs: config.waitTimeoutSec * 1000,
@@ -96,6 +116,7 @@ export function createHeavyGate({
         });
         if (result.status === 'busy') throw new HeavyBusyError(result, config);
         lease = result.lease;
+        suiteEntered = suite;
         admittedGb = minFreeMemGb;
         waitedMs = result.waitedMs;
       }

package/src/lib/review-reports.js

@@ -53,8 +53,10 @@ const cleanId = (s) => String(s ?? '').replace(/[*`_]/g, '').trim().toUpperCase(
 
 const isSeparator = (cells) => cells.every((c) => /^:?-{2,}:?$/.test(c) || c === '');
 
-// A headed table counts only when its header names the `tipo` column: a status table a
-// confirmation lists under "Nenhum." is not a blocker table.
+// A status table a confirmation lists under "Nenhum." is skipped; any other header off the
+// contract still counts, so its rows land in `untyped` and pause the gate.
+const isStatusHeader = (header) => /^(situacao|status)$/.test(normalize(header[1]));
+
 function tableRows(body, keepHeader = () => true) {
   const rows = [];
   let skipping = false;
@@ -77,7 +79,7 @@ function tableRows(body, keepHeader = () => true) {
 function parseBlockers(body) {
   const blockers = [];
   const untyped = [];
-  for (const cells of tableRows(body, (header) => /^tipo$/i.test(header[1] ?? ''))) {
+  for (const cells of tableRows(body, (header) => !isStatusHeader(header))) {
     const row = { id: cleanId(cells[0]), type: normalize(cells[1]), where: cells[2] ?? '', evidence: cells[3] ?? '' };
     (BLOCKER_TYPES.includes(row.type) ? blockers : untyped).push(row);
   }

package/src/lib/tasks/test-nodes.js

@@ -9,6 +9,14 @@ import { PACKAGE_LOCATIONS } from '../detectors/index.js';
 /** `none` yields an UNKNOWN count, never a fabricated zero. */
 export const TEST_RUNNERS = ['dotnet', 'vitest', 'jest', 'node-test', 'playwright', 'none', EVAL_RUNNER];
 
+// A count is a baseline only where it stays still: dotnet/vitest/jest/playwright grow every
+// slice, so their baseline only warned or blocked a deliberate deletion.
+const BASELINE_RUNNERS = ['node-test', EVAL_RUNNER];
+
+export function keepsBaseline(runner) {
+  return BASELINE_RUNNERS.includes(runner);
+}
+
 export const TEST_NODE_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 
 const FALLBACK_NODE_ID = 'default';
@@ -67,12 +75,13 @@ export function inferRunner(command) {
 }
 
 function makeNode(partial) {
+  const runner = partial.runner ?? inferRunner(partial.command);
   return {
     id: partial.id,
     command: partial.command ?? null,
     cwd: partial.cwd ?? '.',
-    runner: partial.runner ?? inferRunner(partial.command),
-    expectedCount: partial.expectedCount ?? null,
+    runner,
+    expectedCount: keepsBaseline(runner) ? partial.expectedCount ?? null : null,
     timeoutMs: partial.timeoutMs ?? null,
     build: partial.build ?? [],
     e2e: partial.e2e ?? false,
@@ -329,11 +338,11 @@ export function morphConfigPath(projectPath = '.') {
  * Refuses a non-integer count (null is UNKNOWN, never 0), an undeclared id, or a
  * declared node with no measurement. Every other config key survives.
  * @param {Array<{id: string, count: number|null}>} measurements
- * @returns {{ recorded: boolean, reason: string|null, updates: Array<{id: string, from: number|null, to: number}>, path: string }}
+ * @returns {{ recorded: boolean, reason: string|null, updates: Array<{id: string, from: number|null, to: number}>, removed: string[], path: string }}
  */
 export function recordTestBaselines(projectPath, measurements) {
   const path = morphConfigPath(projectPath);
-  const refuse = (reason) => ({ recorded: false, reason, updates: [], path });
+  const refuse = (reason) => ({ recorded: false, reason, updates: [], removed: [], path });
 
   if (!existsSync(path)) return refuse('não existe .morph/config/config.json — não há onde gravar');
 
@@ -349,7 +358,10 @@ export function recordTestBaselines(projectPath, measurements) {
     return refuse('config.json não declara project.tests[] — não há entrada onde gravar a baseline');
   }
 
-  const unreadable = measurements.filter((m) => !Number.isInteger(m.count)).map((m) => m.id);
+  const runnerOf = new Map(declared.filter(isPlainObject).map((e) => [e.id, e.runner ?? inferRunner(e.command)]));
+  const unreadable = measurements
+    .filter((m) => keepsBaseline(runnerOf.get(m.id)) && !Number.isInteger(m.count))
+    .map((m) => m.id);
   if (unreadable.length > 0) {
     return refuse(`contagem desconhecida em: ${unreadable.join(', ')} — desconhecido nunca vira 0`);
   }
@@ -370,8 +382,14 @@ export function recordTestBaselines(projectPath, measurements) {
   }
 
   const updates = [];
+  const removed = [];
   for (const entry of declared) {
     if (!entry || !byId.has(entry.id)) continue;
+    if (!keepsBaseline(runnerOf.get(entry.id))) {
+      if ('expectedCount' in entry) removed.push(entry.id);
+      delete entry.expectedCount;
+      continue;
+    }
     const to = byId.get(entry.id);
     updates.push({
       id: entry.id,
@@ -382,5 +400,5 @@ export function recordTestBaselines(projectPath, measurements) {
   }
 
   atomicWriteJson(path, config);
-  return { recorded: true, reason: null, updates, path };
+  return { recorded: true, reason: null, updates, removed, path };
 }

package/src/lib/tasks/test-runner.js

@@ -8,7 +8,7 @@ import { getBuildSteps } from '../../../framework/hooks/shared/build-check.js';
 import { CONFIG_FILE_NAME } from '../../core/state/state-manager.js';
 
 // Per chained project: a fixed cap timed a long `a && b` chain out for being long, not broken.
-export const DEFAULT_TEST_TIMEOUT_PER_PROJECT = 120_000;
+export const DEFAULT_TEST_TIMEOUT_PER_PROJECT = 1_800_000;
 const TEST_OUTPUT_MAX_BUFFER = 256 * 1024 * 1024;
 
 /**
@@ -424,6 +424,45 @@ export function parseTestCount(output, runner) {
   return extractor(stripAnsi(output));
 }
 
+const FAILURE_LINES_MAX = 10;
+const TAP_NOT_OK = /^(\s*)not ok \d+ - (.+?)\s*$/;
+const TAP_DIRECTIVE = /\s#\s*(?:TODO|SKIP)\b/i;
+const VITEST_FAIL = /^\s*FAIL\s+(.+?)\s*$/;
+const VITEST_CROSS = /^\s*[×✗]\s+(.+?)(?:\s+\d+(?:\.\d+)?\s*m?s)?\s*$/;
+// The duration suffix is required: it separates a test line from the summary's `failed: 1` / `Failed!`.
+const DOTNET_FAILED = /^\s*(?:failed|com falha)\s+(\S.*?)\s*(?:\[[^\]]*\]|\([^)]*\))\s*$/i;
+
+function tapLeafFailures(lines) {
+  const seen = [];
+  for (const line of lines) {
+    const match = TAP_NOT_OK.exec(line);
+    if (!match || TAP_DIRECTIVE.test(match[2])) continue;
+    const depth = match[1].length;
+    // TAP prints a subtest's result before its parent's: deeper unclaimed entries above are its children.
+    const children = seen.filter((e) => !e.claimed && e.depth > depth);
+    for (const child of children) child.claimed = true;
+    seen.push({ depth, name: match[2], leaf: children.length === 0, claimed: false });
+  }
+  return seen.filter((e) => e.leaf).map((e) => e.name);
+}
+
+function captures(lines, pattern) {
+  return lines.map((line) => pattern.exec(line)?.[1]).filter(Boolean);
+}
+
+/** Failed test names anywhere in the output (TAP leaves, vitest, dotnet), deduplicated, at most 10; [] when no form matches. */
+export function failureLines(output) {
+  if (typeof output !== 'string' || !output) return [];
+  const lines = stripAnsi(output).split(/\r?\n/);
+  const vitestFiles = captures(lines, VITEST_FAIL);
+  const names = [
+    ...tapLeafFailures(lines),
+    ...(vitestFiles.length > 0 ? vitestFiles : captures(lines, VITEST_CROSS)),
+    ...captures(lines, DOTNET_FAILED),
+  ];
+  return [...new Set(names)].slice(0, FAILURE_LINES_MAX);
+}
+
 /**
  * Asymmetric on purpose: only a drop fails (non-null `reason`); a rise only warns,
  * or every new test would redden the gate and teach deleting tests.

package/src/lib/validators/verify-runner.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'child_process';
-import { existsSync, readFileSync, rmSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 
 import { runBuildCheck, getBuildSteps, isDotnetStack } from '../../../framework/hooks/shared/build-check.js';
@@ -9,7 +9,7 @@ import { composeProjectName, runE2eCheck } from '../../../framework/hooks/shared
 import { buildComposeEnv } from '../e2e/compose-env.js';
 import { e2eApplicability } from '../e2e/applicability.js';
 import {
-  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, discoverDotnetSolution,
+  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, discoverDotnetSolution, failureLines,
 } from '../tasks/test-runner.js';
 import {
   resolveTestNodes, parseTestFilter, nodeMatchesFilter, recordTestBaselines, morphConfigPath,
@@ -24,8 +24,7 @@ import { runValidation } from './validation-runner.js';
 import { checkOutputsTraceability } from './traceability-check.js';
 import { createHeavyGate } from '../heavy/gate.js';
 
-// A cold dotnet build takes minutes, not seconds.
-const DEFAULT_BUILD_TIMEOUT = 120_000;
+const DEFAULT_BUILD_TIMEOUT = 1_800_000;
 
 const VALIDATOR_FEEDBACK_LIMIT = 10;
 
@@ -364,7 +363,8 @@ async function runNodesInLinux({
       // No exit code is NOT a pass: the container died before this node reported.
       ? { passed: false, output: raw.output || '', reason: raw.reason, exitCode: null }
       : { passed: raw.exitCode === 0, output: raw.output || '', exitCode: raw.exitCode };
-    return judgeRun({ node, result, durationMs: raw.durationMs ?? 0 });
+    const logPath = writeFailedRunLog(projectPath, node, result);
+    return judgeRun({ node, result, durationMs: raw.durationMs ?? 0, logPath });
   });
 
   return { runs, environment: suite.environment };
@@ -389,7 +389,9 @@ async function runOneTestNode({
   const result = await _runTestSuite(projectPath, {
     timeout, node, ...(childEnv ? { env: childEnv } : {}),
   });
-  const entry = judgeRun({ node, result, durationMs: Date.now() - start });
+  const durationMs = Date.now() - start;
+  const logPath = writeFailedRunLog(projectPath, node, result);
+  const entry = judgeRun({ node, result, durationMs, logPath });
   if (!evalChannel) return entry;
 
   const judged = judgeEvalRun(entry, node, evalChannel.summaryPath);
@@ -397,6 +399,19 @@ async function runOneTestNode({
   return judged;
 }
 
+// Fail-open: a log that cannot be written must not change the verdict.
+function writeFailedRunLog(projectPath, node, result) {
+  if (result.passed || result.skipped || !result.output) return null;
+  const relPath = `.morph/logs/verify-tests-${String(node.id).replace(/[^\w.-]/g, '_')}.log`;
+  try {
+    mkdirSync(join(projectPath, '.morph', 'logs'), { recursive: true });
+    writeFileSync(join(projectPath, relPath), result.output);
+    return relPath;
+  } catch {
+    return null;
+  }
+}
+
 function discardFile(path) {
   try { rmSync(path, { force: true }); } catch { /* the next run removes it first */ }
 }
@@ -476,13 +491,15 @@ function preDecideRun({ node, filter, projectPath = '.', refreshCache = false })
 }
 
 // The single count rule for host and container runs; a second copy makes them disagree.
-function judgeRun({ node, result, durationMs }) {
+function judgeRun({ node, result, durationMs, logPath = null }) {
   const entry = emptyRunEntry(node);
 
   if (result.skipped) {
     return { ...entry, durationMs, reason: result.reason || 'no test command detected' };
   }
 
+  const logLine = logPath ? [`log completo: ${logPath}`] : [];
+
   // A truncated log tail reads like a passing run cut mid-sentence: lead with the timeout.
   if (result.timedOut) {
     const tail = tailLines(result.output, OUTPUT_TAIL_LINES);
@@ -492,7 +509,7 @@ function judgeRun({ node, result, durationMs }) {
       durationMs,
       timedOut: true,
       reason: result.message,
-      output: tail ? `${result.message}\n${tail}` : result.message,
+      output: [result.message, ...logLine, tail].filter(Boolean).join('\n'),
     };
   }
 
@@ -511,18 +528,39 @@ function judgeRun({ node, result, durationMs }) {
   }
   if (verdict.verdict === 'drop') warnings.push(verdict.reason);
 
+  // Without a baseline, zero is the floor: a green run over no test is a suite that stopped running.
+  if (result.passed && count === 0 && node.runner !== EVAL_RUNNER && !Number.isInteger(node.expectedCount)) {
+    return { ...entry, status: 'fail', durationMs, count, warnings, reason: 'suíte verde sem nenhum teste executado', output: '' };
+  }
+
+  if (result.passed) {
+    return { ...entry, status: 'pass', durationMs, count, warnings, reason: result.reason ?? null, output: '' };
+  }
+
+  // The failing test sits thousands of lines above a TAP summary, never in the tail.
+  const failed = failureLines(result.output);
   return {
     ...entry,
-    status: result.passed ? 'pass' : 'fail',
+    status: 'fail',
     durationMs,
     count,
     warnings,
     // `test-build-failed` / `stale-binary`: refused before any test ran.
-    reason: result.reason ?? null,
-    output: result.passed ? '' : tailLines(result.output, OUTPUT_TAIL_LINES),
+    reason: result.reason ?? failureSummary(failed),
+    output: [
+      ...failed.map((name) => `falhou: ${name}`),
+      ...logLine,
+      tailLines(result.output, OUTPUT_TAIL_LINES),
+    ].filter(Boolean).join('\n'),
   };
 }
 
+function failureSummary(failed) {
+  if (failed.length === 0) return null;
+  const more = failed.length > 3 ? ` (+${failed.length - 3})` : '';
+  return `falhou: ${failed.slice(0, 3).join('; ')}${more}`;
+}
+
 function acceptRecordedDrops(testsNode) {
   const runs = testsNode.runs.map(({ countDrop, ...run }) => (countDrop ? { ...run, status: 'pass', reason: null } : run));
   return rollUpTestRuns(runs, { command: testsNode.command, source: testsNode.source, environment: testsNode.environment });
@@ -615,7 +653,7 @@ function baselineTargetProblem(projectPath, testPlan, { skipTests }) {
 // exited 0 is the one red it accepts: lowering the number is how deleting tests passes.
 function recordBaselineFrom(projectPath, testsNode) {
   const runs = testsNode.runs || [];
-  const refuse = (reason) => ({ recorded: false, reason, updates: [] });
+  const refuse = (reason) => ({ recorded: false, reason, updates: [], removed: [] });
 
   if (runs.length === 0) return refuse('nenhum nó de teste executou');
 

package/src/utils/agents-installer.js

@@ -284,7 +284,7 @@ export const DISPATCH_CONTRACT = [
     'ANTES de encerrar — é o retorno autoritativo, não a sua mensagem final.',
   '2. ESTADO: NÃO toque em `plan.md`, `checks.json`, `feature.json` nem `state.json`: o estado é do orquestrador.',
   '3. TESTE: a prova é do orquestrador (`morph-spec verify {feature}`, depois do seu retorno), não sua. Escreva os testes pelo orçamento: ' +
-    'um por Cn `prova: teste`, variantes em tabela (`[Theory]`/`it.each`); `leitura` sem teste. NÃO rode teste a cada marco nem faça ciclo red→green: ' +
+    'um por Cn `prova: teste`, na camada mais baixa que o prova (a de cima só para o que só existe lá), variantes em tabela (`[Theory]`/`it.each`); `leitura` sem teste. NÃO rode teste a cada marco nem faça ciclo red→green: ' +
     'escreva código e testes, compile, e rode SÓ o filtro dos seus testes UMA vez, em primeiro plano, antes do relatório ' +
     '(`vitest related <arquivos da fatia> --run`; `dotnet test --filter "FullyQualifiedName~<Classe>" --no-build` após o build); ' +
     'se falhar, corrija e rode só os que falharam. Teto: 3 rodadas (`verify --filter` conta, exit 3 não); ' +