@polymorphism-tech/morph-spec 2.1.1 → 2.2.0

package/CLAUDE.md

@@ -17,6 +17,7 @@ Você é um sistema de desenvolvimento orientado por especificações. Opera com
 - Ultrapassar limites de custo sem aprovação
 - Criar recursos Azure manualmente no portal (use Bicep)
 - Gerar código sem contracts definidos
+- **Tomar decisões técnicas sozinho (infraestrutura, bibliotecas, patterns, schemas)**
 
 ### SEMPRE:
 - Seguir as 8 fases obrigatórias (incluindo FASE 0.5: CONTEXT e FASE 1.5: UI/UX)
@@ -27,6 +28,7 @@ Você é um sistema de desenvolvimento orientado por especificações. Opera com
 - Usar Infrastructure as Code (Bicep)
 - Usar exclusivamente Microsoft Agent Framework (.NET 10)
 - Coletar input do usuário na FASE 1.5 (layout, referências, imagens)
+- **Consultar usuário em DECISION POINTS (ver seção DECISION POINTS)**
 
 ---
 
@@ -67,10 +69,13 @@ Use o CLI para validar consistência:
 
 ```bash
 # Validar que todos skillPaths existem
-node bin/validate-agents-skills.js
+npx morph-spec validate-agents-skills
 
 # Modo verbose (mostra todos os mappings)
-node bin/validate-agents-skills.js --verbose
+npx morph-spec validate-agents-skills --verbose
+
+# OU, se em desenvolvimento local do framework:
+# node bin/validate-agents-skills.js
 ```
 
 Warnings de "orphan skills" são OK - são skills extras (infra/integrations) que podem ser usadas manualmente mas não têm agentes auto-ativados.
@@ -81,20 +86,23 @@ Warnings de "orphan skills" são OK - são skills extras (infra/integrations) qu
 
 ### Detecção Automática de Agentes
 
-**SEMPRE** use o CLI `bin/detect-agents.js` para detectar automaticamente quais agentes ativar:
+**SEMPRE** use o CLI para detectar automaticamente quais agentes ativar:
 
 ```bash
 # Detectar agentes baseado no input do usuário
-node bin/detect-agents.js "implementar jobs agendados"
+npx morph-spec detect "implementar jobs agendados"
 # Output: ["standards-architect","azure-architect","blazor-builder","ef-modeler","cost-guardian","ms-agent-expert","hangfire-orchestrator"]
 
 # Modo verbose para ver matches
-node bin/detect-agents.js --verbose "criar dashboard com charts"
+npx morph-spec detect --verbose "criar dashboard com charts"
 # Mostra quais keywords fizeram match
 
 # Modo JSON completo
-node bin/detect-agents.js --json "adicionar RAG pipeline"
+npx morph-spec detect --json "adicionar RAG pipeline"
 # Retorna objeto completo com core, specialists, matches
+
+# OU, se em desenvolvimento local do framework:
+# node bin/detect-agents.js "text..."
 ```
 
 ### Quando Detectar
@@ -127,7 +135,10 @@ Após detectar agentes, **SEMPRE** registrar no state.json:
 
 ```bash
 # Para cada agente detectado
-node bin/state-manager.js add-agent {feature} {agent-id}
+morph-spec state add-agent {feature} {agent-id}
+
+# OU, se em desenvolvimento local do framework:
+# node bin/state-manager.js add-agent {feature} {agent-id}
 ```
 
 ### Benefícios
@@ -383,14 +394,14 @@ Modo Degradado (sem framework):
 Gatilho: Nova feature request do usuário
 Ações:
 1. **Detectar agentes automaticamente:**
-   node bin/detect-agents.js "{user-request}"
+   npx morph-spec detect "{user-request}"
 
 2. Analisar a solicitação inicial
 3. Identificar stack provável (Blazor, Next.js, Shopify)
 4. Estimar complexidade (baixa, média, alta)
 5. Gerar proposal.md com análise inicial
 6. Registrar agentes no state.json:
-   node bin/state-manager.js add-agent {feature} {agent-id}
+   morph-spec state add-agent {feature} {agent-id}
 
 Output: .morph/project/outputs/{feature}/proposal.md
 
@@ -433,9 +444,11 @@ Ações:
    - Use Read tool para ler screenshots
    - Extrair padrões: layout, componentes, cores
 
