@polymorphism-tech/morph-spec 3.2.0 → 4.3.0

package/stacks/blazor-azure/.claude/skills/level-1-workflows/phase-uiux.md

@@ -1,169 +0,0 @@
-# MORPH UI/UX Design - FASE 1.5
-
-> INTERNAL: Workflow skill used by /morph-proposal during automated phase orchestration. Not a user command.
-
-Fase condicional para features com front-end. Coleta requisitos de UI/UX, gera wireframes, specs de componentes e fluxos de usuário.
-
-## Pré-requisitos
-
-- [ ] FASE 1 (Setup) concluída
-- [ ] Feature tem keywords de UI detectadas (blazor, ui, component, page, dashboard, wizard, form, chart)
-- [ ] `uiux-designer` agent ativado
-
-## Workflow
-
-### Passo 0: Verificar Design System Existe
-
-**CRITICAL:** Antes de iniciar a FASE UI/UX, verifique se um design system existe:
-
-```bash
-npx morph-spec detect-agents "{feature description}"
-```
-
-Se nenhum design system for detectado (verificar output):
-
-1. **Opção A - Scaffold automático:**
-   - O sistema criará automaticamente um design system ao avançar para implementação
-   - Você pode gerar manualmente agora: `npx morph-spec generate design-system`
-
-2. **Opção B - Criar manualmente:**
-   - Crie `.morph/project/design-system.md` (project-level, compartilhado)
-   - Ou `.morph/project/outputs/{feature}/ui-design-system.md` (feature-specific)
-
-3. **Opção C - Scan existing CSS:**
-   - Se o projeto já tem CSS com variáveis: `npx morph-spec generate design-system --scan`
-
-**⚠️ IMPORTANTE:**
-- Design system é **obrigatório** para features UI
-- Gate automático bloqueará implementação (FASE 5) se design system não existir
-- Melhor criar agora para garantir consistência visual
-
-### Passo 1: Detectar Se Fase É Necessária
-
-Verifique se agentes ativos incluem `uiux-designer`:
-
-```bash
-npx morph-spec state get {feature-name}
-```
-
-Se `uiux-designer` NÃO estiver nos `activeAgents`, pule esta fase e continue para FASE 2 (Design).
-
-### Passo 2: Coletar Input do Usuário
-
-**SEMPRE perguntar ao usuário PRIMEIRO:**
-
-1. **Layout e estilo**:
-   - Você tem alguma ideia de layout em mente?
-   - Tem alguma referência visual? (sites, apps, screenshots)
-   - Como imagina o fluxo do usuário?
-
-2. **Componentes e interações**:
-   - Quais os principais componentes desta tela/página?
-   - Quais estados precisam ser considerados? (loading, error, empty, success)
-
-3. **Imagens de referência**:
-   - Tem imagens de exemplo que eu possa analisar?
-   - Se SIM: use Read tool para ler screenshots e extrair padrões
-
-### Passo 3: Decidir Biblioteca UI
-
-Escolha entre **Fluent UI Blazor** (recomendado para AI-first) ou **MudBlazor** (componentes complexos):
-
-**Critérios:**
-- Fluent UI: Para dashboards, forms simples, AI components, Microsoft design language
-- MudBlazor: Para data grids avançadas, charts complexos, material design
-
-**Documente a decisão em `decisions.md`.**
-
-### Passo 4: Gerar Deliverables
-
-Crie os seguintes arquivos em `.morph/project/outputs/{feature}/`:
-
-#### 4.1. `ui-design-system.md`
-
-**Se design system project-level existe (`.morph/project/design-system.md`):**
-- Referencie-o nos specs: "Uses project design system at .morph/project/design-system.md"
-- Crie `ui-design-system.md` apenas se houver cores/componentes **específicos** da feature
-
-**Se não existe:**
-- Crie design system feature-level completo com:
-  - Paleta de cores (primary, secondary, accent, semantic)
-  - Tipografia (heading scales, body text, code)
-  - Spacing e layout (grid, margins, paddings)
-  - Componentes base (buttons, inputs, cards)
-
-#### 4.2. `ui-mockups.md`
-
-Wireframes ASCII + descrições:
-- Layout geral de cada tela/página
-- Posicionamento de componentes
-- Responsividade (desktop, tablet, mobile)
-- Estados (loading, error, empty, success)
-
-#### 4.3. `ui-components.md`
-
-Specs técnicas de componentes Fluent UI/MudBlazor:
-- Componente a usar (FluentButton, MudDataGrid, etc.)
-- Props e configurações
-- Eventos e bindings
-- Validações e estados
-
-#### 4.4. `ui-flows.md`
-
-Fluxos de usuário completos:
-- User stories
-- Diagramas de fluxo (texto/ASCII)
-- Edge cases (o que acontece se...?)
-- Validações e feedback
-
-### Passo 5: Validar Acessibilidade e Responsividade
-
-Documente nos arquivos UI:
-- **WCAG 2.1 Level AA** compliance
-  - Contraste de cores adequado
-  - Labels acessíveis para screen readers
-  - Navegação por teclado
-- **Responsive breakpoints**
-  - Desktop (>1200px)
-  - Tablet (768px - 1199px)
-  - Mobile (<768px)
-
-### Passo 6: Atualizar State
-
-```bash
-npx morph-spec state set {feature-name} phase uiux-design
-npx morph-spec state mark-output {feature-name} ui-design-system
-npx morph-spec state mark-output {feature-name} ui-mockups
-npx morph-spec state mark-output {feature-name} ui-components
-npx morph-spec state mark-output {feature-name} ui-flows
-```
-
-## Outputs Gerados
-
-- `.morph/project/outputs/{feature}/ui-design-system.md`
-- `.morph/project/outputs/{feature}/ui-mockups.md`
-- `.morph/project/outputs/{feature}/ui-components.md`
-- `.morph/project/outputs/{feature}/ui-flows.md`
-- `.morph/project/outputs/{feature}/decisions.md` (atualizado com ADR UI library)
-
-## PAUSA OBRIGATÓRIA
-
-Apresente ao usuário 3 ações sugeridas:
-
-1. **Aprovar UI/UX e prosseguir para design técnico**
-2. **Ajustar wireframes/componentes de telas específicas**
-3. **Revisar biblioteca UI escolhida (Fluent UI / MudBlazor)**
-
-## Critérios de Avanço
-
-- [x] Input do usuário coletado (layout, referências)
-- [x] Biblioteca UI escolhida e justificada (ADR)
-- [x] 4 deliverables criados (design-system, mockups, components, flows)
-- [x] Acessibilidade WCAG 2.1 documentada
-- [x] Responsividade especificada
-- [x] State atualizado
-- [x] Usuário aprovou UI/UX
-
----
-
-Continuar automaticamente para FASE 2 (Design) após aprovação.

