@polymorphism-tech/morph-spec 4.3.3 → 4.3.5

package/framework/workflows/docs/full-morph.md

@@ -0,0 +1,76 @@
+# Workflow: FULL MORPH (Alta Complexidade)
+
+> **Layer:** 1 | **Load:** on-keyword | **Keywords:** sistema, autenticação, integração, pattern, cqrs, subsistema
+
+## Critérios
+
+- > 10 arquivos, > 500 linhas, múltiplos componentes novos
+- Infraestrutura Azure (Bicep), decisões arquiteturais estratégicas
+
+## Fases (TODAS obrigatórias)
+
+### FASE 0.5: CONTEXT (automática)
+1. Detectar framework MORPH (`@polymorphism-tech/morph-spec`)
+2. Detectar/criar estrutura `.morph/project/`
+3. Análise automática: stack (glob patterns), arquitetura (pastas), configs, UI library
+4. Analisar histórico: decisions.md passados, preferências do usuário
+5. Gerar/atualizar `.morph/project/standards/inferred.md`
+6. Ativar agentes baseado em stack + keywords
+
+### FASE 0: PROPOSAL
+1. `npx morph-spec detect "{user-request}"`
+2. Analisar solicitação, identificar stack, estimar complexidade
+3. Gerar proposal.md, registrar agentes no state.json
+- **⛔ PAUSA:** 3 itens (1 ação + 1 pergunta + 1 sugestão)
+
+### FASE 1: SETUP
+1. Ler `.morph/config.json`
+2. Confirmar stack, ativar agentes, criar pasta outputs
+3. Carregar padrões (framework/standards/ > project/standards/)
+
+### FASE 1.5: UI/UX (condicional - se keywords UI detectadas)
+1. **Perguntar ao usuário:** layout, referências visuais, fluxo, imagens
+2. Analisar referências fornecidas
+3. Gerar deliverables AGNÓSTICOS de biblioteca (ui-mockups, ui-components, ui-flows)
+4. Validar acessibilidade (WCAG 2.1) e responsividade
+- **⛔ PAUSA:** Aprovar / Ajustar wireframes / Adicionar fluxos
+
+### FASE 2: DESIGN
+1. Gerar spec.md com requisitos completos
+2. **DECISION POINTS** (cada um requer aprovação):
+   - Biblioteca UI (Fluent UI vs MudBlazor)
+   - Padrões Arquiteturais (CQRS vs simples, Repository vs EF direto)
+   - Estrutura de Dados (entidades, relacionamentos)
+   - Infraestrutura Azure (recursos, SKUs, custos)
+   - Bibliotecas/SDKs (NuGet packages)
+3. Gerar contracts.cs, documentar decisões em decisions.md
+- **⛔ PAUSA:** Aprovar / Ajustar escopo / Modificar contracts
+
+### FASE 3: CLARIFY
+1. Identificar ambiguidades, fazer perguntas, documentar em spec.md, validar edge cases
+
+### FASE 4: TASKS
+1. Quebrar spec em tasks T001-TXXX, definir ordem, checkpoints, dependências
+- **⛔ PAUSA:** Aprovar / Repriorizar / Adicionar-remover tasks
+
+### FASE 5: IMPLEMENT
+1. Implementar task por task
+2. `npx morph-spec task done {feature} {task-id}` após cada task
+3. Framework gerencia checkpoints automaticamente (a cada 3 tasks)
+4. Gerar recap.md ao final
+
+### FASE 6: SYNC (condicional - se complexidade média/alta)
+1. Revisar decisions.md, categorizar (coding, architecture, azure, integrations, ui-ux)
+2. Promover para `.morph/project/standards/{category}.md`
+3. Gerar commit dedicado de sync
+- **⛔ PAUSA:** Aprovar promoção de decisões para standards
+
+## Outputs Completos
+proposal.md, ui-design-system.md, ui-mockups.md, ui-components.md, ui-flows.md, spec.md, contracts.cs, tasks.json, decisions.md, recap.md
+
+## Exemplos
+- "Sistema de relatórios com jobs agendados Hangfire"
+- "Autenticação completa com Clerk (login, signup, OAuth)"
+- "Dashboard com gráficos, tabelas e filtros complexos"
+- "RAG pipeline com Azure AI Search e embeddings"
+- "Infraestrutura Azure completa com Bicep"

