@polymorphism-tech/morph-spec 9.2.0 → 9.3.0

package/src/commands/project/status.js

@@ -1,6 +1,8 @@
 import chalk from 'chalk';
 import { loadState, getFeature, derivePhase, deriveOutputs } from '../../core/state/state-manager.js';
 import { sliceProgress } from '../../../framework/hooks/shared/slice-progress.js';
+import { formatNext } from '../../../framework/hooks/shared/next-step.js';
+import { nextStepFor } from '../../lib/next-step.js';
 
 const PHASE_SYMBOLS = {
   completed: '✅',
@@ -87,60 +89,6 @@ function calculateCompletionPercentage(feature) {
   return Math.round((completedPhases / totalPhases) * 100);
 }
 
-function getNextSteps(feature) {
-  const steps = [];
-
-  const phaseApprovalMap = {
-    plan: 'plan',
-    uiux: 'uiux',
-    implement: 'plan',
-    review: 'review'
-  };
-
-  const relevantGate = phaseApprovalMap[feature.phase];
-  const approvalGates = feature.approvalGates || {};
-
-  if (relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved) {
-    steps.push({
-      type: 'approval',
-      message: `Approve ${relevantGate} to advance`,
-      command: `morph-spec approve ${feature.name || 'feature'} ${relevantGate}`
-    });
-  }
-
-  const requiredOutputs = feature.phase === 'uiux' ? [] : PHASE_OUTPUTS[feature.phase] || [];
-  const missingOutputs = requiredOutputs.filter(o => !feature.outputs[o]?.created);
-
-  if (missingOutputs.length > 0) {
-    steps.push({
-      type: 'output',
-      message: `Create missing outputs: ${missingOutputs.join(', ')}`,
-      command: null
-    });
-  }
-
-  const hasApprovalPending = relevantGate && approvalGates[relevantGate] && !approvalGates[relevantGate].approved;
-  if (missingOutputs.length === 0 && !hasApprovalPending) {
-    const currentPhaseIndex = PHASE_ORDER.findIndex(p => p.key === feature.phase);
-    if (currentPhaseIndex >= 0 && currentPhaseIndex < PHASE_ORDER.length - 1) {
-      const nextPhase = PHASE_ORDER[currentPhaseIndex + 1];
-      steps.push({
-        type: 'advance',
-        message: `Advance to ${nextPhase.name}`,
-        command: `morph-spec phase advance ${feature.name || 'feature'}`
-      });
-    } else if (currentPhaseIndex === PHASE_ORDER.length - 1) {
-      steps.push({
-        type: 'complete',
-        message: 'Feature complete! Consider archiving.',
-        command: null
-      });
-    }
-  }
-
-  return steps;
-}
-
 export async function statusCommand(featureName, options = {}) {
   if (!featureName) {
     console.error(chalk.red('✗ Error: Feature name required'));
@@ -191,7 +139,7 @@ export async function statusCommand(featureName, options = {}) {
       })),
       slices,
       approvals: feature.approvalGates || {},
-      nextSteps: getNextSteps(feature)
+      next: nextStepFor(featureName, process.cwd())
     };
 
     console.log(JSON.stringify(status, null, 2));
@@ -235,6 +183,7 @@ export async function statusCommand(featureName, options = {}) {
     console.log(`  Total: ${slices.total}`);
     console.log(chalk.green(`  ✓ Feitas: ${slices.done} (${percentage}%)`));
     if (slices.partial > 0) console.log(chalk.cyan(`  ▶ Parciais: ${slices.partial}`));
+    if (slices.blocked > 0) console.log(chalk.yellow(`  ⏸ Bloqueadas (esperam decisão): ${slices.blocked}`));
     if (slices.pending > 0) console.log(chalk.gray(`  ⬜ Pendentes: ${slices.pending}`));
     console.log('');
   }
@@ -258,19 +207,8 @@ export async function statusCommand(featureName, options = {}) {
     console.log('');
   }
 
