@polymorphism-tech/morph-spec 10.0.0 → 10.2.0

package/framework/templates/examples/design-system-examples.md

@@ -50,9 +50,6 @@
    - *--loading   : Estado de loading
    - *--error     : Estado de erro
 
-   Validacao:
-   morph-spec validate-css src/MyApp.Web
-
    =========================================================================== */
 
 

package/framework/templates/infrastructure/docker/docker-compose.template.yml

@@ -56,7 +56,7 @@ services:
 
   # PostgreSQL Database (Local development)
   postgres:
-    image: postgres:15-alpine
+    image: pgvector/pgvector:pg17
     restart: unless-stopped
     ports:
       - "${POSTGRES_PORT:-5432}:5432"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "10.0.0",
+  "version": "10.2.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/project/doctor.js

@@ -80,7 +80,6 @@ const REQUIRED_COMMAND_FILES = [
   'src/commands/project/status.js',
   'src/commands/project/worktree.js',
   'src/commands/state/approve.js',
-  'src/commands/validation/validate-feature.js',
   'src/commands/scaffold/scaffold.js',
   'src/commands/mcp/mcp-setup.js',
   'src/commands/context/context-refresh.js',

package/src/commands/state/approve.js

@@ -1,9 +1,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { execFileSync } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory, derivePhase } from '../../core/state/state-manager.js';
+import { getFeature, setApprovalGate, getApprovalGate } from '../../core/state/state-manager.js';
 import { unmetPrereqs } from '../../core/state/gate-order.js';
 import { reviewReports, reviewFileName, REVIEW_ROLES, VERDICT_TOKEN, REVIEWED_SHA_TOKEN } from '../../lib/review-reports.js';
 import { shouldPauseGate } from '../../lib/risk-detector.js';
@@ -12,6 +10,7 @@ import { autoApprovalRefusal, printRefusal } from './auto-approval.js';
 import { readTrustFromConfig } from './gate-decision.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { treeMovedSince } from '../../lib/git/evidence-staleness.js';
+import { reviewConfirmation } from '../../lib/review-confirmation.js';
 import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
 import { reportDotnetIgnores } from './advance.js';
 
@@ -31,6 +30,11 @@ function reviewStaleness(reports) {
     return { status: 'skip' };
   }
 
