@polymorphism-tech/morph-spec 9.7.0 → 10.0.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);

package/src/commands/project/init.js

@@ -1,5 +1,4 @@
-import { join, dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
+import { join, resolve } from 'path';
 import { homedir } from 'os';
 import fs from 'fs-extra';
 import ora from 'ora';
@@ -28,13 +27,43 @@ import {
   setupStitch,
   loadMcpRegistry
 } from '../../lib/installers/mcp-installer.js';
-import { setupInfra, installRulesForStack, installCommandsForStack } from '../../scripts/setup-infra.js';
-import { installSkills } from '../../utils/skills-installer.js';
-import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
+import { setupInfra } from '../../scripts/setup-infra.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
 import { updateCommand } from './update.js';
 import { resolvePrimaryRoot } from './worktree.js';
 import { registerProject } from '../../lib/projects/registry.js';
+import { setProjectStack } from '../../lib/installers/stack-sync.js';
+import { installStackAssets } from '../../lib/installers/stack-assets.js';
+
+const GREENFIELD_CHOICES = [
+  { name: 'dotnet+nextjs — stack do Morph: .NET 10 + EF Core/Neon + Next.js/Shadcn (recomendada)', value: { stack: 'dotnet+nextjs', integrations: ['neon'] } },
+  { name: 'dotnet — só a API .NET (EF Core/Neon)', value: { stack: 'dotnet', integrations: ['neon'] } },
+  { name: 'nextjs — só o app web Next.js', value: { stack: 'nextjs', integrations: [] } },
+  { name: 'Decidir depois (o /morph-plan pergunta)', value: null },
+];
+
+/** Empty project: `--stack` wins; a terminal is asked, the Morph stack first; no terminal leaves it to the plan. */
+export async function chooseGreenfieldStack(options = {}, { isTTY = process.stdin.isTTY, prompt = inquirer.prompt } = {}) {
+  if (options.stack) {
+    const integrations = String(options.with ?? '').split(',').map((t) => t.trim()).filter(Boolean);
+    return { stack: options.stack, integrations };
+  }
+  if (!isTTY) return null;
+  const { stackChoice } = await prompt([{
+    type: 'list',
+    name: 'stackChoice',
+    message: 'Projeto novo: qual stack?',
+    choices: GREENFIELD_CHOICES,
+  }]);
+  return stackChoice;
+}
+
+async function reinstallForStack(targetPath, stackTags, spinner) {
+  if (stackTags.length === 0) return;
+  spinner.start('Re-installing stack-filtered assets...');
+  await installStackAssets(targetPath, stackTags);
+  spinner.succeed(`Stack-filtered assets reinstalled for [${stackTags.join(', ')}]`);
+}
 
 /**
  * A linked worktree junctions `.claude/` and `.morph/framework/` but not `.morph/config`/state:
@@ -196,15 +225,17 @@ export async function initCommand(options) {
           if (structure?.uiLibrary) logger.dim(`UI Library: ${structure.uiLibrary}`);
           if (structure?.integrations?.length > 0) logger.dim(`Integrations: ${structure.integrations.join(', ')}`);
 
-          const { standardsChoice } = await inquirer.prompt([{
-            type: 'list',
-            name: 'standardsChoice',
-            message: 'How should morph-spec handle your project standards?',
-            choices: [
-              { name: 'Keep morph-spec defaults (recommended)', value: 'morph-spec' },
-              { name: 'Detect project-specific standards', value: 'detect' }
-            ]
-          }]);
+          const { standardsChoice } = process.stdin.isTTY
+            ? await inquirer.prompt([{
+              type: 'list',
+              name: 'standardsChoice',
+              message: 'How should morph-spec handle your project standards?',
+              choices: [
+                { name: 'Keep morph-spec defaults (recommended)', value: 'morph-spec' },
+                { name: 'Detect project-specific standards', value: 'detect' }
+              ]
+            }])
+            : { standardsChoice: 'morph-spec' };
 
           if (standardsChoice === 'detect') {
             spinner.start('Generating project-specific standards...');
@@ -215,30 +246,27 @@ export async function initCommand(options) {
             logger.dim('Review and edit .morph/context/standards.md as needed.');
           }
 
-          const stackTags = getProjectTags(config);
-          if (stackTags.length > 0) {
-            spinner.start('Re-installing stack-filtered assets...');
-            const frameworkDir = join(targetPath, '.morph', 'framework');
-            const fwSrcDir = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'framework');
-
-            const rulesSrc = join(fwSrcDir, 'rules');
-            const rulesDest = join(targetPath, '.claude', 'rules');
-            installRulesForStack(rulesSrc, rulesDest, stackTags);
-            installCommandsForStack(join(fwSrcDir, 'commands'), join(targetPath, '.claude', 'commands'), stackTags);
-
-            await installSkills(targetPath, { projectTags: stackTags });
-
-            await installAgents(targetPath, fwSrcDir, { projectTags: stackTags });
-            await installDomainAgents(targetPath, fwSrcDir, { projectTags: stackTags });
-
-            spinner.succeed(`Stack-filtered assets reinstalled for [${stackTags.join(', ')}]`);
-          }
-
+          await reinstallForStack(targetPath, getProjectTags(config), spinner);
           spinner.start('Continuing...');
         }
       } catch (error) {
         logger.dim(`  Stack detection skipped: ${error.message}`);
       }
+    } else {
+      const choice = await chooseGreenfieldStack(options);
+      if (choice) {
+        spinner.stop();
+        const result = setProjectStack(targetPath, choice.stack, { integrations: choice.integrations, log: (line) => logger.dim(line) });
+        if (result.error) {
+          logger.warn(`Stack não declarada: ${result.error}`);
+        } else {
+          config = await readJson(configPath);
+          await reinstallForStack(targetPath, getProjectTags(config), spinner);
+        }
+        spinner.start('Continuing...');
+      } else {
+        logger.dim('  Stack: não declarada — o /morph-plan pergunta antes de planejar (recomendada: a do Morph)');
+      }
     }
 
     let mcpSetupResult = null;
@@ -460,13 +488,12 @@ export async function initCommand(options) {
 
     const agents = infraResult?.agents;
     if (agents) {
-      const total = (agents.tier1 || 0) + (agents.tier2 || 0) + (agents.specialists || 0) + (agents.personas || 0);
-      logger.dim(`  ✓ .claude/agents/ (${total} domain personas installed)`);
+      logger.dim(`  ✓ .claude/agents/ (${agents.installed ?? 0} Gate 3 agents installed)`);
     } else {
       logger.dim('  ✓ .claude/agents/ (native subagents installed)');
     }
 
-    logger.dim('  ✓ ~/.claude/statusline.sh (global statusline installed)');
+    logger.dim('  ✓ ~/.claude/statusline.js (global statusline installed)');
 
     logger.blank();
     const globalSettingsPath = join(homedir(), '.claude', 'settings.local.json');

package/src/commands/project/stack-scan.js

@@ -1,56 +1,17 @@
-import chalk from 'chalk';
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { getFeatureDir } from '../../core/paths/output-schema.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
-import { notAuditedReason, scanStack, renderStackScan } from '../../lib/stack/stack-scan.js';
-import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
+import { scanStack, renderStackScan } from '../../lib/stack/stack-scan.js';
 
-export const STACK_SCAN_FILE = 'stack-scan.md';
-
-/** Scan the tree at `cwd`; with a feature, write `2-plan/stack-scan.md`. */
+/** Scan the tree at `cwd`; prints, never writes — the plan reads stdout. */
 export function runStackScan(featureName, cwd = process.cwd()) {
   const result = scanStack(cwd, readMorphConfig(cwd));
-  const markdown = renderStackScan(result, featureName ?? 'projeto');
-  if (!featureName) return { ...result, markdown, written: null, exit: 0 };
-
-  const featureDir = join(cwd, getFeatureDir(featureName));
-  if (!existsSync(featureDir)) return { ...result, markdown, written: null, exit: 2, error: 'feature-not-found' };
-  const planDir = join(featureDir, '2-plan');
-  mkdirSync(planDir, { recursive: true });
-  const written = join(planDir, STACK_SCAN_FILE);
-  writeFileSync(written, markdown, 'utf8');
-  return { ...result, markdown, written, exit: 0 };
+  return { ...result, markdown: renderStackScan(result, featureName ?? 'projeto'), exit: 0 };
 }
 
 export function stackScanCommand(featureName, options = {}) {
-  if (featureName) {
-    const owner = assertOwnerTree(featureName, process.cwd());
-    if (owner.blocked) {
-      for (const { tone, text } of ownerTreeRefusalLines(featureName, owner.tree, owner.branch, `morph-spec stack-scan ${featureName}`)) {
-        console.error(chalk[tone](text));
-      }
-      process.exit(1);
-    }
-  }
-
   const result = runStackScan(featureName);
   if (options.json) {
     const { markdown, ...rest } = result;
     console.log(JSON.stringify(rest, null, 2));
-    process.exit(result.exit);
-  }
-  if (result.error === 'feature-not-found') {
-    console.error(chalk.red(`stack-scan: a feature "${featureName}" não existe — rode morph-spec create ${featureName} antes`));
-    process.exit(2);
-  }
-  if (result.written) {
-    const high = result.deviations.filter((d) => d.severity === 'Bloqueante' || d.severity === 'Alto').length;
-    console.log(chalk.green(`✓ stack-scan: ${join(getFeatureDir(featureName), '2-plan', STACK_SCAN_FILE)} gravado`));
-    const summary = result.greenfield ? 'greenfield'
-      : !result.audited ? notAuditedReason(result)
-      : `${result.deviations.length} desvio(s), ${high} Bloqueante/Alto`;
-    console.log(chalk.gray(`  ${summary}`));
   } else {
     process.stdout.write(result.markdown);
   }

package/src/commands/project/stack-set.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import { setProjectStack } from '../../lib/installers/stack-sync.js';
+import { installStackAssets } from '../../lib/installers/stack-assets.js';
+import { getProjectTags } from '../../lib/stack-filter.js';
+
+export async function stackSetCommand(stack, options = {}) {
+  const integrations = String(options.with ?? '').split(',').map((t) => t.trim()).filter(Boolean);
+  const result = setProjectStack(process.cwd(), stack, {
+    integrations,
+    log: options.json ? () => {} : (line) => console.log(chalk.gray(line)),
+  });
+  if (result.error) {
+    if (options.json) console.log(JSON.stringify({ error: result.error }, null, 2));
+    else console.error(chalk.red(`✗ ${result.error}`));
+    process.exit(1);
+  }
+  const { stack: declared, integrations: declaredIntegrations, sync } = result;
+  await installStackAssets(process.cwd(), getProjectTags({ project: { stack: declared, integrations: declaredIntegrations } }));
+  if (options.json) {
+    console.log(JSON.stringify({ stack: declared, integrations: declaredIntegrations, rulesAdded: sync.added, rulesUpdated: sync.updated }, null, 2));
+  } else {
+    console.log(chalk.green(`✓ stack ${declared}`) + chalk.gray(` — rules, commands e skills da stack instalados (${sync.added.length + sync.updated.length} rule(s) de domínio nova(s))`));
+    console.log(chalk.yellow('  As rules carregam no início de uma sessão do Claude Code: implemente numa sessão nova.'));
+  }
+  process.exit(0);
+}

package/src/commands/project/status.js

@@ -1,6 +1,6 @@
 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 { implementProgress } from '../../../framework/hooks/shared/report-progress.js';
 import { formatNext } from '../../../framework/hooks/shared/next-step.js';
 import { nextStepFor } from '../../lib/next-step.js';
 
@@ -20,8 +20,8 @@ const PHASE_ORDER = [
 
 const PHASE_OUTPUTS = {
   plan: ['plan', 'checks'],
-  uiux: ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-  implement: [],
+  uiux: ['uiMockups'],
+  implement: ['implementReport'],
   review: ['verifierReport', 'reviewerReport']
 };
 
@@ -118,7 +118,7 @@ export async function statusCommand(featureName, options = {}) {
   if (!feature.outputs) {
     feature.outputs = deriveOutputs(featureName, process.cwd());
   }
-  const slices = sliceProgress(featurePath);
+  const scenarios = implementProgress(featurePath);
 
   if (options.json) {
     const status = {
@@ -137,7 +137,7 @@ export async function statusCommand(featureName, options = {}) {
         created: output.created,
         path: output.path
       })),
-      slices,
+      scenarios,
       approvals: feature.approvalGates || {},
       next: nextStepFor(featureName, process.cwd())
     };
@@ -177,14 +177,13 @@ export async function statusCommand(featureName, options = {}) {
   }
   console.log('');
 
-  if (slices && slices.total > 0) {
-    console.log(chalk.white.bold('Fatias:'));
-    const percentage = Math.round((slices.done / slices.total) * 100);
-    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}`));
+  if (scenarios && scenarios.total > 0) {
+    console.log(chalk.white.bold('Cenários (3-implement/report.md):'));
+    const percentage = Math.round((scenarios.done / scenarios.total) * 100);
+    console.log(`  Total: ${scenarios.total}`);
+    console.log(chalk.green(`  ✓ Feitos: ${scenarios.done} (${percentage}%)`));
+    if (scenarios.blocked > 0) console.log(chalk.yellow(`  ⏸ Bloqueados (esperam decisão): ${scenarios.blocked}`));
+    if (scenarios.pending > 0) console.log(chalk.gray(`  ⬜ Pendentes: ${scenarios.pending}`));
     console.log('');
   }