@polymorphism-tech/morph-spec 9.7.0 → 10.0.0

package/src/lib/specs/screen-checklist.js

@@ -5,30 +5,19 @@
 import { createHash } from 'crypto';
 import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { verifierScreenChecklist } from '../review-reports.js';
 import { LEGACY_MOCKUP_EXEMPTION, uiuxChecklistPause } from '../risk-detector.js';
 
-const PACKAGE_AGENTS = fileURLToPath(new URL('../../../framework/agents.json', import.meta.url));
-
 /** `match` roda sobre o rótulo normalizado; um rótulo que casa com vários itens responde a todos. */
 export const SCREEN_CHECKLIST_ITEMS = [
-  { id: 'superficie', label: 'Superfície', match: /\bsuperficie\b/ },
-  { id: 'volume', label: 'Volume esperado', match: /\bvolume\b/ },
-  { id: 'paginacao', label: 'Paginação', match: /\bpaginacao\b/ },
-  { id: 'ordenacao', label: 'Ordenação', match: /\bordenacao\b/ },
-  { id: 'filtro', label: 'Filtro', match: /\bfiltros?\b/ },
-  { id: 'vazio', label: 'Estado vazio', match: /\bvazio\b/ },
-  { id: 'carregando', label: 'Estado carregando', match: /\bcarregando\b|\bcarregamento\b/ },
-  { id: 'erro', label: 'Estado de erro', match: /\berro\b/ },
-  { id: 'mobile', label: 'Mobile', match: /\bmobile\b/ },
-  { id: 'abas', label: 'Abas', match: /\babas\b/ },
+  { id: 'servidor', label: 'Lista no servidor', match: /\bpaginacao\b|\bordenacao\b|\bservidor\b/ },
+  { id: 'estados', label: 'Estados vazio e carregando', match: /\bvazio\b|\bcarregando\b|\bcarregamento\b/ },
+  { id: 'erro', label: 'Erro com próxima ação', match: /\berro\b/ },
+  { id: 'acao', label: 'Uma ação primária', match: /\bprimaria\b/ },
+  { id: 'mobile', label: 'Celular', match: /\bmobile\b|\bcelular\b/ },
 ];
 
-// A superfície decide quais standards a tela lê, não um comportamento que a tela entregue exiba.
-const NOT_VERIFIED_AT_REVIEW = new Set(['superficie']);
-
 // As exatas, e as que começam adiando a decisão ("a definir depois", "TBD.").
 const PLACEHOLDERS = new Set(['', '-', '--', '—', '–', '...', 'x', 'todo', 'definir', 'pendente']);
 const PLACEHOLDER_PREFIX_RE = /^(a definir|tbd|\?|…)/;