+  const confirmation = reviewConfirmation(cwd, reports, head);
+  const excused = new Set(
+    confirmation.confirmed ? confirmation.moved.filter((m) => m.skippable).map((m) => m.role) : [],
+  );
+
   let unstamped = null;
   for (const [role, report] of Object.entries(reports)) {
     if (report.status === 'missing') continue;
@@ -48,7 +52,7 @@ function reviewStaleness(reports) {
       unstamped ??= { status: 'unstamped', file, head };
       continue;
     }
-    if (!treeMovedSince(cwd, reviewed, head)) continue;
+    if (excused.has(role) || !treeMovedSince(cwd, reviewed, head)) continue;
     let ahead = 0;
     try {
       ahead = Number(execFileSync('git', ['rev-list', '--count', `${reviewed}..${head}`], { cwd, stdio: 'pipe' }).toString().trim()) || 0;
@@ -218,7 +222,7 @@ export async function approveCommand(featureName, gateName, options = {}) {
             for (const role of unusable) {
               const { status } = reports[role];
               const what = status === 'missing' ? 'não existe'
-                : status === 'partial' ? 'está PARCIAL — retome o mesmo agente por SendMessage'
+                : status === 'partial' ? 'está PARCIAL — despache o mesmo papel de novo dizendo o que já está no relatório'
                   : `não tem \`${VERDICT_TOKEN} SHIP|FIX\``;
               console.error(chalk.gray(`   ${reviewFileName(role)} ${what}.`));
             }
@@ -280,110 +284,6 @@ program
   .description('Approve a phase gate to allow workflow progression')
   .action(approveCommand);
 
-export async function approvalStatusCommand(featureName, options = {}) {
-  try {
-    const feature = getFeature(featureName);
-    if (!feature) {
-      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
-      process.exit(1);
-    }
-
-    // Phase derived from the filesystem + approved gates, never "unknown".
-    const featurePath = join(process.cwd(), '.morph', 'features', featureName);
-    const phase = feature.phase || derivePhase(featurePath);
-
-    // The uiux branch is optional: a feature that never took it has no
-    // 1-design/ folder and no uiux approval — that is "n/a", not "rejected".
-    const uiuxGate = getApprovalGate(featureName, 'uiux');
-    const uiuxTaken = uiuxGate?.approved === true || existsSync(join(featurePath, '1-design'));
-
-    if (options.json) {
-      const status = {
-        feature: featureName,
-        phase,
-        status: feature.status,
-        uiuxTaken,
-        gates: {}
-      };
-
-      for (const gateName of VALID_GATES) {
-        status.gates[gateName] = getApprovalGate(featureName, gateName) || { approved: false };
-      }
-
-      console.log(JSON.stringify(status, null, 2));
-      return;
-    }
-
-    console.log(chalk.bold(`\n📋 Approval Status for: ${featureName}`));
-    console.log('━'.repeat(60));
-
-    console.log(chalk.cyan(`\nCurrent Phase: ${phase}`));
-    console.log(chalk.gray(`Feature Status: ${feature.status || 'unknown'}\n`));
-
-    console.log(chalk.bold('Approval Gates:'));
-
-    for (const gateName of VALID_GATES) {
-      const gateStatus = getApprovalGate(featureName, gateName);
-
-      if (!gateStatus) {
-        console.log(`  ${chalk.gray('○')} ${gateName}: ${chalk.gray('Not yet evaluated')}`);
-        continue;
-      }
-
-      if (gateName === 'uiux' && !uiuxTaken) {
-        console.log(`  ${chalk.gray('—')} ${gateName}: ${chalk.gray('n/a (ramo de design não tomado)')}`);
-        continue;
-      }
-
-      if (gateStatus.approved) {
-        console.log(`  ${chalk.green('✓')} ${gateName}: ${chalk.green('Approved')}`);
-        if (gateStatus.timestamp) {
-          console.log(chalk.gray(`      Approved at: ${gateStatus.timestamp}`));
-        }
-        if (gateStatus.approvedBy) {
-          console.log(chalk.gray(`      Approved by: ${gateStatus.approvedBy}`));
-        }
-      } else {
-        // Distinguish "never evaluated" (initialized approved:false, no
-        // timestamp) from an explicit rejection/revocation (has timestamp).
-        const neverEvaluated = !gateStatus.timestamp && !gateStatus.rejectedAt && !gateStatus.revokedAt;
-        if (neverEvaluated) {
-          console.log(`  ${chalk.gray('○')} ${gateName}: ${chalk.gray('Pending (not yet evaluated)')}`);
-          continue;
-        }
-        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Revoked')}`);
-        if (gateStatus.reason) {
-          console.log(chalk.gray(`      Reason: ${gateStatus.reason}`));
-        }
-        if (gateStatus.timestamp) {
-          console.log(chalk.gray(`      Rejected at: ${gateStatus.timestamp}`));
-        }
-      }
-    }
-
-    const history = getApprovalHistory(featureName);
-    if (history && history.length > 0) {
-      console.log(chalk.bold('\nApproval History:'));
-      history.slice(-5).forEach(entry => {
-        const status = entry.approved ? chalk.green('✓ Approved') : chalk.red('✗ Rejected');
-        console.log(`  ${status} ${entry.gate} - ${entry.timestamp}`);
-      });
-    }
-
-    console.log('\n' + '━'.repeat(60) + '\n');
-
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Error showing approval status: ${error.message}\n`));
-    process.exit(1);
-  }
-}
-
-program
-  .command('approval-status <feature>')
-  .alias('status')
-  .description('Show approval status for all gates')
-  .action(approvalStatusCommand);
-
 if (import.meta.url === `file://${process.argv[1]}`) {
   if (process.argv.length > 2) {
     program.parse(process.argv);

package/src/commands/state/auto-approval.js

@@ -30,7 +30,7 @@ export function autoApprovalRefusal({ cwd, featureName, feature, gate, approvedB
   }
 
   if (gate === 'plan') {
-    const block = planAutoApprovalBlock(cwd, featureName);
+    const block = planAutoApprovalBlock(cwd, featureName, feature);
     if (block) {
       return {
         title: `O gate "plan" não pode ser auto-aprovado — ${block}.`,

package/src/commands/state/create.js

@@ -132,7 +132,7 @@ export async function createCommand(featureName, options = {}) {
     const alreadyExists = existsSync(join(process.cwd(), '.morph', 'features', featureName, 'feature.json'));
     if (!alreadyExists && (description === null || String(description).trim() === '')) {
       console.error(chalk.red(`\n❌ A feature needs a description at birth: "${featureName}"`));
-      console.error(chalk.gray('   Pass --description "<what/why>" (or --request "<pedido>", which seeds it).'));
+      console.error(chalk.gray('   Pass --description "<what/why>" (or --request '<pedido>', which seeds it).'));
       console.error(chalk.gray('   This keeps features identifiable — no more anonymous scaffolds.\n'));
       process.exit(1);
     }

package/src/commands/state/gate-check.js

@@ -59,9 +59,9 @@ export function collectReviewSignal(cwd, featureName, feature, planChecks = read
 }
 
 /** Why an automatic signature may not close the plan gate: the rule that makes gate-check pause it. */
-export function planAutoApprovalBlock(cwd, featureName) {
+export function planAutoApprovalBlock(cwd, featureName, feature) {
   const planChecks = readPlanChecks(cwd, featureName);
-  const workType = getFeature(featureName)?.workType || 'feature';
+  const workType = feature?.workType || 'feature';
   const reason = planChecksPause(planChecks.status)
     ?? planCritiquePause(readPlanCritique(cwd, featureName, { workType, planChecks }))
     ?? rungPause({ gate: 'plan', rungs: pausingRungs(planChecks.checks) })?.reason;

package/src/commands/state/report-check.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { execFileSync } from 'child_process';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { implementProgress, parseReport, reportPath } from '../../../framework/hooks/shared/report-progress.js';
@@ -14,6 +15,8 @@ import { isTestPath } from '../../lib/graph/sanitize.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { collectReviewRequirement } from './gate-check.js';
 import { featureGeneratesMedia } from '../../lib/plan/media.js';
+import { resolveBaseRef } from '../../lib/git/branch-classifier.js';
+import { reviewConfirmation } from '../../lib/review-confirmation.js';
 
 /** Each review report: complete when it carries a readable verdict and is not partial. */
 export function inspectReviewReports(cwd, feature) {
@@ -75,10 +78,44 @@ function treeFor(cwd, feature, beforeEval) {
   const tree = treeState(cwd, { snapshot });
   if (!beforeEval) return { tree };
   const reviewModels = reviewDispatch(cwd, feature);
+  const gate3 = gate3Briefing(cwd, feature);
   const next = snapshotTree(cwd);
-  if (!next) return { tree, beforeEval: null, reviewModels };
+  if (!next) return { tree, beforeEval: null, reviewModels, gate3 };
   atomicWriteJson(path, next);
-  return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length }, reviewModels };
+  return { tree, beforeEval: { at: next.at, files: Object.keys(next.files).length }, reviewModels, gate3 };
+}
+
+function gitLine(cwd, args) {
+  try {
+    return execFileSync('git', args, { cwd, stdio: 'pipe' }).toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function readVerification(cwd, feature) {
+  try {
+    return JSON.parse(readFileSync(join(cwd, '.morph', 'features', feature, 'feature.json'), 'utf8')).verification ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// What every dispatch needs, in one read. `redispatch: null` = no report yet, every required role goes.
+function gate3Briefing(cwd, feature) {
+  const sha = gitLine(cwd, ['rev-parse', 'HEAD']);
+  const defaultRef = resolveBaseRef(detectDefaultBranch(cwd), cwd);
+  const reports = reviewReports(cwd, feature);
+  const anyReport = Object.values(reports).some((report) => report.status !== 'missing');
+  const moved = anyReport && sha ? reviewConfirmation(cwd, reports, sha).moved : [];
+  const { checks } = readPlanChecks(cwd, feature);
+  return {
+    base: defaultRef ? gitLine(cwd, ['merge-base', defaultRef, 'HEAD']) : null,
+    sha,
+    flaky: readVerification(cwd, feature)?.flaky ?? [],
+    e2eChecks: (checks?.checks ?? []).filter((check) => check.proof === 'e2e').map((check) => check.id),
+    redispatch: anyReport ? moved.filter((role) => !role.skippable).map((role) => role.role) : null,
+  };
 }
 
 export function reportCheckCommand(feature, options = {}) {
@@ -128,6 +165,11 @@ function printHuman(obj) {
     const m = obj.reviewModels;
     console.log(chalk.gray(`  dispatch: verifier ${m.verifier.model}, reviewer ${m.reviewer.model}${m.security.required ? `, security ${m.security.model}` : ''}`));
   }
+  if (obj.gate3) {
+    const g = obj.gate3;
+    console.log(chalk.gray(`  gate 3: base ${g.base?.slice(0, 8) ?? '-'}, sha ${g.sha?.slice(0, 8) ?? '-'}`
+      + `${g.redispatch ? `, voltam: ${g.redispatch.join(', ') || 'nenhum'}` : ''}${g.flaky.length ? `, instáveis: ${g.flaky.join(', ')}` : ''}`));
+  }
   printTree(obj.tree);
   console.log('');
 }

package/src/commands/validation/verify.js

@@ -109,12 +109,14 @@ const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'],
 const CI_EXCLUSIVE_FLAGS = [
   ['filter', '--filter'], ['skipTests', '--skip-tests'], ['skipBuild', '--skip-build'], ['skipE2e', '--skip-e2e'],
   ['freshE2e', '--fresh-e2e'], ['linux', '--linux'], ['recordBaseline', '--record-baseline'], ['refreshCache', '--refresh-cache'],
-  ['noPersist', '--no-persist'],
+  ['noPersist', '--no-persist'], ['fresh', '--fresh'],
 ];
 
-async function runLocalVerify(featureName, options) {
+async function runLocalVerify(featureName, options, fingerprint) {
   try {
     return await runVerify(process.cwd(), featureName, {
+      fingerprint,
+      fresh: options.fresh,
       timeout: options.timeout,
       skipTests: options.skipTests,
       skipBuild: options.skipBuild,
@@ -214,11 +216,12 @@ export async function verifyCommand(featureName, options = {}) {
   // Taken before the run: it is the tree the run is about to read.
   const fingerprint = treeFingerprint(process.cwd());
 
-  const result = ci ? ci.result : await runLocalVerify(featureName, options);
+  const result = ci ? ci.result : await runLocalVerify(featureName, options, fingerprint);
 
   const cleanup = ci ? { status: 'skipped', reason: 'ci' } : afterHeavyRun({
     projectPath: process.cwd(),
     config: readHeavyConfig(process.cwd()),
+    onlyUnderPressure: true,
   });
 
   const historyKey = 'verifications.feature';
@@ -254,6 +257,7 @@ export async function verifyCommand(featureName, options = {}) {
       e2eReason: result.nodes.e2e.status === 'skip' ? (result.nodes.e2e.reason ?? null) : null,
       sha: ci ? ci.run.headSha : getHeadSha(process.cwd()),
       ts: now,
+      ...(result.flaky?.length ? { flaky: result.flaky } : {}),
       ...(ci ? { source: 'ci', ciRun: ci.run.url } : {}),
     };
     await updateFeature(featureName, 'verification', stamp);

package/src/core/state/state-manager.js

@@ -521,27 +521,3 @@ export function getApprovalGate(featureName, gate) {
   return feature.approvalGates[gate] || null;
 }
 
-export function getApprovalHistory(featureName) {
-  const state = loadState();
-  const feature = state.features[featureName];
-
-  if (!feature || !feature.approvalGates) {
-    return [];
-  }
-
-  const history = [];
-
-  Object.entries(feature.approvalGates).forEach(([gate, data]) => {
-    if (data.timestamp) {
-      history.push({
-        gate,
-        approved: data.approved,
-        timestamp: data.timestamp,
-        approvedBy: data.approvedBy || data.rejectedBy,
-        reason: data.reason
-      });
-    }
-  });
-
-  return history.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
-}

package/src/lib/detectors/index.js

@@ -54,7 +54,7 @@ export function detectProject(targetPath, opts = {}) {
       if (depNames.includes('@neondatabase/serverless') || depNames.includes('postgres') || depNames.includes('pg')) {
         structure.integrations.push('neon');
       }
-      if (depNames.includes('@neondatabase/auth')) {
+      if (depNames.includes('@neon/auth') || depNames.includes('@neondatabase/auth')) {
         structure.integrations.push('neon-auth');
       }
       if (depNames.includes('stripe')) {

package/src/lib/heavy/cleanup.js

@@ -1,4 +1,5 @@
 import { readdirSync } from 'node:fs';
+import { freemem } from 'node:os';
 import { getBuildSteps } from '../../../framework/hooks/shared/build-check.js';
 import { listProcesses, defaultProcExec } from '../procs/list.js';
 import { readProjectConfig } from '../../../framework/hooks/shared/heavy-config.js';
@@ -8,6 +9,7 @@ const DOTNET_ACTIVE = /\bdotnet(?:\.exe)?["']?\s+(?:build|test|publish|pack|msbu
 const IDLE_WORKER = /\/nodemode:\d|vbcscompiler|razorserver/i;
 const SHUTDOWN_TIMEOUT_MS = 30_000;
 const TAIL_CHARS = 400;
+const GB = 1024 ** 3;
 
 function hasDotnet(projectPath) {
   const config = readProjectConfig(projectPath);
@@ -32,14 +34,18 @@ export function dotnetBusy(procs) {
   });
 }
 
-export function afterHeavyRun({ projectPath, config, env = process.env, deps = {} }) {
+export function afterHeavyRun({ projectPath, config, env = process.env, onlyUnderPressure = false, deps = {} }) {
   const {
-    exec = defaultProcExec, list = listProcesses, dotnet = hasDotnet, exclusive = runExclusive,
+    exec = defaultProcExec, list = listProcesses, dotnet = hasDotnet, exclusive = runExclusive, freeMem = freemem,
   } = deps;
 
   if (!config.enabled) return { status: 'skipped', reason: 'semáforo desligado: sem ele nada prova que outra sessão não está compilando' };
   if (!config.shutdownBuildServer) return { status: 'skipped', reason: 'desligado em heavy.shutdownBuildServer' };
   if (!dotnet(projectPath)) return { status: 'skipped', reason: 'projeto sem .NET' };
+  // A warm compiler is what makes the next round short; twice the floor keeps the next queue open.
+  if (onlyUnderPressure && freeMem() / GB >= config.minFreeMemGb * 2) {
+    return { status: 'skipped', reason: 'RAM livre de sobra: o compilador fica quente para a próxima rodada' };
+  }
 
   const guarded = exclusive({
     dir: heavyDir(env), label: 'build-server-shutdown', maxHoldMs: config.maxHoldMinutes * 60_000, env,

package/src/lib/installers/memory-installer.js

@@ -39,7 +39,7 @@ metadata:
 
 | Command | Skill invoked |
 |---------|---------------|
-| \`/morph-plan {feature}\` | \`Skill(morph-plan)\` — entrevista → plan.md → plan-check → gate do plano |
+| \`/morph-plan {feature}\` | \`Skill(morph-plan)\` — tese → plan.md → plan-check → gate do plano |
 | \`/morph-apply {feature}\` | \`Skill(morph-apply)\` — fatias do plano → verify → review → Gate 3 |
 | \`/morph-status [feature]\` | inspect state.json |
 | \`/morph-archive {feature}\` | move completed feature to .morph/archive/ |

package/src/lib/plan/checks.js

@@ -123,9 +123,16 @@ export function validatePlan(plan, { workType = null, riskRules = true, text = n
   errors.push(...statesErrors(plan, at));
   warnings.push(...defaultsWarnings(plan, at));
 
-  if (plan.sections.some((s) => !s.key && /^fatias$/i.test(s.name.trim()))) {
+  const isSlices = (s) => /^fatias$/i.test(s.name.trim());
+  if (plan.sections.some((s) => !s.key && isSlices(s))) {
     warnings.push('## Fatias não é lida desde a 10.0: o plano inteiro se implementa numa sessão, e os cenários definem o pronto');
   }
+  const known = new Set(Object.values(SECTIONS).map(foldRisk));
+  for (const s of plan.sections.filter((section) => !section.key && !isSlices(section))) {
+    warnings.push(known.has(foldRisk(s.name))
+      ? `## ${s.name} repetida${at(s.line)} — só a primeira é lida, o conteúdo desta se perde`
+      : `## ${s.name} não é seção do plano${at(s.line)} — o plan-check não a lê`);
+  }
 
   for (const r of plan.reuse) {
     if (!REUSE_VERDICTS.includes(r.verdict)) {

package/src/lib/plan/critique.js

@@ -1,8 +1,21 @@
 import { existsSync, readFileSync } from 'fs';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+import { featureGeneratesMedia } from './media.js';
 
 export const CRITIQUE_EXEMPT_WORK_TYPES = ['chore', 'hotfix'];
 
+const SMALL_PLAN_MAX_CHECKS = 3;
+const SMALL_PLAN_PROOFS = ['teste', 'leitura'];
+
+/** A plan this size has little for a fresh reader to catch; a rung or a proof outside the code does. */
+export function isSmallPlan(checks, planText = '') {
+  const scenarios = checks?.checks ?? [];
+  return scenarios.length > 0
+    && scenarios.length <= SMALL_PLAN_MAX_CHECKS
+    && scenarios.every((scenario) => SMALL_PLAN_PROOFS.includes(scenario.proof) && !scenario.rung)
+    && !featureGeneratesMedia(planText);
+}
+
 const PLAN_HASH_RE = /^\*\*Plan-Hash:\*\*\s*`?([0-9a-f]{64})`?\s*$/m;
 const APPLIED_RE = /^\*\*Aplicado-em:\*\*\s*`?([0-9a-f]{64})`?\s*$/gm;
 
@@ -21,8 +34,15 @@ export function readPlanCritique(cwd, featureName, { workType, planChecks }) {
   if (CRITIQUE_EXEMPT_WORK_TYPES.includes(workType)) return 'exempt';
   const currentHash = planChecks?.status === 'fresh' ? planChecks.checks?.planHash : null;
   if (!currentHash) return null;
+  if (isSmallPlan(planChecks.checks, readText(getAbsoluteOutputPath(cwd, featureName, 'plan')) ?? '')) return 'exempt';
   const path = getAbsoluteOutputPath(cwd, featureName, 'planCritique');
-  let text = null;
-  try { text = existsSync(path) ? readFileSync(path, 'utf8') : null; } catch { text = null; }
-  return critiqueStatus(text, currentHash);
+  return critiqueStatus(readText(path), currentHash);
+}
+
+function readText(path) {
+  try {
+    return existsSync(path) ? readFileSync(path, 'utf8') : null;
+  } catch {
+    return null;
+  }
 }

package/src/lib/review-confirmation.js

@@ -0,0 +1,67 @@
+import { execFileSync } from 'child_process';
+import { basename } from 'path';
+import { treeMovedSince } from './git/evidence-staleness.js';
+import { isTestOnly, securityReviewFor } from './risk-detector.js';
+
+function resolveCommit(cwd, ref) {
+  try {
+    return execFileSync('git', ['rev-parse', '--verify', `${ref}^{commit}`], { cwd, stdio: 'pipe' }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function changedBetween(cwd, from, to) {
+  try {
+    return execFileSync('git', ['diff', '--name-only', '--no-renames', from, to, '--', '.', ':(exclude).morph'], { cwd, stdio: 'pipe' })
+      .toString().split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+function citedByBlockers(reports) {
+  return Object.values(reports)
+    .flatMap((report) => report.rounds ?? [])
+    .flatMap((round) => round.blockers ?? [])
+    .map((blocker) => `${blocker.where} ${blocker.evidence}`)
+    .join('\n');
+}
+
+const openedBlockers = (report) => (report.rounds ?? []).some((round) => (round.blockers ?? []).length > 0);
+const isCleanShip = (report) => report.verdict === 'SHIP' && (report.blockers ?? []).length === 0;
+
+function deltaIsNarrow(role, delta, cited) {
+  if (delta === null) return false;
+  if (role === 'security') return !securityReviewFor(delta).required;
+  return delta.every((file) => isTestOnly(file) || cited.includes(file) || cited.includes(basename(file)));
+}
+
+/**
+ * After a fix, a role that shipped clean need not return when the delta stays inside what the
+ * blockers named (security: when it touches no sensitive path). `moved` lists the roles behind
+ * `head`; `skippable` says it holds; `confirmed` says a role that opened blockers re-judged `head`,
+ * without which nothing is skippable at approval.
+ */
+export function reviewConfirmation(cwd, reports, head) {
+  const cited = citedByBlockers(reports);
+  const moved = [];
+  let confirmed = false;
+
+  for (const [role, report] of Object.entries(reports)) {
+    if (report.status === 'missing' || !report.reviewedSha) continue;
+    const reviewed = resolveCommit(cwd, report.reviewedSha);
+    if (!reviewed) continue;
+    if (!treeMovedSince(cwd, reviewed, head)) {
+      if (openedBlockers(report)) confirmed = true;
+      continue;
+    }
+    moved.push({
+      role,
+      reviewed,
+      skippable: isCleanShip(report) && deltaIsNarrow(role, changedBetween(cwd, reviewed, head), cited),
+    });
+  }
+
+  return { moved, confirmed };
+}

package/src/lib/review-reports.js

@@ -32,6 +32,7 @@ const SCREEN_CHECKLIST_SECTION_RE = sectionRe('Checklist\\s+de\\s+tela');
 
 /** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. Chore: só o revisor (review leve). */
 export function requiredReviewRoles({ workType, securityRequired = false } = {}) {
+  // Sem `security` mesmo em caminho sensível: o humano assina todo hotfix.
   if (workType === 'hotfix') return ['verifier'];
   const base = workType === 'chore' ? ['reviewer'] : ['verifier', 'reviewer'];
   return securityRequired ? [...base, 'security'] : base;

package/src/lib/risk-detector.js

@@ -83,7 +83,7 @@ export function reviewPause(signal) {
            + ' auto-avaliação de quem implementou não decide o ship';
     }
     if (r.status === 'partial') {
-      return `\`${file}\` está PARCIAL — retome o mesmo agente por SendMessage; parcial não é veredito`;
+      return `\`${file}\` está PARCIAL — despache o mesmo papel de novo dizendo o que já está no relatório; parcial não é veredito`;
     }
     if (r.status !== 'ok') {
       return `\`${file}\` sem \`**Verdict:** SHIP|FIX\` — o relatório não seguiu o contrato`;
@@ -144,7 +144,7 @@ export function verifierModelFor({ promptModelTouched = false, generatesMedia =
 
 // Teste e artefato de teste não são superfície de ataque: `e2e/login.spec.ts` não pede a persona security.
 const E2E_DIR_RE = /(^|\/)e2e\//;
-const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
+export const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
 
 export function securityReviewFor(changedFiles = []) {
   const risky = changedFiles

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

@@ -83,6 +83,7 @@ function makeNode(partial) {
     runner,
     expectedCount: keepsBaseline(runner) ? partial.expectedCount ?? null : null,
     timeoutMs: partial.timeoutMs ?? null,
+    parallel: partial.parallel ?? false,
     build: partial.build ?? [],
     e2e: partial.e2e ?? false,
     linuxImage: partial.linuxImage ?? null,
@@ -133,6 +134,9 @@ function firstProblem(raw, projectPath) {
   if (raw.timeoutMs !== undefined && !(Number.isInteger(raw.timeoutMs) && raw.timeoutMs > 0)) {
     return 'timeoutMs must be an integer > 0';
   }
+  if (raw.parallel !== undefined && typeof raw.parallel !== 'boolean') {
+    return 'parallel must be a boolean';
+  }
   if (raw.build !== undefined && (!Array.isArray(raw.build) || raw.build.some((b) => typeof b !== 'string'))) {
     return 'build must be an array of strings';
   }
@@ -208,6 +212,7 @@ export function validateTestNodes(config, projectPath = null) {
       runner: entry.runner ?? inferRunner(entry.command),
       expectedCount: entry.expectedCount ?? null,
       timeoutMs: entry.timeoutMs ?? null,
+      parallel: entry.parallel ?? false,
       build: entry.build ?? [],
       e2e: entry.e2e ?? false,
       linuxImage: entry.linuxImage ?? null,