@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

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('');
   }
 

package/src/commands/project/update.js

@@ -1,7 +1,7 @@
 import { join, dirname, relative, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { spawnSync } from 'child_process';
-import { existsSync, readdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -27,9 +27,10 @@ import {
 } from '../../utils/version-checker.js';
 import { installClaudeHooks, installGlobalStatusline } from '../../utils/claude-settings-manager.js';
 import { installSkills } from '../../utils/skills-installer.js';
-import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
+import { installAgents } from '../../utils/agents-installer.js';
 import { injectMorphImport } from '../../utils/claude-md-injector.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
+import { detectStackTags, mergeDetectedTags } from '../../lib/installers/stack-sync.js';
 import { updateClaudeMdAgentsBlock, installRulesForStack, installCommandsForStack } from '../../scripts/setup-infra.js';
 import { reconcileLegacyTemplatesCopy } from '../../lib/installers/templates-reconcile.js';
 import { createEffects } from '../../lib/installers/effects.js';
@@ -145,6 +146,26 @@ export function stateJsonIsTracked(targetPath) {
   }
 }
 
+const SLICES_HEADING = /^## Fatias\s*$/m;
+
+/** Active features still planned in 9.x slices: a plan with `## Fatias` and no `3-implement/report.md` yet. */
+export function legacySliceFeatures(targetPath) {
+  const featuresDir = join(targetPath, '.morph', 'features');
+  let names;
+  try { names = readdirSync(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name); } catch { return []; }
+  return names.filter((name) => {
+    const dir = join(featuresDir, name);
+    if (existsSync(join(dir, '3-implement', 'report.md'))) return false;
+    try { return SLICES_HEADING.test(readFileSync(join(dir, '2-plan', 'plan.md'), 'utf8')); } catch { return false; }
+  }).sort();
+}
+
+export function legacySliceNotice(names) {
+  if (names.length === 0) return null;
+  return `Feature(s) planejada(s) em fatias (9.x): ${names.join(', ')}. Plano não aprovado: tire \`## Fatias\` e rode \`morph-spec plan-check <f>\`. `
+    + 'Já em implement: segue pelos `reports/F*.md`; para o formato novo, crie `3-implement/report.md` com uma linha por `Cn` (CHANGELOG 10.0.0).';
+}
+
 export function untrackCommittedStateJson(targetPath, fx = createEffects({ dryRun: false })) {
   if (!stateJsonIsTracked(targetPath)) return false;
   return fx.gitIndex('rm --cached --quiet', '.morph/state.json', { cwd: targetPath });
@@ -487,6 +508,19 @@ export async function updateCommand(options = {}) {
     try {
       if (configBackup) projectTags = getProjectTags(configBackup);
     } catch {}
+    // The same detection as `syncStackRules`, folded in before the installs: `restoreUserConfig`
+    // writes `configBackup`, and a dry run sees `.claude/rules/` before the clean, not after.
+    if (configBackup) {
+      try {
+        const detected = detectStackTags(targetPath, { config: configBackup });
+        const merged = mergeDetectedTags(configBackup, detected.persist);
+        if (merged.changed) {
+          configBackup.project = merged.config.project;
+          logger.dim(`  ✓ config.json: + ${merged.added.join(', ')} (detectado nos arquivos)`);
+        }
+        projectTags = [...new Set([...getProjectTags(configBackup), ...detected.tags])];
+      } catch {}
+    }
 
     let commandsCopied = false;
     const commandsSrc = join(frameworkDir, 'commands');
@@ -504,7 +538,6 @@ export async function updateCommand(options = {}) {
 
     updateSpinner.text = 'Syncing agents to .claude/agents/...';
     const agentsResult = await installAgents(targetPath, frameworkDir, { projectTags, fx });
-    await installDomainAgents(targetPath, frameworkDir, { projectTags, fx });
 
     updateSpinner.text = 'Syncing rules to .claude/rules/...';
     const rulesSrc = join(frameworkDir, 'rules');
@@ -566,6 +599,9 @@ export async function updateCommand(options = {}) {
       }
     }
 
+    const sliceNotice = legacySliceNotice(legacySliceFeatures(targetPath));
+    if (sliceNotice) notices.push(sliceNotice);
+
     const untracked = untrackCommittedStateJson(targetPath, fx);
 
     updateSpinner.text = 'Saving version info...';

package/src/commands/project/worktree.js

@@ -320,15 +320,6 @@ export async function runWorktreeSetup(feature, options = {}) {
 
     const graph = seedWorktreeGraph(worktreePath, cwd);
 
-    // Fail-open; a no-op under `create --worktree`, which regenerates it after its copy.
-    try {
-      if (existsSync(join(worktreePath, '.morph', 'features', feature, 'feature.json'))) {
-        const { writeHandoff } = await import('../../lib/generators/handoff-generator.js');
-        // `worktree` is root-owned and absent from this branch copy: pass it so the doc says "Local: worktree".
-        writeHandoff(feature, worktreePath, { worktree: { path: worktreePath, branch } });
-      }
-    } catch {}
-
     try {
       const { loadState, saveState } = await import('../../core/state/state-manager.js');
       const state = loadState(false);
@@ -834,9 +825,9 @@ export function pickRemovalFailure(stderrs) {
 
 /**
  * PROVE-or-DECLINE. `refused` (proved unsafe) restores the junctions; a git FAILURE leaves them down
- * (`infraLeftUnlinked`) unless `relinkOnFailure` (the reaper, whose agent may still be live).
+ * (`infraLeftUnlinked`).
  */
-export async function teardownWorktree(worktreePath, { root, feature, branch, options = {}, deleteBranch = true, addressByTarget = false, relinkOnFailure = false, stamp }) {
+export async function teardownWorktree(worktreePath, { root, feature, branch, options = {}, deleteBranch = true, addressByTarget = false, stamp }) {
   // ORDER IS LOAD-BEARING: unlink the junctions BEFORE git touches the dir. `git worktree remove`
   // follows them and deletes the root's installation; a declined path is repaired by the rollback below.
   const unlinked = unlinkWorktreeInfraLinks(worktreePath, root);
@@ -881,8 +872,7 @@ export async function teardownWorktree(worktreePath, { root, feature, branch, op
   // would make the next retry (or a raw `--force`) follow the junctions out.
   const refused = !canRemove;
   let relinked = false;
-  const relinkAfterFailure = relinkOnFailure && !refused && !worktreeRemoved && !removalFailure?.alreadyDeregistered;
-  if ((refused || relinkAfterFailure) && unlinked.length && existsSync(worktreePath)) {
+  if (refused && unlinked.length && existsSync(worktreePath)) {
     try {
       setupInfraLinks(worktreePath, root);
       relinked = true;
@@ -1055,7 +1045,6 @@ export async function runWorktreeRemove(featureArg, options = {}) {
     options: { discardIgnored: options.discardIgnored === true },
     // The branch is the work: deleting it would discard unintegrated commits. Opt-in only.
     deleteBranch: options.deleteBranch === true,
-    relinkOnFailure: options.relinkOnFailure === true,
     // Re-run advice must address the worktree the way it was addressable here:
     // a `--target` worktree has no feature name that would resolve.
     addressByTarget: !featureAddressable,