-  const nextSteps = getNextSteps(feature);
-  if (nextSteps.length > 0) {
-    console.log(chalk.white.bold('Next Steps:'));
-    nextSteps.forEach((step, index) => {
-      console.log(chalk.yellow(`  ${index + 1}. ${step.message}`));
-      if (step.command) {
-        console.log(chalk.gray(`     → ${step.command}`));
-      }
-    });
-    console.log('');
-  } else {
-    console.log(chalk.green('✓ Nada pendente.\n'));
-  }
+  const next = nextStepFor(featureName, process.cwd());
+  if (next) console.log(chalk.yellow(`${formatNext(next)}\n`));
 
   console.log(chalk.gray('─'.repeat(60)));
   console.log(chalk.gray('Run with --verbose for detailed output'));

package/src/commands/state/advance.js

@@ -143,7 +143,7 @@ export async function advanceCommand(featureName, options = {}) {
         process.exit(1);
       }
 
-      console.error(chalk.red(`\n❌ A fase "${phase}" não pode ser encerrada — artefato(s) obrigatório(s) ausente(s) ou PARCIAL:`));
+      console.error(chalk.red(`\n❌ A fase "${phase}" não pode ser encerrada — artefato(s) obrigatório(s) ausente(s), PARCIAL ou BLOQUEADO:`));
       for (const rel of missingArtifacts) console.error(chalk.gray(`   • ${rel}`));
       console.error(chalk.gray('\n   Produza o artefato e rode de novo, ou passe --force para avançar assim mesmo.\n'));
       process.exit(1);

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