-3. Decidir biblioteca UI (Fluent UI vs MudBlazor)
-   - Justificar escolha baseado na feature
-   - Documentar em decisions.md
+3. **🤔 DECISION POINT: Biblioteca UI**
+   - NUNCA decidir sozinho entre Fluent UI vs MudBlazor
+   - Usar template de DECISION POINTS para apresentar opções
+   - Incluir vantagens, desvantagens, complexidade
+   - Documentar escolha em decisions.md com ADR
 
 4. Gerar deliverables:
    - ui-mockups.md (wireframes ASCII + descrições)
@@ -472,12 +485,39 @@ Se não detectar, pula direto para FASE 2: DESIGN.
 ### FASE 2: DESIGN
 ```
 Gatilho: Contexto confirmado (ou UI/UX aprovado se FASE 1.5 executou)
+
+⚠️ IMPORTANTE: Esta fase contém múltiplos DECISION POINTS. NUNCA tome decisões
+técnicas sozinho. Sempre apresente opções usando o template de DECISION POINTS.
+
 Ações:
 1. Gerar `spec.md` com requisitos completos
-2. Gerar `contracts.cs` com interfaces/DTOs
-3. Iniciar `decisions.md` com ADRs relevantes
-4. Estimar custos e documentar
-5. Definir infraestrutura necessária (Bicep)
+
+2. **🤔 DECISION POINT: Padrões Arquiteturais**
+   - Apresentar opções: CQRS vs simples, Repository vs EF direto, etc.
+   - Incluir trade-offs de complexidade vs benefícios
+   - Aguardar aprovação do usuário
+
+3. **🤔 DECISION POINT: Estrutura de Dados**
+   - Apresentar opções de design de entidades
+   - Justificar relacionamentos (1:N, N:N, JSON, etc.)
+   - Aguardar aprovação do usuário
+
+4. Gerar `contracts.cs` com interfaces/DTOs aprovados
+
+5. **🤔 DECISION POINT: Infraestrutura Azure (se necessário)**
+   - Apresentar opções de recursos (Service Bus vs Queue vs Redis)
+   - Incluir SKUs e custos mensais estimados
+   - Justificar escolhas baseado em requisitos
+   - Aguardar aprovação do usuário
+
+6. Estimar custos totais e validar contra limites
+
+7. **🤔 DECISION POINT: Bibliotecas/SDKs (se necessário)**
+   - Apresentar opções de NuGet packages necessários
+   - Justificar escolha de cada dependência
+   - Aguardar aprovação do usuário
+
+8. Documentar TODAS as decisões em `decisions.md` com ADRs
 
 Outputs:
 - .morph/project/outputs/{feature}/spec.md
@@ -728,6 +768,7 @@ Toda pausa obrigatória DEVE terminar com **exatamente 3 itens** que ajudem o us
 | ❓ | Pergunta Aberta | Para clarificar intenções | "Qual a prioridade: performance ou custo?" |
 | 💡 | Sugestão Estratégica | Para propor alternativas | "Considerar serverless em vez de Container App?" |
 | ⚡ | Ação Rápida | Atalho para comum | "Usar padrão CQRS nesta feature?" |
+| 🤔 | Decisão Técnica | Apresentar opções para decisões críticas | "Service Bus vs Storage Queue: qual usar?" (Ver DECISION POINTS) |
 
 ### Estratégia por Fase
 
@@ -784,6 +825,251 @@ Complexidade estimada: **MÉDIA** | Stack: **.NET + Blazor** | Custo: **~$5/mês
 
 ---
 
+## DECISION POINTS
+
+### ⚠️ REGRA CRÍTICA: NUNCA DECIDA SOZINHO
+
+Você DEVE pausar e consultar o usuário em tempo real quando encontrar decisões técnicas significativas.
+
+**Decisões que SEMPRE requerem aprovação do usuário:**
+
+#### 1. **Infraestrutura Azure**
+- Escolha de recursos (Service Bus vs Storage Queue vs Redis vs Event Grid)
+- SKUs e tiers (Basic vs Standard vs Premium)
+- Regiões e replicação
+- Recursos pagos vs free tier
+
+**Exemplo de decisão automática (ERRADO):**
+```
+❌ "Vou usar Azure Service Bus Standard tier para mensageria."
+```
+
+**Exemplo correto:**
+```
+✅ "Para mensageria assíncrona, temos 3 opções:
+   1. Service Bus Standard ($10/mês): Suporta tópicos, sessões, até 1GB
+   2. Storage Queue ($0.05/mês): Apenas filas simples, até 500TB
+   3. Event Grid ($0.30/mi eventos): Pub/sub nativo, serverless
+
+   Recomendo Storage Queue se você precisa apenas de filas simples e baratas.
+   Qual prefere?"
+```
+
+#### 2. **Bibliotecas e Frameworks**
+- NuGet packages (.NET libraries)
+- UI libraries (Fluent UI vs MudBlazor vs Radzen)
+- ORMs além do padrão
+- Auth providers (Clerk vs Azure AD vs Auth0)
+- SDKs de terceiros
+
+**Exemplo de decisão automática (ERRADO):**
+```
+❌ "Vou usar MudBlazor para os componentes UI."
+```
+
+**Exemplo correto:**
+```
+✅ "Para componentes UI no Blazor, temos 2 opções principais:
+   1. Fluent UI Blazor: Design Microsoft 365, componentes AI-ready, mais moderno
+   2. MudBlazor: Material Design, mais componentes prontos, comunidade maior
+
+   Recomendo Fluent UI se você quer visual moderno e integração com IA.
+   Qual prefere?"
+```
+
+#### 3. **Padrões Arquiteturais**
+- CQRS vs operações simples
+- Repository Pattern vs EF direto no Service
+- Mediator (MediatR) vs chamadas diretas
+- Event Sourcing vs CRUD tradicional
+- DDD patterns complexos
+
+**Exemplo de decisão automática (ERRADO):**
+```
+❌ "Vou implementar CQRS para separar leitura e escrita."
+```
+
+**Exemplo correto:**
+```
+✅ "Para essa feature de relatórios, podemos usar:
+   1. CQRS: Separar comandos e queries, melhor performance em leitura
+      Complexidade: Média-Alta | Benefício: Escalabilidade
+   2. Repositórios simples: Um repositório por entidade
+      Complexidade: Baixa | Benefício: Mais rápido de implementar
+
+   Recomendo CQRS se você planeja escalar leituras independentemente.
+   Qual abordagem prefere?"
+```
+
+#### 4. **Estrutura de Dados**
+- Design de entidades e relacionamentos
+- Normalização vs denormalização
+- Schemas de API (DTOs, contratos)
+- Índices e otimizações de banco
+
+**Exemplo de decisão automática (ERRADO):**
+```
+❌ "Vou criar uma entidade User com relacionamento N:N com Roles."
+```
+
+**Exemplo correto:**
+```
+✅ "Para relacionamento User-Roles, temos 2 opções:
+   1. N:N com tabela intermediária UserRoles
+      Pros: Flexível, pode adicionar metadados (data de atribuição)
+      Cons: Mais complexo, mais JOINs
+   2. JSON array em User.Roles
+      Pros: Mais simples, menos JOINs
+      Cons: Menos flexível, dificulta queries por role
+
+   Recomendo N:N se você precisa saber quando role foi atribuída.
+   Qual estrutura prefere?"
+```
+
+---
+
+### Template de Decisão
+
+Quando encontrar uma decisão técnica, SEMPRE use este formato:
+
+```markdown
+---
+🤔 **DECISÃO TÉCNICA NECESSÁRIA**
+
+**Contexto:** {Por que precisamos decidir isso agora}
+
+**Opções disponíveis:**
+
+**Opção 1: {Nome}**
+- ✅ Vantagens: {lista concisa}
+- ❌ Desvantagens: {lista concisa}
+- 💰 Custo: {se Azure} ou N/A
+- ⚡ Complexidade: {baixa/média/alta}
+
+**Opção 2: {Nome}**
+- ✅ Vantagens: {lista concisa}
+- ❌ Desvantagens: {lista concisa}
+- 💰 Custo: {se Azure} ou N/A
+- ⚡ Complexidade: {baixa/média/alta}
+
+**Opção 3: {Nome}** (se houver)
+- ...
+
+**💡 Minha recomendação:**
+{Opção X} porque {justificativa técnica baseada no contexto do projeto}
+
+**Trade-offs principais:**
+- {Trade-off 1: ex: performance vs custo}
+- {Trade-off 2: ex: simplicidade vs escalabilidade}
+
+**Qual opção você prefere?** Ou quer ajustar alguma delas?
+
+---
+```
+
+---
+
+### Quando NÃO pausar (decisões triviais)
+
+Decisões automáticas permitidas (não precisa consultar):
+- ✅ Nomenclatura de variáveis/métodos (seguir standards)
+- ✅ Estrutura de pastas (seguir Clean Architecture padrão do projeto)
+- ✅ Imports e usings
+- ✅ Formatação de código
+- ✅ Tipos primitivos (string vs int, etc.)
+- ✅ Validações básicas (Required, MaxLength, etc.)
+- ✅ Padrões já definidos em project/standards/
+
+**Regra de ouro:** Se a decisão afeta **custo**, **arquitetura**, **dependências externas** ou **estrutura de dados**, SEMPRE consultar.
+
+---
+
+### Exemplo Real Completo
+
+**Situação:** Usuário pediu "adicionar cache para melhorar performance"
+
+**❌ ERRADO (decisão automática):**
+```
+Vou implementar cache usando Redis Premium tier.
+```
+
+**✅ CORRETO (apresentar opções):**
+
+```markdown
+---
+🤔 **DECISÃO TÉCNICA NECESSÁRIA**
+
+**Contexto:** Você pediu cache para melhorar performance das queries de produtos. Precisamos decidir qual estratégia usar.
+
+**Opções disponíveis:**
+
+**Opção 1: In-Memory Cache (IMemoryCache .NET)**
+- ✅ Vantagens: Zero custo, simples, rápido para dados pequenos
+- ❌ Desvantagens: Limitado à memória do servidor, perdido em restart, não compartilhado entre instâncias
+- 💰 Custo: $0
+- ⚡ Complexidade: Baixa
+
+**Opção 2: Redis (Azure Cache for Redis - Basic tier)**
+- ✅ Vantagens: Persistente, compartilhado, suporta estruturas complexas
+- ❌ Desvantagens: Custo adicional, latência de rede
+- 💰 Custo: ~$16/mês (Basic C0)
+- ⚡ Complexidade: Média
+
+**Opção 3: Distributed Memory Cache (SQL Server)**
+- ✅ Vantagens: Usa SQL existente, sem custo adicional, compartilhado
+- ❌ Desvantagens: Mais lento que Redis, usa DB para cache
+- 💰 Custo: $0 (usa SQL existente)
+- ⚡ Complexidade: Baixa-Média
+
+**💡 Minha recomendação:**
+Opção 1 (IMemoryCache) se você tem apenas 1 instância do app e dados de cache < 100MB.
+Opção 3 (SQL Distributed Cache) se você tem múltiplas instâncias mas quer evitar custo de Redis.
+
+**Trade-offs principais:**
+- Performance vs Custo: Redis é mais rápido mas custa $16/mês
+- Simplicidade vs Escalabilidade: IMemoryCache é simples mas não escala para múltiplas instâncias
+
+**Qual opção você prefere?** Ou quer ajustar alguma delas?
+---
+```
+
+---
+
+### Integração com Fases
+
+**FASE 1.5 (UI/UX):**
+- ❓ Perguntar: Fluent UI vs MudBlazor vs outra biblioteca
+- ❓ Perguntar: Preferências de layout, cores, componentes
+
+**FASE 2 (DESIGN):**
+- ❓ Perguntar: Padrões arquiteturais (CQRS, Repository, etc.)
+- ❓ Perguntar: Infraestrutura Azure (recursos, SKUs)
+- ❓ Perguntar: Bibliotecas e SDKs necessários
+- ❓ Perguntar: Estrutura de dados (entidades, relacionamentos)
+
+**Durante IMPLEMENTAÇÃO:**
+- ❓ Pausar: Se encontrar decisão não prevista no design
+- ❓ Pausar: Se precisar adicionar dependência nova
+- ❓ Pausar: Se precisar mudar estrutura de dados aprovada
+
+---
+
+### Validação Automática (CLI)
+
+Use o comando `morph-spec validate-decisions` para verificar se decisões foram documentadas:
+
+```bash
+# Validar decisions.md de uma feature
+morph-spec validate-decisions {feature-name}
+
+# O comando verifica:
+# - Decisões de infraestrutura têm ADRs?
+# - Bibliotecas escolhidas estão documentadas?
+# - Padrões arquiteturais estão justificados?
+```
+
+---
+
 ## AGENTES
 
 ### Core Agents (Sempre Ativos)
@@ -867,13 +1153,16 @@ Os limites de custo são definidos em `.morph/config/config.json` e podem ser cu
 
 ```bash
 # Calcular custos de arquivos Bicep
