@polymorphism-tech/morph-spec 9.6.0 → 9.8.0

package/src/lib/e2e/stack-teardown.js

@@ -13,12 +13,18 @@ import {
   resolveComposeFile,
   tearDownStack,
 } from '../../../framework/hooks/shared/e2e-check.js';
+import { stopHostServices } from '../../../framework/hooks/shared/host-services.js';
 import { buildComposeEnv } from './compose-env.js';
 
-export function tearDownFeatureStack(feature, { root, worktreePath = null, volumes = true, _exec = defaultExec } = {}) {
+export function tearDownFeatureStack(feature, { root, worktreePath = null, volumes = true, images, _exec = defaultExec } = {}) {
   const cwd = worktreePath && existsSync(worktreePath) ? worktreePath : root;
   const projectName = composeProjectName(feature);
   const gitCommonDir = resolveGitCommonDir(root);
+  // Before the compose lookup: a worktree already gone still leaves its host processes running.
+  const stopped = stopHostServicesSafely(gitCommonDir, projectName);
+  const hostServices = stopped.killed.length + stopped.skipped.length + stopped.warnings.length > 0
+    ? { hostServices: stopped }
+    : {};
 
   try {
     const config = readConfig(cwd) ?? readConfig(root);
@@ -33,25 +39,34 @@ export function tearDownFeatureStack(feature, { root, worktreePath = null, volum
 
     if (!composeFile) {
       // Nothing to bring down, but a stamp left behind would tell the next `up` a stack it cannot see is fresh.
-      return { attempted: false, cwd, status: 'skip', stampDeleted: deleteStamp(gitCommonDir, projectName) };
+      return { attempted: false, cwd, status: 'skip', stampDeleted: deleteStamp(gitCommonDir, projectName), ...hostServices };
     }
 
     const env = {
       COMPOSE_PROJECT_NAME: projectName,
       ...buildComposeEnv({ cwd: composeCwd, config, featureName: feature, gitCommonDir }),
     };
-    const result = tearDownStack(composeCwd, { composeFile, projectName, env, volumes }, _exec);
+    const result = tearDownStack(composeCwd, { composeFile, projectName, env, volumes, images }, _exec);
 
     return {
       attempted: true,
       cwd: composeCwd,
       status: result.status,
       stampDeleted: deleteStamp(gitCommonDir, projectName),
+      ...hostServices,
       ...(result.status === 'fail' && result.output ? { output: result.output } : {}),
     };
   } catch {
     // The stamp must not outlive the stack it described, even when the teardown itself blew up.
-    return { attempted: false, cwd, status: 'fail', stampDeleted: deleteStamp(gitCommonDir, projectName) };
+    return { attempted: false, cwd, status: 'fail', stampDeleted: deleteStamp(gitCommonDir, projectName), ...hostServices };
+  }
+}
+
+function stopHostServicesSafely(gitCommonDir, projectName) {
+  try {
+    return stopHostServices(gitCommonDir, projectName);
+  } catch (err) {
+    return { killed: [], skipped: [], warnings: [`host services not stopped: ${err?.message ?? err}`] };
   }
 }
 

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

@@ -21,7 +21,8 @@ export const reviewFileName = (role) => OUTPUT_SCHEMA[REVIEW_ROLES[role].output]
 // Append-only: uma reavaliação acrescenta ao fim, e vale o ÚLTIMO token/seção.
 const VERDICT_RE = /\*\*Verdict:\*\*\s*([A-Za-z]+)/g;
 const REVIEWED_SHA_RE = /\*\*Reviewed-SHA:\*\*\s*`?([0-9a-f]{7,40})/gi;
-const sectionRe = (title) => new RegExp(`^##\\s+${title}\\s*$`, 'gim');
+// A confirmation round nests its sections one level down (`###`); both levels count.
+const sectionRe = (title) => new RegExp(`^(#{2,3})\\s+${title}\\s*$`, 'gim');
 const BLOCKERS_SECTION_RE = sectionRe('Bloqueadores');
 const CHECKS_SECTION_RE = sectionRe('Checks');
 const MEDIA_SECTION_RE = /^##\s+M[íi]dia\s+gerada\s*$/m;
@@ -37,7 +38,7 @@ export function requiredReviewRoles({ workType, securityRequired = false } = {})
 function sectionBodies(text, re) {
   return [...text.matchAll(re)].map((m) => {
     const rest = text.slice(m.index + m[0].length);
-    const next = rest.search(/^#{1,2}\s/m);
+    const next = rest.search(new RegExp(`^#{1,${m[1].length}}\\s`, 'm'));
     return next === -1 ? rest : rest.slice(0, next);
   });
 }
@@ -50,13 +51,26 @@ function lastSectionBody(text, re) {
 const normalize = (s) => String(s ?? '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/\s+/g, ' ').trim();
 const cleanId = (s) => String(s ?? '').replace(/[*`_]/g, '').trim().toUpperCase();
 
-function tableRows(body) {
+const isSeparator = (cells) => cells.every((c) => /^:?-{2,}:?$/.test(c) || c === '');
+
+// 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 = [];
-  for (const line of body.split(/\r?\n/)) {
-    if (!/^\s*\|/.test(line)) continue;
+  let skipping = false;
+  const lines = body.split(/\r?\n/);
+  for (const [i, line] of lines.entries()) {
+    if (!/^\s*\|/.test(line)) { skipping = false; continue; }
     const cells = line.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
-    if (cells.every((c) => /^:?-{2,}:?$/.test(c) || c === '')) continue;
-    rows.push(cells);
+    if (isSeparator(cells)) continue;
+    const next = lines[i + 1]?.trim().replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+    if (next && /^\s*\|/.test(lines[i + 1]) && isSeparator(next) && !skipping) {
+      skipping = !keepHeader(cells);
+      continue;
+    }
+    if (!skipping) rows.push(cells);
   }
   return rows;
 }
@@ -65,8 +79,7 @@ function tableRows(body) {
 function parseBlockers(body) {
   const blockers = [];
   const untyped = [];
-  for (const cells of tableRows(body)) {
-    if (/^#$|^id$/i.test(cells[0]) && /^tipo$/i.test(cells[1] ?? '')) continue;
+  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);
   }
@@ -78,7 +91,7 @@ const STATUS_BY_KEY = Object.fromEntries(CHECK_STATUSES.map((s) => [normalize(s)
 // Vale a última linha de cada Cn em todas as seções: uma confirmação traz só os Cn que mudou.
 function parseChecks(bodies) {
   const byId = new Map();
-  for (const cells of bodies.flatMap(tableRows)) {
+  for (const cells of bodies.flatMap((body) => tableRows(body))) {
     const id = cleanId(cells[0]);
     if (!/^C\d+$/.test(id)) continue;
     const raw = String(cells[1] ?? '').replace(/[*`]/g, '').trim();

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,8 @@ 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;
 
 /**
  * Fallback test command when the project declared no nodes; `projectCount` scales the timeout.
@@ -423,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.
@@ -496,6 +536,8 @@ export function runTestSuite(projectPath = '.', opts = {}) {
       timeout,
       encoding: 'utf8',
       stdio: 'pipe',
+      // Node's 1 MiB default kills a large suite mid-run (ENOBUFS), which then reads as a red suite.
+      maxBuffer: TEST_OUTPUT_MAX_BUFFER,
       ...(env ? { env } : {}),
     });
     return { passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout };

package/src/lib/telemetry/metrics.js

@@ -5,6 +5,7 @@ import { ingestedBytes } from './telemetry-reader.js';
 import { producerOf } from '../../../framework/hooks/shared/command-tokens.js';
 import { isFailedToolCall } from '../../../framework/hooks/shared/telemetry-logger.js';
 import { GATE_EVENT, GATE_STEPS } from '../../../framework/hooks/shared/gate-event.js';
+import { QUEUE_FULL_EXIT, REVIEW_AGENT_TYPES, morphVerifyCall, testRunKind } from '../../../framework/hooks/shared/heavy-command.js';
 
 export const RERUN_WINDOW_MS = 10 * 60 * 1000;
 
@@ -81,13 +82,53 @@ function newCounters() {
   };
 }
 
-function addTime(counters, klass, durationMs) {
-  const slot = counters.timeByClass[klass] ||= { runs: 0, measuredMs: 0, unmeasured: 0 };
+const newTimeSlot = () => ({ runs: 0, measuredMs: 0, unmeasured: 0 });
+
+function addRun(slot, durationMs) {
   slot.runs += 1;
   if (Number.isFinite(durationMs)) slot.measuredMs += durationMs;
   else slot.unmeasured += 1;
 }
 
+// `agent_type` carries the dispatch name when one is given (`ver-c`, `gate3-motor`), not the persona,
+// so the metric also reads Gate 3 names; `byPersona` is the part the test-budget hook recognizes.
+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();
+  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;
+    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);
+    });
+  }
+  return out;
+}
+
 function finishCounters(c, turnsObserved) {
   return {
     toolCalls: c.toolCalls,
@@ -180,6 +221,7 @@ export function computeMetrics(events, opts = {}) {
   const reuse = { runs: 0, byTree: {}, skipReasons: {} };
   const gates = {};
   const openPauses = new Map();
+  const testBash = [];
   let v2 = 0;
   let legacy = 0;
   let turnsObserved = false;
@@ -257,10 +299,11 @@ export function computeMetrics(events, opts = {}) {
     }
 
     if (e.tool !== 'Bash' && e.tool !== 'PowerShell') continue;
+    if (e.tool === 'Bash' && typeof e.command === 'string') testBash.push(e);
     const { kind, klass } = classifyCommand(e.command);
     const git = gitCalls(e.command);
     for (const c of sinks) {
-      addTime(c, klass, e.durationMs);
+      addRun(c.timeByClass[klass] ||= newTimeSlot(), e.durationMs);
       c.git.status += git.status;
       c.git.diff += git.diff;
     }
@@ -335,6 +378,7 @@ export function computeMetrics(events, opts = {}) {
       unchangedRepeats,
     },
     dotnetFullSuite: fullSuite,
+    testOutsideVerify: testOutsideVerify(testBash),
     reuse,
     gates,
     features: featureRows,

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

@@ -77,7 +77,7 @@ export class PackageValidator {
     }
 
     return {
-      status: results.length === 0 ? 'ok' : 'error',
+      status: allIssues.some(i => i.level === 'error') ? 'error' : 'ok',
       totalFiles: csprojFiles.length,
       filesWithIssues: results.length,
       // The runner's contract: without these counts the findings read as `errors: 0`.
@@ -301,7 +301,7 @@ export async function validatePackages(projectPath = '.', options = {}) {
     validator.formatResults(results);
   }
 
-  if (options.autoFix && results.status !== 'ok') {
+  if (options.autoFix && results.results?.length) {
     const fixedCount = await validator.autoFix(results);
     console.log(chalk.green(`\n✅ Auto-fixed ${fixedCount} issue(s)`));
   }

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,8 +284,11 @@ 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: ' +
-    'escreva código e testes, compile, e rode SÓ o filtro dos seus testes UMA vez, em primeiro plano, antes do relatório; se falhar, corrija e rode só os que falharam. ' +
+    '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); ' +
+    'o hook nega a 4ª e o `verify` sem `--filter`: grave `PARCIAL` com o que ainda falha e devolva. ' +
     'Grave a saída em arquivo (`… > .morph/logs/test-last.log 2>&1`, sem nada depois) e leia o arquivo — um pipe troca o exit do teste pelo do último comando. ' +
     'Em batch paralelo SEM isolamento, só compile. Com `isolation: "worktree"`, o mesmo vale no seu worktree, e o último ato é o commit na branch dele.',
   '4. SOBREVIVÊNCIA: o limite de turnos corta sem aviso: commite `chore(F{n}): wip …` a cada marco (um arquivo ou uma fatia escrita), não só ao fim — ' +

package/src/utils/file-copier.js

@@ -1,4 +1,5 @@
 import fs from 'fs-extra';
+import { execFileSync } from 'child_process';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { WORKTREE_DIR_NAMES } from '../lib/worktree/dirs.js';
@@ -140,18 +141,39 @@ const ignoredDir = (line) => line.trim()
   .replace(/^\[(\w)(\w)\]/, (_, a, b) => (a.toLowerCase() === b.toLowerCase() ? a : `[${a}${b}]`))
   .toLowerCase();
 
-/** Never rewrites an existing line. @returns {string[]} the entries added */
+function trackedUnder(projectPath, dirs) {
+  let files;
+  try {
+    files = execFileSync('git', ['ls-files', '-z'], { cwd: projectPath, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).split('\0');
+  } catch { return new Map(); }
+  const found = new Map();
+  for (const file of files) {
+    const segments = file.toLowerCase().split('/').slice(0, -1);
+    for (const dir of dirs) if (!found.has(dir) && segments.includes(dir)) found.set(dir, file);
+  }
+  return found;
+}
+
+/**
+ * Never rewrites an existing line. Build output is never versioned, so a tracked file
+ * under a `bin`/`obj` segment is source that entry would hide: the entry is skipped.
+ * @returns {string[]} the entries added; `.skipped` lists `{ entry, file }` when any was skipped
+ */
 export function ensureDotnetBuildIgnores(projectPath) {
   const gitignorePath = join(projectPath, '.gitignore');
   const content = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
   const present = new Set(content.split(/\r?\n/).filter((l) => !l.trim().startsWith('#')).map(ignoredDir));
-  const missing = DOTNET_BUILD_DIRS.filter((dir) => !present.has(dir)).map((dir) => `${dir}/`);
-  if (!missing.length) return [];
+  const absent = DOTNET_BUILD_DIRS.filter((dir) => !present.has(dir));
+  const tracked = absent.length ? trackedUnder(projectPath, absent) : new Map();
+  const missing = absent.filter((dir) => !tracked.has(dir)).map((dir) => `${dir}/`);
+  const skipped = [...tracked].map(([dir, file]) => ({ entry: `${dir}/`, file }));
+  const result = (added) => (skipped.length ? Object.assign(added, { skipped }) : added);
+  if (!missing.length) return result([]);
   const eol = content.includes('\r\n') ? '\r\n' : '\n';
   const lead = content && !content.endsWith('\n') ? eol : '';
   const block = [...(content ? [''] : []), '# .NET build output', ...missing, ''].join(eol);
   fs.writeFileSync(gitignorePath, content + lead + block);
-  return missing;
+  return result(missing);
 }
 
 // Without the LF pin, Windows autocrlf marks every rewritten feature.json dirty