@@ -189,10 +189,10 @@ export async function gateCheckCommand(featureName, gateName, options = {}) {
     const computed = shouldPauseGate({ trust }, signals);
     const manual = feature.gateDecisions?.[gateName];
     const manualPause = manual?.source === 'manual' && manual.pause === true;
-    const { pause, reason } = manualPause ? { pause: true, reason: manual.reason } : computed;
+    const { pause, reason, signal } = manualPause ? { pause: true, reason: manual.reason, signal: 'manual' } : computed;
 
     const entry = await persistGateDecision(featureName, gateName, {
-      pause, reason, signals, trust, cwd, source: manualPause ? 'manual' : 'gate-check',
+      pause, reason, signal, signals, trust, cwd, source: manualPause ? 'manual' : 'gate-check',
     });
 
     if (options.json) {

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

@@ -4,6 +4,7 @@ import { join } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 import { mockupsHash } from '../../lib/specs/screen-checklist.js';
+import { recordGateEvent } from '../../../framework/hooks/shared/gate-event.js';
 
 export const VALID_GATES = ['plan', 'uiux', 'review'];
 
@@ -31,7 +32,7 @@ export function readTrustFromConfig() {
  * The ONE write path of `gateDecisions.{gate}`, shared by `gate-decision` and `gate-check`.
  * Does not validate `gateName`. A uiux decision records the `mockupsHash` it saw.
  */
-export async function persistGateDecision(featureName, gateName, { pause, reason, signals = {}, trust, cwd = process.cwd(), source } = {}) {
+export async function persistGateDecision(featureName, gateName, { pause, reason, signal, signals = {}, trust, cwd = process.cwd(), source } = {}) {
   const entry = {
     pause,
     reason: reason || (pause ? 'risco detectado' : 'nenhum sinal de risco'),
@@ -43,6 +44,7 @@ export async function persistGateDecision(featureName, gateName, { pause, reason
   };
 
   await updateFeature(featureName, `gateDecisions.${gateName}`, entry);
+  recordGateEvent(cwd, { feature: featureName, gate: gateName, step: 'decision', pause, signal, source });
   return entry;
 }
 
@@ -91,6 +93,7 @@ export async function gateDecisionCommand(featureName, gateName, options = {}) {
     const entry = await persistGateDecision(featureName, gateName, {
       pause,
       reason: options.reason,
+      signal: 'manual',
       signals,
       trust: options.trust,
       source: 'manual',

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/verify.js

@@ -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/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/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/next-step.js

@@ -0,0 +1,10 @@
+import { collectNextSignals, decideNext } from '../../framework/hooks/shared/next-step.js';
+import { treeMovedSince } from './git/evidence-staleness.js';
+
+/** The CLI collector: the hook-readable facts plus verify staleness (git). Null without feature.json. */
+export function nextStepFor(featureName, tree) {
+  const signals = collectNextSignals(featureName, tree);
+  if (!signals) return null;
+  signals.verificationStale = treeMovedSince(tree, signals.verification?.sha);
+  return { ...decideNext(signals), phase: signals.phase, failStreak: signals.failStreak };
+}

package/src/lib/risk-detector.js

@@ -158,23 +158,25 @@ export function shouldPauseGate(config, signals) {
   const trust = config?.trust ?? 'auto';
 
   if (trust === 'manual') {
-    return { pause: true, reason: 'trust mode is manual' };
+    return { pause: true, signal: 'trust-manual', reason: 'trust mode is manual' };
   }
 
   if (FORCED_PAUSE_WORK_TYPES.includes(signals.workType)) {
     return {
       pause: true,
+      signal: 'hotfix',
       reason: 'hotfix: aprovação humana obrigatória no ship (política de tipo — ignora trust:auto)',
     };
   }
 
   if (signals.designSystemDivergence) {
-    return { pause: true, reason: 'design-system divergence detected' };
+    return { pause: true, signal: 'design-system', reason: 'design-system divergence detected' };
   }
 
   if (Array.isArray(signals.standardsViolations) && signals.standardsViolations.length > 0) {
     return {
       pause: true,
+      signal: 'standards',
       reason: `standards violations detected: ${signals.standardsViolations.join(', ')}`,
     };
   }
@@ -183,6 +185,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.verificationStatus === 'fail') {
     return {
       pause: true,
+      signal: 'verify-red',
       reason: 'último morph-spec verify está VERMELHO — rode verify e corrija antes de aprovar o gate',
     };
   }
@@ -191,6 +194,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && !signals.verificationStatus) {
     return {
       pause: true,
+      signal: 'verify-missing',
       reason: 'nenhum `morph-spec verify` carimbado nesta feature — rode `morph-spec verify {feature}` antes do ship',
     };
   }
@@ -200,7 +204,7 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && signals.e2eStatus === 'skip') {
     const klass = classifyE2eSkip(signals.e2eReason);
     if (E2E_SKIP_CLASSES_THAT_PAUSE.includes(klass)) {
-      return { pause: true, reason: e2ePauseReason(klass, signals.e2eReason) };
+      return { pause: true, signal: 'e2e-skip', reason: e2ePauseReason(klass, signals.e2eReason) };
     }
   }
 
@@ -208,13 +212,14 @@ export function shouldPauseGate(config, signals) {
   if (signals.gate === 'review' && signals.verificationStale === true) {
     return {
       pause: true,
+      signal: 'verify-stale',
       reason: 'verification stamp desatualizado (o código mudou depois do commit do stamp) — rode `morph-spec verify` de novo antes do ship',
     };
   }
 
   if (signals.gate === 'review') {
     const reason = reviewPause(signals.reviewReports);
-    if (reason) return { pause: true, reason };
+    if (reason) return { pause: true, signal: 'review-reports', reason };
   }
 
   // Prompt e modelo não são lidos por build nem por teste. Depois dos relatórios de review de propósito:
@@ -229,6 +234,7 @@ export function shouldPauseGate(config, signals) {
     if (signals.evalsStatus === null || signals.evalsStatus === undefined) {
       return {
         pause: true,
+        signal: 'prompt-model-no-eval',
         reason: `mudou prompt/modelo (${where}) e o projeto não declara nó de eval`
               + ' — nenhum build ou teste unitário fica vermelho por um prompt trocado;'
               + ' declare um `runner: "evals"` em project.tests[] ou registre a dispensa com `morph-spec gate-decision`',
@@ -237,6 +243,7 @@ export function shouldPauseGate(config, signals) {
     if (signals.evalsStatus === 'skip') {
       return {
         pause: true,
+        signal: 'prompt-model-eval-skip',
         reason: `mudou prompt/modelo (${where}) e o eval não foi executado neste verify`
               + ' — rode `morph-spec verify {feature}` (escopo de feature) antes do ship',
       };
@@ -250,6 +257,7 @@ export function shouldPauseGate(config, signals) {
       && signals.mediaClaims.section !== true) {
     return {
       pause: true,
+      signal: 'media-claims',
       reason: '`4-review/verifier.md` sem a seção `## Mídia gerada` — as quatro afirmações de mídia'
             + ' (custo, revisão humana, marcação, hot path) não foram provadas'
             + ' (evals/review-checklist.md, "Verificador")',
@@ -259,7 +267,7 @@ export function shouldPauseGate(config, signals) {
   // Sem o checklist de tela completo, paginação, ordenação, filtro e os três estados não viram cenário.
   if (signals.gate === 'uiux') {
     const reason = uiuxChecklistPause(signals.screenChecklist);
-    if (reason) return { pause: true, reason };
+    if (reason) return { pause: true, signal: 'uiux-checklist', reason };
   }
 
   // Cobra-se só o item devido (`uncovered`): tela toda "não se aplica", design legado ou ausente não devem nada.
@@ -268,6 +276,7 @@ export function shouldPauseGate(config, signals) {
     if (section !== true) {
       return {
         pause: true,
+        signal: 'screen-checklist',
         reason: `\`4-review/verifier.md\` sem a seção \`## Checklist de tela\` — o design decidiu ${firstOf(uncovered)}`
               + ' e o verificador não registrou a conferência contra a tela entregue'
               + ' (evals/review-checklist.md, "Contrato de tela")',
@@ -275,6 +284,7 @@ export function shouldPauseGate(config, signals) {
     }
     return {
       pause: true,
+      signal: 'screen-checklist',
       reason: `a seção \`## Checklist de tela\` não confere ${firstOf(uncovered)}`
             + ' — uma linha por item decidido de cada tela, mesmo quando não verificável',
     };
@@ -282,17 +292,18 @@ export function shouldPauseGate(config, signals) {
 
   if (signals.gate === 'plan') {
     const reason = planChecksPause(signals.planChecks);
-    if (reason) return { pause: true, reason };
+    if (reason) return { pause: true, signal: 'plan-checks', reason };
   }
 
   if (typeof signals.sliceCount === 'number' && signals.sliceCount > MAX_SLICES) {
     return {
       pause: true,
+      signal: 'slice-count',
       reason: `${signals.sliceCount} fatias, acima de ${MAX_SLICES} — o plano é grande demais para uma feature`,
     };
   }
 
-  return { pause: false, reason: '' };
+  return { pause: false, signal: null, reason: '' };
 }
 
 export function getRiskSignals(signals) {

package/src/lib/stack/stack-scan.js

@@ -99,7 +99,19 @@ function auditDotnet(files, read) {
   const otherDb = has(/^(Microsoft\.EntityFrameworkCore\.SqlServer|Pomelo\.EntityFrameworkCore\.MySql|MySql\.|MySqlConnector|Microsoft\.Data\.SqlClient|System\.Data\.SqlClient)/);
   rows.push({ layer: 'ORM', detected: ef.length > 0 ? 'EF Core' : (packages.has('Dapper') ? 'Dapper' : 'ausente'), expected: 'EF Core', ok: ef.length > 0 });
   rows.push({ layer: 'Banco', detected: npgsql.length > 0 ? 'Postgres (Npgsql)' : (otherDb.join(', ') || 'ausente'), expected: 'Neon (Postgres)', ok: npgsql.length > 0 && otherDb.length === 0 });
-  rows.push({ layer: 'IA', detected: has(/^Microsoft\.(Agents\.AI|Extensions\.AI)/).join(', ') || 'ausente', expected: 'MAF quando houver agentes', ok: true });
+  const semanticKernel = has(/^Microsoft\.SemanticKernel/);
+  const kernelFunction = grepFiles(source, read, /\[KernelFunction\b/);
+  const hostedAgents = has(/^Azure\.AI\.(Projects|Agents\.Persistent)\b/);
+  const floatingAi = has(/^(Microsoft\.Agents\.AI|Microsoft\.Extensions\.AI|OpenAI$|Google\.GenAI$|ModelContextProtocol)/)
+    .filter((p) => /\*|^[[(]/.test(packages.get(p) ?? ''));
+  rows.push({ layer: 'IA', detected: has(/^Microsoft\.(Agents\.AI|Extensions\.AI|SemanticKernel)/).join(', ') || 'ausente', expected: 'MAF quando houver agentes', ok: semanticKernel.length === 0 && kernelFunction.length === 0 && hostedAgents.length === 0 });
+  const antiPatterns = '`morph-spec standards --show ai-agents-setup#7-what-not-to-do-anti-patterns`';
+  if (semanticKernel.length > 0 || kernelFunction.length > 0) {
+    add('Alto', `Semantic Kernel em vez de MAF (${semanticKernel.join(', ') || '`[KernelFunction]`'})`, [...(semanticKernel.length > 0 ? projects : []), ...kernelFunction],
+      `\`Microsoft.Agents.AI\` (\`agent.RunAsync()\`, tool por \`AIFunctionFactory.Create()\`); ${antiPatterns}`);
+  }
+  if (hostedAgents.length > 0) add('Alto', `Serviço de agente hospedado (${hostedAgents.join(', ')})`, projects, `modelo direto por \`IChatClient\`; ${antiPatterns}`);
+  for (const p of floatingAi) add('Médio', `Versão flutuante de SDK de IA (${p} ${packages.get(p)})`, [], 'versão exata, a do pin (`morph-spec doctor --ai`)');
   rows.push({ layer: 'Jobs', detected: has(/^Hangfire/).length > 0 ? 'Hangfire' : 'ausente', expected: 'Hangfire só com razão real', ok: true });
   if (packages.has('Dapper') && ef.length === 0) add('Bloqueante', 'ORM diferente (Dapper puro sem EF Core)', projects, 'migrar o acesso a dados para EF Core');
   if (otherDb.length > 0) add('Bloqueante', `Banco diferente (${otherDb.join(', ')})`, projects, 'migrar para Neon (Postgres, Npgsql)');

package/src/lib/telemetry/metrics.js

@@ -4,6 +4,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';
 
 export const RERUN_WINDOW_MS = 10 * 60 * 1000;
 
@@ -122,6 +123,43 @@ function reuseStateOf(e) {
   return { state: 'absent', reason: null };
 }
 
+const newGateSlot = () => ({ decisions: 0, paused: 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.
+function trackGate(gates, open, e) {
+  if (!e.gate || !GATE_STEPS.includes(e.step)) return;
+  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 credit = (field) => {
+    slot[field] += 1;
+    bySignal(pending.signal)[field] += 1;
+  };
+
+  if (e.step === 'unapprove') {
+    slot.unapproved += 1;
+    return;
+  }
+  if (e.step === 'approve') {
+    if (pending) credit('approvedAfterPause');
+    open.delete(key);
+    return;
+  }
+  slot.decisions += 1;
+  if (pending && e.pause && e.signal === pending.signal) 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 });
+  } else {
+    slot.autoPassed += 1;
+    open.delete(key);
+  }
+}
+
 /** The returned shape is documented in framework/docs/CLI.md, "cost --metrics". */
 export function computeMetrics(events, opts = {}) {
   const top = Number.isInteger(opts.top) && opts.top > 0 ? opts.top : 10;
@@ -140,6 +178,8 @@ export function computeMetrics(events, opts = {}) {
   const lastFingerprint = new Map();
   const unchangedRepeats = {};
   const reuse = { runs: 0, byTree: {}, skipReasons: {} };
+  const gates = {};
+  const openPauses = new Map();
   let v2 = 0;
   let legacy = 0;
   let turnsObserved = false;
@@ -166,6 +206,11 @@ export function computeMetrics(events, opts = {}) {
       continue;
     }
 
+    if (e.event === GATE_EVENT) {
+      trackGate(gates, openPauses, e);
+      continue;
+    }
+
     if (e.event === 'Verify') {
       if (e.fingerprint && e.persisted !== false) {
         if (lastFingerprint.get(fkey) === e.fingerprint) {
@@ -291,6 +336,7 @@ export function computeMetrics(events, opts = {}) {
     },
     dotnetFullSuite: fullSuite,
     reuse,
+    gates,
     features: featureRows,
   };
 }

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

@@ -713,7 +713,7 @@ async function runE2eNode({
       command: result.command ?? null,
       durationMs,
       reason: result.reason ?? null,
-      output: result.output || '',
+      output: tailLines(result.output || '', OUTPUT_TAIL_LINES),
       count: Number.isInteger(result.count) ? result.count : null,
       warnings: Array.isArray(result.warnings) ? result.warnings : [],
     },