-node bin/calculate-costs.js infra/main.bicep --verbose
+morph-spec cost infra/main.bicep --verbose
 
 # Múltiplos arquivos (glob pattern)
-node bin/calculate-costs.js "infra/**/*.bicep" --json
+morph-spec cost "infra/**/*.bicep" --json
 
 # Usar config customizado
-node bin/calculate-costs.js infra/main.bicep --config .morph/config/config.json
+morph-spec cost infra/main.bicep --config .morph/config/config.json
+
+# OU, se em desenvolvimento local do framework:
+# node bin/calculate-costs.js infra/main.bicep --verbose
 ```
 
 **Funcionalidades:**
@@ -921,7 +1210,7 @@ ln -s ../../.morph/hooks/pre-commit-costs.sh .git/hooks/pre-commit
 |------|------|-----|
 | **FASE 2 (Design)** | Estimar custos de infra proposta | `/morph-design` (integrado) |
 | **Antes de commit** | Validar custos automaticamente | Pre-commit hook |
-| **Revisão manual** | Verificar custos de Bicep | `calculate-costs.js --verbose` |
+| **Revisão manual** | Verificar custos de Bicep | `morph-spec cost <bicep-files> --verbose` |
 
 ### Exemplo de ADR de Custo
 
@@ -1062,35 +1351,38 @@ O MORPH-SPEC rastreia automaticamente o progresso de features usando `.morph/sta
 
 ### CLI para State Management
 
