@polymorphism-tech/morph-spec 9.2.0 → 9.4.0

package/framework/templates/REGISTRY.json

@@ -642,213 +642,6 @@
       "isFragment": true,
       "validatePlaceholders": true
     },
-    {
-      "id": "hop-squad-leader",
-      "kind": "template",
-      "name": "Squad Leader HOP",
-      "path": "meta-prompts/squad-leaders/squad-leader.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "Generic squad leader higher-order prompt with mission, domain-leaders, standards, tasks, deliverables, constraints",
-      "outputName": "squad-leader-prompt.md",
-      "placeholders": [
-        "AGENT_ID",
-        "CONSTRAINTS",
-        "DELIVERABLES",
-        "DOMAIN",
-        "DOMAIN_LEADERS",
-        "FEATURE_NAME",
-        "MISSION",
-        "SPEC_SUMMARY",
-        "STANDARDS",
-        "TASKS"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "squad-leader",
-      "validatePlaceholders": true
-    },
-    {
-      "id": "hop-backend-squad",
-      "kind": "template",
-      "name": "Backend Squad Leader HOP",
-      "path": "meta-prompts/squad-leaders/backend-squad.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "Backend squad leader HOP for dotnet-senior with backend domain leaders, .NET 10 standards, architecture and security guidelines",
-      "outputName": "backend-squad-prompt.md",
-      "placeholders": [
-        "ADDITIONAL_LEADERS",
-        "AGENT_ID",
-        "CONSTRAINTS",
-        "DELIVERABLES",
-        "FEATURE_NAME",
-        "MISSION",
-        "SPEC_SUMMARY",
-        "TASKS"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "squad-leader",
-      "applicableStacks": [
-        "nextjs-neon"
-      ],
-      "validatePlaceholders": true
-    },
-    {
-      "id": "hop-frontend-squad",
-      "kind": "template",
-      "name": "Frontend Squad Leader HOP",
-      "path": "meta-prompts/squad-leaders/frontend-squad.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "Frontend squad leader HOP for ui-designer with Next.js domain leaders and design system standards",
-      "outputName": "frontend-squad-prompt.md",
-      "placeholders": [
-        "ADDITIONAL_LEADERS",
-        "AGENT_ID",
-        "CONSTRAINTS",
-        "DELIVERABLES",
-        "DOMAIN",
-        "FEATURE_NAME",
-        "MISSION",
-        "SPEC_SUMMARY",
-        "TASKS"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "squad-leader",
-      "applicableStacks": [
-        "nextjs-neon"
-      ],
-      "validatePlaceholders": true
-    },
-    {
-      "id": "hop-checkpoint-validator",
-      "kind": "template",
-      "name": "Checkpoint Validator HOP",
-      "path": "meta-prompts/validators/checkpoint-validator.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "Checkpoint validator HOP running architecture, security, design-system, and packages validators with pass/fail decision logic",
-      "outputName": "checkpoint-validator-prompt.md",
-      "placeholders": [
-        "CHECKPOINT_FREQUENCY",
-        "CHECKPOINT_NUM",
-        "FEATURE_NAME",
-        "FILES_CHANGED",
-        "RECENT_TASKS",
-        "TASKS_COMPLETED",
-        "TASKS_SINCE_LAST",
-        "TASKS_TOTAL"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "validator",
-      "validatePlaceholders": true
-    },
-    {
-      "id": "hop-pre-commit-validator",
-      "kind": "template",
-      "name": "Pre-Commit Validator HOP",
-      "path": "meta-prompts/validators/pre-commit-validator.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "Pre-commit hook validator HOP checking conventional commits, secrets, agent spec validity, and stack-specific rules",
-      "outputName": "pre-commit-validator-prompt.md",
-      "placeholders": [
-        "BRANCH_NAME",
-        "FEATURE_NAME",
-        "STAGED_FILES",
-        "STAGED_FILE_COUNT",
-        "TODO"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "validator",
-      "validatePlaceholders": false
-    },
-    {
-      "id": "hop-fusion-agent",
-      "kind": "template",
-      "name": "Fusion Agent HOP",
-      "path": "meta-prompts/fusion/fusion-agent.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "F-Thread fusion participant HOP with approach hints per thread index (standard, alternative, optimized) and self-assessment scoring",
-      "outputName": "fusion-agent-prompt.md",
-      "placeholders": [
-        "AGENT_ID",
-        "DELIVERABLES",
-        "FUSION_STRATEGY",
-        "SPEC_SUMMARY",
-        "STANDARDS",
-        "TASK_DESCRIPTION",
-        "THREAD_COUNT",
-        "THREAD_COUNT_MINUS_ONE",
-        "THREAD_ID",
-        "THREAD_INDEX"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "fusion",
-      "validatePlaceholders": true
-    },
-    {
-      "id": "hop-fusion-aggregator",
-      "kind": "template",
-      "name": "Fusion Aggregator HOP",
-      "path": "meta-prompts/fusion/fusion-aggregator.md",
-      "location": "framework",
-      "category": "meta-prompts",
-      "technology": "handlebars",
-      "phase": "implement",
-      "required": false,
-      "description": "F-Thread aggregator HOP that scores and selects the winning implementation using best-of-n, consensus, or manual-select strategies",
-      "outputName": "fusion-aggregator-prompt.md",
-      "placeholders": [
-        "AGENT_1",
-        "AGENT_2",
-        "AGENT_3",
-        "FEATURE_NAME",
-        "FUSION_RESULTS",
-        "FUSION_STRATEGY",
-        "SESSION_ID",
-        "THREAD_COUNT",
-        "WINNING_AGENT",
-        "WINNING_SCORE",
-        "WINNING_THREAD"
-      ],
-      "stackSpecific": false,
-      "engine": "handlebars",
-      "deprecated": false,
-      "hopType": "fusion",
-      "validatePlaceholders": true
-    },
     {
       "id": "dotnet-abstractions-handler",
       "kind": "fragment",

package/package.json

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

package/src/commands/observability/cost.js

@@ -145,6 +145,18 @@ function printMetricsBody(m) {
     ? trees.map(([tree, s]) => `${tree} rodou ${s.ran}, pulou ${s.skipped}`).join(' · ')
     : 'nenhum evento Verify na janela'}`);
   for (const [reason, n] of Object.entries(m.reuse.skipReasons)) console.log(chalk.gray(`    pulou ${n}×: ${reason}`));
+  const gates = Object.entries(m.gates);
+  if (!gates.length) {
+    console.log('  gates: nenhum evento Gate na janela');
+    return;
+  }
+  for (const [gate, g] of gates) {
+    console.log(`  gate ${gate}: ${g.decisions} decisões, ${g.paused} pausas → ${g.approvedAfterPause} aprovadas como estavam, `
+      + `${g.reworkedAfterPause} retrabalhadas${g.unapproved ? `, ${g.unapproved} desaprovações` : ''}`);
+    for (const [signal, s] of Object.entries(g.bySignal)) {
+      console.log(chalk.gray(`    ${signal}: ${s.paused} pausas, ${s.approvedAfterPause} aprovadas como estavam, ${s.reworkedAfterPause} retrabalhadas`));
+    }
+  }
 }
 
 function printMetrics(feature, options, cwd) {

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/project/worktree.js

@@ -743,7 +743,7 @@ export async function clearRootWorktreeRegistration(root, feature, { stamp } = {
     let unchanged = true;
     try { execFileSync('git', ['diff', '--quiet', 'HEAD', '--', featPathspec], gitOpts); } catch { unchanged = false; }
     if (!unchanged) {
-      execFileSync('git', ['commit', '-m', `morph-spec finish: clear ${feature} worktree registration`, '--', featPathspec], gitOpts);
+      execFileSync('git', ['commit', '-m', `chore(morph): clear ${feature} worktree registration`, '--', featPathspec], gitOpts);
     }
   } catch { /* fail-open — a dirty root is a nuisance, not a reason to fail */ }
   return { shedBackup: null };

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

@@ -123,7 +123,7 @@ export function runArchive(feature, opts = {}) {
       ...(adrIndex.changed ? [ADR_INDEX_PATHSPEC] : []),
     ];
     try {
-      execFileSync('git', ['commit', '-m', `morph-spec archive: ${feature}`, '--', ...pathspecs], { cwd, stdio: 'pipe' });
+      execFileSync('git', ['commit', '-m', `chore(morph): archive ${feature}`, '--', ...pathspecs], { cwd, stdio: 'pipe' });
       committed = true;
     } catch { /* nothing to commit / no identity — not fatal, the move + stage stand */ }
   }

package/src/commands/state/finish.js

@@ -494,7 +494,7 @@ export function finishPreflight({ feature, root, worktreePath, cwd, mode, branch
 }
 
 async function integrateMerge({ emit, root, feature, expectedBranch, defaultBranch, isWorktreeFlow, worktreePath, options, arch, backupStamp }) {
-  const mergeMsg = `morph-spec finish: merge ${expectedBranch}`;
+  const mergeMsg = `chore(morph): merge ${expectedBranch}`;
   const adrNote = adrIndexNote(arch);
 
   if (isWorktreeFlow) {

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/core/templates/template-registry.js

@@ -36,7 +36,7 @@ export function clearRegistryCache() {
   _registryCache.clear();
 }
 
-export function getAllTemplates(projectPath = null) {
+function getAllTemplates(projectPath = null) {
   const registry = loadTemplateRegistry(projectPath);
   return registry.templates || [];
 }
@@ -46,48 +46,6 @@ export function getTemplateById(templateId, projectPath = null) {
   return templates.find(t => t.id === templateId) || null;
 }
 
-export function getTemplatesByCategory(category, projectPath = null) {
-  const templates = getAllTemplates(projectPath);
-  return templates.filter(t => t.category === category);
-}
-
-export function getTemplatesByStack(stackId, projectPath = null) {
-  const templates = getAllTemplates(projectPath);
-  return templates.filter(t => {
-    if (!t.stackSpecific) return true;
-
-    return t.stacks && t.stacks.includes(stackId);
-  });
-}
-
-export function getRequiredTemplates(stackId = null, projectPath = null) {
-  let templates = getAllTemplates(projectPath);
-
-  templates = templates.filter(t => t.required === true);
-
-  if (stackId) {
-    templates = templates.filter(t => {
-      if (!t.stackSpecific) return true;
-      return t.stacks && t.stacks.includes(stackId);
-    });
-  }
-
-  return templates;
-}
-
-export function searchTemplates(keyword, projectPath = null) {
-  const templates = getAllTemplates(projectPath);
-  const lowerKeyword = keyword.toLowerCase();
-
-  return templates.filter(t => {
-    return (
-      t.id.toLowerCase().includes(lowerKeyword) ||
-      t.name.toLowerCase().includes(lowerKeyword) ||
-      (t.description && t.description.toLowerCase().includes(lowerKeyword))
-    );
-  });
-}
-
 const FRAMEWORK_TEMPLATES_DIR = join(__dirname, '../../../framework/templates');
 
 /** Path inside this package's `framework/templates/`, not a project's `.morph/`; throws when missing. */

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 || []);