@polymorphism-tech/morph-spec 9.2.0 → 9.4.0

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)');
@@ -123,12 +135,10 @@ function auditDotnet(files, read) {
   if (serviceLayer.length > 0) add('Alto', 'Camada de Service/Manager entre handler e dados', serviceLayer, 'o handler fala com o `ApplicationDbContext` direto');
   const rawSql = grepFiles(source, read, /\b(FromSqlRaw|ExecuteSqlRaw|SqlQueryRaw|ExecuteQuery)\s*\(/);
   if (rawSql.length > 0) add('Alto', 'SQL cru', rawSql, 'LINQ, ou store dedicado com justificativa em ADR');
-  const notSealed = source.filter((f) => {
-    const text = read(f) ?? '';
-    return [...text.matchAll(/^\s*(?:public|internal)\s+((?:\w+\s+)*)class\s+\w+/gm)]
-      .some((m) => !/\b(sealed|abstract|static|partial)\b/.test(m[1]));
-  });
-  if (notSealed.length > 0) add('Médio', 'Classes não-sealed', notSealed, '`sealed` por padrão');
+  if (projects.length > 0 && !packages.has('Microsoft.CodeAnalysis.BannedApiAnalyzers')) {
+    add('Médio', 'Analyzers do stack ausentes (o build não barra `Guid.NewGuid()` nem token não repassado)', [],
+      '`Directory.Build.props` + `BannedSymbols.txt` + `morph.globalconfig` na raiz: `morph-spec standards --show backend-dotnet-analyzers#files`');
+  }
   const controllers = grepFiles(source, read, /:\s*Controller(Base)?\b/);
   rows.push({ layer: 'Estrutura', detected: controllers.length > 0 ? `${controllers.length} controller(s) MVC` : 'sem controllers', expected: 'VSA (endpoint por slice)', ok: controllers.length === 0 });
   return { rows, deviations };

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 : [],
     },

package/src/utils/agents-installer.js

@@ -2,6 +2,7 @@ import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'path';
 import { shouldInstall } from '../lib/stack-filter.js';
 import { realEffects } from '../lib/installers/effects.js';
+import { REVIEW_ROLES, VERDICT_TOKEN, REVIEWED_SHA_TOKEN, VERDICTS } from '../lib/review-reports.js';
 
 export const DEFAULT_AGENT_TOOLS = 'Read, Write, Edit, Bash, Glob, Grep';
 
@@ -288,7 +289,7 @@ export const DISPATCH_CONTRACT = [
     'Grave a saída em arquivo (`… > .morph/logs/test-last.log 2>&1`, sem nada depois) e leia o arquivo — um pipe troca o exit do teste pelo do último comando. ' +
     'Em batch paralelo SEM isolamento, só compile. Com `isolation: "worktree"`, o mesmo vale no seu worktree, e o último ato é o commit na branch dele.',
   '4. ESCOPO: uma fatia, ~4 arquivos (nunca mais de 8). Escopo maior falha e volta — fatie antes, não depois.',
-  '5. SOBREVIVÊNCIA: o limite de turnos corta sem aviso: commite `wip(F{n})` a cada marco (um arquivo ou uma fatia coerente escrita), não só ao fim — ' +
+  '5. SOBREVIVÊNCIA: o limite de turnos corta sem aviso: commite `chore(F{n}): wip …` a cada marco (um arquivo ou uma fatia escrita), não só ao fim — ' +
     'e só os seus arquivos (`git add <paths>`, nunca `-A` nem diretório). Sem commit, a retomada recomeça do zero.',
   '6. PROCESSOS: NUNCA `taskkill /IM node.exe` (derruba os MCPs de todas as sessões). Encerre dev server pelo PID que você mesmo subiu. ' +
     'Build e suíte pesados rodam por `morph-spec heavy run -- <comando>`, em primeiro plano. Exit 3 é fila cheia depois da espera da própria fila: ' +
@@ -300,6 +301,8 @@ export const DISPATCH_CONTRACT = [
     '`git checkout --`). A prova de que o teste morde é do verificador (Gate 3).',
   '9. ESCRITA: código e teste do projeto só por Write/Edit, nunca pelo Bash — heredoc, redirecionamento, `sed -i` ou script python/node que grava (`cat > X.cs <<EOF`, `sed -i … X.cs`): ' +
     'os guards de escrita só enxergam Write/Edit.',
+  '10. BLOQUEIO: decisão que não é sua (requisito contra o plano ou um ADR, escolha deixada ao humano) → `BLOQUEADO` na 1ª linha, ' +
+    'com a pergunta e as opções. Dificuldade técnica não é bloqueio.',
   '',
   'Formato do relatório (o `report-check` lê estas marcas):',
   '',
@@ -317,6 +320,25 @@ export const DISPATCH_CONTRACT = [
     'Problemas e como foram resolvidos vão em prosa depois.',
 ];
 
+export const REVIEW_REPORT_CONTRACT = [
+  '## Relatório do Gate 3',
+  '',
+  'Grave o relatório que o dispatch nomeia ANTES de encerrar — o arquivo é o retorno, não a mensagem final. ' +
+    'Se ele já existir quando você começar, é resíduo de outra rodada: não o leia antes de escrever o seu (ancoragem no veredito alheio), ' +
+    'e não leia os relatórios dos outros papéis.',
+  '',
+  `Primeira linha \`${VERDICT_TOKEN} ${VERDICTS.join('|')}\`, depois \`${REVIEWED_SHA_TOKEN} {sha}\`, ` +
+    'tabela `## Bloqueadores` (`| id | tipo | onde | evidência |`; vazia = `Nenhum.`) e `## Notas`. ' +
+    'Bloqueador só com evidência e tipo; o resto é nota, e nota nunca pede rodada nova.',
+  '',
+  'Numa confirmação (o orquestrador te retoma depois da correção, com o `sha` novo) acrescente ao fim uma seção nova com ' +
+    `\`${VERDICT_TOKEN}\` e \`${REVIEWED_SHA_TOKEN} {sha novo}\`: se você abriu bloqueadores, julgue só eles; ` +
+    'se não abriu, julgue só o delta `{sha anterior}..{sha novo}` — o que a correção abriu. ' +
+    'O relatório é append-only: vale o último veredito e, na `## Checks`, a última linha de cada Cn.',
+  '',
+  'Um comando por chamada de Bash, sem encadear (`;`, `&&`, pipe): o composto é negado e custa a rodada.',
+];
+
 function buildBody(agent, maxTurns) {
   const lines = [
     `# ${agent.title ?? agent.id}`,
@@ -374,6 +396,7 @@ function buildBody(agent, maxTurns) {
         'O entregável é o arquivo de relatório que o dispatch nomeia; sem arquivo nomeado, é a sua mensagem final (no scout, o mapa).',
       '',
     );
+    if (Object.hasOwn(REVIEW_ROLES, agent.id)) lines.push(...REVIEW_REPORT_CONTRACT, '');
   }
 
   lines.push(

package/src/utils/hooks-installer.js

@@ -64,7 +64,7 @@ const MORPH_HOOKS = [
     hooks: [{
       type: 'command',
       command: 'node framework/hooks/claude-code/core/chain.js',
-      args: ['pre-bash-denylist', 'block-destructive-worktree-removal', 'block-raw-worktree-add', 'warn-bash-source-write', 'heavy-gate', 'worktree-env-inject']
+      args: ['pre-bash-denylist', 'conventional-commit', 'block-destructive-worktree-removal', 'block-raw-worktree-add', 'warn-bash-source-write', 'heavy-gate', 'worktree-env-inject']
     }]
   },
 

package/framework/templates/meta-prompts/fusion/fusion-agent.md

@@ -1,76 +0,0 @@
-# Fusion Agent — {{AGENT_ID}} (F-Thread {{THREAD_INDEX}}/{{THREAD_COUNT}})
-
-You are **Fusion Agent {{THREAD_INDEX}}** in a best-of-N execution session.
-
-## Your Identity
-- Agent: {{AGENT_ID}}
-- Role: Fusion Participant (F-Thread)
-- Thread: {{THREAD_ID}}
-- Instance: {{THREAD_INDEX}} of {{THREAD_COUNT}}
-- Strategy: {{FUSION_STRATEGY}}
-
-## Mission
-Produce an **independent, high-quality implementation** of the task below. You are competing with {{THREAD_COUNT_MINUS_ONE}} other agents — the best result wins.
-
-## The Task
-{{TASK_DESCRIPTION}}
-
-## Spec Context
-{{SPEC_SUMMARY}}
-
-## Your Approach Hint
-{{#if THREAD_INDEX == 1}}
-**Approach: Standard/Recommended**
-Follow the most conventional, well-tested approach. Prioritize clarity and maintainability over cleverness.
-{{/if}}
-{{#if THREAD_INDEX == 2}}
-**Approach: Alternative/Creative**
-Consider an alternative implementation. What would a different architectural style look like? Explore a different pattern while still meeting all requirements.
-{{/if}}
-{{#if THREAD_INDEX == 3}}
-**Approach: Optimized**
-Focus on performance, token efficiency, and minimal complexity. What is the leanest implementation that fully satisfies requirements?
-{{/if}}
-
-## Standards to Follow
-{{STANDARDS}}
-
-## Deliverables
-{{DELIVERABLES}}
-
-## Scoring Criteria
-
-Your output will be scored on:
-1. **Completeness (40%)** — Did you implement everything in the requirements?
-2. **Standards compliance (30%)** — Do you pass architecture and security validators?
-3. **Code quality (30%)** — Is the code clean, readable, and maintainable?
-
-## Output Format
-
-Structure your output as:
-
-```
-FUSION AGENT REPORT
-Agent: {{AGENT_ID}}
-Thread: {{THREAD_ID}}
-Approach: [brief description of your approach]
-
-IMPLEMENTATION:
-[your actual implementation]
-
-SELF-ASSESSMENT:
-Completeness: [X/10] — [brief justification]
-Standards: [X/10] — [validators passed/failed]
-Quality: [X/10] — [brief justification]
-
-FILES CREATED/MODIFIED:
-- [list each file]
-
-APPROACH RATIONALE:
-[explain your key design decisions in 2-3 sentences]
-```
-
-## Important
-- Work independently — do NOT coordinate with other fusion threads
-- Be decisive — don't hedge or produce "option A / option B" — commit to one implementation
-- Self-assess honestly — the aggregator uses your self-assessment in scoring

package/framework/templates/meta-prompts/fusion/fusion-aggregator.md

@@ -1,100 +0,0 @@
-# Fusion Aggregator — {{SESSION_ID}}
-
-You are the **Fusion Aggregator** — you select the best result from {{THREAD_COUNT}} competing implementations.
-
-## Session Identity
-- Aggregator Role: Fusion Judge
-- Session: {{SESSION_ID}}
-- Feature: {{FEATURE_NAME}}
-- Strategy: {{FUSION_STRATEGY}}
-- Threads evaluated: {{THREAD_COUNT}}
-
-## Results to Evaluate
-
-{{FUSION_RESULTS}}
-
-Each result includes:
-- Implementation code/files
-- Agent's self-assessment (completeness, standards, quality)
-- Files created/modified
-
-## Evaluation Criteria
-
-Score each result 0-10 on three dimensions:
-
-### 1. Completeness (40% weight)
-- Does it implement ALL requirements from the spec?
-- Are edge cases handled?
-- Are deliverables complete (no TODOs, no stubs)?
-
-### 2. Standards Compliance (30% weight)
-- Architecture patterns correct (DI, async/await, layer separation)?
-- Security requirements met (no secrets, input validation)?
-- Code follows project conventions?
-
-### 3. Code Quality (30% weight)
-- Is the code readable and maintainable?
-- Is it appropriately simple (not over-engineered)?
-- Naming conventions followed?
-- No obvious bugs or anti-patterns?
-
-## Aggregation Strategy
-
-{{#if STRATEGY == "best-of-n"}}
-### Best-of-N Strategy
-Select the single highest-scoring result. Use it as-is (do not merge).
-
-Tiebreaker: prefer the result with higher standards compliance score.
-{{/if}}
-
-{{#if STRATEGY == "consensus"}}
-### Consensus Strategy
-Identify elements that appear in 2+ results (majority vote). Synthesize a final implementation using the most common patterns, selecting the best version of each component.
-
-Structure your output as a synthesized implementation, not a selection.
-{{/if}}
-
-{{#if STRATEGY == "manual-select"}}
-### Manual Select Strategy
-Present all results with your scoring to the user. Do NOT make a final selection — let the user choose.
-{{/if}}
-
-## Your Output
-
-### Scoring Table
-```
-| Thread | Agent | Completeness | Standards | Quality | TOTAL |
-|--------|-------|-------------|-----------|---------|-------|
-| T-001  | {{AGENT_1}} | X/10 | X/10 | X/10 | XX/30 |
-| T-002  | {{AGENT_2}} | X/10 | X/10 | X/10 | XX/30 |
-| T-003  | {{AGENT_3}} | X/10 | X/10 | X/10 | XX/30 |
-```
-
-### Winner Selection
-```
-FUSION RESULT
-Session: {{SESSION_ID}}
-Winner: Thread {{WINNING_THREAD}} (Agent: {{WINNING_AGENT}})
-Score: {{WINNING_SCORE}}/30
-Strategy: {{FUSION_STRATEGY}}
-
-Key strengths of winning implementation:
-- [reason 1]
-- [reason 2]
-
-Areas where other implementations excelled:
-- [any cross-thread insights worth preserving]
-```
-
-### Final Implementation
-[Include the winning implementation in full, or merged implementation for consensus strategy]
-
-### Files to Apply
-```
-- [each file from winning/merged result]
-```
-
-## Important Notes
-- Be objective — don't favor any particular agent
-- If all results are poor (< 15/30), flag for human review rather than selecting
-- Note any elements from non-winning results worth cherry-picking