@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

package/framework/templates/docs/ui-mockups.md

@@ -1,119 +1,31 @@
-# UI Mockups & Wireframes: {{titleCase FEATURE_NAME}}
+# Mockups: {{titleCase FEATURE_NAME}}
 
-| Field | Value |
-|-------|-------|
-| **Feature** | {{FEATURE_NAME}} |
-| **Created** | {{DATE}} |
+<!-- Uma `## Tela:` por tela nova ou alterada. As opções navegáveis ficam em 1-design/opcoes/{tela}.html;
+     a escolhida vira 1-design/prototipos/{tela}.html, com os prints {tela}-1280.png e {tela}-390.png ao lado,
+     e um seletor de estado (data-estado="vazio|carregando|erro", ?estado=) com {tela}-{estado}-390.png de cada
+     estado que o checklist diz que se aplica. Faltando um, o Gate uiux pausa. -->
 
----
-
-## Screen Inventory
-
-| Screen ID | Name | Route | Priority |
-|-----------|------|-------|----------|
-| **S001** | {Screen Name} | /path | High |
-| **S002** | {Screen Name} | /path | Medium |
-
----
-
-## Tela: {Primary Screen}
+## Tela: {Nome da tela}
 
 **Protótipo:** 1-design/prototipos/{tela}.html
-
-O protótipo renderizado é a fonte visual da tela; os prints `{tela}-1280.png` e `{tela}-390.png` ficam ao lado dele, e sem os três arquivos o Gate uiux pausa. O layout em texto abaixo é opcional.
-
-### Desktop Layout
-
-```
-┌─────────────────────────────────────┐
-│  Header                    [User ▼] │
-├─────────────────────────────────────┤
-│                                     │
-│  [Title]                            │
-│                                     │
-│  ┌──────────────────────────────┐  │
-│  │ Main Content Area            │  │
-│  │                              │  │
-│  │  [Card 1]    [Card 2]        │  │
-│  │                              │  │
-│  │  ┌────────────────────────┐  │  │
-│  │  │ Data Table             │  │  │
-│  │  │ ...                    │  │  │
-│  │  └────────────────────────┘  │  │
-│  └──────────────────────────────┘  │
-│                                     │
-└─────────────────────────────────────┘
-```
-
-### Mobile Layout
-
-```
-┌──────────────────────┐
-│ ☰  Title    [User ▼]│
-├──────────────────────┤
-│                      │
-│ [Card 1]             │
-│                      │
-│ [Card 2]             │
-│                      │
-│ [View All Items]     │
-│                      │
-└──────────────────────┘
-```
+**Direção escolhida:** <qual opção de opcoes/{tela}.html e por quê, numa frase>
 
 ### Checklist de tela
 
-Troque cada `…` pela decisão — "não se aplica" vale se escrito; `…`, vazio ou "a definir" reprovam o Gate uiux.
+Troque cada `…` pela decisão. "Não se aplica" vale se escrito; `…`, vazio ou "a definir" reprovam o Gate uiux.
 
 | Item | Decisão |
 |---|---|
-| Superfície | … |
-| Volume esperado | … |
-| Paginação | … |
-| Ordenação | … |
-| Filtro | … |
-| Estado vazio | … |
-| Estado carregando | … |
-| Estado de erro | … |
-| Mobile | … |
-| Abas | … |
-
----
-
-## States
-
-### Loading
-- Show skeleton placeholders
-- Spinner for primary content
-
-### Empty
-- Icon + message
-- Clear call-to-action button
-
-### Error
-- Warning icon
-- User-friendly message
-- Retry button
-
-### Success (After Action)
-- Toast notification
-- Auto-dismiss after 3s
-
----
-
-## Interactions
-
-- **Hover**: Subtle elevation increase
-- **Click**: Scale down (0.98)
-- **Transitions**: Fade-in 200ms
+| Lista no servidor | … |
+| Estados vazio e carregando | … |
+| Erro com próxima ação | … |
+| Uma ação primária | … |
+| Celular | … |
 