-Use `bin/state-manager.js` para manipular o state:
+Use o comando `morph-spec state` para manipular o state:
 
 ```bash
 # Inicializar state (primeira vez)
-node bin/state-manager.js init
+morph-spec state init
 
 # Criar/atualizar feature
-node bin/state-manager.js set feature-name phase design
-node bin/state-manager.js set feature-name status in_progress
+morph-spec state set feature-name phase design
+morph-spec state set feature-name status in_progress
 
 # Atualizar tasks
-node bin/state-manager.js set feature-name tasks.completed 5
-node bin/state-manager.js set feature-name tasks.total 12
+morph-spec state set feature-name tasks.completed 5
+morph-spec state set feature-name tasks.total 12
 
 # Adicionar agentes
-node bin/state-manager.js add-agent feature-name blazor-builder
+morph-spec state add-agent feature-name blazor-builder
 
 # Marcar outputs como criados
-node bin/state-manager.js mark-output feature-name spec
-node bin/state-manager.js mark-output feature-name contracts
+morph-spec state mark-output feature-name spec
+morph-spec state mark-output feature-name contracts
 
 # Registrar checkpoint
-node bin/state-manager.js checkpoint feature-name "Completadas tasks T001-T003"
+morph-spec state checkpoint feature-name "Completadas tasks T001-T003"
 
 # Listar todas as features
-node bin/state-manager.js list
+morph-spec state list
 
 # Obter detalhes de uma feature (JSON)
-node bin/state-manager.js get feature-name
+morph-spec state get feature-name
+
+# OU, se em desenvolvimento local do framework:
+# node bin/state-manager.js <command>
 ```
 
 ### Quando Atualizar State

