@polymorphism-tech/morph-spec 9.1.0 → 9.3.0

package/src/commands/state/next.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { formatNext } from '../../../framework/hooks/shared/next-step.js';
+import { nextStepFor } from '../../lib/next-step.js';
+import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
+
+// Read-only: decides in the tree that owns the feature, since the root copy of a worktree feature is a birth skeleton.
+export function nextCommand(featureName, options = {}) {
+  const owner = resolveFeatureTree(featureName, process.cwd());
+  const next = owner.source === 'none' || owner.source === 'branch-only' ? null : nextStepFor(featureName, owner.tree);
+
+  if (!next) {
+    const error = owner.source === 'branch-only' ? 'feature-not-in-tree' : 'feature-not-found';
+    if (options.json) console.log(JSON.stringify({ error, feature: featureName, branch: owner.branch ?? null }));
+    else console.error(chalk.red(`\n❌ ${error}: ${featureName}${owner.branch ? ` (morph-spec worktree setup ${featureName})` : ''}\n`));
+    process.exit(1);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify({ ...next, feature: featureName, tree: owner.tree }));
+    return;
+  }
+  console.log(formatNext(next));
+  if (owner.tree !== process.cwd()) console.log(chalk.gray(`   árvore dona: ${owner.tree}`));
+}

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

@@ -130,6 +130,7 @@ function decide(report, observed, stale) {
   }
   // PARCIAL: the agent stopped short (turn ceiling) and resumes from its last
   // `wip` commit — completing it DEGRADADO would stamp unfinished work as done.
+  if (report.exists && report.blocked) return { verdict: 'report-blocked', action: 'ask-human' };
   if (report.exists && report.partial) return { verdict: 'report-incomplete', action: 'resume' };
   if (report.exists) return { verdict: 'report-incomplete', action: 'complete-degraded' };
   if (!observed.available) return { verdict: 'report-missing-evidence-unknown', action: 'redispatch' };
@@ -151,7 +152,8 @@ const ACTION_HINT = {
   'refresh-from-evidence': 'o relatório está COMPLETO mas VELHO: o agente da fatia seguiu escrevendo arquivos depois de gravá-lo, então ele descreve um estado já ultrapassado. NÃO re-despache e não confie no texto — confira os arquivos em `observed` (evidência real, não auto-declarada) e atualize o relatório a partir deles.',
   'complete-degraded': 'complete os itens faltantes a partir da mensagem de retorno do sub-agent, carimbe o relatório como DEGRADADO e registre nele a falha de protocolo.',
   resume: 'relatório PARCIAL: o sub-agent parou antes do fim (limite de turnos) e a fatia NÃO está pronta. Não carimbe DEGRADADO — retome o MESMO agente por `SendMessage` (cole no recado `tree.dirty` e `tree.commits` desta saída e o que falta) ou re-despache só o que falta, a partir do último commit `wip`.',
-  'accept-degraded': 'o TRABALHO entrou — não re-despache. Grave você mesmo o relatório da fatia a partir da mensagem de retorno, carimbado como DEGRADADO, com a falha de protocolo registrada nele.',
+  'ask-human': 'relatório BLOQUEADO: o sub-agent parou numa decisão que não é dele (requisito que contradiz o plano ou um ADR, escolha do humano) e o relatório traz a pergunta e as opções. NÃO re-despache — a mesma pergunta volta. Se o plano ou um ADR já decide, decida você e registre no relatório; senão, faça a pergunta por `AskUserQuestion`. Depois retome o MESMO agente por `SendMessage` com a resposta.',
+  'accept-degraded':'o TRABALHO entrou — não re-despache. Grave você mesmo o relatório da fatia a partir da mensagem de retorno, carimbado como DEGRADADO, com a falha de protocolo registrada nele.',
   redispatch: 're-despache a fatia UMA vez com o mesmo prompt. Segunda ausência sem trabalho entregue = falha real: escale ao humano.',
 };
 

package/src/commands/validation/mutate.js