----
+### Componentes
 
-## Accessibility
-- [ ] 44x44px minimum touch targets
-- [ ] Focus indicators visible
-- [ ] Proper heading hierarchy (H1 → H2 → H3)
+- <componente do design system reusado, ou novo e por quê>
 
----
+### Fluxo
 
-*Generated with MORPH Framework*
+1. <passo do usuário até o resultado>

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

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

package/package.json

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

package/src/commands/e2e/e2e.js

@@ -16,7 +16,9 @@ import {
   deleteStamp,
   getStackStatus,
   isDockerAvailable,
+  isHostOnlyStack,
   lintComposeIsolation,
+  resetE2eData,
   readStamp,
   resolveComposeFile,
   resolveSpecCommand,
@@ -34,8 +36,9 @@ import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js
 const EXIT_USAGE = 2;
 const EXIT_BUSY = 3;
 
-// No compose file is a usage error here, unlike in the verify node where it is a graded skip.
-function resolveContext(featureName, { json = false } = {}) {
+// No compose file and no e2e.hostServices is a usage error here, unlike in the verify node where
+// it is a graded skip. `composeFile` is null for a host-only stack.
+function resolveContext(featureName, { json = false, onMissing } = {}) {
   const root = resolvePrimaryRoot(process.cwd());
   const found = findWorktreeForFeature(featureName, root);
   const cwd = found?.path ?? root;
@@ -43,11 +46,13 @@ function resolveContext(featureName, { json = false } = {}) {
   const config = readConfig(cwd) ?? readConfig(root);
   const composeFile = resolveComposeFile(cwd, config);
 
-  if (!composeFile) {
+  if (!composeFile && !isHostOnlyStack(config, composeFile)) {
     const message =
-      `No compose file found in ${cwd} (compose.yaml, docker-compose.yml, …). ` +
-      'Set project.e2e.composeFile in .morph/config/config.json if it lives elsewhere.';
-    if (json) console.log(JSON.stringify({ error: message, tree: cwd }, null, 2));
+      `No compose file found in ${cwd} (compose.yaml, docker-compose.yml, …) and no e2e.hostServices. ` +
+      'Set e2e.composeFile in .morph/config/config.json if it lives elsewhere, ' +
+      'or declare the app in e2e.hostServices when it has no dependency to containerize.';
+    if (onMissing) onMissing(message, cwd);
+    else if (json) console.log(JSON.stringify({ error: message, tree: cwd }, null, 2));
     else console.error(chalk.red(`\n❌ ${message}\n`));
     return null;
   }
@@ -86,7 +91,7 @@ export async function e2eUpCommand(featureName, options = {}) {
 
   // Isolation BEFORE the docker check: a compose that hardcodes host ports or container names
   // collides with a sibling worktree whatever we inject.
-  const lint = lintComposeIsolation(readComposeText(ctx.cwd, ctx.composeFile));
+  const lint = ctx.composeFile ? lintComposeIsolation(readComposeText(ctx.cwd, ctx.composeFile)) : { findings: [] };
   const isolation = decideIsolation({ findings: lint.findings, insideWorktree: ctx.insideWorktree });
   if (isolation.status === 'fail') {
     if (options.json) {
@@ -106,7 +111,7 @@ export async function e2eUpCommand(featureName, options = {}) {
   }
 
   const exec = options._exec ?? defaultExec;
-  if (!isDockerAvailable(ctx.cwd, exec)) {
+  if (ctx.composeFile && !isDockerAvailable(ctx.cwd, exec)) {
     console.error(chalk.red('\n❌ Docker is not available in this environment.\n'));
     process.exit(EXIT_USAGE);
   }
@@ -149,7 +154,7 @@ export async function e2eUpCommand(featureName, options = {}) {
     tree: ctx.tree,
     composeFile: ctx.composeFile,
     status: failed ? 'fail' : 'pass',
-    reused: result.stack.reused,
+    reused: ctx.composeFile ? result.stack.reused : hostServices.reused,
     reason: result.reason,
     auth: { status: auth.status, reason: auth.reason },
     ...(hostServices.status === 'skip' ? {} : { hostServices: hostServices.services }),
@@ -164,7 +169,9 @@ export async function e2eUpCommand(featureName, options = {}) {
     if (result.output) console.error(result.output);
     for (const w of result.warnings) console.error(chalk.yellow(`⚠️  ${w}`));
   } else {
-    const how = result.stack.reused ? chalk.gray(`(${result.stack.reason})`) : chalk.gray('(built)');
+    const how = !ctx.composeFile
+      ? chalk.gray(`(${result.stack.reason})`)
+      : result.stack.reused ? chalk.gray(`(${result.stack.reason})`) : chalk.gray('(built)');
     console.log(chalk.green(`\n✓ Stack up — ${ctx.projectName} ${how}`));
     console.log(chalk.gray(`  tree: ${ctx.tree}`));
     for (const s of hostServices.services) {
@@ -190,18 +197,24 @@ export async function e2eStatusCommand(featureName, options = {}) {
   if (!ctx) process.exit(EXIT_USAGE);
 
   const exec = options._exec ?? defaultExec;
-  const status = getStackStatus(ctx.cwd, {
-    composeFile: ctx.composeFile,
-    projectName: ctx.projectName,
-    env: ctx.env,
-  }, exec);
+  const hostServices = ctx.gitCommonDir ? hostServicesStatus(ctx.gitCommonDir, ctx.projectName) : [];
+  const status = ctx.composeFile
+    ? getStackStatus(ctx.cwd, {
+      composeFile: ctx.composeFile,
+      projectName: ctx.projectName,
+      env: ctx.env,
+    }, exec)
+    : {
+      up: hostServices.length > 0 && hostServices.every((h) => h.alive),
+      healthy: hostServices.length > 0 && hostServices.every((h) => h.alive && h.health !== false),
+      services: [],
+    };
 
   const stamp = computeSourceStamp(ctx.cwd, exec);
   const previous = ctx.gitCommonDir ? readStamp(ctx.gitCommonDir, ctx.projectName) : null;
   const fresh = Boolean(stamp && previous?.stamp === stamp);
 
   const spec = resolveSpecCommand(ctx.cwd, ctx.config, ctx.config?.project?.frontendPath);
-  const hostServices = ctx.gitCommonDir ? hostServicesStatus(ctx.gitCommonDir, ctx.projectName) : [];
 
   const payload = {
     feature: featureName,
@@ -228,7 +241,7 @@ export async function e2eStatusCommand(featureName, options = {}) {
     console.log('');
     console.log(chalk.bold(`E2E stack — ${ctx.projectName}`));
     console.log(chalk.gray(`tree:    ${ctx.tree}`));
-    console.log(chalk.gray(`compose: ${ctx.composeFile}`));
+    console.log(chalk.gray(`compose: ${ctx.composeFile ?? 'none (host services only)'}`));
     console.log(chalk.gray(`url:     ${payload.baseUrl}`));
     console.log('');
     console.log(`  up       ${status.up ? chalk.green('yes') : chalk.gray('no')}`);
@@ -257,12 +270,14 @@ export async function e2eDownCommand(featureName, options = {}) {
   if (!ctx) process.exit(EXIT_USAGE);
 
   const hostServices = stopHostServices(ctx.gitCommonDir, ctx.projectName);
-  const result = tearDownStack(ctx.cwd, {
-    composeFile: ctx.composeFile,
-    projectName: ctx.projectName,
-    env: ctx.env,
-    volumes: Boolean(options.volumes),
-  }, options._exec ?? defaultExec);
+  const result = ctx.composeFile
+    ? tearDownStack(ctx.cwd, {
+      composeFile: ctx.composeFile,
+      projectName: ctx.projectName,
+      env: ctx.env,
+      volumes: Boolean(options.volumes),
+    }, options._exec ?? defaultExec)
+    : { status: 'pass', output: '' };
   const stampDeleted = deleteStamp(ctx.gitCommonDir, ctx.projectName);
   const cleanup = afterHeavyRun({ projectPath: ctx.cwd, config: readHeavyConfig(ctx.cwd) });
 
@@ -288,6 +303,56 @@ export async function e2eDownCommand(featureName, options = {}) {
   process.exit(0);
 }
 
+// Between the verifier's flows: the next flow starts from the seeded state, not from the rows the
+// previous one left. Exit 1 only on fail; skip (nothing configured to reset) is exit 0.
+export async function e2eResetCommand(featureName, options = {}) {
+  const emit = (payload) => {
+    if (options.json) {
+      console.log(JSON.stringify(payload, null, 2));
+    } else if (payload.status === 'fail') {
+      console.error(chalk.red(`\n✗ ${payload.reason}\n`));
+      if (payload.output) console.error(payload.output);
+    } else if (payload.status === 'skip') {
+      console.log(chalk.gray(`\n○ e2e reset: ${payload.reason}\n`));
+    } else {
+      const what = payload.reset.mode === 'command'
+        ? `e2e.resetCommand (${payload.reset.command})`
+        : payload.reset.mode === 'volumes'
+          ? `recreated ${payload.reset.services.join(', ')} (volumes ${payload.reset.volumes.join(', ')})`
+          : 'no data reset';
+      console.log(chalk.green(`\n✓ e2e reset — ${what}`));
+      if (payload.auth.reason) console.log(chalk.gray(`  auth: ${payload.auth.reason}`));
+      console.log('');
+    }
+    process.exit(payload.status === 'fail' ? 1 : 0);
+  };
+
+  const ctx = resolveContext(featureName, {
+    ...options,
+    onMissing: (message, tree) => emit({ feature: featureName, tree, status: 'fail', reason: message }),
+  });
+  if (!ctx) return;
+
+  const result = resetE2eData(ctx.cwd, {
+    config: ctx.config,
+    composeFile: ctx.composeFile,
+    projectName: ctx.projectName,
+    gitCommonDir: ctx.gitCommonDir,
+    env: ctx.env,
+  }, options._exec ?? defaultExec);
+
+  emit({
+    feature: featureName,
+    project: ctx.projectName,
+    tree: ctx.tree,
+    status: result.status,
+    reason: result.reason,
+    reset: result.reset,
+    auth: result.auth,
+    ...(result.status === 'fail' && result.output ? { output: result.output } : {}),
+  });
+}
+
 function stoppedAnything({ killed, skipped, warnings }) {
   return killed.length + skipped.length + warnings.length > 0;
 }

package/src/commands/graph/diff.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+import { execFileSync } from 'child_process';
+import { loadGraph, getFreshness, staleCause } from '../../lib/graph/graph-loader.js';
+import { parseDiff, buildDiffTree, renderDiffTree, declarationDrift } from '../../lib/graph/diff-tree.js';
+import { detectDefaultBranch } from '../../lib/git/default-branch.js';
+
+const git = (cwd, ...args) => execFileSync('git', args, { cwd, stdio: 'pipe' }).toString();
+
+function fail(options, payload, lines) {
+  if (options.json) console.log(JSON.stringify({ ok: false, ...payload }, null, 2));
+  else for (const [tone, text] of lines) console.error(chalk[tone](text));
+  process.exit(1);
+}
+
+// Only the committed range: the graph is a snapshot of HEAD, so a diff of the working tree would put
+// lines the graph never saw against symbols at the wrong place.
+export async function graphDiffCommand(options = {}) {
+  const projectPath = options.path || process.cwd();
+  const loaded = loadGraph(projectPath);
+  if (!loaded.ok) {
+    fail(options, { reason: 'no-graph', detail: loaded.reason }, [
+      ['yellow', `\n○ Sem grafo (${loaded.reason}): leia o diff cru (git diff).\n`],
+    ]);
+  }
+
+  const freshness = getFreshness(projectPath, loaded.graph);
+  if (freshness.state !== 'fresh') {
+    fail(options, { reason: 'stale-graph', freshness }, [
+      ['yellow', `\n○ O grafo não é deste commit (${staleCause(freshness)}): a árvore sairia com símbolos e linhas errados.`],
+      ['gray', '   Rode `morph-spec graph refresh` e repita; ou leia o diff cru (git diff).\n'],
+    ]);
+  }
+
+  let base = options.base;
+  try {
+    base ??= git(projectPath, 'merge-base', detectDefaultBranch(projectPath) || 'main', 'HEAD').trim();
+  } catch {
+    fail(options, { reason: 'no-base' }, [['yellow', '\n○ Sem base para o diff: passe --base <ref>.\n']]);
+  }
+  const changes = parseDiff(git(projectPath, 'diff', '-U0', '--no-renames', '--no-color', base, 'HEAD'));
+  let uncommitted = [];
+  try {
+    const dirty = new Set(git(projectPath, 'diff', '--name-only', 'HEAD').split('\n').filter(Boolean));
+    uncommitted = [...changes.keys()].filter((f) => dirty.has(f));
+  } catch { uncommitted = []; }
+
+  const tree = buildDiffTree(loaded.graph, changes);
+  const drift = declarationDrift(tree, (file) => {
+    try { return git(projectPath, 'show', `HEAD:${file}`).split(/\r?\n/); } catch { return []; }
+  });
+  if (drift.length) {
+    fail(options, { reason: 'graph-drift', drift }, [
+      ['yellow', `\n○ O grafo diz ser deste commit, mas ${drift.length} símbolo(s) não estão na linha que ele aponta (ex.: ${drift[0].label} em ${drift[0].file}:${drift[0].line}).`],
+      ['gray', '   A extração leu arquivos diferentes do commit. Rode `morph-spec graph build` e repita; ou leia o diff cru (git diff).\n'],
+    ]);
+  }
+  const payload = { ok: true, base, head: freshness.headCommit, ...tree, uncommitted };
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  const { added, modified, entries, files } = tree.counts;
+  console.log(chalk.green(`\n✅ ${added} novo(s) +, ${modified} alterado(s) ~, ${entries} entrada(s), em ${files} arquivo(s) — ${String(base).slice(0, 8)}..${String(freshness.headCommit).slice(0, 8)}`));
+  for (const line of renderDiffTree(tree)) console.log(`   ${line}`);
+  if (tree.unmapped.length) {
+    console.log(chalk.gray(`\n   Sem símbolo tocado (só import/topo do arquivo, config, doc, ou fora do .graphifyignore) — leia no diff:`));
+    for (const f of tree.unmapped) console.log(chalk.gray(`     ${f}`));
+  }
+  if (uncommitted.length) {
+    console.log(chalk.yellow(`\n   ⚠ Mudança não commitada em ${uncommitted.length} arquivo(s) do diff: ela não está nesta árvore. Commit e repita.`));
+  }
+  console.log('');
+}

package/src/commands/graph/status.js

@@ -37,7 +37,7 @@ export async function graphStatusCommand(options = {}) {
     console.log(chalk.yellow(`\n○ Sem grafo (${loaded.reason})`));
     console.log(chalk.gray(`   ${loaded.path}`));
     console.log(chalk.gray('   Gere com: morph-spec graph build'));
-    console.log(chalk.gray('   Sem grafo, scout e skills seguem por grep normalmente.\n'));
+    console.log(chalk.gray('   Sem grafo, as skills seguem por grep normalmente.\n'));
     return;
   }
 

package/src/commands/observability/cost.js

@@ -111,11 +111,9 @@ function printMetricsBody(m) {
   const tov = m.testOutsideVerify;
   const timed = (t) => `${String(t.runs).padStart(4)}×  ${fmtDuration(t.measuredMs / 1000).padStart(8)}`
     + (t.unmeasured ? chalk.gray(` (${t.unmeasured} sem duração)`) : '');
-  console.log('\n' + chalk.white.bold('Teste fora do verify (sub-agentes)')
+  console.log('\n' + chalk.white.bold('Teste fora do verify')
     + chalk.gray(` · de ${tov.total.runs} testes+verifies, ${fmtDuration(tov.total.measuredMs / 1000)} cronometrados`
       + (tov.total.unmeasured ? `, ${tov.total.unmeasured} sem duração` : '')));
-  console.log(`  sub-agente rodando verify cheio      ${timed(tov.subagentVerify)}`);
-  console.log(`  implementador, 3ª rodada em diante   ${timed(tov.implementerRound3Plus)}`);
   console.log(`  agente de review rodando teste       ${timed(tov.reviewTests)}`);
   console.log(chalk.gray(`    ${tov.reviewTests.byPersona.runs}× pela persona morph-* (o que o hook test-budget reconhece);`
     + ' o resto veio de um nome de dispatch (ver-, rev-, gate3-…)'));
@@ -163,7 +161,7 @@ function printMetricsBody(m) {
     return;
   }
   for (const [gate, g] of gates) {
-    console.log(`  gate ${gate}: ${g.decisions} decisões, ${g.paused} pausas → ${g.approvedAfterPause} aprovadas como estavam, `
+    console.log(`  gate ${gate}: ${g.decisions} decisões, ${g.paused} pausas (${g.pausedForHuman} para o humano) → ${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`));

package/src/commands/observability/telemetry.js

@@ -35,7 +35,7 @@ export function telemetryCommand(options = {}) {
   }
 
   section('Skills', summary.skills, s => `${chalk.green(s.name.padEnd(24))} ${s.count}`);
-  section('Personas despachadas', summary.personas, p => `${chalk.magenta(p.name.padEnd(24))} ${p.count}`);
+  section('Sub-agents despachados', summary.personas, p => `${chalk.magenta(p.name.padEnd(24))} ${p.count}`);
   section('Base de conhecimento (standards lidos explicitamente)', summary.standards,
     s => `${chalk.yellow(String(s.count).padStart(3))}×  ${s.path}`);
   if (summary.standards.length || summary.tools.some(t => t.name === 'Read')) {

package/src/commands/project/doctor.js

@@ -16,8 +16,9 @@ import {
   getInstalledCLIVersion
 } from '../../utils/version-checker.js';
 import { resetMorphSettings } from '../../utils/claude-settings-manager.js';
-import { checkMissingAgents, checkAgentsDrift, maxTurnsError, surfacesError, effortError } from '../../utils/agents-installer.js';
+import { checkMissingAgents, checkAgentsDrift, maxTurnsError } from '../../utils/agents-installer.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
+import { stackRuleGaps } from '../../lib/installers/stack-sync.js';
 import { auditGraph } from '../../lib/graph/graph-health.js';
 import { auditFeatureLifecycle } from '../../core/state/lifecycle-audit.js';
 import { validateTestNodes, morphConfigPath, discoverFrontendPackages } from '../../lib/tasks/test-nodes.js';
@@ -114,27 +115,27 @@ export function validateAgentsJson(agentsData) {
   }
 
   const version = agentsData.version || 'unknown';
-  const isV5 = version.startsWith('5.');
+  const isCurrent = version.startsWith('6.');
   const v4Fields = [];
-  const missingV5Fields = [];
+  const missingFields = [];
 
   for (const [id, data] of agentEntries) {
     if (data.tier !== undefined) v4Fields.push(`${id}.tier`);
     if (data.active_phases !== undefined) v4Fields.push(`${id}.active_phases`);
     if (data.reports_to !== undefined) v4Fields.push(`${id}.reports_to`);
     if (data.teammate !== undefined) v4Fields.push(`${id}.teammate`);
-    if (!data.title) missingV5Fields.push(`${id}.title`);
-    if (!Array.isArray(data.domains)) missingV5Fields.push(`${id}.domains`);
-    if (typeof data.persona !== 'string' || !data.persona) missingV5Fields.push(`${id}.persona`);
+    if (!data.title) missingFields.push(`${id}.title`);
+    if (!Array.isArray(data.domains)) missingFields.push(`${id}.domains`);
+    if (typeof data.persona !== 'string' || !data.persona) missingFields.push(`${id}.persona`);
   }
 
-  if (isV5) {
+  if (isCurrent) {
     checks.push({ name: `agents.json schema (v${version})`, status: 'ok' });
   } else {
     checks.push({
       name: `agents.json schema (v${version})`,
       status: 'warn',
-      msg: 'expected v5.x — run agents migration'
+      msg: "expected v6.x — run 'morph-spec update'"
     });
   }
 
@@ -155,26 +156,12 @@ export function validateAgentsJson(agentsData) {
     ? { name: 'agents.json maxTurns', status: 'error', msg: maxTurnsErrors.join(' | ') }
     : { name: 'agents.json maxTurns', status: 'ok' });
 
-  const surfacesErrors = agentEntries
-    .map(([id, data]) => surfacesError(id, data?.surfaces, data?.standards))
-    .filter(Boolean);
-  checks.push(surfacesErrors.length > 0
-    ? { name: 'agents.json surfaces', status: 'error', msg: surfacesErrors.join(' | ') }
-    : { name: 'agents.json surfaces', status: 'ok' });
-
-  const effortErrors = agentEntries
-    .map(([id, data]) => effortError(id, data?.effort))
-    .filter(Boolean);
-  checks.push(effortErrors.length > 0
-    ? { name: 'agents.json effort', status: 'error', msg: effortErrors.join(' | ') }
-    : { name: 'agents.json effort', status: 'ok' });
-
-  if (missingV5Fields.length > 0 && isV5) {
-    const sample = missingV5Fields.slice(0, 3).join(', ');
+  if (missingFields.length > 0 && isCurrent) {
+    const sample = missingFields.slice(0, 3).join(', ');
     checks.push({
-      name: 'agents.json v5 required fields',
+      name: 'agents.json required fields',
       status: 'warn',
-      msg: `${missingV5Fields.length} missing: ${sample}${missingV5Fields.length > 3 ? '...' : ''}`
+      msg: `${missingFields.length} missing: ${sample}${missingFields.length > 3 ? '...' : ''}`
     });
   }
 
@@ -194,7 +181,6 @@ const REQUIRED_AGENTS = [
   'verifier',
   'reviewer',
   'security',
-  'scout'
 ];
 
 async function doctorFullCommand(frameworkRoot) {
@@ -589,15 +575,6 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
       }
     }
 
-    const { reapAgentWorktrees } = await import('../../lib/worktree/agent-reaper.js');
-    const reap = await reapAgentWorktrees(targetPath);
-    if (reap.ok) {
-      const gone = reap.reaped.map((r) => r.path ?? r.branch);
-      prune.agentReap = { reaped: gone, branchesDeleted: reap.branchesDeleted, preserved: reap.preserved, ...(reap.busy ? { busy: true } : {}) };
-      if (!options.json && gone.length) logger.success(`sobras de sub-agent removidas: ${gone.join(', ')}`);
-      if (!options.json && reap.busy) logger.warn('reaper de sub-agent já em execução em outro processo; nada foi feito nesta rodada');
-    }
-
     const { resolvePrimaryRoot } = await import('./worktree.js');
     const { applyEditorSettings } = await import('../../lib/worktree/vscode-settings.js');
     const editor = applyEditorSettings(resolvePrimaryRoot(targetPath));
@@ -660,9 +637,6 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
   if (problems.some(prunable) && !options.prune) {
     logger.dim('\n  Rode `morph-spec doctor --worktrees --prune` para limpar os registros órfãos e os diretórios vazios.');
   }
-  if (issues.some((i) => i.type === 'agent-worktree-leftover' && i.reapable) && !options.prune) {
-    logger.dim('\n  Rode `morph-spec worktree reap` (ou `doctor --worktrees --prune`) para remover as sobras de sub-agent que já pararam.');
-  }
   if (!problems.length) {
     logger.success('Nenhuma inconsistência — os itens acima são informativos.');
     return true;
@@ -1058,6 +1032,16 @@ export async function doctorCommand(options = {}) {
         hasWarnings = true;
       }
 
+      const gaps = stackRuleGaps(targetPath);
+      if (gaps?.stackMissing) {
+        checks.push({ name: 'project.stack', status: 'warn', msg: 'ausente/unknown no config.json — nenhuma regra de stack instalada; morph-spec stack-set <stack> (a do Morph: standard architecture-stack-baseline), antes da sessão que implementa' });
+        hasWarnings = true;
+      }
+      if (gaps?.missing.length) {
+        checks.push({ name: 'stack rules', status: 'warn', msg: `faltando para [${gaps.tags.join(', ')}]: ${gaps.missing.join(', ')} — rode morph-spec verify ou update` });
+        hasWarnings = true;
+      }
+
       const agentsPathClaude = join(claudePath, 'agents');
       if (await pathExists(agentsPathClaude)) {
         const agentFiles = await fs.readdir(agentsPathClaude);

package/src/commands/project/fleet.js

@@ -32,17 +32,16 @@ export function fleetCommand(options = {}) {
 
   console.log(chalk.white.bold(
     // PHASE at 18 fits `aguardando-merge`; narrower misaligns every column after it.
-    col('FEATURE', 20) + col('TYPE', 9) + col('PHASE', 18) + col('FATIAS', 8)
+    col('FEATURE', 20) + col('TYPE', 9) + col('PHASE', 18) + col('CENÁRIOS', 10)
     + col('GATES PEND.', 20) + col('WHERE', 24) + col('REMOTO', 16) + col('CLAIM', 16)
-    + col('PORTS', 12) + col('HANDOFF', 9) + 'ATIVIDADE',
+    + col('PORTS', 12) + 'ATIVIDADE',
   ));
   for (const e of fleet.entries) {
-    const slices = e.slices ? `${e.slices.done}/${e.slices.total}` : '-';
+    const scenarios = e.scenarios ? `${e.scenarios.done}/${e.scenarios.total}` : '-';
     const gates = e.pendingGates.length ? e.pendingGates.join(',') : '-';
     // pr-pending exists only on its branch, never in a worktree or the root.
     const where = (e.location === 'worktree' || e.location === 'pr-pending') ? e.branch : 'raiz';
     const ports = e.env ? `${e.env.range[0]}-${e.env.range[1]}` : '-';
-    const handoff = e.handoff?.exists ? 'sim' : '-';
     const activity = [
       e.lastCommit ? `commit ${e.lastCommit}` : null,
       Number.isInteger(e.dirty) && e.dirty > 0 ? chalk.yellow(`${e.dirty} dirty`) : null,
@@ -51,10 +50,10 @@ export function fleetCommand(options = {}) {
     // length and append the padding by hand.
     const claimPlain = e.claim ? `${e.claim.live ? 'sessão' : 'morta'} (${claimAge(e.claim)})` : '-';
     console.log(
-      col(e.feature, 20) + col(e.workType || '-', 9) + col(e.phase, 18) + col(slices, 8)
+      col(e.feature, 20) + col(e.workType || '-', 9) + col(e.phase, 18) + col(scenarios, 10)
       + col(gates, 20) + col(where, 24) + col(remoteCell(e.remote), 16)
       + claimCell(e.claim) + ' '.repeat(Math.max(1, 16 - claimPlain.length))
-      + col(ports, 12) + col(handoff, 9) + activity,
+      + col(ports, 12) + activity,
     );
   }
   const claimed = fleet.entries.filter((e) => e.claim?.live);