package/bin/validate-agents-skills.js

@@ -118,11 +118,15 @@ function validateAgentsSkills(config, verbose = false) {
     const skillPath = `.claude/skills/${skillFile.replace('.claude/skills/', '')}`;
 
     if (!agentSkillPaths.has(skillPath)) {
-      warnings.push({
-        type: 'orphan-skill',
-        skillPath: skillPath,
-        message: `Skill '${skillPath}' has no corresponding agent in agents.json`
-      });
+      // Orphan skills são OK - podem ser usados manualmente
+      // Apenas reportar em verbose mode
+      if (verbose) {
+        info.push({
+          type: 'manual-skill',
+          skillPath: skillPath,
+          message: `ℹ️  Manual skill: ${skillPath} (no auto-activation)`
+        });
+      }
     }
   }
 
@@ -194,6 +198,14 @@ function displayResults(results, verbose) {
     log('║ ✅ All agents and skills are properly mapped!                  ║', 'green');
   }
 
+  // Nota sobre manual skills
+  const manualSkills = info.filter(i => i.type === 'manual-skill').length;
+  if (manualSkills > 0 && verbose) {
+    log('║                                                                ║', 'cyan');
+    log(`║ ℹ️  ${manualSkills} manual-only skills found (use --verbose to see)    ║`, 'gray');
+    log('║   These are extra skills without auto-activation.             ║', 'gray');
+  }
+
   log('╚════════════════════════════════════════════════════════════════╝\n', 'cyan');
 }
 

package/detectors/structure-detector.js