package/stacks/blazor-azure/.claude/skills/level-2-domains/README.md

@@ -1,14 +0,0 @@
-# Level 2: Domains
-
-Domain expertise skills organized by squad.
-
-**Purpose:** Skills that provide deep domain knowledge (backend, frontend, infra, quality, ai-agents, integrations).
-
-**Squads:**
-- backend/ - Backend Squad (led by dotnet-senior)
-- frontend/ - Frontend Squad (led by ui-designer)
-- infrastructure/ - Infrastructure Squad (led by azure-architect)
-- quality/ - Quality Squad (coordinated by standards-architect)
-- ai-agents/ - AI/Agent specialists
-- integrations/ - External integration specialists
-- architecture/ - Architecture and planning

package/stacks/blazor-azure/.claude/skills/level-2-domains/ai-agents/ai-system-architect.md

@@ -1,192 +0,0 @@
-# AI System Architect
-
-Expert in agentic system architecture, multi-agent orchestration, and RAG pipelines.
-
-> **Layer:** 2 | **Load:** on-keyword | **Keywords:** orchestration, multi-agent, rag, vector search, embedding, agentic, memory, reasoning
-
-> **Ref:** `agent-framework-workflows.md` — Workflow patterns with AgentWorkflowBuilder
-> **Ref:** `agent-framework-production.md` — Middleware, A2A, MCP, caching
-> **Ref:** `vector-search-rag.md` — Vector Search + RAG with EF Core 10
-
-## Responsibilities
-
-1. Design scalable agentic architectures
-2. Define orchestration patterns (workflows, inter-agent communication)
-3. Implement RAG pipelines (chunking, embedding, retrieval)
-4. Select patterns from 20 agentic design patterns
-
----
-
-## 20 Agentic Design Patterns
-
-| # | Pattern | Use Case | When to Use | Key Trade-off |
-|---|---------|----------|-------------|---------------|
-| 1 | **Prompt Chaining** | Multi-step processing | Data transformation, pipelines | Modular vs context explosion |
-| 2 | **Routing** | Direct to specialist | Multiple domains | Specialization vs misrouting |
-| 3 | **Parallelization** | Independent chunks | Large-scale processing | Speed vs coordination complexity |
-| 4 | **Reflection** | Draft → critique → refine | Quality control, creative tasks | Quality vs cost (limit 3 iterations) |
-| 5 | **Tool Use** | External tool calls | Multi-step workflows | Quality vs misfire propagation |
-| 6 | **Planning** | Step-by-step before execute | Goal-oriented workflows | Strategic vs setup complexity |
-| 7 | **Multi-Agent Collaboration** | Specialized agents + manager | Iterative refinement, dev | Specialization vs extensive testing |
-| 8 | **Memory Management** | Short/episodic/long-term | Continuity, personalization | Context preservation vs privacy risk |
-| 9 | **Learning & Adaptation** | Feedback → update prompts | Continuous improvement | Improvement vs learning wrong things |
-| 10 | **Goal Setting & Monitoring** | SMART goals + metrics | Complex projects, autonomous ops | Efficiency vs goal conflicts |
-| 11 | **Exception Handling** | Retry + exponential backoff | Production systems | Visibility vs infra complexity |
-| 12 | **Human-in-the-Loop** | Human review for high-risk | Compliance, edge cases | Trust vs latency |
-| 13 | **Knowledge Retrieval (RAG)** | Chunk + embed + search | Private/proprietary data | Accuracy vs infra to maintain |
-| 14 | **Inter-Agent Communication** | Structured messaging (A2A) | Enterprise, distributed | Fault isolation vs extreme complexity |
-| 15 | **Resource-Aware Optimization** | Route by complexity/cost | Cost-sensitive, high volume | Cost reduction vs tuning effort |
-| 16 | **Reasoning Techniques** | CoT, ToT, Self-Consistency | Complex problems, math | Robust vs token-heavy (rarely needed) |
-| 17 | **Evaluation & Monitoring** | Quality gates, drift detection | Production, enterprise | Reliability vs alert fatigue |
-| 18 | **Guardrails & Safety** | PII, injection, malicious check | Public-facing systems | Risk mitigation vs false positives |
-| 19 | **Prioritization** | Score by value/risk/effort | Dynamic environments, task mgmt | Adaptability vs context switching |
-| 20 | **Exploration & Discovery** | Broad knowledge exploration | Research, competitive analysis | Innovation vs resource-heavy |
-
-### Common Pattern Combinations
-
-| Combination | Use Case |
-|------------|----------|
-| Prompt Chaining + Reflection | Content generation with quality control |
-| Routing + Tool Use | Customer service with integrations |
-| Planning + Multi-Agent | Complex development projects |
-| Memory + Learning | Personalized assistants that evolve |
-| Parallelization + Exception Handling | Data processing at scale |
-| Human-in-Loop + Guardrails | Critical systems with compliance |
-
----
-
-## Microsoft Agent Framework Orchestration
-
-### Workflow Patterns
-
-```csharp
-// Sequential — pipeline processing
-Workflow sequential = AgentWorkflowBuilder.BuildSequential(researcher, analyst, writer);
-AIAgent seqAgent = await sequential.AsAgentAsync();
-
-// GroupChat — iterative refinement with manager
-Workflow groupChat = AgentWorkflowBuilder
-    .CreateGroupChatBuilderWith(agents =>
-        new AgentWorkflowBuilder.RoundRobinGroupChatManager(agents)
-        { MaximumIterationCount = 3 })
-    .AddParticipants(writer, editor, reviewer)
-    .Build();
-
-// Handoff — dynamic routing
-var handoff = AgentWorkflowBuilder.StartHandoffWith(triageAgent)
-    .WithHandoffs(triageAgent, [specialistA, specialistB])
-    .WithHandoff(specialistA, triageAgent)
-    .WithHandoff(specialistB, triageAgent)
-    .Build();
-```
-
-### A2A Protocol
-
-```csharp
-app.MapA2A(agent, "/a2a/agent-name", agentCard: new()
-{
-    Name = "Agent Name",
-    Description = "What this agent does.",
-    Version = "1.0"
-});
-// Discovery: GET /a2a/agent-name/v1/card
-// Message:   POST /a2a/agent-name/v1/message:stream
-```
-
-### Small Specialized Agents > Monolithic Agent
-
-Design principle: each agent has one clear responsibility, composed via workflows.
-
----
-
-## RAG Pipeline with Microsoft Stack
-
-### Architecture
-
-```
-Extraction → Staging (Blob) → Chunking → Embedding → Indexing (AI Search) → Retrieval
-```
-
-### Chunking Strategies
-
-| Strategy | Method | Best For |
-|----------|--------|----------|
-| Paragraph Splitter | By paragraphs | General text |
-| Markdown Header Splitter | By headers (#, ##) | Documentation |
-| Token-based Splitter | By token count | Fixed-size chunks |
-| Semantic Splitter | By semantic similarity | Highest quality |
-
-**Principle:** Test ALL strategies and rank by metrics (avg similarity score, token count, relevance).
-
-### Agent Framework Integration
-
-```csharp
-[Description("Searches knowledge base")]
-public async Task<SearchResult[]> SearchKnowledgeAsync(
-    [Description("Search query")] string query, CancellationToken ct = default)
-{
-    var embedding = await _embeddings.GenerateAsync(query, ct);
-    var results = await _searchClient.SearchAsync<KnowledgeChunk>(query,
-        new SearchOptions { VectorSearch = new() {
-            Queries = { new VectorizedQuery(embedding) { KNearestNeighborsCount = 5 } }
-        }}, ct);
-    return results.Value.GetResults().ToArray();
-}
-```
-
-### Why Staging in Blob Storage?
-
-Immutability, versioning, low cost, fallback on processing bugs, audit trail.
-
-### Key Insight
-
-**LLM comes LAST.** 80% of RAG work happens before the model is called (extraction, chunking, embedding, evaluation).
-
----
-
-## When NOT to Use Agent Framework
-
-| Scenario | Use Instead |
-|----------|------------|
-| Single LLM call resolves | `IChatClient` directly |
-| No tools needed | `ChatClient.GetResponseAsync()` |
-| Model < 3B params | Tool calling unreliable |
-| Just summarization/translation | No agent needed |
-
----
-
-## Checklist
-
-### System Design
-- [ ] Patterns selected and justified
-- [ ] Orchestration pattern chosen (Sequential/Concurrent/GroupChat/Handoff/Magentic)
-- [ ] Specialized agents mapped with clear responsibilities
-
-### RAG Pipeline (if applicable)
-- [ ] Data source identified and accessible
-- [ ] Staging in Blob Storage configured
-- [ ] Multiple chunking strategies tested and ranked
-- [ ] Azure AI Search index configured (vector + hybrid)
-
-### Orchestration
-- [ ] Workflow built with `AgentWorkflowBuilder`
-- [ ] Error handling via middleware
-- [ ] OpenTelemetry monitoring enabled
-
-### Security & Cost
-- [ ] Guardrails implemented (PII, injection, malicious content)
-- [ ] Resource-Aware Optimization (model selection by complexity)
-- [ ] Token usage monitored and costs documented
-
----
-
-## References
-
-- [Microsoft Agent Framework](https://learn.microsoft.com/agent-framework/)
-- [Azure AI Search](https://learn.microsoft.com/azure/search/)
-- [GitHub: microsoft/agent-framework](https://github.com/microsoft/agent-framework)
-- `.wiki/ai/20-agentic-design-patterns.md` — Full 20 patterns reference
-
----
-
-*MORPH-SPEC by Polymorphism Tech*

package/stacks/blazor-azure/.claude/skills/level-2-domains/architecture/po-pm-advisor.md

@@ -1,197 +0,0 @@
-# PO/PM Advisor
-
-Especialista em requisitos, priorização e gestão de produto para clarificar features e ROI.
-
-## Responsabilidades
-
-1. **Clarificar requisitos** ambíguos ou incompletos
-2. **Priorizar features** por valor de negócio
-3. **Calcular ROI** e esforço estimado
-4. **Definir critérios** de aceitação
-
-## Triggers
-
-Keywords: `unclear`, `requirements`, `priority`, `ROI`, `mvp`, `scope`, `acceptance criteria`, `user story`
-
-## Framework de Clarificação
-
-### Perguntas Essenciais
-
-Quando receber uma feature request ambígua, faça estas perguntas:
-
-1. **Quem?** - Qual o usuário/persona principal?
-2. **O quê?** - O que exatamente deve acontecer?
-3. **Por quê?** - Qual problema resolve? Qual o valor?
-4. **Quando?** - Urgência? Deadline externo?
-5. **Como medir?** - Como saberemos que funcionou?
-
-### Template de User Story
-
-```markdown
-## User Story: {Nome da Feature}
-
-**Como** {persona/usuário},
-**Eu quero** {ação/funcionalidade},
-**Para que** {benefício/valor}.
-
-### Critérios de Aceitação
-
-**Dado** {contexto inicial},
-**Quando** {ação do usuário},
-**Então** {resultado esperado}.
-
-### Fora do Escopo
-
-- {Item explicitamente excluído}
-
-### Perguntas Pendentes
-
-- [ ] {Dúvida não resolvida}
-```
-
-## Matriz de Priorização (RICE)
-
-| Fator | Descrição | Escala |
-|-------|-----------|--------|
-| **R**each | Quantos usuários impacta | 1-10 |
-| **I**mpact | Quanto impacta cada usuário | 0.25, 0.5, 1, 2, 3 |
-| **C**onfidence | Confiança nas estimativas | 0-100% |
-| **E**ffort | Pessoa-semanas de trabalho | 1+ |
-
-```
-RICE Score = (Reach × Impact × Confidence) / Effort
-```
-
-### Exemplo
-
-| Feature | Reach | Impact | Confidence | Effort | Score |
-|---------|-------|--------|------------|--------|-------|
-| Login social | 8 | 1 | 80% | 1 | 6.4 |
-| Dashboard | 5 | 2 | 90% | 3 | 3.0 |
-| Export PDF | 3 | 0.5 | 100% | 0.5 | 3.0 |
-| Dark mode | 4 | 0.25 | 100% | 1 | 1.0 |
-
-## MVP vs Nice-to-Have
-
-### Critérios para MVP
-
-1. **Resolve o problema core** do usuário
-2. **Diferencia** da concorrência
-3. **Validável** em 2-4 semanas
-4. **Mensurável** (métricas definidas)
-
-### Framework MoSCoW
-
-| Categoria | Significado | Exemplo |
-|-----------|-------------|---------|
-| **M**ust have | Essencial, sem isso não funciona | Login, CRUD básico |
-| **S**hould have | Importante, mas não crítico | Filtros avançados |
-| **C**ould have | Desejável se houver tempo | Exportar relatório |
-| **W**on't have | Fora deste release | Integração X |
-
-## Estimativa de Esforço
-
-### T-Shirt Sizing
-
-| Size | Dias | Complexidade |
-|------|------|--------------|
-| XS | 0.5 | Task trivial |
-| S | 1-2 | Feature simples |
-| M | 3-5 | Feature com complexidade |
-| L | 5-10 | Feature complexa |
-| XL | 10+ | Épico, precisa quebrar |
-
-### Fatores de Risco
-
-Multiplicar estimativa por:
-
-| Fator | Multiplicador |
-|-------|---------------|
-| Tecnologia nova | 1.5x |
-| Integração externa | 1.3x |
-| Requisitos vagos | 1.5x |
-| Primeiro da equipe | 1.3x |
-
-## Template de ADR (Architecture Decision Record)
-
-```markdown
-# ADR-{XXX}: {Título da Decisão}
-
-## Status
-{PROPOSED | ACCEPTED | DEPRECATED | SUPERSEDED}
-
-## Contexto
-{Situação que requer decisão}
-
-## Opções Consideradas
-
-### Opção 1: {Nome}
-- Prós: ...
-- Contras: ...
-- Custo: ...
-
-### Opção 2: {Nome}
-- Prós: ...
-- Contras: ...
-- Custo: ...
-
-## Decisão
-{Opção escolhida e por quê}
-
-## Consequências
-- {Implicação positiva}
-- {Implicação negativa}
-- {Trade-off aceito}
-```
-
-## Cálculo de ROI
-
-```markdown
-## ROI Estimado: {Feature}
-
-### Benefícios (anual)
-- Aumento de conversão: R$ X
-- Redução de suporte: R$ Y
-- Economia de tempo: R$ Z
-- **Total Benefícios**: R$ (X+Y+Z)
-
-### Custos
-- Desenvolvimento: R$ A (horas × rate)
-- Infraestrutura: R$ B/mês × 12
-- Manutenção: R$ C/ano
-- **Total Custos**: R$ (A+B+C)
-
-### ROI
-**ROI = (Benefícios - Custos) / Custos × 100**
-
-ROI = (X+Y+Z - A+B+C) / (A+B+C) × 100 = **{N}%**
-
-### Payback
-**Meses = Custo Inicial / (Benefício Mensal - Custo Mensal)**
-```
-
-## Red Flags em Requisitos
-
-Alertar quando detectar:
-
-- "Deve ser igual ao [concorrente X]" sem especificar
-- "Simples" ou "rápido" sem estimativa
-- "Usuários querem..." sem evidência
-- Escopo crescente sem priorização
-- Deadline impossível sem trade-offs
-
-## Checklist de Requisitos
-
-- [ ] Persona/usuário definido
-- [ ] Problema claramente articulado
-- [ ] Valor de negócio quantificado
-- [ ] Critérios de aceitação escritos
-- [ ] Fora do escopo explícito
-- [ ] Dependências mapeadas
-- [ ] Riscos identificados
-- [ ] Estimativa de esforço
-- [ ] Prioridade definida (RICE/MoSCoW)
-
----
-
-*MORPH-SPEC by Polymorphism Tech*