package/framework/workflows/docs/standard.md

@@ -0,0 +1,44 @@
+# Workflow: STANDARD (Média Complexidade)
+
+> **Layer:** 1 | **Load:** on-keyword | **Keywords:** paginação, filtro, refatorar, performance, exportar
+
+## Critérios
+
+- 3-10 arquivos, 50-500 linhas, 1-2 componentes simples
+- Sem infraestrutura complexa, decisões táticas (não estratégicas)
+
+## Fases
+
+### 1. FASE 0: PROPOSAL (simplificada)
+- Análise inicial em 1 parágrafo
+- Detecta agentes relevantes
+- **PAUSA:** Aprovar?
+
+### 2. FASE 2: DESIGN (apenas spec.md)
+- Spec técnico conciso (1-2 páginas)
+- Sem contracts.cs se trivial
+- Decisões táticas em decisions.md
+- **PAUSA:** Aprovar?
+
+### 3. FASE 4: TASKS (se > 5 tasks)
+- Breakdown em tasks
+- **PAUSA:** Aprovar?
+
+### 4. FASE 5: IMPLEMENT
+- Implementa task por task
+- Gera recap.md ao final
+
+## Outputs
+proposal.md, spec.md, recap.md (mínimo necessário)
+
+## Fases Puladas
+- FASE 1 (SETUP) - contexto já carregado
+- FASE 1.5 (UI/UX) - se não tiver front-end significativo
+- FASE 3 (CLARIFY) - se spec for claro
+- FASE 6 (SYNC) - decisões não são estratégicas
+
+## Exemplos
+- "Adicionar paginação na tabela de usuários"
+- "Criar filtro por data no relatório"
+- "Refatorar serviço de email para async"
+- "Adicionar botão de exportar CSV"

package/framework/workflows/docs/ui-refresh.md