@@ -15,7 +15,7 @@ import { groupByNode, loadPlan } from '../../lib/mutation/plan.js';
 import { dotnetSubset, jsSubset, mutatedTypesOf, testFilesCiting, testProjectDirsOf } from '../../lib/mutation/subset.js';
 import { isFinished } from '../../dashboard/scanner/feature-status.js';
 import { dotnetAdapter, genericAdapter, spawnExec } from '../../lib/mutation/adapters.js';
-import { runMutation } from '../../lib/mutation/runner.js';
+import { noSubsetReason, runMutation } from '../../lib/mutation/runner.js';
 import { renderSection, summarize } from '../../lib/mutation/report.js';
 import { readJournal, restoreSnapshot } from '../../lib/mutation/snapshot.js';
 
@@ -101,8 +101,7 @@ function testDirsOf(node, root, { projectsOnly = false } = {}) {
   return testProjectDirsOf(root, projectsOnly ? targets.filter((t) => !/\.slnx?$/i.test(t)) : targets, cwd);
 }
 
-function subsetFor({ node, group, root, options }) {
-  if (options.subset === false) return { usable: false, reason: '--no-subset' };
+function subsetFor({ node, group, root }) {
   const mutatedFiles = group.regions.map((r) => r.file);
   if (node.runner === 'dotnet') {
     const base = detectDefaultBranch(root);
@@ -193,6 +192,12 @@ export async function mutateCommand(featureArg, options = {}) {
     return fail(`${named}\nNó e2e: true declarado: ${e2eIds}. ${e2eManualProtocol(feature, uncited[0].e2e[0])}`, EXIT.usage);
   }
 
+  const subsets = groups.map((group) => subsetFor({ node: group.node, group, root }));
+  const noSubset = subsets.findIndex((s) => !s.usable);
+  if (noSubset >= 0) {
+    return fail(`suíte "${groups[noSubset].node.id}": ${noSubsetReason(subsets[noSubset].reason)}.`, EXIT.usage);
+  }
+
   if (!options.allowDirty) {
     const dirty = gitOut(root, ['status', '--porcelain', '--', ...new Set(regions.map((r) => r.file))]).trim();
     if (dirty) return fail(`há alteração não commitada nos arquivos a mutar:\n${dirty}\nCommite o fix ANTES de mutar (ou use --allow-dirty sabendo que o snapshot é o único caminho de volta).`, EXIT.usage);
@@ -207,13 +212,11 @@ export async function mutateCommand(featureArg, options = {}) {
   const exec = options.exec ?? spawnExec;
 
   const merged = { wallMs: 0, mutants: [], timings: [], restore: { files: [], ok: true, treeClean: true }, binary: { proof: 'unavailable', projects: [] }, baseline: {}, method: { schemata: 0, rebuild: 0, subset: {} } };
-  const subsets = [];
   try {
     for (const [index, group] of groups.entries()) {
       const workDir = join(base, runId, `g${index}`);
       mkdirSync(workDir, { recursive: true });
-      const subset = subsetFor({ node: group.node, group, root, options });
-      subsets.push(subset);
+      const subset = subsets[index];
       const timeoutMs = options.timeoutMs ?? group.node.timeoutMs ?? 900_000;
       const make = group.node.runner === 'dotnet' ? dotnetAdapter : genericAdapter;
       const adapter = make({ node: group.node, root, workDir, exec, subset, timeoutMs });

package/src/commands/validation/plan-check.js

@@ -5,7 +5,7 @@ import { atomicWriteJson } from '../../core/state/state-manager.js';
 import { isGateApproved } from '../../../framework/hooks/shared/state-reader.js';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { parsePlan } from '../../lib/plan/plan-parser.js';
-import { buildChecks, knownPersonas, parallelGroups, planHash, validatePlan } from '../../lib/plan/checks.js';
+import { buildChecks, knownPersonas, parallelGroups, planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
 import { knownSurfaces } from '../../lib/specs/screen-checklist.js';
 import { revocationWarnings } from '../../lib/specs/adr-index.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
@@ -25,7 +25,9 @@ export function runPlanCheck(featureName, cwd = process.cwd()) {
 
   const text = readFileSync(planPath, 'utf8');
   const plan = parsePlan(text);
-  const { errors, warnings } = validatePlan(plan, { personas: knownPersonas(cwd), surfaces: knownSurfaces(cwd) });
+  const { errors, warnings } = validatePlan(plan, {
+    personas: knownPersonas(cwd), surfaces: knownSurfaces(cwd), ...planRuleOptions(cwd, featureName),
+  });
   warnings.push(...revocationWarnings(cwd, plan));
   const groups = errors.length === 0 ? parallelGroups(plan.slices) : [];
   const hash = planHash(text);

package/src/commands/validation/tests-audit.js

@@ -0,0 +1,7 @@
+import { auditTests, renderTestsAudit } from '../../lib/tests-audit/audit.js';
+
+export function testsAuditCommand(options = {}) {
+  const result = auditTests(process.cwd());
+  console.log(options.json ? JSON.stringify(result, null, 2) : renderTestsAudit(result));
+  if (!result.ok) process.exit(2);
+}

package/src/commands/validation/validate-feature.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import { parsePlan } from '../../lib/plan/plan-parser.js';
-import { knownPersonas, planHash, validatePlan } from '../../lib/plan/checks.js';
+import { knownPersonas, planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
 
 // Matched against section markers (headings and line-start bold labels), never whole-file
 // substrings. required → ERROR, recommended → WARNING, optional → never penalized; an array is any-of.
@@ -115,7 +115,9 @@ function validateOutput(featurePath, outputFile) {
 // `planDir` is `.morph/features/{f}/2-plan`, so the project is four levels up.
 function validatePlanOutput(content, planDir, result) {
   const plan = parsePlan(content);
-  const { errors, warnings } = validatePlan(plan, { personas: knownPersonas(path.resolve(planDir, '..', '..', '..', '..')) });
+  const root = path.resolve(planDir, '..', '..', '..', '..');
+  const feature = path.basename(path.resolve(planDir, '..'));
+  const { errors, warnings } = validatePlan(plan, { personas: knownPersonas(root), ...planRuleOptions(root, feature) });
   result.errors.push(...errors);
   result.warnings.push(...warnings);
   result.sections.found.push(...plan.sections.filter((x) => x.key).map((x) => x.name));

package/src/commands/validation/verify.js

@@ -81,10 +81,8 @@ function decidePersistence({ cwd, featureName, noPersist }) {
 }
 
 function baselineStampBlock(baseline) {
-  if (!baseline?.recorded) return baseline?.reason ? `record-baseline: ${baseline.reason}` : 'record-baseline';
-  const fell = baseline.updates.filter((u) => u.from !== null && u.to < u.from);
-  if (fell.length === 0) return null;
-  return `record-baseline: a contagem caiu em ${fell.map((u) => `${u.id} (${u.from} → ${u.to})`).join(', ')}`;
+  if (baseline?.recorded) return null;
+  return baseline?.reason ? `record-baseline: ${baseline.reason}` : 'record-baseline';
 }
 
 // The single writer of both node maps the schema fixes (`verification.nodes` and the history
@@ -154,6 +152,17 @@ async function runLocalVerify(featureName, options) {
   }
 }
 
+function exitWithReusedStamp(featureName, reused, why, options) {
+  console.error(chalk.green(`\n↪ ${why} (sha ${reused.sha.slice(0, 8)}, ${reused.ts}): nada mudou fora de .morph/ desde aquela rodada verde.\n`));
+  if (options.json) {
+    console.log(JSON.stringify({
+      feature: featureName, status: reused.status, nodes: reused.nodes, e2eReason: reused.e2eReason ?? null,
+      reused: { sha: reused.sha, ts: reused.ts, source: reused.source ?? 'local' }, persisted: false, reason: 'stamp-reused',
+    }, null, 2));
+  }
+  process.exit(0);
+}
+
 // Exit 2 is "the command cannot mean what you typed" (unknown feature, `--filter` matching
 // nothing, `--record-baseline` without config.json, `--linux` without Docker): never a verdict.
 export async function verifyCommand(featureName, options = {}) {
@@ -178,6 +187,8 @@ export async function verifyCommand(featureName, options = {}) {
 
   let ci = null;
   if (options.ci) {
+    const fresh = reusableLocalStamp(process.cwd(), feature.verification);
+    if (fresh) exitWithReusedStamp(featureName, fresh, 'stamp verde e fresco — o CI não roda de novo', options);
     try {
       const outcome = await runCiVerify(process.cwd(), featureName, readMorphConfig(process.cwd()), {
         log: (line) => console.error(chalk.gray(`   ${line}`)),
@@ -189,17 +200,6 @@ export async function verifyCommand(featureName, options = {}) {
         console.error(chalk.yellow(`\n⏳ ${outcome.reason}. Não é vermelho e não há stamp: não repita em laço — siga e deixe o gate-check decidir.\n`));
         process.exit(3);
       } else {
-        const reused = reusableLocalStamp(process.cwd(), feature.verification);
-        if (reused) {
-          console.error(chalk.green(`\n↪ CI indisponível (${outcome.reason}) — stamp fresco reaproveitado (sha ${reused.sha.slice(0, 8)}, ${reused.ts}): nada mudou fora de .morph/ desde aquela rodada verde.\n`));
-          if (options.json) {
-            console.log(JSON.stringify({
-              feature: featureName, status: reused.status, nodes: reused.nodes, e2eReason: reused.e2eReason ?? null,
-              reused: { sha: reused.sha, ts: reused.ts, source: reused.source ?? 'local' }, persisted: false, reason: 'stamp-reused',
-            }, null, 2));
-          }
-          process.exit(0);
-        }
         console.error(chalk.yellow(`\n↪ CI indisponível (${outcome.reason}) — verify local.\n`));
       }
     } catch (err) {
@@ -240,6 +240,7 @@ export async function verifyCommand(featureName, options = {}) {
       status: result.status,
       nodes: nodeStatuses(result),
       attempts: (prevEntry?.attempts ?? 0) + 1,
+      failStreak: result.status === 'fail' ? (prevEntry?.failStreak ?? 0) + 1 : 0,
       updatedAt: now,
     };
     await updateFeature(featureName, historyKey, compact);
@@ -277,8 +278,12 @@ export async function verifyCommand(featureName, options = {}) {
   }
 
   if (options.json) {
+    // Each node's tail is already in `feedback`, prefixed by node: printing it twice doubles what the session ingests.
+    const withoutOutput = ({ output: _, ...rest }) => rest;
+    const nodes = Object.fromEntries(Object.entries(result.nodes).map(([k, node]) => [k,
+      Array.isArray(node.runs) ? { ...withoutOutput(node), runs: node.runs.map(withoutOutput) } : withoutOutput(node)]));
     const output = {
-      ...result, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup,
+      ...result, nodes, persisted: persist, ...(persist ? {} : { reason }), repeatOf, cleanup,
       ...(ci ? { source: 'ci', ciRun: { id: ci.run.databaseId, url: ci.run.url, sha: ci.run.headSha }, workflowCreated: ci.created } : {}),
     };
     console.log(JSON.stringify(output, null, 2));

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

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirS
 import { join, dirname } from 'path';
 import { getAllOutputPaths, getOutputPath } from '../paths/output-schema.js';
 import { derivePhaseFrom, diskArtifactProbe } from '../../../framework/hooks/shared/state-reader.js';
+import { recordGateEvent } from '../../../framework/hooks/shared/gate-event.js';
 
 const STATE_FILE_NAME = '.morph/state.json';
 const FEATURES_DIR_NAME = '.morph/features';
@@ -649,6 +650,9 @@ export async function setApprovalGate(featureName, gate, approved, metadata = {}
 
   state.features[featureName] = feature;
   saveState(state);
+  recordGateEvent(process.cwd(), {
+    feature: featureName, gate, step: approved ? 'approve' : 'unapprove', approvedBy: feature.approvalGates[gate].approvedBy,
+  });
 }
 
 export function getApprovalGate(featureName, gate) {

package/src/dashboard/app/main.jsx

@@ -1,13 +1,13 @@
-import { StrictMode } from 'react';
-import { createRoot } from 'react-dom/client';
-import { BrowserRouter } from 'react-router-dom';
-import App from './App.jsx';
-import './styles/index.css';
-
-createRoot(document.getElementById('root')).render(
-  <StrictMode>
-    <BrowserRouter>
-      <App />
-    </BrowserRouter>
-  </StrictMode>
-);
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { BrowserRouter } from 'react-router-dom';
+import App from './App.jsx';
+import './styles/index.css';
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </StrictMode>
+);

package/src/dashboard/app/pages/FeatureDetail.jsx

@@ -26,11 +26,12 @@ const TABS = [
 const SLICE_STATUS = {
   feito: { label: 'feita', tone: 'text-[var(--color-ok)]', icon: CheckCircle },
   parcial: { label: 'parcial', tone: 'text-[var(--color-phase-implement)]', icon: CircleDashed },
+  bloqueado: { label: 'bloqueada', tone: 'text-[var(--color-warn)]', icon: PauseCircle },
   pendente: { label: 'pendente', tone: 'text-[var(--color-faint)]', icon: Circle },
 };
 
 function isReady(sl, byId) {
-  if (sl.status === 'feito') return false;
+  if (sl.status === 'feito' || sl.status === 'bloqueado') return false;
   return (sl.depends || []).every((d) => byId[d]?.status === 'feito');
 }
 
@@ -67,6 +68,8 @@ export function nextAction(f) {
   if (paused) return `O ${GATE_LABEL[paused.gate] || paused.gate} pausou${paused.reason ? `: ${paused.reason}` : ''}. A decisão é sua, no Claude Code.`;
   if (f.inEvaluation) return 'Os relatórios do Gate 3 chegaram. A decisão sai dos vereditos, dos bloqueadores e dos cenários provados.';
   if (f.phase === 'implement' && f.slicesList?.length) {
+    const blocked = f.slicesList.find((sl) => sl.status === 'bloqueado');
+    if (blocked) return `${blocked.id} está bloqueada: o relatório traz uma pergunta que só você responde, no Claude Code.`;
     const open = f.slicesList.find((sl) => sl.status === 'parcial') || f.slicesList.find((sl) => sl.status === 'pendente');
     if (open) return `${f.slices.done} de ${f.slices.total} fatias feitas. Próxima: ${open.id}, ${open.title}.`;
     return 'Todas as fatias feitas. Falta o verify da feature e a revisão.';
@@ -330,6 +333,7 @@ function SliceRow({ sl, f, open, onToggle, ready }) {
 const BOARD_COLUMNS = [
   { id: 'pendente', label: 'Pendentes' },
   { id: 'parcial', label: 'Parciais' },
+  { id: 'bloqueado', label: 'Bloqueadas' },
   { id: 'feito', label: 'Feitas' },
 ];
 
@@ -389,7 +393,7 @@ function SlicesTab({ f, view = 'list', onView = () => {} }) {
       <div className="flex flex-wrap items-center justify-between gap-3">
         <Segmented label="Visualização das fatias" value={view} onChange={onView} options={[{ id: 'list', label: 'Lista', icon: Rows }, { id: 'board', label: 'Quadro', icon: Kanban }]} />
         <p className="text-sm text-[var(--color-dim)]">
-          {f.slices.done} de {f.slices.total} feitas{f.slices.partial ? `, ${f.slices.partial} parciais` : ''}{ready ? `, ${ready} prontas para começar` : ''}
+          {f.slices.done} de {f.slices.total} feitas{f.slices.partial ? `, ${f.slices.partial} parciais` : ''}{f.slices.blocked ? `, ${f.slices.blocked} bloqueadas` : ''}{ready ? `, ${ready} prontas para começar` : ''}
         </p>
       </div>
       {view === 'board' ? <SlicesBoard f={f} byId={byId} /> : (

package/src/dashboard/scanner/features-scanner.js

@@ -123,10 +123,13 @@ export function readSlices(dir) {
       covers: Array.isArray(x.covers) ? x.covers : [],
     };
   });
-  return { counts: { total: progress.total, done: progress.done, partial: progress.partial, pending: progress.pending }, list };
+  return {
+    counts: { total: progress.total, done: progress.done, partial: progress.partial, blocked: progress.blocked, pending: progress.pending },
+    list,
+  };
 }
 
-const NO_SLICES = { total: 0, done: 0, partial: 0, pending: 0 };
+const NO_SLICES = { total: 0, done: 0, partial: 0, blocked: 0, pending: 0 };
 
 function gatesOf(feature) {
   const skipped = new Set(feature.skippedPhases || []);

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/ci/workflow-scaffold.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync } from 'fs';
 import { join, posix, relative, resolve } from 'path';
 import { PACKAGE_LOCATIONS } from '../detectors/index.js';
 import { CI_ARTIFACT, CI_RESULT_FILE } from './github-ci.js';
+import { discoverDotnetSolution } from '../tasks/test-runner.js';
 
 const LOCKFILES = [
   ['package-lock.json', 'npm ci'],
@@ -50,6 +51,16 @@ function dotnetSetup(root, config) {
   ];
 }
 
+// The verify build node runs `dotnet build --no-restore` (right on a warm tree): a fresh checkout restores first,
+// against the same target the build node resolves.
+function dotnetRestore(root, config) {
+  if (!usesDotnet(root, config)) return [];
+  const backend = config?.project?.backendPath;
+  if (typeof backend === 'string') return step('dotnet restore', backend, 'dotnet restore');
+  const { target } = discoverDotnetSolution(root);
+  return step('dotnet restore', '.', target && target !== '.' ? `dotnet restore "${target}"` : 'dotnet restore');
+}
+
 const step = (name, dir, run) => [
   `      - name: ${name}`,
   ...(dir === '.' ? [] : [`        working-directory: ${posix.normalize(dir)}`]),
@@ -94,6 +105,7 @@ export function renderCiWorkflow(root, config) {
     lines.push(...step(`install (${pkg.dir})`, pkg.dir, pkg.install));
     if (pkg.playwright) lines.push(...step(`playwright browsers (${pkg.dir})`, pkg.dir, 'npx playwright install --with-deps chromium'));
   }
+  lines.push(...dotnetRestore(root, config));
   lines.push(
     '      - name: morph-spec verify',
     '        shell: bash',

package/src/lib/e2e/applicability.js

@@ -0,0 +1,37 @@
+import { basename } from 'path';
+import { readPlanChecks } from '../plan/checks.js';
+import { changedPathsAgainst, detectDefaultBranch } from '../git/default-branch.js';
+import { resolveComposeFile } from '../../../framework/hooks/shared/e2e-check.js';
+import { E2E_SPEC_LOCATIONS } from '../../../framework/hooks/shared/frontend-locations.js';
+
+export const E2E_NOT_APPLICABLE = 'not applicable: no `prova: e2e` scenario and the diff touches no UI, e2e spec or container file';
+
+const UI_FILE = /\.(tsx|jsx|vue|svelte|astro|css|scss|sass|less|html)$/i;
+const RUNTIME_FILE = /(^|\/)(dockerfile[^/]*|\.dockerignore|(docker-)?compose[^/]*\.ya?ml|playwright\.config\.[cm]?[jt]s)$/i;
+const E2E_DIR = /(^|\/)e2e\//i;
+const KNOWN_PACKAGE_DIRS = E2E_SPEC_LOCATIONS.filter((dir) => dir !== '.');
+
+function packageDirsOf(config) {
+  const declared = [config?.project?.frontendPath, ...(config?.project?.tests ?? []).filter((n) => n?.runner !== 'dotnet').map((n) => n?.cwd)];
+  const extra = declared.filter((d) => typeof d === 'string').map((d) => d.replace(/\\/g, '/').replace(/^\.\/|\/$/g, '')).filter((d) => d && d !== '.');
+  return [...KNOWN_PACKAGE_DIRS, ...extra];
+}
+
+const touchesRuntime = (file, composeFile, packageDirs) => UI_FILE.test(file)
+  || RUNTIME_FILE.test(file)
+  || E2E_DIR.test(file)
+  || (composeFile && basename(file) === basename(composeFile))
+  || packageDirs.some((dir) => file === dir || file.startsWith(`${dir}/`));
+
+/** Unknown (no git, no base, empty diff) is applicable: the e2e only stands down on evidence. */
+export function e2eApplicability(projectPath, featureName, config) {
+  const { checks } = readPlanChecks(projectPath, featureName);
+  if (checks?.checks?.some((c) => c.proof === 'e2e')) return { applicable: true, reason: 'prova: e2e' };
+  const base = detectDefaultBranch(projectPath);
+  const changed = base ? changedPathsAgainst(base, projectPath).filter((f) => !f.startsWith('.morph/')) : [];
+  if (changed.length === 0) return { applicable: true, reason: 'diff unknown' };
+  const composeFile = resolveComposeFile(projectPath, config);
+  const packageDirs = packageDirsOf(config);
+  const hit = changed.find((f) => touchesRuntime(f, composeFile, packageDirs));
+  return hit ? { applicable: true, reason: hit } : { applicable: false, reason: E2E_NOT_APPLICABLE };
+}

package/src/lib/generators/handoff-generator.js

@@ -6,6 +6,8 @@ import { join } from 'path';
 import { ensureCommonExclude } from '../../../framework/hooks/shared/git-exclude.js';
 import { derivePhaseForFeature, getPendingGates } from '../../../framework/hooks/shared/state-reader.js';
 import { sliceProgress, readySlices } from '../../../framework/hooks/shared/slice-progress.js';
+import { formatNext } from '../../../framework/hooks/shared/next-step.js';
+import { nextStepFor } from '../next-step.js';
 
 const POINTER_CANDIDATES = [
   ['2-plan/plan.md', 'plano: problema, cenários com prova, decisões e fatias'],
@@ -46,29 +48,13 @@ function readWorktreeEnv(cwd) {
   }
 }
 
-function nextAction(feature, phase, slices, featureName) {
-  const gates = feature.approvals || feature.approvalGates || {};
-  const approved = (g) => gates[g]?.approved === true;
-
-  switch (phase) {
-    case 'plan':
-      return `Escreva \`2-plan/plan.md\`, rode \`morph-spec plan-check ${featureName}\` até zero erro e aprove o gate do plano (\`morph-spec advance ${featureName}\`). Skill: /morph-plan ${featureName}.`;
-    case 'uiux':
-      return approved('uiux')
-        ? `Gate de uiux aprovado — implemente as fatias do plano via /morph-apply ${featureName}.`
-        : `Complete \`1-design/design-system.md\` e aprove o gate de uiux (\`morph-spec advance ${featureName}\`).`;
-    case 'implement': {
-      const ready = readySlices(slices).map((s) => `${s.id} "${s.title}"`).join(', ');
-      return ready
-        ? `Implemente as fatias prontas — ${ready} — via /morph-apply ${featureName} (cada fatia grava 3-implement/reports/{id}.md).`
-        : `Todas as fatias têm relatório final — rode \`morph-spec verify ${featureName}\` e siga para a review. Skill: /morph-apply ${featureName}.`;
-    }
-    case 'review':
-      return approved('review')
-        ? `Gate 3 aprovado — feche: \`morph-spec finish ${featureName} --pr\` (abre PR) ou \`--merge\` (merge local na default). Arquiva + integra num passo.`
-        : `Rode /morph-review ${featureName} (verificador ∥ revisor, segurança se exigida) e aprove o Gate 3; depois \`morph-spec finish ${featureName} --pr|--merge\`.`;
-    default:
-      return `Rode \`morph-spec status ${featureName}\` para orientar o próximo passo.`;
+function nextLine(featureName, cwd) {
+  const fallback = `Rode \`morph-spec next ${featureName}\`.`;
+  try {
+    const next = nextStepFor(featureName, cwd);
+    return next ? formatNext(next) : fallback;
+  } catch {
+    return fallback;
   }
 }
 
@@ -129,7 +115,7 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     '',
     `- Gates: ${gateLine}`,
     slices
-      ? `- Fatias: ${slices.done}/${slices.total} feitas${slices.partial ? ` · ${slices.partial} parcial(is)` : ''} · prontas agora: ${readySlices(slices).map((s) => `**${s.id}** "${s.title}"`).join(', ') || 'nenhuma'}`
+      ? `- Fatias: ${slices.done}/${slices.total} feitas${slices.partial ? ` · ${slices.partial} parcial(is)` : ''}${slices.blocked ? ` · ${slices.blocked} bloqueada(s)` : ''} · prontas agora: ${readySlices(slices).map((s) => `**${s.id}** "${s.title}"`).join(', ') || 'nenhuma'}`
       : '- Fatias: sem checks.json ainda (rode plan-check)',
     pendingGates.length ? `- Gates pendentes: ${pendingGates.join(', ')}` : null,
     '',
@@ -141,7 +127,7 @@ export function buildHandoff(featureName, cwd = process.cwd(), opts = {}) {
     '',
     '## Próxima ação',
     '',
-    nextAction(feature, phase, slices, featureName),
+    nextLine(featureName, cwd),
     '',
     '## Retomar',
     '',

package/src/lib/mutation/adapters.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import { dotnetBuildCommands, withFilter, withTrx, withoutBuild } from './commands.js';
-import { methodOf, parseTrx } from './trx.js';
+import { parseTrx } from './trx.js';
 import { stripAnsi } from '../tasks/test-runner.js';
 
 const MAX_CAPTURE = 16 * 1024 * 1024;
@@ -39,14 +39,10 @@ export function dotnetAdapter({ node, root, workDir, exec, subset, timeoutMs })
   const trxDir = join(workDir, 'trx');
   mkdirSync(trxDir, { recursive: true });
   const base = withoutBuild(node.command);
-  const filterOf = { subset: () => subset.filter, names: (filter) => filter };
-  const commandFor = (scope, label, filter) => withTrx(
-    scope === 'full' ? base : withFilter(base, filterOf[scope](filter)),
-    { dir: trxDir, name: `${label}.trx` },
-  );
-  const runTests = async ({ scope, label, env, filter }) => {
+  const commandFor = (label) => withTrx(withFilter(base, subset.filter), { dir: trxDir, name: `${label}.trx` });
+  const runTests = async ({ label, env }) => {
     const trxPath = join(trxDir, `${label}.trx`);
-    const r = await exec(commandFor(scope, label, filter), { cwd, env, timeoutMs, label });
+    const r = await exec(commandFor(label), { cwd, env, timeoutMs, label });
     if (!existsSync(trxPath)) {
       return { outcome: 'crash', executed: null, total: null, failed: 0, failedTests: [], durationMs: r.durationMs, note: r.timedOut ? `timeout de ${timeoutMs} ms` : `sem TRX (exit ${r.status})` };
     }
@@ -62,12 +58,6 @@ export function dotnetAdapter({ node, root, workDir, exec, subset, timeoutMs })
     buildCommands: dotnetBuildCommands(node, root),
     cwd,
     runTests,
-    reproduce: ({ names, label, env }) => runTests({
-      scope: 'names',
-      label,
-      env,
-      filter: [...new Set(names.map(methodOf))].map((n) => `FullyQualifiedName~${n}`).join('|'),
-    }),
   };
 }
 
@@ -78,9 +68,8 @@ export function genericAdapter({ node, root, exec, subset, timeoutMs }) {
     hasSubset: Boolean(subset?.usable),
     buildCommands: [],
     cwd,
-    async runTests({ scope, label, env }) {
-      const command = scope === 'subset' ? subset.command : node.command;
-      const r = await exec(command, { cwd, env, timeoutMs, label });
+    async runTests({ label, env }) {
+      const r = await exec(subset.command, { cwd, env, timeoutMs, label });
       if (r.timedOut) return { outcome: 'crash', executed: null, total: null, failed: 0, failedTests: [], durationMs: r.durationMs, note: `timeout de ${timeoutMs} ms` };
       if (r.status === 0) return { outcome: 'green', executed: null, total: null, failed: 0, failedTests: [], durationMs: r.durationMs };
       const failedTests = genericFailures(`${r.stdout}\n${r.stderr}`);