@@ -50,6 +50,7 @@ export async function detectStructure(projectPath) {
  * Detect stack type
  */
 async function detectStack(projectPath) {
+  // Order matters: more specific patterns first
   const patterns = {
     blazor: [
       '**/*.razor',
@@ -57,19 +58,47 @@ async function detectStack(projectPath) {
       '**/Components/**/*.razor'
     ],
     nextjs: [
-      'pages/**/*.tsx',
-      'app/**/*.tsx',
       'next.config.js',
-      'next.config.mjs'
+      'next.config.mjs',
+      'next.config.ts',
+      'pages/**/*.tsx',
+      'app/**/*.tsx'
     ],
     shopify: [
       '**/*.liquid',
       'sections/**/*.liquid',
       'templates/**/*.liquid'
     ],
+    react: [
+      'src/App.jsx',
+      'src/App.tsx',
+      'vite.config.js',
+      'craco.config.js'
+    ],
+    vue: [
+      'vite.config.js', // Vue 3 + Vite
+      'vue.config.js',  // Vue 2
+      'src/App.vue'
+    ],
     dotnet: [
       '**/*.csproj',
       '**/Program.cs'
+    ],
+    typescript: [
+      'tsconfig.json',
+      'src/**/*.ts'
+    ],
+    nodejs: [
+      'package.json'  // Fallback: generic Node.js
+    ],
+    python: [
+      'requirements.txt',
+      'pyproject.toml',
+      'setup.py'
+    ],
+    go: [
+      'go.mod',
+      'main.go'
     ]
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "MORPH-SPEC v2.0: AI-First development framework with .NET 10, Microsoft Agent Framework, and Fluent UI Blazor",
   "keywords": [
     "claude-code",

package/src/commands/create-story.js

@@ -6,6 +6,7 @@
 
 import fs from 'fs';
 import path from 'path';
+import yaml from 'yaml';
 import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
@@ -257,10 +258,77 @@ export async function createStoryCommand(feature, storyId, options) {
       // Write file
       await writeFile(outputPath, renderedStory);
 
+      // ============================================================================
+      // Update sprint-status.yaml (create if doesn't exist)
+      // ============================================================================
+      const sprintStatusPath = path.join(process.cwd(), `.morph/project/outputs/${feature}/sprint-status.yaml`);
+      let sprintStatus;
+
+      if (fs.existsSync(sprintStatusPath)) {
+        // Load existing
+        const content = fs.readFileSync(sprintStatusPath, 'utf-8');
+        sprintStatus = yaml.parse(content);
+      } else {
+        // Create new
+        sprintStatus = {
+          feature: feature,
+          epic: options.epic || toTitleCase(feature),
+          created: new Date().toISOString().split('T')[0],
+          updated: new Date().toISOString().split('T')[0],
+          stories: [],
+          metrics: {
+            total_stories: 0,
+            ready: 0,
+            in_progress: 0,
+            ready_for_qa: 0,
+            done: 0,
+            completion_percent: 0
+          },
+          current: null,
+          next: null
+        };
+      }
+
+      // Add new story to sprint-status
+      sprintStatus.stories.push({
+        id: storyId,
+        title: storyData.storyTitle,
+        file: `stories/${storyId}.md`,
+        status: 'ready',
+        created: new Date().toISOString().split('T')[0],
+        assigned: null,
+        started: null,
+        completed: null
+      });
+
+      // Update metrics
+      sprintStatus.metrics.total_stories = sprintStatus.stories.length;
+      sprintStatus.metrics.ready = sprintStatus.stories.filter(s => s.status === 'ready').length;
+      sprintStatus.metrics.in_progress = sprintStatus.stories.filter(s => s.status === 'in_progress').length;
+      sprintStatus.metrics.ready_for_qa = sprintStatus.stories.filter(s => s.status === 'ready_for_qa').length;
+      sprintStatus.metrics.done = sprintStatus.stories.filter(s => s.status === 'done').length;
+      sprintStatus.metrics.completion_percent = sprintStatus.stories.length > 0
+        ? Math.round((sprintStatus.metrics.done / sprintStatus.stories.length) * 100)
+        : 0;
+      sprintStatus.updated = new Date().toISOString().split('T')[0];
+
+      // Set next story if null
+      if (!sprintStatus.next) {
+        sprintStatus.next = {
+          story_id: storyId,
+          recommendation: `Story ${storyId} is ready for development`
+        };
+      }
+
+      // Write sprint-status.yaml
+      const yamlContent = yaml.stringify(sprintStatus);
+      fs.writeFileSync(sprintStatusPath, yamlContent);
+
       spinner.succeed('Story created!');
       logger.blank();
 
       logger.success(`Story file: ${chalk.cyan(outputPath)}`);
+      logger.success(`Updated: ${chalk.cyan('sprint-status.yaml')}`);
       logger.blank();
 
       logger.header('Dev Notes Auto-Injected:');

package/src/commands/init.js

@@ -1,4 +1,5 @@
 import { join } from 'path';
+import fs from 'fs-extra';
 import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
@@ -12,7 +13,8 @@ import {
   ensureDir,
   writeFile,
   readFile,
-  updateGitignore
+  updateGitignore,
+  createSymlink
 } from '../utils/file-copier.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
 
@@ -52,16 +54,18 @@ export async function initCommand(options) {
     }
     await copyFile(claudeMdPath, claudeMdDest);
 
-    // 2. Create .morph/project structure
-    spinner.text = 'Creating .morph/project structure...';
+    // 2. Create .morph directory structure
+    spinner.text = 'Creating .morph structure...';
     const projectPath = join(morphPath, 'project');
+    const configDir = join(morphPath, 'config');
     await ensureDir(join(projectPath, 'context'));
     await ensureDir(join(projectPath, 'standards'));
     await ensureDir(join(projectPath, 'outputs'));
+    await ensureDir(configDir);
 
     // 3. Create config.json
     spinner.text = 'Generating config.json...';
-    const configPath = join(morphPath, 'config.json');
+    const configPath = join(configDir, 'config.json');
     const dirName = targetPath.split(/[\\/]/).pop();
 
     const config = {
@@ -99,12 +103,102 @@ Run \`morph-spec detect\` to analyze your project.
 `;
     await writeFile(contextReadme, readmeContent);
 
-    // 5. Save version info
+    // 5. Copy templates from content
+    spinner.text = 'Copying templates...';
+    const contentDir = getContentDir();
+    const templatesSrc = join(contentDir, '.morph', 'templates');
+    const templatesDest = join(morphPath, 'templates');
+    if (await pathExists(templatesSrc)) {
+      await copyDirectory(templatesSrc, templatesDest);
+    }
+
+    // 6. Copy standards from content
+    spinner.text = 'Copying standards...';
+    const standardsSrc = join(contentDir, '.morph', 'standards');
+    const standardsDest = join(morphPath, 'standards');
+    if (await pathExists(standardsSrc)) {
+      await copyDirectory(standardsSrc, standardsDest);
+    }
+
+    // 7. Copy agents.json
+    spinner.text = 'Copying agents configuration...';
+    const agentsSrc = join(contentDir, '.morph', 'config', 'agents.json');
+    const agentsDest = join(configDir, 'agents.json');
+    if (await pathExists(agentsSrc)) {
+      await copyFile(agentsSrc, agentsDest);
+    }
+
+    // 8. Copy azure-pricing files
+    spinner.text = 'Copying Azure pricing data...';
+    const pricingSrc = join(contentDir, '.morph', 'config', 'azure-pricing.json');
+    const pricingDest = join(configDir, 'azure-pricing.json');
+    if (await pathExists(pricingSrc)) {
+      await copyFile(pricingSrc, pricingDest);
+    }
+    const pricingSchemaSrc = join(contentDir, '.morph', 'config', 'azure-pricing.schema.json');
+    const pricingSchemaDest = join(configDir, 'azure-pricing.schema.json');
+    if (await pathExists(pricingSchemaSrc)) {
+      await copyFile(pricingSchemaSrc, pricingSchemaDest);
+    }
+
+    // 9. Copy .claude commands and create symlinks for skills
+    spinner.text = 'Setting up Claude Code integration...';
+    const claudeSrc = join(contentDir, '.claude');
+    const claudeDest = join(targetPath, '.claude');
+
+    let symlinkCount = 0;
+    let copyCount = 0;
+
+    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);
+      }
+
+      // Create symlinks for skills (or copy if symlink fails)
+      const skillsSrc = join(claudeSrc, 'skills');
+      const skillsDest = join(claudeDest, 'skills');
+
+      if (await pathExists(skillsSrc)) {
+        // Ensure skills destination directory exists
+        await ensureDir(skillsDest);
+
+        // Recursively walk through skills directory
+        const walkDir = async (dir, basePath) => {
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+
+          for (const entry of entries) {
+            const srcPath = join(dir, entry.name);
+            const relPath = join(basePath, entry.name);
+            const destPath = join(skillsDest, relPath);
+
+            if (entry.isDirectory()) {
+              await ensureDir(destPath);
+              await walkDir(srcPath, relPath);
+            } else if (entry.isFile() && entry.name.endsWith('.md')) {
+              // Create symlink for skill files
+              const result = await createSymlink(srcPath, destPath, 'file');
+              if (result === 'symlink') {
+                symlinkCount++;
+              } else {
+                copyCount++;
+              }
+            }
+          }
+        };
+
+        await walkDir(skillsSrc, '');
+      }
+    }
+
+    // 10. Save version info
     spinner.text = 'Saving version info...';
     const cliVersion = getInstalledCLIVersion();
     await saveProjectMorphVersion(targetPath, cliVersion);
 
-    // 6. Update .gitignore
+    // 11. Update .gitignore
     spinner.text = 'Updating .gitignore...';
     await updateGitignore(targetPath);
 
@@ -126,16 +220,21 @@ Run \`morph-spec detect\` to analyze your project.
     ]);
     logger.blank();
 
-    logger.info('Structure created:');
-    logger.dim(`CLAUDE.md                → ${join(targetPath, 'CLAUDE.md')}`);
-    logger.dim(`.morph/config.json       → Project config`);
-    logger.dim(`.morph/project/context/  → Project context`);
-    logger.dim(`.morph/project/standards/→ Project standards`);
-    logger.dim(`.morph/project/outputs/  → Feature outputs`);
-    logger.blank();
+    logger.info('Files installed:');
+    logger.dim(`  ✓ CLAUDE.md`);
+    logger.dim(`  ✓ .morph/config/ (config.json, agents.json, azure-pricing.json)`);
+    logger.dim(`  ✓ .morph/standards/ (coding.md, architecture.md, azure.md, ...)`);
+    logger.dim(`  ✓ .morph/templates/ (Bicep, integrations, saas, ...)`);
+    logger.dim(`  ✓ .morph/project/ (context, standards, outputs)`);
+    logger.dim(`  ✓ .claude/commands/ (slash commands)`);
+
+    if (symlinkCount > 0) {
+      logger.dim(`  ✓ .claude/skills/ (${symlinkCount} symlinked)`);
+    } else if (copyCount > 0) {
+      logger.dim(`  ✓ .claude/skills/ (${copyCount} copied)`);
+      logger.warn(`  ⚠ Symlinks not supported (copied instead). Skills won't auto-update.`);
+    }
 
-    logger.info('Content (via npm package):');
-    logger.dim(`Templates and standards available via morph-spec update`);
     logger.blank();
 
   } catch (error) {

package/src/commands/state.js

@@ -236,7 +236,7 @@ async function listCommand(options) {
         ? `${feature.tasks.completed}/${feature.tasks.total}`
         : '0/0';
 
-      logger.info(`${statusEmoji}  ${chalk.bright(name)}`);
+      logger.info(`${statusEmoji}  ${chalk.bold(name)}`);
       logger.dim(`   Phase: ${feature.phase.padEnd(16)} │ Tasks: ${progress}`);
       logger.dim(`   Agents: ${feature.activeAgents.slice(0, 5).join(', ') || 'None'}`);
       logger.blank();

package/src/utils/file-copier.js

@@ -53,6 +53,32 @@ export async function readFile(path) {
   return fs.readFile(path, 'utf8');
 }
 
+/**
+ * Create symlink with fallback to copy if symlink fails
+ * @param {string} target - Path to the original file/folder
+ * @param {string} link - Path where symlink should be created
+ * @param {string} type - 'file' or 'dir'
+ * @returns {Promise<'symlink' | 'copy'>} - Returns how the link was created
+ */
+export async function createSymlink(target, link, type = 'file') {
+  await fs.ensureDir(dirname(link));
+
+  try {
+    // Try to create symlink
+    await fs.ensureSymlink(target, link, type);
+    return 'symlink';
+  } catch (error) {
+    // Fallback: copy the file/directory if symlink fails
+    // (Windows may require admin permissions for symlinks)
+    if (type === 'file') {
+      await copyFile(target, link);
+    } else {
+      await copyDirectory(target, link);
+    }
+    return 'copy';
+  }
+}
+
 export async function updateGitignore(projectPath) {
   const gitignorePath = join(projectPath, '.gitignore');