@@ -0,0 +1,39 @@
+# Workflow: UI REFRESH (Redesign Visual)
+
+> **Layer:** 1 | **Load:** on-keyword | **Keywords:** redesign, redesenhar, bonito, visual, estetica, modernizar
+
+## Critérios
+
+- Páginas existentes com código funcional
+- Apenas mudanças visuais (CSS, HTML, layout)
+- Sem mudanças em lógica de negócio, sem infraestrutura
+
+## Fases
+
+### 1. ANÁLISE VISUAL (FASE 0+1 combinadas)
+- Listar páginas a redesenhar
+- Identificar componentes compartilhados e design system existente
+- Se protótipo existir: ler e extrair padrões
+- **PAUSA:** Escolher direção estética
+
+### 2. DESIGN SYSTEM (FASE 1.5 simplificada)
+- Definir variáveis CSS novas
+- Listar componentes CSS a criar (checklist)
+- Gerar/atualizar design-system.css
+- **PAUSA:** Aprovar componentes
+
+### 3. IMPLEMENT (por página)
+- Atualizar CSS primeiro, depois cada página .razor
+- Build incremental a cada 2-3 páginas
+- Validar com `morph-spec validate-css`
+
+## Outputs
+design-refresh-checklist.md, CSS atualizado, páginas .razor, recap.md
+
+## Fases Puladas
+Setup completo, Contracts, Tasks detalhadas, Infra, Clarify, Sync
+
+## Exemplos
+- "Redesenhar as páginas do checkout para ficar mais bonito"
+- "Modernizar visual do dashboard"
+- "Aplicar novo design system nas telas existentes"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "description": "MORPH-SPEC: AI-First development framework with validation pipeline and multi-stack support",
   "keywords": [
     "claude-code",
@@ -26,8 +26,9 @@
   "files": [
     "bin/",
     "src/",
+    ".morph/",
+    "framework/",
     "scripts/",
-    "stacks/",
     "docs/",
     "README.md",
     "LICENSE",
@@ -38,7 +39,6 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "postinstall": "node scripts/postinstall.js",
     "start": "node bin/morph-spec.js",
     "test": "node --test --test-concurrency=1",
     "test:coverage": "c8 --reporter=text --reporter=html --reporter=lcov node --test --test-concurrency=1",

package/src/commands/feature/create-story.js

@@ -11,22 +11,26 @@ import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../../utils/logger.js';
 import { ensureDir, writeFile } from '../../utils/file-copier.js';
-import { resolveTemplatesDir } from '../../lib/stacks/stack-resolver.js';
 
 // ============================================================================
 // Helper Functions
 // ============================================================================
 
+function resolveTemplatesDir(basePath) {
+  return path.join(basePath, '.morph', 'templates');
+}
+
 function readTemplate(templateName) {
-  // Try npm-installed package path first
-  const pkgTemplatesDir = resolveTemplatesDir(path.join(process.cwd(), 'node_modules/@polymorphism-tech/morph-spec'));
-  const templatePath = path.join(pkgTemplatesDir, templateName);
+  // Try npm-installed package path first (framework templates)
+  const pkgFrameworkDir = path.join(process.cwd(), 'node_modules/@polymorphism-tech/morph-spec', 'framework', 'templates');
+  const templatePath = path.join(pkgFrameworkDir, templateName);
 
   // Fallback to local if in development
   if (!fs.existsSync(templatePath)) {
-    const localPath = path.join(resolveTemplatesDir(process.cwd()), templateName);
-    if (fs.existsSync(localPath)) {
-      return fs.readFileSync(localPath, 'utf-8');
+    // Check project-local override first, then framework
+    const localMorphPath = path.join(resolveTemplatesDir(process.cwd()), templateName);
+    if (fs.existsSync(localMorphPath)) {
+      return fs.readFileSync(localMorphPath, 'utf-8');
     }
     throw new Error(`Template not found: ${templateName}`);
   }

package/src/commands/project/detect-agents.js

@@ -6,14 +6,13 @@ import { logger } from '../../utils/logger.js';
 import { analyzeRequestComplexity } from '../../lib/analysis/complexity-analyzer.js';
 import { LearningSystem } from '../../lib/learning/learning-system.js';
 import { loadStandardsForAgent, getStandardsListForAgent } from '../../lib/standards/standards-context-injector.js';
-import { resolveAgentsConfigPath } from '../../lib/stacks/stack-resolver.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const frameworkRoot = join(__dirname, '..', '..', '..');
 
 function loadAgentsConfig() {
   try {
-    const configPath = resolveAgentsConfigPath(frameworkRoot);
+    const configPath = join(frameworkRoot, '.morph/config/agents.json');
     const content = readFileSync(configPath, 'utf8');
     return JSON.parse(content);
   } catch (err) {

package/src/commands/project/init.js

@@ -21,6 +21,8 @@ import { saveProjectMorphVersion, getInstalledCLIVersion } from '../../utils/ver
 import { installClaudeHooks } from '../../utils/hooks-installer.js';
 import { AutoContextOrchestrator } from '../../core/orchestrator.js';
 import { detectClaudeCode } from '../../llm/environment-detector.js';
+import inquirer from 'inquirer';
+import { detectProject } from '../../lib/detectors/index.js';
 
 export async function initCommand(options) {
   const targetPath = options.path || process.cwd();
@@ -77,7 +79,6 @@ export async function initCommand(options) {
       frameworkVersion: getInstalledCLIVersion(),
       project: {
         name: dirName,
-        stack: 'unknown',
         architecture: 'unknown'
       }
     };
@@ -107,23 +108,16 @@ Run \`morph-spec detect\` to analyze your project.
 `;
     await writeFile(contextReadme, readmeContent);
 
-    // 5. Copy templates from content
-    spinner.text = 'Copying templates...';
+    // 5. Copy framework templates (project-local overrides start from framework defaults)
     const contentDir = getContentDir();
-    const templatesSrc = join(contentDir, '.morph', 'templates');
+    const frameworkTemplatesSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'templates');
     const templatesDest = join(morphPath, 'templates');
     let templatesCopied = false;
-    if (await pathExists(templatesSrc)) {
-      await copyDirectory(templatesSrc, templatesDest);
+    if (await pathExists(frameworkTemplatesSrc)) {
+      await copyDirectory(frameworkTemplatesSrc, templatesDest);
       templatesCopied = true;
-    }
-
-    // 6. Copy standards from content (stack-specific)
-    spinner.text = 'Copying stack-specific standards...';
-    const standardsSrc = join(contentDir, '.morph', 'standards');
-    const standardsDest = join(morphPath, 'standards');
-    if (await pathExists(standardsSrc)) {
-      await copyDirectory(standardsSrc, standardsDest);
+    } else {
+      await ensureDir(templatesDest);
     }
 
     // 6b. Copy framework standards hierarchy (universal standards)
@@ -136,9 +130,9 @@ Run \`morph-spec detect\` to analyze your project.
       logger.dim('  ✓ Copied framework standards: core/, backend/, frontend/, infrastructure/');
     }
 
-    // 7. Copy agents.json (sourced from framework root .morph/config/ — canonical single source of truth)
+    // 7. Copy agents.json (sourced from framework/ — canonical single source of truth)
     spinner.text = 'Copying agents configuration...';
-    const agentsSrc = join(import.meta.dirname, '..', '..', '..', '.morph', 'config', 'agents.json');
+    const agentsSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'agents.json');
     const agentsDest = join(configDir, 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyFile(agentsSrc, agentsDest);
@@ -158,28 +152,29 @@ Run \`morph-spec detect\` to analyze your project.
     }
 
     // 9. Copy .claude commands and create symlinks for skills
-    // Source: framework root .claude/ (canonical for all stacks)
+    // Source: framework/ (canonical for all stacks)
     spinner.text = 'Setting up Claude Code integration...';
-    const claudeSrc = join(import.meta.dirname, '..', '..', '..', '.claude');
+    const frameworkDir = join(import.meta.dirname, '..', '..', '..', 'framework');
     const claudeDest = join(targetPath, '.claude');
 
     let symlinkCount = 0;
     let copyCount = 0;
     let commandsCopied = false;
 
-    if (await pathExists(claudeSrc)) {
-      // Copy commands directory (slash commands)
-      const commandsSrc = join(claudeSrc, 'commands');
-      const commandsDest = join(claudeDest, 'commands');
-      if (await pathExists(commandsSrc)) {
-        await copyDirectory(commandsSrc, commandsDest);
-        commandsCopied = true;
-      } else {
-        logger.warn('  ⚠ .claude/commands/ source missing — commands not installed');
-      }
+    // Copy commands directory (slash commands): framework/commands/ → .claude/commands/
+    const commandsSrc = join(frameworkDir, 'commands');
+    const commandsDest = join(claudeDest, 'commands');
+    if (await pathExists(commandsSrc)) {
+      await copyDirectory(commandsSrc, commandsDest);
+      commandsCopied = true;
+    } else {
+      logger.warn('  ⚠ framework/commands/ source missing — commands not installed');
+    }
 
-      // Create directory links for skill categories (or copy if linking fails)
-      const skillsSrc = join(claudeSrc, 'skills');
+    // Create directory links for skill categories (or copy if linking fails)
+    // Source: framework/skills/ → .claude/skills/
+    {
+      const skillsSrc = join(frameworkDir, 'skills');
       const skillsDest = join(claudeDest, 'skills');
 
       if (await pathExists(skillsSrc)) {
@@ -261,7 +256,7 @@ Run \`morph-spec detect\` to analyze your project.
     logger.dim(`  ✓ .morph/config/ (config.json, agents.json, azure-pricing.json)`);
     logger.dim(`  ✓ .morph/standards/ (coding.md, architecture.md, azure.md, ...)`);
     if (templatesCopied) {
-      logger.dim(`  ✓ .morph/templates/ (Bicep, integrations, saas, ...)`);
+      logger.dim(`  ✓ .morph/templates/ (project-local overrides for framework templates)`);
     }
     logger.dim(`  ✓ .morph/project/ (context, standards, outputs)`);
     if (commandsCopied) {
@@ -279,7 +274,49 @@ Run \`morph-spec detect\` to analyze your project.
 
     logger.blank();
 
-    // 12. Auto-detect project context (if Claude Code is available and not --skip-detection)
+    // 12. Interactive stack/standards detection for existing projects
+    const hasProjectFiles = await pathExists(join(targetPath, 'package.json'))
+      || await pathExists(join(targetPath, 'src'))
+      || (await fs.readdir(targetPath)).some(f => f.endsWith('.csproj'));
+
+    if (hasProjectFiles) {
+      logger.blank();
+      logger.header('Existing Project Detected');
+
+      try {
+        const quickResults = await detectProject(targetPath, { conversation: false, generateStandards: false });
+        const structure = quickResults.structure;
+
+        if (structure?.stack && structure.stack !== 'unknown') {
+          logger.info(`Stack detected: ${structure.stack}`);
+          if (structure?.architecture) logger.dim(`Architecture: ${structure.architecture}`);
+          if (structure?.uiLibrary) logger.dim(`UI Library: ${structure.uiLibrary}`);
+        }
+
+        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' }
+          ]
+        }]);
+
+        if (standardsChoice === 'detect') {
+          spinner.start('Generating project-specific standards...');
+          const fullResults = await detectProject(targetPath, { conversation: false });
+          const inferredPath = join(morphPath, 'project', 'standards', 'inferred.md');
+          await writeFile(inferredPath, fullResults.inferred.markdown);
+          spinner.succeed('Generated .morph/project/standards/inferred.md');
+          logger.dim('Review and edit .morph/project/standards/inferred.md as needed.');
+        }
+      } catch (error) {
+        logger.warn(`Stack detection failed: ${error.message}`);
+      }
+    }
+
+    // 13. LLM-based auto-detect project context (if Claude Code is available and not --skip-detection)
     if (!options.skipDetection && detectClaudeCode()) {
       logger.blank();
       logger.header('Auto-Detecting Project Context');

package/src/commands/project/update.js

@@ -26,6 +26,79 @@ import { installClaudeHooks } from '../../utils/hooks-installer.js';
 import { AutoContextOrchestrator } from '../../core/orchestrator.js';
 import { detectClaudeCode } from '../../llm/environment-detector.js';
 
+/**
+ * Backup user's config.json before cleaning
+ * @param {string} morphPath - Path to .morph directory
+ * @returns {Promise<object|null>} Backup of config.json or null
+ */
+async function backupUserConfig(morphPath) {
+  try {
+    const configPath = join(morphPath, 'config', 'config.json');
+    if (await pathExists(configPath)) {
+      const config = await readJson(configPath);
+      return config;
+    }
+  } catch (error) {
+    // If backup fails, return null and continue
+  }
+  return null;
+}
+
+/**
+ * Clean framework directories but preserve .morph/project/
+ * @param {string} morphPath - Path to .morph directory
+ * @param {string} targetPath - Project root path
+ */
+async function cleanFrameworkDirs(morphPath, targetPath) {
+  const dirsToClean = [
+    join(morphPath, 'templates'),
+    join(morphPath, 'standards'),
+    join(morphPath, 'config'),
+    join(targetPath, '.claude')
+  ];
+
+  for (const dir of dirsToClean) {
+    try {
+      if (await pathExists(dir)) {
+        await fs.remove(dir);
+      }
+    } catch (error) {
+      // Continue even if cleanup fails for one directory
+    }
+  }
+}
+
+/**
+ * Restore user's config.json after reinstallation
+ * @param {string} morphPath - Path to .morph directory
+ * @param {string} targetPath - Project root path
+ * @param {object|null} configBackup - Backup of config.json
+ * @param {string} currentVersion - Current CLI version
+ */
+async function restoreUserConfig(morphPath, targetPath, configBackup, currentVersion) {
+  const configDir = join(morphPath, 'config');
+  await ensureDir(configDir);
+  const configPath = join(configDir, 'config.json');
+
+  if (configBackup) {
+    // Preserve user data but update framework version
+    configBackup.frameworkVersion = currentVersion;
+    await writeJson(configPath, configBackup);
+  } else {
+    // Create basic config if none existed
+    const dirName = targetPath.split(/[\\/]/).pop();
+    const defaultConfig = {
+      framework: 'global',
+      frameworkVersion: currentVersion,
+      project: {
+        name: dirName,
+        architecture: 'unknown'
+      }
+    };
+    await writeJson(configPath, defaultConfig);
+  }
+}
+
 export async function updateCommand(options) {
   const targetPath = process.cwd();
   const contentDir = getContentDir();
@@ -34,10 +107,17 @@ export async function updateCommand(options) {
   logger.header('MORPH-SPEC Update');
 
   // Check if MORPH is initialized
+  let needsInitialization = false;
   if (!(await pathExists(morphPath))) {
-    logger.error('MORPH not initialized in this directory.');
-    logger.dim('Run "morph-spec init" first.');
-    process.exit(1);
+    logger.warn('MORPH not fully initialized. Creating basic structure...');
+    needsInitialization = true;
+
+    // Create basic .morph structure
+    await ensureDir(join(morphPath, 'project', 'context'));
+    await ensureDir(join(morphPath, 'project', 'standards'));
+    await ensureDir(join(morphPath, 'project', 'outputs'));
+    await ensureDir(join(morphPath, 'config'));
+    logger.dim('  ✓ Created .morph directory structure');
   }
 
   // Check CLI version
@@ -93,13 +173,25 @@ export async function updateCommand(options) {
   const updateSpinner = ora('Updating MORPH-SPEC...').start();
 
   try {
+    // Backup user config before cleaning
+    updateSpinner.text = 'Backing up user configuration...';
+    const configBackup = await backupUserConfig(morphPath);
+    if (configBackup) {
+      logger.dim('  ✓ User config backed up');
+    }
+
+    // Clean framework directories (preserve .morph/project/)
+    updateSpinner.text = 'Cleaning old framework files...';
+    await cleanFrameworkDirs(morphPath, targetPath);
+    logger.dim('  ✓ Old framework files removed');
+
     const updateTemplates = !options.standards || options.templates;
     const updateStandards = !options.templates || options.standards;
 
     // Update templates
     if (updateTemplates) {
       updateSpinner.text = 'Updating templates...';
-      const templatesSrc = join(contentDir, '.morph', 'templates');
+      const templatesSrc = join(contentDir, 'framework', 'templates');
       const templatesDest = join(morphPath, 'templates');
       await copyDirectory(templatesSrc, templatesDest);
     }
@@ -107,7 +199,7 @@ export async function updateCommand(options) {
     // Update standards
     if (updateStandards) {
       updateSpinner.text = 'Updating standards...';
-      const standardsSrc = join(contentDir, '.morph', 'standards');
+      const standardsSrc = join(contentDir, 'framework', 'standards');
       const standardsDest = join(morphPath, 'standards');
       await copyDirectory(standardsSrc, standardsDest);
     }
@@ -173,20 +265,15 @@ export async function updateCommand(options) {
     const claudeMdDest = join(targetPath, 'CLAUDE.md');
     await copyDirectory(claudeMdSrc, claudeMdDest);
 
+    // Restore user config after framework reinstallation
+    updateSpinner.text = 'Restoring user configuration...';
+    await restoreUserConfig(morphPath, targetPath, configBackup, cliCheck.current);
+    logger.dim('  ✓ User config restored with updated framework version');
+
     // Update .morphversion
     updateSpinner.text = 'Saving version info...';
     await saveProjectMorphVersion(targetPath, cliCheck.current);
 
-    // Update config.json frameworkVersion (BUG #9 fix)
-    const configPath = join(morphPath, 'config', 'config.json');
-    if (await pathExists(configPath)) {
-      try {
-        const config = await readJson(configPath);
-        config.frameworkVersion = cliCheck.current;
-        await writeJson(configPath, config);
-      } catch { /* preserve existing config if read/write fails */ }
-    }
-
     updateSpinner.succeed('MORPH-SPEC updated successfully!');
     logger.blank();
 

package/src/commands/templates/template-customize.js

@@ -25,14 +25,6 @@ export async function templateCustomizeCommand(templateId, options) {
       process.exit(1);
     }
 
-    // 2. Check if template is framework (universal)
-    if (template.location !== 'framework') {
-      logger.warn(`Template "${templateId}" is already stack-specific`);
-      logger.dim(`  Located at: stacks/${template.stacks?.[0]}/.morph/templates/${template.path}`);
-      logger.dim('\n  You can edit it directly or copy to another stack.');
-      process.exit(0);
-    }
-
     // 3. Resolve source path (framework template)
     const projectPath = options.projectPath || process.cwd();
     const sourcePath = resolveTemplatePathById(templateId, projectPath);
@@ -42,15 +34,9 @@ export async function templateCustomizeCommand(templateId, options) {
       process.exit(1);
     }
 
-    // 4. Determine destination (stack-specific or project-local)
-    const stackId = options.stack || 'blazor-azure';
-    const destDir = options.local
-      ? join(projectPath, '.morph/templates', dirname(template.path))
-      : join(projectPath, 'stacks', stackId, '.morph/templates', dirname(template.path));
-
-    const destPath = options.local
-      ? join(projectPath, '.morph/templates', template.path)
-      : join(projectPath, 'stacks', stackId, '.morph/templates', template.path);
+    // 4. Destination is always project-local .morph/templates/
+    const destDir = join(projectPath, '.morph/templates', dirname(template.path));
+    const destPath = join(projectPath, '.morph/templates', template.path);
 
     // 5. Check if already exists
     if (existsSync(destPath) && !options.force) {

package/src/commands/templates/template-list.js

@@ -8,7 +8,6 @@ import {
   getAllTemplates,
   getTemplatesByCategory,
   getTemplatesByPhase,
-  getTemplatesByStack,
   getRequiredTemplates,
   getRegistryStats
 } from '../../core/templates/template-registry.js';
@@ -55,11 +54,8 @@ export async function templateListCommand(options) {
     } else if (options.phase) {
       templates = getTemplatesByPhase(options.phase);
       logger.dim(`Phase: ${options.phase}`);
-    } else if (options.stack) {
-      templates = getTemplatesByStack(options.stack);
-      logger.dim(`Stack: ${options.stack}`);
     } else if (options.required) {
-      templates = getRequiredTemplates(options.stack);
+      templates = getRequiredTemplates();
       logger.dim('Required templates only');
     } else {
       templates = getAllTemplates();
@@ -86,14 +82,6 @@ export async function templateListCommand(options) {
         });
       }
 
-      if (stackTemplates.length > 0) {
-        logger.info(chalk.bold.yellow(`\n📦 Stack-Specific Templates (${stackTemplates.length})`));
-        stackTemplates.forEach(t => {
-          const formatted = formatTemplate(t);
-          const stacks = t.stacks ? chalk.dim(`(${t.stacks.join(', ')})`) : '';
-          console.log(`  ${formatted.id.padEnd(30)} ${formatted.name.padEnd(40)} ${stacks} ${formatted.badges}`);
-        });
-      }
     } else {
       // Flat list
       templates.forEach(t => {
@@ -109,8 +97,6 @@ export async function templateListCommand(options) {
       logger.info(chalk.bold('\n📊 Statistics'));
       console.log(`  Total Templates: ${chalk.green(stats.total)}`);
       console.log(`  Framework: ${chalk.cyan(stats.framework)}`);
-      console.log(`  Blazor-Azure: ${chalk.yellow(stats.blazorAzure)}`);
-      console.log(`  Next.js-Supabase: ${chalk.yellow(stats.nextjsSupabase)}`);
       console.log(`  Required: ${chalk.green(stats.required)}`);
       console.log(`  Optional: ${chalk.dim(stats.optional)}`);
     }

package/src/commands/templates/template-render.js

@@ -107,12 +107,11 @@ export async function templateRenderCommand(templateId, outputPath, variablesJso
 
     // 2. Resolve template path
     const projectPath = options.projectPath || process.cwd();
-    const stackId = options.stack || 'blazor-azure';
-    const templatePath = resolveTemplatePathById(templateId, projectPath, stackId);
+    const templatePath = resolveTemplatePathById(templateId, projectPath);
 
     if (!templatePath) {
       logger.error(`Template file not found for ${templateId}`);
-      logger.dim('  Searched in: framework/templates/ and stack templates');
+      logger.dim('  Searched in: .morph/templates/ and framework/templates/');
       process.exit(1);
     }