@@ -141,30 +130,9 @@ const isNotApplicable = (answer) => NOT_APPLICABLE_RE.test(normalizeLabel(answer
 
 const labelOf = (id) => SCREEN_CHECKLIST_ITEMS.find((item) => item.id === id)?.label ?? id;
 
-// O vocabulário válido de `Superfície`: as `surfaces` da `ui-designer`, da cópia instalada ou do pacote.
-// null quando a persona não declara o campo, e então o valor não é validado.
-export function knownSurfaces(cwd) {
-  const surfaces = readAgentsJson(cwd)?.agents?.['ui-designer']?.surfaces;
-  return surfaces && typeof surfaces === 'object' && !Array.isArray(surfaces) ? Object.keys(surfaces) : null;
-}
-
-/** The project's installed `agents.json`, else the package's; null when unreadable. */
-export function readAgentsJson(cwd) {
-  for (const path of [join(cwd, '.morph', 'framework', 'agents.json'), PACKAGE_AGENTS]) {
-    if (!existsSync(path)) continue;
-    try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
-  }
-  return null;
-}
-
-function namesSurface(answer, surfaces) {
-  const norm = normalizeLabel(answer);
-  return surfaces.some((key) => new RegExp(`(^|[^a-z0-9-])${key}([^a-z0-9-]|$)`).test(norm));
-}
-
 // Sem nenhuma `## Tela:`, só o formato antigo é legado; qualquer outro heading é "nenhuma tela
 // declarada", senão trocar o heading pularia o checklist.
-export function auditScreenChecklist(markdown, { surfaces = null } = {}) {
+export function auditScreenChecklist(markdown) {
   const parsed = parseScreens(markdown);
   const problems = [];
   if (parsed.length === 0) {
@@ -185,18 +153,25 @@ export function auditScreenChecklist(markdown, { surfaces = null } = {}) {
     } else {
       if (missing.length) problems.push(`tela "${screen.name}": falta ${missing.map(labelOf).join(', ')}`);
       if (unanswered.length) problems.push(`tela "${screen.name}": sem resposta em ${unanswered.map(labelOf).join(', ')}`);
-      const surface = screen.answers.get('superficie');
-      if (surfaces?.length && surface !== undefined && !isPlaceholder(surface) && !isNotApplicable(surface)
-          && !namesSurface(surface, surfaces)) {
-        problems.push(`tela "${screen.name}": Superfície "${surface}" não é uma das superfícies da ui-designer (${surfaces.join(', ')})`);
-      }
     }
-    return { name: screen.name, hasChecklist: screen.hasChecklist, missing, unanswered, prototype: screen.prototype };
+    return { name: screen.name, hasChecklist: screen.hasChecklist, missing, unanswered, prototype: screen.prototype, states: statesOf(screen) };
   });
   return { legacy: false, screens, problems };
 }
 
-// Linha **Protótipo:** da tela + o HTML + os prints do laço de autocrítica ao lado dele.
+/** The states the prototype must switch to, by the checklist items that apply to the screen. */
+export const PROTOTYPE_STATES = { estados: ['vazio', 'carregando'], erro: ['erro'] };
+export const STATE_PRINT_WIDTH = 390;
+
+function statesOf(screen) {
+  return Object.entries(PROTOTYPE_STATES).flatMap(([id, states]) => {
+    const answer = screen.answers.get(id);
+    return answer && !isPlaceholder(answer) && !isNotApplicable(answer) ? states : [];
+  });
+}
+
+// Linha **Protótipo:** da tela + o HTML + os prints do laço de autocrítica ao lado dele; cada estado
+// que o checklist diz que se aplica tem `data-estado` no HTML e o print de celular.
 export function auditPrototypes(screens, designDir) {
   const problems = [];
   for (const screen of screens) {
@@ -205,9 +180,19 @@ export function auditPrototypes(screens, designDir) {
       continue;
     }
     const base = screen.prototype.replace(/\.html$/i, '');
-    const expected = [screen.prototype, ...PROTOTYPE_WIDTHS.map((width) => `${base}-${width}.png`)];
+    const states = screen.states ?? [];
+    const expected = [
+      screen.prototype,
+      ...PROTOTYPE_WIDTHS.map((width) => `${base}-${width}.png`),
+      ...states.map((state) => `${base}-${state}-${STATE_PRINT_WIDTH}.png`),
+    ];
     const missing = expected.filter((rel) => !existsSync(join(designDir, rel)));
     if (missing.length) problems.push(`tela "${screen.name}": falta ${missing.map((rel) => `1-design/${rel}`).join(', ')}`);
+    const html = existsSync(join(designDir, screen.prototype)) ? readFileSync(join(designDir, screen.prototype), 'utf8') : '';
+    const unswitchable = html ? states.filter((state) => !new RegExp(`data-estado\\s*=\\s*["']${state}["']`).test(html)) : [];
+    if (unswitchable.length) {
+      problems.push(`tela "${screen.name}": o protótipo não alterna para ${unswitchable.join(', ')} (falta \`data-estado="…"\` no seletor de estado)`);
+    }
   }
   return problems;
 }
@@ -216,7 +201,7 @@ export function auditPrototypes(screens, designDir) {
 export function collectScreenChecklist(cwd, featureName, gateName) {
   const mockups = readMockups(cwd, featureName);
   if (mockups === null) return { mockups: false, legacy: false, screens: [], problems: [] };
-  const audit = auditScreenChecklist(mockups, { surfaces: knownSurfaces(cwd) });
+  const audit = auditScreenChecklist(mockups);
   const signal = { mockups: true, legacy: audit.legacy, screens: audit.screens.map((s) => s.name), problems: audit.problems };
   if (audit.legacy) signal.exempt = LEGACY_MOCKUP_EXEMPTION;
   if (gateName === 'uiux' && !audit.legacy) {
@@ -255,7 +240,7 @@ export function checklistCoverage(designMarkdown, reportSection) {
   for (const screen of parseScreens(designMarkdown)) {
     const done = covered.get(screenKey(screen.name)) ?? new Set();
     const owed = [...screen.answers]
-      .filter(([id, answer]) => !NOT_VERIFIED_AT_REVIEW.has(id) && !isPlaceholder(answer) && !isNotApplicable(answer))
+      .filter(([, answer]) => !isPlaceholder(answer) && !isNotApplicable(answer))
       .map(([id]) => id)
       .filter((id) => !done.has(id));
     if (owed.length) gaps.push(`${screen.name}: ${owed.map(labelOf).join(', ')}`);

package/src/lib/stack/dotnet-build-ignores.js

@@ -1,15 +1,14 @@
-import { readdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { ensureDotnetBuildIgnores } from '../../utils/file-copier.js';
 import { getProjectTags } from '../stack-filter.js';
 import { readMorphConfig } from '../tasks/test-runner.js';
-import { readPlanChecks } from '../plan/checks.js';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
 
-export const DOTNET_IMPLEMENTERS = ['dotnet-senior', 'ef-modeler', 'maf-expert'];
-
 const SKIPPED_DIRS = new Set([...WORKTREE_DIR_NAMES, 'node_modules', 'bin', 'obj']);
 const DOTNET_PROJECT_FILE = /\.(?:csproj|slnx?)$/i;
+const DOTNET_IN_PLAN = /\.(?:cs|csproj|slnx?)\b|\bdotnet\s+(?:test|build|new)\b/i;
 const MAX_DEPTH = 6;
 
 export function hasDotnetProjectFile(root, depth = 0) {
@@ -21,16 +20,16 @@ export function hasDotnetProjectFile(root, depth = 0) {
     && hasDotnetProjectFile(join(root, e.name), depth + 1));
 }
 
-function planHasDotnetSlice(tree, featureName) {
+function planMentionsDotnet(tree, featureName) {
   if (!featureName) return false;
-  const { checks } = readPlanChecks(tree, featureName);
-  return (checks?.slices || []).some((slice) => DOTNET_IMPLEMENTERS.includes(String(slice.persona || '').replace(/^morph-/, '')));
+  const path = getAbsoluteOutputPath(tree, featureName, 'plan');
+  try { return existsSync(path) && DOTNET_IN_PLAN.test(readFileSync(path, 'utf8')); } catch { return false; }
 }
 
-// The plan's slices are checked because a greenfield tree has no stack or .csproj yet.
+// The plan is read because a greenfield tree has no stack or .csproj yet.
 export function isDotnetProject(tree, { featureName, configRoot = tree } = {}) {
   if (getProjectTags(readMorphConfig(configRoot)).includes('dotnet')) return true;
-  return planHasDotnetSlice(tree, featureName) || hasDotnetProjectFile(tree);
+  return planMentionsDotnet(tree, featureName) || hasDotnetProjectFile(tree);
 }
 
 /** Returns the `.gitignore` entries added; `[]` when not .NET or on any error. */

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/telemetry/metrics.js

@@ -95,36 +95,16 @@ function addRun(slot, durationMs) {
 const REVIEW_NAME = /^(?:ver|rev|sec|g3|gate3|eval|review|reviewer|security)\d*-/;
 const isReviewAgent = (type) => REVIEW_AGENT_TYPES.has(type) || type === 'morph-evaluator' || REVIEW_NAME.test(String(type ?? ''));
 
-// Same split as the test-budget hook: review first, then an unfiltered verify, then the round count.
 // A run refused by the full heavy queue ran no test.
 function testOutsideVerify(bashEvents) {
-  const out = {
-    total: newTimeSlot(),
-    subagentVerify: newTimeSlot(),
-    implementerRound3Plus: newTimeSlot(),
-    reviewTests: { ...newTimeSlot(), byPersona: newTimeSlot() },
-  };
-  const byAgent = new Map();
+  const out = { total: newTimeSlot(), reviewTests: { ...newTimeSlot(), byPersona: newTimeSlot() } };
   for (const e of bashEvents) {
     if (e.event === 'PostToolUseFailure' && e.exitCode === QUEUE_FULL_EXIT) continue;
-    const verify = morphVerifyCall(e.command);
-    if (!verify && !testRunKind(e.command)) continue;
+    if (!morphVerifyCall(e.command) && !testRunKind(e.command)) continue;
     addRun(out.total, e.durationMs);
-    if (!e.agentId) continue;
-    if (isReviewAgent(e.agentType)) {
-      addRun(out.reviewTests, e.durationMs);
-      if (REVIEW_AGENT_TYPES.has(e.agentType)) addRun(out.reviewTests.byPersona, e.durationMs);
-      continue;
-    }
-    if (!byAgent.has(e.agentId)) byAgent.set(e.agentId, []);
-    byAgent.get(e.agentId).push({ e, unfilteredVerify: Boolean(verify && !verify.filtered) });
-  }
-  for (const runs of byAgent.values()) {
-    runs.sort((a, b) => String(a.e.ts ?? '').localeCompare(String(b.e.ts ?? '')));
-    runs.forEach(({ e, unfilteredVerify }, round) => {
-      if (unfilteredVerify) addRun(out.subagentVerify, e.durationMs);
-      else if (round >= 2) addRun(out.implementerRound3Plus, e.durationMs);
-    });
+    if (!e.agentId || !isReviewAgent(e.agentType)) continue;
+    addRun(out.reviewTests, e.durationMs);
+    if (REVIEW_AGENT_TYPES.has(e.agentType)) addRun(out.reviewTests.byPersona, e.durationMs);
   }
   return out;
 }
@@ -164,7 +144,7 @@ function reuseStateOf(e) {
   return { state: 'absent', reason: null };
 }
 
-const newGateSlot = () => ({ decisions: 0, paused: 0, autoPassed: 0, approvedAfterPause: 0, reworkedAfterPause: 0, unapproved: 0, bySignal: {} });
+const newGateSlot = () => ({ decisions: 0, paused: 0, pausedForHuman: 0, pausedUnattributed: 0, autoPassed: 0, approvedAfterPause: 0, reworkedAfterPause: 0, unapproved: 0, bySignal: {} });
 
 // A pause stays open until the next approve or a decision that no longer pauses on the same signal:
 // re-running gate-check over the same unchanged pause is not rework.
@@ -173,7 +153,7 @@ function trackGate(gates, open, e) {
   const slot = gates[e.gate] ||= newGateSlot();
   const key = `${e.feature || ''}\u0000${e.gate}`;
   const pending = open.get(key);
-  const bySignal = (signal) => slot.bySignal[signal || 'desconhecido'] ||= { paused: 0, approvedAfterPause: 0, reworkedAfterPause: 0 };
+  const bySignal = (signal) => slot.bySignal[signal || 'desconhecido'] ||= { paused: 0, pausedForHuman: 0, pausedUnattributed: 0, approvedAfterPause: 0, reworkedAfterPause: 0 };
   const credit = (field) => {
     slot[field] += 1;
     bySignal(pending.signal)[field] += 1;
@@ -189,12 +169,30 @@ function trackGate(gates, open, e) {
     return;
   }
   slot.decisions += 1;
-  if (pending && e.pause && e.signal === pending.signal) return;
+  const resolver = e.resolver ?? 'human';
+  if (pending && e.pause && e.signal === pending.signal) {
+    // Same signal, new owner: the session ran out of attempts and the pause escalated to the human.
+    if (pending.resolver === 'session' && resolver === 'human') {
+      slot.pausedForHuman += 1;
+      bySignal(pending.signal).pausedForHuman += 1;
+    }
+    pending.resolver = resolver;
+    return;
+  }
   if (pending) credit(e.source === 'manual' && !e.pause ? 'approvedAfterPause' : 'reworkedAfterPause');
   if (e.pause) {
     slot.paused += 1;
     bySignal(e.signal).paused += 1;
-    open.set(key, { signal: e.signal });
+    if (resolver === 'human') {
+      slot.pausedForHuman += 1;
+      bySignal(e.signal).pausedForHuman += 1;
+    }
+    // Written before the resolver existed: counted as human above, but nobody recorded who cleared it.
+    if (e.resolver === undefined) {
+      slot.pausedUnattributed += 1;
+      bySignal(e.signal).pausedUnattributed += 1;
+    }
+    open.set(key, { signal: e.signal, resolver });
   } else {
     slot.autoPassed += 1;
     open.delete(key);

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

@@ -123,16 +123,8 @@ export function readReuseVerdicts(projectPath, featureName) {
   return verdicts;
 }
 
-// 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) {
+export function collectChangedFiles(projectPath) {
   const files = new Set();
-  for (const slice of readPlanChecks(projectPath, featureName).checks?.slices ?? []) {
-    for (const file of slice.files ?? []) {
-      if (typeof file === 'string') files.add(file.replace(/\\/g, '/'));
-    }
-  }
-
   try {
     const out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], {
       cwd: projectPath,

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,
@@ -21,11 +21,9 @@ import {
   evalEmptyRunProblem, evalColdCacheWarning,
 } from '../tasks/eval-node.js';
 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;
 
@@ -71,7 +69,6 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     _runValidation = runValidation,
     _runE2eCheck = runE2eCheck,
     _e2eApplicability = e2eApplicability,
-    _checkOutputsTraceability = checkOutputsTraceability,
   } = options;
 
   const stack = readStack(projectPath);
@@ -171,10 +168,6 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     appendTestsFeedback(feedback, nodes.tests);
   }
 
-  // Outside `nodes` on purpose: status comes only from the nodes, so a traceability
-  // warning never turns red.
-  const traceability = _checkOutputsTraceability(projectPath, featureName);
-
   const baseline = recordBaseline ? recordBaselineFrom(projectPath, nodes.tests) : null;
   if (baseline && !baseline.recorded) {
     feedback.push(`[baseline] não gravada: ${baseline.reason}`);
@@ -194,7 +187,6 @@ async function runVerifyGated(projectPath, featureName, options, gate) {
     status,
     nodes,
     feedback,
-    traceability,
     ...(baseline ? { baseline } : {}),
   };
 }
@@ -364,7 +356,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 +382,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 +392,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 +484,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 +502,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 +521,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 +646,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');