aiox-core 5.0.3 → 5.0.5

package/pro/squads/squad-creator-pro/workflows/wf-squad-fusion.yaml

@@ -1,1684 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════════════
-# WORKFLOW: SQUAD FUSION v2.0 (Dragon Ball Style)
-# ═══════════════════════════════════════════════════════════════════════════════
-# Fusão de múltiplos squads similares em um único squad otimizado
-# Baseado em padrões de: Git Merge, Database Migration, ETL, M&A, Microservices
-#
-# PRINCÍPIOS FUNDAMENTAIS:
-# 1. IDEMPOTENCY: Rodar 2x = mesmo resultado (sem duplicatas)
-# 2. PROVENANCE: Todo componente rastreável à origem
-# 3. ROLLBACK: Cada fase reversível
-# 4. QUALITY GATES: Validação entre cada fase
-# 5. INCREMENTAL: Nunca Big Bang
-#
-# MODOS:
-# - YOLO: Execução automática com decisões padrão (60-75% qualidade)
-# - QUALITY: Checkpoints humanos em cada fase (85-95% qualidade)
-# ═══════════════════════════════════════════════════════════════════════════════
-
-workflow:
-  id: wf-squad-fusion
-  name: "Squad Fusion Workflow"
-  version: "2.2.0"
-  author: "Squad Architect"
-  icon: "🐉"
-
-  # ═══════════════════════════════════════════════════════════════════════════════
-  # EXECUTOR DISTRIBUTION (após análise com *optimize)
-  # ═══════════════════════════════════════════════════════════════════════════════
-  executor_summary:
-    total_steps: 56
-    distribution:
-      Worker: { count: 44, percent: 79, description: "Determinístico, bash/template" }
-      Agent: { count: 5, percent: 9, description: "Requer LLM para decisão semântica" }
-      Hybrid: { count: 6, percent: 11, description: "Worker + Agent validation" }
-      Human: { count: 1, percent: 1, description: "Aprovação para ações irreversíveis" }
-
-    agent_decision_points:
-      - id: semantic_match_detection
-        reason: "Comparar função real de agents com nomes diferentes"
-      - id: quality_comparison
-        reason: "Avaliar qualidade além de métricas quantitativas"
-      - id: create_golden_records
-        reason: "Decidir versão canônica entre variantes"
-      - id: define_tiers
-        reason: "Organizar agents por função/propósito"
-      - id: define_routing_rules
-        reason: "Mapear especialidades para cenários de uso"
-      - id: create_orchestrator_if_needed
-        reason: "Criar orchestrator com conhecimento dos agents"
-
-  patterns_applied:
-    - "Three-Way Merge (Git)"
-    - "Expand-Contract (Database)"
-    - "ETL Quality Gates"
-    - "Strangler Fig (Microservices)"
-    - "Due Diligence (M&A)"
-    - "Entity Resolution (Deduplication)"
-    - "CDC Event Logging"
-
-  description: |
-    Workflow para fusão de múltiplos squads em um único squad consolidado.
-    Segue o princípio "Dragon Ball Fusion" - combina o melhor de cada fonte.
-
-    GARANTIAS:
-    - Zero perda de componentes (auditado)
-    - Zero duplicatas não-intencionais
-    - 100% rastreabilidade (provenance)
-    - Rollback possível até Phase 6
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# CONFIGURATION
-# ═══════════════════════════════════════════════════════════════════════════════
-config:
-  modes:
-    yolo:
-      description: "Execução automática, decisões padrão"
-      human_checkpoints: false
-      default_decisions:
-        duplicate_resolution: "keep_highest_quality"
-        scope_filtering: "strict"
-        naming: "auto"
-        cleanup_sources: false  # YOLO nunca deleta fontes
-
-    quality:
-      description: "Checkpoints humanos, decisões validadas"
-      human_checkpoints: true
-      requires_approval:
-        - phase_1_discovery
-        - phase_2_deduplication
-        - phase_3_scope
-        - phase_5_validation
-
-  # Diretórios padrão
-  paths:
-    workspace: "/tmp/fusion-{target_name}-{timestamp}"
-    backup: "backups/squads/pre-fusion-{timestamp}"
-    audit_log: "{workspace}/fusion-audit.yaml"
-
-  # Limiares de qualidade
-  quality_thresholds:
-    min_agent_lines: 300
-    min_task_lines: 100
-    similarity_threshold: 0.85  # Para fuzzy matching
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# UNIVERSAL ANTI-PATTERNS (NUNCA FAZER)
-# ═══════════════════════════════════════════════════════════════════════════════
-anti_patterns:
-  critical:
-    - id: AP_001
-      name: "Big Bang Migration"
-      description: "Tentar fundir tudo de uma vez"
-      risk: "Falha total, impossível debugar"
-      mitigation: "Fases incrementais com validação"
-
-    - id: AP_002
-      name: "Silent Data Loss"
-      description: "Componentes desaparecem sem log"
-      risk: "Funcionalidade perdida descoberta tarde"
-      mitigation: "Audit log de cada operação"
-
-    - id: AP_003
-      name: "Force Override"
-      description: "Resolver conflitos sem análise"
-      risk: "Perda de contexto e funcionalidade"
-      mitigation: "Documentar rationale de cada decisão"
-
-    - id: AP_004
-      name: "No Rollback Plan"
-      description: "Sem backup ou checkpoint"
-      risk: "Preso com erros"
-      mitigation: "Snapshot antes de cada fase destrutiva"
-
-    - id: AP_005
-      name: "Assumption Over Count"
-      description: "Assumir contagens ao invés de executar comandos"
-      risk: "Inventário errado → fusão errada"
-      mitigation: "SEMPRE executar comandos de contagem"
-
-    - id: AP_006
-      name: "Orphaned References"
-      description: "Links quebrados após fusão"
-      risk: "Erros em runtime"
-      mitigation: "Validar todas referências pós-merge"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 0: INITIALIZATION
-# ═══════════════════════════════════════════════════════════════════════════════
-phases:
-  - id: phase_0_init
-    name: "Initialization"
-    description: "Setup workspace e validação inicial"
-    pattern: "Pre-flight checks"
-    rollback: "Trivial - nada modificado ainda"
-
-    inputs:
-      required:
-        - name: source_squads
-          type: "list[string]"
-          description: "Lista de squads a serem fusionados"
-          validation: "Cada squad deve existir em squads/"
-          example: '["media-buy", "media-squad", "meta-ads"]'
-
-        - name: target_name
-          type: "string"
-          description: "Nome do squad resultante (snake_case)"
-          validation: "^[a-z0-9]+(-[a-z0-9]+)*$"
-          example: "traffic-masters"
-
-        - name: target_domain
-          type: "string"
-          description: "Domínio principal"
-          example: "paid_traffic"
-
-      optional:
-        - name: mode
-          type: "enum[yolo, quality]"
-          default: "quality"
-
-        - name: exclude_patterns
-          type: "list[string]"
-          description: "Patterns de agents a excluir"
-          example: '["brand-*", "pr-*", "*-organic"]'
-
-    steps:
-      - id: validate_inputs
-        action: "Validar todos os inputs"
-        checks:
-          - "target_name não existe em squads/"
-          - "source_squads tem pelo menos 2 itens"
-          - "Nenhum squad fonte é igual ao target"
-
-      - id: validate_sources
-        action: "Verificar existência de cada squad fonte"
-        command_template: |
-          for squad in {source_squads}:
-            if not exists("squads/{squad}"):
-              ABORT("Squad não existe: {squad}")
-            if not exists("squads/{squad}/agents") and not exists("squads/{squad}/skills"):
-              WARN("Squad sem agents nem skills: {squad}")
-
-      - id: create_workspace
-        action: "Criar workspace isolado"
-        commands:
-          - "mkdir -p {workspace}/agents"
-          - "mkdir -p {workspace}/tasks"
-          - "mkdir -p {workspace}/skills"
-          - "mkdir -p {workspace}/data"
-          - "mkdir -p {workspace}/templates"
-          - "mkdir -p {workspace}/checklists"
-          - "mkdir -p {workspace}/workflows"
-          - "mkdir -p {workspace}/_audit"
-          - "mkdir -p {workspace}/_conflicts"
-
-      - id: init_audit_log
-        action: "Inicializar log de auditoria"
-        creates: "{workspace}/fusion-audit.yaml"
-        template: |
-          # Fusion Audit Log
-          # Gerado automaticamente - NÃO EDITAR MANUALMENTE
-
-          fusion:
-            id: "{fusion_id}"
-            started_at: "{timestamp}"
-            mode: "{mode}"
-            target: "{target_name}"
-            sources: {source_squads}
-
-          events: []
-
-      - id: create_backup
-        action: "Backup dos squads fonte (pattern: snapshot before)"
-        command_template: |
-          mkdir -p {backup_path}
-          for squad in {source_squads}:
-            tar -czf {backup_path}/{squad}.tar.gz squads/{squad}
-        rationale: "Permite rollback completo até o final"
-
-    output:
-      workspace_path: "string"
-      backup_path: "string"
-      fusion_id: "string"
-      audit_log_path: "string"
-
-    quality_gate:
-      name: "Init Gate"
-      checks:
-        - "Workspace criado com todas subpastas"
-        - "Backup de todos squads fonte existe"
-        - "Audit log inicializado"
-      veto_on: "Qualquer check falhar"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 1: DISCOVERY (Due Diligence - M&A Pattern)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_1_discovery
-    name: "Discovery (Due Diligence)"
-    description: "Inventário COMPLETO de todos os assets"
-    pattern: "M&A Due Diligence + Schema Discovery"
-    rollback: "Trivial - apenas leitura"
-
-    critical_rule: |
-      🚨 REGRA ABSOLUTA: EXECUTAR COMANDOS, NUNCA ASSUMIR
-
-      A IA DEVE executar CADA comando listado abaixo.
-      NÃO é permitido:
-      - Estimar baseado em um squad
-      - Pular squads "similares"
-      - Arredondar números
-      - Usar contagens de sessões anteriores
-
-      CADA número deve vir de um comando executado NESTA sessão.
-
-    steps:
-      - id: inventory_agents
-        action: "Contar e listar agents de CADA squad"
-        executor: Worker
-        command_per_squad: |
-          echo "=== {squad} AGENTS ===" && \
-          find squads/{squad}/agents -name '*.md' 2>/dev/null | wc -l && \
-          find squads/{squad}/agents -name '*.md' -exec basename {} .md \; 2>/dev/null | sort
-        store_as: "inventory.{squad}.agents"
-
-      - id: inventory_tasks
-        action: "Contar tasks (MÚLTIPLOS LOCAIS)"
-        executor: Worker
-        rationale: "Tasks podem estar em /tasks, /skills/tasks, ou outros locais"
-        command_per_squad: |
-          echo "=== {squad} TASKS ===" && \
-          find squads/{squad} -path '*/tasks/*.md' -type f 2>/dev/null | wc -l && \
-          find squads/{squad} -path '*/tasks/*.md' -type f -exec basename {} .md \; 2>/dev/null | sort
-        store_as: "inventory.{squad}.tasks"
-
-      - id: inventory_skills
-        action: "Contar skills (estrutura especial)"
-        executor: Worker
-        rationale: "Skills usam SKILL.md dentro de subpastas"
-        command_per_squad: |
-          echo "=== {squad} SKILLS ===" && \
-          find squads/{squad} -name 'SKILL.md' -type f 2>/dev/null | wc -l && \
-          find squads/{squad} -name 'SKILL.md' -type f 2>/dev/null | xargs -I {} dirname {} | xargs -I {} basename {}
-        store_as: "inventory.{squad}.skills"
-
-      - id: inventory_data
-        action: "Contar data/knowledge files"
-        executor: Worker
-        command_per_squad: |
-          echo "=== {squad} DATA ===" && \
-          count_data=$(find squads/{squad}/data -name '*.md' -type f 2>/dev/null | wc -l) && \
-          count_knowledge=$(find squads/{squad}/knowledge -name '*.md' -type f 2>/dev/null | wc -l) && \
-          echo "Data: $count_data, Knowledge: $count_knowledge, Total: $((count_data + count_knowledge))"
-        store_as: "inventory.{squad}.data"
-
-      - id: inventory_other
-        action: "Contar templates, checklists, workflows"
-        executor: Worker
-        command_per_squad: |
-          echo "=== {squad} OTHER ===" && \
-          echo "Templates: $(find squads/{squad} -path '*/templates/*.md' -type f 2>/dev/null | wc -l)" && \
-          echo "Checklists: $(find squads/{squad} -path '*/checklists/*.md' -type f 2>/dev/null | wc -l)" && \
-          echo "Workflows: $(find squads/{squad} -path '*/workflows/*.yaml' -o -path '*/workflows/*.md' -type f 2>/dev/null | wc -l)"
-        store_as: "inventory.{squad}.other"
-
-      - id: inventory_quality
-        action: "Medir qualidade dos agents (linhas de código)"
-        executor: Worker
-        rationale: "Linhas = proxy para completude"
-        command_per_squad: |
-          echo "=== {squad} QUALITY ===" && \
-          wc -l squads/{squad}/agents/*.md 2>/dev/null | sort -n
-        store_as: "inventory.{squad}.quality"
-
-      - id: build_inventory_table
-        action: "Construir tabela consolidada"
-        executor: Worker
-        template: |
-          ## 📊 INVENTÁRIO COMPLETO (Discovery)
-
-          | Squad | Agents | Tasks | Skills | Data | Templates | Checklists | Workflows |
-          |-------|--------|-------|--------|------|-----------|------------|-----------|
-          {{#each squads}}
-          | {{name}} | {{agents}} | {{tasks}} | {{skills}} | {{data}} | {{templates}} | {{checklists}} | {{workflows}} |
-          {{/each}}
-          | **TOTAL** | **{{sum.agents}}** | **{{sum.tasks}}** | **{{sum.skills}}** | **{{sum.data}}** | **{{sum.templates}}** | **{{sum.checklists}}** | **{{sum.workflows}}** |
-
-          ### Validação de Soma
-          - Soma calculada: {{sum.agents}} agents
-          - Soma por comando: `{{sum_command_result}}`
-          - Match: {{match_status}}
-
-      - id: cross_reference_map
-        action: "Mapear referências cruzadas entre componentes"
-        executor: Worker
-        rationale: "Pattern: Foreign Key Reconciliation"
-        command: |
-          # Encontrar referências a outros agents/tasks nos arquivos
-          for squad in {source_squads}:
-            grep -r "handoff_to\|depends_on\|uses\|calls" squads/{squad} --include="*.md" --include="*.yaml"
-        store_as: "cross_references"
-
-      - id: log_discovery
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "discovery_complete"
-          data: "inventory"
-          timestamp: "{now}"
-
-    checkpoint:
-      type: "human_review"
-      condition: "mode == 'quality'"
-      prompt: |
-        ## Discovery Complete
-
-        {{inventory_table}}
-
-        ### Validação
-        - [ ] Todas as contagens estão corretas?
-        - [ ] Algum squad parece incompleto?
-        - [ ] Cross-references mapeadas?
-
-        Aprovar para continuar?
-      options:
-        - "Aprovar"
-        - "Refazer contagem de squad específico"
-        - "Abortar fusão"
-
-    quality_gate:
-      name: "Discovery Gate"
-      checks:
-        - "Todos squads têm pelo menos 1 agent OU 1 skill"
-        - "Soma manual = soma automática"
-        - "Nenhum squad com 0 assets"
-      veto_on: "Discrepância de contagem > 0"
-
-    output:
-      inventory: "InventoryTable"
-      total_assets: "AssetCounts"
-      cross_references: "list[Reference]"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 2: DEDUPLICATION (Entity Resolution Pattern)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_2_deduplication
-    name: "Deduplication (Entity Resolution)"
-    description: "Identificar e resolver duplicatas"
-    pattern: "Entity Resolution + Fuzzy Matching + Golden Record"
-    rollback: "Trivial - apenas análise"
-
-    steps:
-      - id: exact_match_detection
-        action: "Detectar duplicatas por nome exato"
-        executor: Worker
-        algorithm: |
-          1. Criar set de todos os nomes de agents/tasks
-          2. Identificar nomes que aparecem em múltiplos squads
-          3. Para cada duplicata:
-             a. Comparar conteúdo (hash)
-             b. Se hash igual → duplicata exata
-             c. Se hash diferente → variantes
-        command: |
-          # Listar todos agents de todos squads
-          for squad in {source_squads}:
-            find squads/{squad}/agents -name '*.md' -exec basename {} .md \;
-          # Encontrar duplicados
-          | sort | uniq -d
-
-      - id: semantic_match_detection
-        action: "Detectar duplicatas semânticas (mesma função, nomes diferentes)"
-        executor: Agent
-        rationale: |
-          Pattern: Fuzzy Matching
-          Mapa estático de sinônimos é INSUFICIENTE.
-          LLM precisa ler descrições e comparar função real.
-        semantic_groups:
-          - group: "analyst"
-            patterns: ["ads-analyst", "performance-analyst", "analyst", "metrics-analyst"]
-          - group: "scaler"
-            patterns: ["scale-optimizer", "scaling-specialist", "scaler", "growth-optimizer"]
-          - group: "auditor"
-            patterns: ["fiscal", "compliance-auditor", "auditor", "validator"]
-          - group: "creative"
-            patterns: ["creative-analyst", "creative-strategist", "creative-director", "creative-generator"]
-          - group: "traffic"
-            patterns: ["traffic-manager", "traffic-head", "media-buyer", "ads-manager"]
-
-      - id: quality_comparison
-        action: "Comparar qualidade das variantes"
-        executor: Agent
-        rationale: |
-          Linhas != Qualidade. LLM precisa ler AMBOS os agents e avaliar:
-          - Profundidade do voice_dna
-          - Qualidade dos output_examples
-          - Frameworks documentados
-          - Anti-patterns definidos
-        metrics:
-          - name: "lines"
-            description: "Linhas de código (mais = mais completo)"
-            weight: 0.4
-          - name: "voice_dna"
-            description: "Presença de voice_dna section"
-            weight: 0.2
-          - name: "output_examples"
-            description: "Número de output_examples"
-            weight: 0.2
-          - name: "frameworks"
-            description: "Frameworks documentados"
-            weight: 0.1
-          - name: "recency"
-            description: "Data de última modificação"
-            weight: 0.1
-        command_per_duplicate: |
-          # Para cada par de duplicatas
-          echo "=== Comparando {agent_a} vs {agent_b} ===" && \
-          echo "Linhas A: $(wc -l < squads/{squad_a}/agents/{agent_a}.md)" && \
-          echo "Linhas B: $(wc -l < squads/{squad_b}/agents/{agent_b}.md)" && \
-          echo "voice_dna A: $(grep -c 'voice_dna' squads/{squad_a}/agents/{agent_a}.md)" && \
-          echo "voice_dna B: $(grep -c 'voice_dna' squads/{squad_b}/agents/{agent_b}.md)"
-
-      - id: create_golden_records
-        action: "Criar registros dourados (versão canônica)"
-        executor: Hybrid
-        rationale: |
-          Pattern: Golden Record Creation
-          - YOLO mode: Agent decide baseado em heurísticas
-          - QUALITY mode: Agent recomenda, Human aprova
-        rules:
-          yolo_mode:
-            - "Escolher agent com mais linhas"
-            - "Em empate, escolher mais recente"
-          quality_mode:
-            - "Apresentar comparação ao humano"
-            - "Humano escolhe ou pede merge manual"
-
-      - id: build_dedup_table
-        action: "Construir tabela de deduplicação"
-        executor: Worker
-        template: |
-          ## 🔴 DUPLICATAS DETECTADAS
-
-          ### Duplicatas Exatas (mesmo nome)
-          | Agent | Squad A | Squad B | Linhas A | Linhas B | 🏆 Vencedor | Rationale |
-          |-------|---------|---------|----------|----------|-------------|-----------|
-          {{#each exact_duplicates}}
-          | {{name}} | {{squad_a}} | {{squad_b}} | {{lines_a}} | {{lines_b}} | **{{winner}}** | {{rationale}} |
-          {{/each}}
-
-          ### Duplicatas Semânticas (função similar)
-          | Função | Agent A (Squad) | Agent B (Squad) | Score A | Score B | 🏆 Vencedor |
-          |--------|-----------------|-----------------|---------|---------|-------------|
-          {{#each semantic_duplicates}}
-          | {{function}} | {{agent_a}} ({{squad_a}}) | {{agent_b}} ({{squad_b}}) | {{score_a}} | {{score_b}} | **{{winner}}** |
-          {{/each}}
-
-          ### Decisões de Merge
-          Total duplicatas: {{total_duplicates}}
-          - Resolvidas automaticamente: {{auto_resolved}}
-          - Requerem revisão humana: {{needs_review}}
-
-      - id: log_deduplication
-        action: "Registrar decisões no audit log"
-        executor: Worker
-        audit_event:
-          type: "deduplication_complete"
-          decisions: "dedup_decisions"
-          timestamp: "{now}"
-
-    checkpoint:
-      type: "human_review"
-      condition: "mode == 'quality'"
-      prompt: |
-        ## Deduplication Results
-
-        {{dedup_table}}
-
-        ### Revisão Necessária
-        {{#each needs_review}}
-        - {{agent_a}} vs {{agent_b}}: Qual manter?
-        {{/each}}
-
-        Aprovar resoluções?
-      options:
-        - "Aprovar todas"
-        - "Revisar caso a caso"
-        - "Abortar fusão"
-
-    quality_gate:
-      name: "Deduplication Gate"
-      checks:
-        - "Todas duplicatas têm decisão"
-        - "Nenhum conflito não-resolvido"
-        - "Winners existem no disco"
-      veto_on: "Duplicata sem resolução"
-
-    output:
-      duplicates_found: "number"
-      duplicates_resolved: "list[DedupDecision]"
-      agents_to_keep: "list[{agent, source_squad}]"
-      agents_to_exclude: "list[{agent, reason}]"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 3: SCOPE FILTERING
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_3_scope
-    name: "Scope Filtering"
-    description: "Filtrar componentes fora do domínio target"
-    pattern: "Domain-Driven Filtering"
-    rollback: "Trivial - apenas classificação"
-
-    steps:
-      - id: define_domain_keywords
-        action: "Definir keywords do domínio target"
-        executor: Worker
-        example:
-          domain: "paid_traffic"
-          include_keywords:
-            primary: ["ads", "traffic", "campaign", "pixel", "tracking", "attribution"]
-            secondary: ["creative", "copy", "scaling", "optimization", "roas", "cpa", "ctr"]
-            platforms: ["meta", "google", "youtube", "tiktok", "linkedin"]
-          exclude_keywords:
-            explicit: ["brand", "pr", "organic", "seo", "content-marketing"]
-            ambiguous: ["social", "web-design", "email"]  # Requer análise
-
-      - id: classify_agents
-        action: "Classificar cada agent como IN_SCOPE ou OUT_OF_SCOPE"
-        executor: Hybrid
-        rationale: |
-          - Score >= 2 ou < 0: Worker decide (determinístico)
-          - Score 0-2: Agent analisa conteúdo e decide
-        algorithm: |
-          Para cada agent não-excluído por deduplicação:
-            1. Extrair nome e primeiro parágrafo
-            2. Calcular score de relevância:
-               - +2 por cada primary keyword
-               - +1 por cada secondary keyword
-               - -2 por cada exclude keyword
-            3. Se score >= 2: IN_SCOPE
-               Se score < 0: OUT_OF_SCOPE
-               Se 0 <= score < 2: NEEDS_REVIEW
-        command_per_agent: |
-          echo "=== Classificando {agent} ===" && \
-          head -50 squads/{squad}/agents/{agent}.md | \
-          grep -iE "ads|traffic|campaign|pixel|scaling|roas|meta|google" | wc -l
-
-      - id: classify_tasks
-        action: "Classificar tasks pelo mesmo critério"
-        executor: Hybrid
-        note: "Tasks geralmente são mais específicas, menos ambiguidade"
-
-      - id: build_scope_table
-        action: "Construir tabela de classificação"
-        executor: Worker
-        template: |
-          ## 🎯 CLASSIFICAÇÃO DE ESCOPO
-
-          ### ✅ IN_SCOPE ({{in_scope_count}} componentes)
-          {{#each in_scope}}
-          - **{{name}}** ({{squad}}) - Score: {{score}} - {{keywords_matched}}
-          {{/each}}
-
-          ### ❌ OUT_OF_SCOPE ({{out_scope_count}} componentes)
-          {{#each out_of_scope}}
-          - ~~{{name}}~~ ({{squad}}) - Motivo: {{reason}}
-          {{/each}}
-
-          ### ⚠️ NEEDS_REVIEW ({{review_count}} componentes)
-          {{#each needs_review}}
-          - **{{name}}** ({{squad}}) - Score: {{score}} - Ambíguo: {{ambiguity_reason}}
-          {{/each}}
-
-      - id: log_scope
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "scope_filtering_complete"
-          in_scope: "in_scope_count"
-          out_of_scope: "out_scope_count"
-          timestamp: "{now}"
-
-    checkpoint:
-      type: "human_review"
-      condition: "mode == 'quality'"
-      prompt: |
-        ## Scope Classification
-
-        {{scope_table}}
-
-        ### Decisões pendentes
-        {{#each needs_review}}
-        - {{name}}: Incluir ou excluir?
-        {{/each}}
-
-        Opções:
-        1. Aprovar como está
-        2. Incluir todos ambíguos
-        3. Excluir todos ambíguos
-        4. Decidir caso a caso
-      options:
-        - "1"
-        - "2"
-        - "3"
-        - "4"
-
-    quality_gate:
-      name: "Scope Gate"
-      checks:
-        - "Pelo menos 5 agents IN_SCOPE"
-        - "Nenhum componente sem classificação"
-        - "Exclusões têm rationale"
-      veto_on: "Menos de 5 agents no escopo"
-
-    output:
-      final_components:
-        agents: "list[{name, source}]"
-        tasks: "list[{name, source}]"
-        skills: "list[{name, source}]"
-        data: "list[{name, source}]"
-      excluded_components: "list[{name, reason}]"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 4: COLLECTION (ETL Extract + Transform)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_4_collection
-    name: "Collection (ETL Extract)"
-    description: "Copiar componentes selecionados para workspace"
-    pattern: "ETL Extract + Idempotency + Exactly-Once"
-    rollback: "Deletar workspace e recomeçar"
-
-    critical_rule: |
-      🚨 IDEMPOTENCY: Rodar esta fase 2x deve dar o mesmo resultado
-
-      Cada cópia deve:
-      1. Verificar se já existe no destino
-      2. Se existe E é idêntico → skip
-      3. Se existe E é diferente → CONFLICT (mover para _conflicts/)
-      4. Se não existe → copiar
-
-    steps:
-      - id: collect_agents
-        action: "Copiar agents selecionados"
-        executor: Worker
-        command_per_agent: |
-          source="squads/{source_squad}/agents/{agent}.md"
-          dest="{workspace}/agents/{agent}.md"
-
-          if [ -f "$dest" ]; then
-            if diff -q "$source" "$dest" > /dev/null; then
-              echo "SKIP: {agent} já existe (idêntico)"
-            else
-              echo "CONFLICT: {agent} existe com conteúdo diferente"
-              mv "$dest" "{workspace}/_conflicts/{agent}-{source_squad}.md"
-              cp "$source" "$dest"
-            fi
-          else
-            cp "$source" "$dest"
-            echo "COPIED: {agent}"
-          fi
-        audit_each: true
-
-      - id: collect_tasks
-        action: "Copiar tasks (com dedup por nome)"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            find squads/{squad} -path '*/tasks/*.md' -type f | while read task; do
-              name=$(basename "$task")
-              dest="{workspace}/tasks/$name"
-              # Mesmo padrão de idempotency
-              ...
-            done
-
-      - id: collect_skills
-        action: "Copiar estrutura de skills preservando hierarquia"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            if [ -d "squads/{squad}/skills" ]; then
-              cp -rn squads/{squad}/skills/* {workspace}/skills/ 2>/dev/null || true
-            fi
-
-      - id: collect_data
-        action: "Copiar data e knowledge bases"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            find squads/{squad}/data squads/{squad}/knowledge -name '*.md' -type f 2>/dev/null | while read file; do
-              name=$(basename "$file")
-              cp -n "$file" "{workspace}/data/$name" 2>/dev/null || echo "SKIP: $name exists"
-            done
-
-      - id: collect_templates
-        action: "Copiar templates"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            find squads/{squad} -path '*/templates/*.md' -type f 2>/dev/null | while read file; do
-              name=$(basename "$file")
-              cp -n "$file" "{workspace}/templates/$name" 2>/dev/null || echo "SKIP: $name exists"
-            done
-
-      - id: collect_checklists
-        action: "Copiar checklists"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            find squads/{squad} -path '*/checklists/*.md' -type f 2>/dev/null | while read file; do
-              name=$(basename "$file")
-              cp -n "$file" "{workspace}/checklists/$name" 2>/dev/null || echo "SKIP: $name exists"
-            done
-
-      - id: collect_workflows
-        action: "Copiar workflows"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            find squads/{squad} -path '*/workflows/*.yaml' -o -path '*/workflows/*.md' -type f 2>/dev/null | while read file; do
-              name=$(basename "$file")
-              cp -n "$file" "{workspace}/workflows/$name" 2>/dev/null || echo "SKIP: $name exists"
-            done
-
-      - id: handle_conflicts
-        action: "Listar conflitos para resolução"
-        executor: Hybrid
-        rationale: |
-          - Listar: Worker (ls)
-          - Resolver: Agent decide ou Human aprova
-        command: |
-          ls {workspace}/_conflicts/ 2>/dev/null | wc -l
-        if_conflicts: "Apresentar ao humano para resolução"
-
-      - id: verify_collection
-        action: "Verificar contagens pós-coleta"
-        executor: Worker
-        command: |
-          echo "=== WORKSPACE CONTENTS ===" && \
-          echo "Agents: $(find {workspace}/agents -name '*.md' | wc -l)" && \
-          echo "Tasks: $(find {workspace}/tasks -name '*.md' | wc -l)" && \
-          echo "Skills: $(find {workspace}/skills -name 'SKILL.md' | wc -l)" && \
-          echo "Data: $(find {workspace}/data -name '*.md' | wc -l)" && \
-          echo "Templates: $(find {workspace}/templates -name '*.md' | wc -l)" && \
-          echo "Checklists: $(find {workspace}/checklists -name '*.md' | wc -l)" && \
-          echo "Workflows: $(find {workspace}/workflows -name '*.yaml' -o -name '*.md' | wc -l)" && \
-          echo "Conflicts: $(find {workspace}/_conflicts -name '*.md' | wc -l)"
-
-      - id: reconciliation
-        action: "Reconciliação: comparar esperado vs coletado"
-        executor: Worker
-        rationale: "Pattern: ETL Reconciliation"
-        check: |
-          expected_agents = len(final_components.agents)
-          collected_agents = count({workspace}/agents/*.md)
-          if expected_agents != collected_agents:
-            ALERT("Discrepância: esperado {expected}, coletado {collected}")
-
-      - id: log_collection
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "collection_complete"
-          collected: "workspace_contents"
-          conflicts: "conflict_count"
-          timestamp: "{now}"
-
-    quality_gate:
-      name: "Collection Gate"
-      checks:
-        - "Contagem coletada = contagem esperada (ou diferença explicada)"
-        - "Zero conflitos não-resolvidos"
-        - "Todos arquivos copiados são válidos (não vazios)"
-      veto_on: "Discrepância não explicada OU conflito não resolvido"
-
-    output:
-      workspace_contents:
-        agents: "number"
-        tasks: "number"
-        skills: "number"
-        data: "number"
-        templates: "number"
-        checklists: "number"
-        workflows: "number"
-      conflicts_resolved: "number"
-      provenance_map: "map[component -> source_squad]"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 5: VALIDATION (Quality Gates)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_5_validation
-    name: "Validation (Quality Gates)"
-    description: "Validar integridade antes de criar estrutura final"
-    pattern: "ETL Quality Gates + Data Validation"
-    rollback: "Voltar para Phase 4 e corrigir"
-
-    steps:
-      - id: structural_validation
-        action: "Validar estrutura de cada componente"
-        executor: Worker
-        checks:
-          agents:
-            - "Arquivo não vazio"
-            - "YAML frontmatter válido (se presente)"
-            - "Seções obrigatórias presentes"
-          tasks:
-            - "Arquivo não vazio"
-            - "Estrutura de task válida"
-          skills:
-            - "SKILL.md existe em cada pasta de skill"
-
-      - id: reference_validation
-        action: "Validar todas as referências"
-        executor: Worker
-        rationale: "Pattern: Foreign Key Validation"
-        checks:
-          - "handoff_to referencia agents existentes"
-          - "depends_on referencia tasks existentes"
-          - "uses referencia data existente"
-        command: |
-          # Extrair todas referências
-          grep -rh "handoff_to\|depends_on\|uses" {workspace} --include="*.md" | \
-          # Verificar se targets existem
-          while read ref; do
-            target=$(echo "$ref" | extract_target)
-            if ! exists("{workspace}/*/$target*"); then
-              echo "BROKEN REF: $ref"
-            fi
-          done
-
-      - id: quality_validation
-        action: "Validar qualidade mínima"
-        executor: Worker
-        checks:
-          - name: "Agent Lines"
-            rule: "Agents >= 300 linhas (exceto orchestrators)"
-            command: |
-              for agent in {workspace}/agents/*.md; do
-                lines=$(wc -l < "$agent")
-                if [ $lines -lt 300 ]; then
-                  echo "WARN: $(basename $agent) tem apenas $lines linhas"
-                fi
-              done
-
-          - name: "Task Lines"
-            rule: "Tasks >= 100 linhas"
-
-          - name: "Required Sections"
-            rule: "Agents têm voice_dna, output_examples, anti_patterns"
-            command: |
-              for agent in {workspace}/agents/*.md; do
-                if ! grep -q "voice_dna" "$agent"; then
-                  echo "MISSING voice_dna: $(basename $agent)"
-                fi
-                if ! grep -q "output_examples" "$agent"; then
-                  echo "MISSING output_examples: $(basename $agent)"
-                fi
-              done
-
-      - id: build_validation_report
-        action: "Construir relatório de validação"
-        executor: Worker
-        template: |
-          ## ✅ VALIDATION REPORT
-
-          ### Structural Validation
-          - Agents válidos: {{valid_agents}}/{{total_agents}}
-          - Tasks válidas: {{valid_tasks}}/{{total_tasks}}
-          - Skills válidas: {{valid_skills}}/{{total_skills}}
-
-          ### Reference Validation
-          - Referências válidas: {{valid_refs}}/{{total_refs}}
-          - Referências quebradas: {{broken_refs}}
-          {{#if broken_refs}}
-          #### Broken References
-          {{#each broken_ref_details}}
-          - {{source}} → {{target}} ({{type}})
-          {{/each}}
-          {{/if}}
-
-          ### Quality Validation
-          | Metric | Pass | Fail | Warn |
-          |--------|------|------|------|
-          | Agent Lines (>=300) | {{agent_lines.pass}} | {{agent_lines.fail}} | {{agent_lines.warn}} |
-          | Task Lines (>=100) | {{task_lines.pass}} | {{task_lines.fail}} | - |
-          | Required Sections | {{sections.pass}} | {{sections.fail}} | - |
-
-          ### Overall Status
-          {{#if all_pass}}
-          ✅ **PASS** - Pronto para criar estrutura final
-          {{else}}
-          ⚠️ **WARN** - {{warn_count}} avisos, {{fail_count}} falhas
-          {{/if}}
-
-      - id: log_validation
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "validation_complete"
-          status: "pass|warn|fail"
-          details: "validation_report"
-          timestamp: "{now}"
-
-    checkpoint:
-      type: "human_review"
-      condition: "mode == 'quality' OR validation_status != 'pass'"
-      prompt: |
-        ## Validation Results
-
-        {{validation_report}}
-
-        {{#if has_failures}}
-        ### ⚠️ Atenção: Existem falhas
-
-        Opções:
-        1. Ignorar falhas e continuar (não recomendado)
-        2. Corrigir falhas manualmente e re-validar
-        3. Abortar fusão
-        {{else}}
-        Aprovar e continuar para criação da estrutura final?
-        {{/if}}
-
-    quality_gate:
-      name: "Validation Gate"
-      checks:
-        - "Zero referências quebradas (HARD FAIL)"
-        - "Zero arquivos vazios (HARD FAIL)"
-        - "90% agents com >= 300 linhas (SOFT FAIL)"
-      veto_on: "Qualquer HARD FAIL"
-
-    output:
-      validation_status: "pass|warn|fail"
-      validation_report: "markdown"
-      issues_to_fix: "list[Issue]"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 6: STRUCTURE CREATION (ETL Load)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_6_structure
-    name: "Structure Creation (ETL Load)"
-    description: "Criar estrutura final do squad fusionado"
-    pattern: "ETL Load + Expand-Contract"
-    rollback: "Deletar squads/{target_name} e workspace permanece intacto"
-
-    steps:
-      - id: create_target_directory
-        action: "Criar estrutura de diretórios"
-        executor: Worker
-        command: |
-          mkdir -p squads/{target_name}/agents
-          mkdir -p squads/{target_name}/tasks
-          mkdir -p squads/{target_name}/skills
-          mkdir -p squads/{target_name}/data
-          mkdir -p squads/{target_name}/templates
-          mkdir -p squads/{target_name}/checklists
-          mkdir -p squads/{target_name}/workflows
-
-      - id: move_components
-        action: "Mover componentes do workspace para destino"
-        executor: Worker
-        rationale: "Move (não copy) para garantir exactly-once"
-        command: |
-          mv {workspace}/agents/* squads/{target_name}/agents/ 2>/dev/null || true
-          mv {workspace}/tasks/* squads/{target_name}/tasks/ 2>/dev/null || true
-          mv {workspace}/skills/* squads/{target_name}/skills/ 2>/dev/null || true
-          mv {workspace}/data/* squads/{target_name}/data/ 2>/dev/null || true
-          mv {workspace}/templates/* squads/{target_name}/templates/ 2>/dev/null || true
-          mv {workspace}/checklists/* squads/{target_name}/checklists/ 2>/dev/null || true
-          mv {workspace}/workflows/* squads/{target_name}/workflows/ 2>/dev/null || true
-
-      # ─────────────────────────────────────────────────────────────────────────
-      # STEPS CRÍTICOS: Definir estrutura semântica (requer LLM)
-      # ─────────────────────────────────────────────────────────────────────────
-      - id: define_tiers
-        action: "Organizar agents em tiers baseado em função"
-        executor: Agent
-        rationale: |
-          Precisa entender o PROPÓSITO de cada agent para classificar:
-          - Tier 0: Diagnóstico/Estratégia (pensar antes de agir)
-          - Tier 1: Especialistas de Plataforma (execução especializada)
-          - Tier 2: Execução/Operação (trabalho do dia-a-dia)
-        prompt: |
-          Analise os agents coletados em {workspace}/agents/ e organize em tiers.
-
-          Para cada agent:
-          1. Leia o arquivo completo
-          2. Identifique sua função principal
-          3. Classifique no tier apropriado
-
-          Output esperado (YAML):
-          ```yaml
-          tiers:
-            tier_0:
-              name: "Strategic/Diagnostic"
-              agents: [agent1, agent2]
-              when_to_use: "Quando precisa de diagnóstico ou estratégia"
-            tier_1:
-              name: "Platform Specialists"
-              agents: [agent3, agent4]
-              when_to_use: "Quando precisa de expertise em plataforma específica"
-            tier_2:
-              name: "Execution/Operations"
-              agents: [agent5, agent6]
-              when_to_use: "Quando precisa de execução operacional"
-          ```
-        store_as: "tiers"
-
-      - id: define_routing_rules
-        action: "Criar regras de routing por especialidade"
-        executor: Agent
-        rationale: |
-          Precisa mapear especialidades de cada agent para criar routing:
-          - Qual agent usar para Meta Ads?
-          - Qual agent usar para Google Ads?
-          - Qual agent usar para scaling?
-        prompt: |
-          Analise os agents em {workspace}/agents/ e crie regras de routing.
-
-          Para cada agent:
-          1. Identifique suas especialidades
-          2. Mapeie para cenários de uso
-
-          Output esperado (YAML):
-          ```yaml
-          routing:
-            meta_ads: [agent-especialista-meta]
-            google_ads: [agent-especialista-google]
-            youtube_ads: [agent-especialista-youtube]
-            scaling: [agent-scaling-1, agent-scaling-2]
-            creative: [agent-creative]
-            analytics: [agent-analytics]
-            compliance: [agent-compliance]
-          ```
-        store_as: "routing_rules"
-
-      - id: generate_config
-        action: "Gerar config.yaml"
-        executor: Worker
-        depends_on: [define_tiers, define_routing_rules]
-        template: |
-          # ═══════════════════════════════════════════════════════════════════════════════
-          # {target_name} - Squad Fusion Result
-          # ═══════════════════════════════════════════════════════════════════════════════
-          # Gerado por wf-squad-fusion v2.0
-          # Data: {timestamp}
-          # Modo: {mode}
-
-          pack:
-            name: "{target_name}"
-            title: "{target_title}"
-            version: "1.0.0"
-            author: "Squad Architect (Fusion)"
-            description: |
-              Fusão de {source_count} squads: {source_list}
-              Domínio: {target_domain}
-            icon: "{icon}"
-            slash_prefix: "{prefix}"
-
-          # ═══════════════════════════════════════════════════════════════════════════════
-          # FUSION METADATA (Provenance)
-          # ═══════════════════════════════════════════════════════════════════════════════
-          fusion:
-            workflow: "wf-squad-fusion"
-            workflow_version: "2.0.0"
-            fusion_id: "{fusion_id}"
-            fusion_date: "{timestamp}"
-            fusion_mode: "{mode}"
-            source_squads:
-            {{#each sources}}
-              - name: "{{name}}"
-                contributed:
-                  agents: {{agents}}
-                  tasks: {{tasks}}
-                  skills: {{skills}}
-            {{/each}}
-            assets_total:
-              agents: {final_agents}
-              tasks: {final_tasks}
-              skills: {final_skills}
-              data: {final_data}
-              templates: {final_templates}
-              checklists: {final_checklists}
-              workflows: {final_workflows}
-            deduplication:
-              duplicates_found: {duplicates_found}
-              duplicates_resolved: {duplicates_resolved}
-            scope_filtering:
-              in_scope: {in_scope}
-              excluded: {excluded}
-
-          # ═══════════════════════════════════════════════════════════════════════════════
-          # ORCHESTRATOR
-          # ═══════════════════════════════════════════════════════════════════════════════
-          orchestrator:
-            agent: "{target_name}-chief"
-            activation: "@{target_name}"
-
-          # ═══════════════════════════════════════════════════════════════════════════════
-          # TIER STRUCTURE
-          # ═══════════════════════════════════════════════════════════════════════════════
-          tiers:
-          {{#each tiers}}
-            tier_{{level}}:
-              name: "{{name}}"
-              agents:
-              {{#each agents}}
-                - {{this}}
-              {{/each}}
-              when_to_use: "{{when}}"
-          {{/each}}
-
-          # ═══════════════════════════════════════════════════════════════════════════════
-          # ROUTING
-          # ═══════════════════════════════════════════════════════════════════════════════
-          routing:
-          {{#each routing_rules}}
-            {{key}}: {{agents}}
-          {{/each}}
-
-      - id: generate_readme
-        action: "Gerar README.md"
-        executor: Worker
-        template: |
-          # {target_name}
-
-          > 🐉 Fusão Dragon Ball de {source_count} squads
-
-          ## Origem
-
-          Este squad foi criado pela fusão de:
-          {{#each sources}}
-          - **{{name}}**: {{agents}} agents, {{tasks}} tasks
-          {{/each}}
-
-          ## 📊 Composição Final
-
-          | Tipo | Quantidade |
-          |------|------------|
-          | Agents | {agents_count} |
-          | Tasks | {tasks_count} |
-          | Skills | {skills_count} |
-          | Data | {data_count} |
-          | Templates | {templates_count} |
-          | Checklists | {checklists_count} |
-          | Workflows | {workflows_count} |
-
-          ## 🎯 Agents por Tier
-
-          {{#each tiers}}
-          ### Tier {{level}}: {{name}}
-          {{#each agents}}
-          - `@{{this}}`
-          {{/each}}
-          {{/each}}
-
-          ## 🔧 Comandos Disponíveis
-
-          {{#each tasks}}
-          - `*{{name}}` - {{description}}
-          {{/each}}
-
-          ## 📈 Skills
-
-          {{#each skills}}
-          - `{{name}}` - {{description}}
-          {{/each}}
-
-          ## 🔗 Provenance
-
-          Cada componente mantém rastreabilidade à sua origem.
-          Ver `config.yaml` seção `fusion` para detalhes completos.
-
-          ---
-
-          *Gerado por wf-squad-fusion v2.0 em {timestamp}*
-
-      - id: create_orchestrator_if_needed
-        action: "Criar orchestrator se não existe"
-        executor: Agent
-        condition: "!exists(squads/{target_name}/agents/{target_name}-chief.md)"
-        rationale: |
-          Orchestrator precisa conhecer TODOS os agents do squad e saber:
-          - Quando acionar cada um
-          - Como fazer handoff entre eles
-          - Quais comandos disponibilizar
-        prompt: |
-          Crie um orchestrator para o squad {target_name}.
-
-          Context:
-          - Agents disponíveis: {agent_list}
-          - Tiers definidos: {tiers}
-          - Routing rules: {routing_rules}
-          - Domínio: {target_domain}
-
-          O orchestrator deve:
-          1. Ter voice_dna próprio (profissional, direto)
-          2. Conhecer todos os agents e suas especialidades
-          3. Saber quando delegar para qual agent
-          4. Ter comandos que façam sentido para o domínio
-
-          Use o template base de:
-          squads/squad-creator-pro/templates/orchestrator-tmpl.md
-
-          Output: Markdown completo do orchestrator
-        output_path: "squads/{target_name}/agents/{target_name}-chief.md"
-
-      - id: preserve_audit_log
-        action: "Mover audit log para destino"
-        executor: Worker
-        command: |
-          mv {workspace}/fusion-audit.yaml squads/{target_name}/fusion-audit.yaml
-          mv {workspace}/_audit/* squads/{target_name}/_audit/ 2>/dev/null || true
-
-      - id: final_count_verification
-        action: "Verificação final de contagem"
-        executor: Worker
-        command: |
-          echo "=== FINAL SQUAD CONTENTS ===" && \
-          echo "Agents: $(find squads/{target_name}/agents -name '*.md' | wc -l)" && \
-          echo "Tasks: $(find squads/{target_name}/tasks -name '*.md' | wc -l)" && \
-          echo "Skills: $(find squads/{target_name}/skills -name 'SKILL.md' | wc -l)" && \
-          echo "Data: $(find squads/{target_name}/data -name '*.md' | wc -l)"
-
-      - id: log_structure_creation
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "structure_created"
-          path: "squads/{target_name}"
-          timestamp: "{now}"
-
-    quality_gate:
-      name: "Structure Gate"
-      checks:
-        - "config.yaml existe e é válido"
-        - "README.md existe"
-        - "Pelo menos 1 agent existe"
-        - "Orchestrator existe"
-        - "Contagem final = contagem esperada"
-      veto_on: "Qualquer check falhar"
-
-    output:
-      squad_path: "string"
-      config_valid: "boolean"
-      final_counts: "AssetCounts"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 7: INTEGRATION TEST (Strangler Fig Pattern)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_7_integration
-    name: "Integration Test"
-    description: "Testar squad fusionado antes de cleanup"
-    pattern: "Strangler Fig - Parallel Run"
-    rollback: "Squad fonte ainda existe, pode reverter"
-
-    steps:
-      - id: smoke_test_activation
-        action: "Testar ativação do orchestrator"
-        executor: Hybrid
-        rationale: "Verificar estrutura=Worker, testar comportamento=Agent"
-        test: |
-          # Simular: @{target_name}
-          # Verificar que orchestrator responde
-
-      - id: smoke_test_routing
-        action: "Testar routing entre agents"
-        executor: Hybrid
-        rationale: "Verificar existência=Worker, testar funcionamento=Agent"
-        test: |
-          # Para cada tier, verificar que agents são alcançáveis
-
-      - id: smoke_test_tasks
-        action: "Testar que tasks são executáveis"
-        executor: Worker
-        test: |
-          # Para cada task, verificar sintaxe e dependências
-
-      - id: generate_test_report
-        action: "Gerar relatório de testes"
-        executor: Worker
-        template: |
-          ## 🧪 INTEGRATION TEST REPORT
-
-          ### Activation Tests
-          - Orchestrator activation: {{orchestrator_status}}
-          - Agent count visible: {{agents_visible}}
-
-          ### Routing Tests
-          {{#each routing_tests}}
-          - {{route}}: {{status}}
-          {{/each}}
-
-          ### Task Tests
-          {{#each task_tests}}
-          - *{{task}}: {{status}}
-          {{/each}}
-
-          ### Overall: {{overall_status}}
-
-      - id: log_integration
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "integration_test_complete"
-          status: "pass|fail"
-          timestamp: "{now}"
-
-    checkpoint:
-      type: "human_review"
-      condition: "mode == 'quality'"
-      prompt: |
-        ## Integration Test Results
-
-        {{test_report}}
-
-        Squad fusionado está funcional?
-        Aprovar para finalizar (opcional: cleanup de fontes)?
-
-    quality_gate:
-      name: "Integration Gate"
-      checks:
-        - "Orchestrator ativa sem erro"
-        - "Pelo menos 80% dos routing tests passam"
-        - "Pelo menos 90% das tasks são válidas"
-      veto_on: "Orchestrator não ativa"
-
-    output:
-      test_status: "pass|warn|fail"
-      test_report: "markdown"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 7.5: COMMAND SYNC (IDE Integration)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_7_5_command_sync
-    name: "Command Sync (IDE Integration)"
-    description: "Sincronizar commands para .claude/commands/ e remover commands antigos"
-    pattern: "Deploy + Cleanup"
-    rollback: "Re-sync from squads/"
-
-    critical_rule: |
-      🚨 OBRIGATÓRIO: Sempre executar após criar squad fusionado
-
-      Esta fase garante que:
-      1. Novos commands do target squad estão disponíveis
-      2. Commands dos squads fonte removidos são limpos
-      3. IDE reconhece o novo squad imediatamente
-
-    steps:
-      - id: remove_old_commands
-        action: "Remover commands dos squads fonte"
-        executor: Worker
-        command: |
-          for squad in {source_squads}:
-            if [ -d ".claude/commands/{squad}" ]; then
-              rm -rf ".claude/commands/{squad}"
-              echo "✅ Removed: .claude/commands/{squad}"
-            fi
-            if [ -f ".claude/commands/{squad}.md" ]; then
-              rm -f ".claude/commands/{squad}.md"
-              echo "✅ Removed: .claude/commands/{squad}.md"
-            fi
-
-      - id: create_command_structure
-        action: "Criar estrutura de commands do target"
-        executor: Worker
-        command: |
-          mkdir -p .claude/commands/{target_name}/agents
-          mkdir -p .claude/commands/{target_name}/tasks
-          mkdir -p .claude/commands/{target_name}/skills
-
-      - id: copy_agents_to_commands
-        action: "Copiar agents para .claude/commands/"
-        executor: Worker
-        command: |
-          cp squads/{target_name}/agents/*.md .claude/commands/{target_name}/agents/
-          echo "✅ Copied $(ls -1 .claude/commands/{target_name}/agents/*.md | wc -l) agents"
-
-      - id: copy_tasks_to_commands
-        action: "Copiar tasks para .claude/commands/"
-        executor: Worker
-        command: |
-          cp squads/{target_name}/tasks/*.md .claude/commands/{target_name}/tasks/
-          echo "✅ Copied $(ls -1 .claude/commands/{target_name}/tasks/*.md | wc -l) tasks"
-
-      - id: copy_skills_to_commands
-        action: "Copiar skills para .claude/commands/"
-        executor: Worker
-        command: |
-          find squads/{target_name}/skills -name 'SKILL.md' -exec cp {} .claude/commands/{target_name}/skills/ \; 2>/dev/null
-          echo "✅ Copied skills"
-
-      - id: create_main_command
-        action: "Criar arquivo de comando principal"
-        executor: Worker
-        template: |
-          # /{target_name} - {target_title}
-
-          Activate the {target_title} squad.
-
-          ## Instructions
-
-          **Read and follow `squads/{target_name}/agents/{target_name}-chief.md` activation-instructions exactly.**
-
-          Do NOT search for files. Do NOT load additional files on activation.
-          Only read the agent file above and execute its greeting script.
-        output_path: ".claude/commands/{target_name}.md"
-
-      - id: verify_command_sync
-        action: "Verificar sincronização"
-        executor: Worker
-        command: |
-          echo "=== COMMAND SYNC VERIFICATION ==="
-          echo "Main command: $(test -f .claude/commands/{target_name}.md && echo '✅' || echo '❌')"
-          echo "Agents dir: $(test -d .claude/commands/{target_name}/agents && echo '✅' || echo '❌')"
-          echo "Tasks dir: $(test -d .claude/commands/{target_name}/tasks && echo '✅' || echo '❌')"
-          echo "Agent count: $(ls -1 .claude/commands/{target_name}/agents/*.md 2>/dev/null | wc -l)"
-          echo "Task count: $(ls -1 .claude/commands/{target_name}/tasks/*.md 2>/dev/null | wc -l)"
-
-      - id: log_command_sync
-        action: "Registrar no audit log"
-        executor: Worker
-        audit_event:
-          type: "command_sync_complete"
-          target: ".claude/commands/{target_name}"
-          sources_removed: "{source_squads}"
-          timestamp: "{now}"
-
-    quality_gate:
-      name: "Command Sync Gate"
-      checks:
-        - ".claude/commands/{target_name}.md existe"
-        - ".claude/commands/{target_name}/agents/ tem agents"
-        - ".claude/commands/{target_name}/tasks/ tem tasks"
-        - "Commands dos squads fonte foram removidos"
-      veto_on: "Main command não existe"
-
-    output:
-      commands_synced: "boolean"
-      old_commands_removed: "list[string]"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PHASE 8: CLEANUP (Optional)
-# ═══════════════════════════════════════════════════════════════════════════════
-  - id: phase_8_cleanup
-    name: "Cleanup (Optional)"
-    description: "Remover squads fonte após fusão bem-sucedida"
-    pattern: "Expand-Contract - Contract Phase"
-    rollback: "Restaurar do backup"
-
-    prerequisite: "Phase 7 status == pass"
-
-    steps:
-      - id: confirm_cleanup
-        action: "Confirmar com usuário antes de deletar"
-        executor: Human
-        rationale: "Decisão irreversível requer aprovação humana"
-        prompt: |
-          ## ⚠️ CLEANUP CONFIRMATION
-
-          A fusão foi bem-sucedida. Deseja remover os squads fonte?
-
-          Squads a remover:
-          {{#each source_squads}}
-          - squads/{{this}}/
-          {{/each}}
-
-          Backup disponível em: {{backup_path}}
-
-          **Esta ação é irreversível (exceto via restore do backup).**
-
-          Confirmar remoção?
-        options:
-          - "Sim, remover fontes"
-          - "Não, manter fontes (recomendado para teste)"
-          - "Remover apenas depois de X dias"
-
-      - id: remove_sources
-        action: "Remover squads fonte"
-        executor: Worker
-        condition: "user_confirmed_cleanup == true"
-        command: |
-          for squad in {source_squads}:
-            rm -rf squads/{squad}
-            echo "REMOVED: squads/{squad}"
-
-      - id: update_registry
-        action: "Atualizar squad-registry.yaml"
-        executor: Worker
-        command: "Execute *refresh-registry"
-
-      - id: cleanup_workspace
-        action: "Remover workspace temporário"
-        executor: Worker
-        command: "rm -rf {workspace}"
-
-      - id: log_cleanup
-        action: "Registrar no audit log final"
-        executor: Worker
-        audit_event:
-          type: "fusion_complete"
-          sources_removed: "boolean"
-          timestamp: "{now}"
-
-    output:
-      sources_removed: "boolean"
-      final_status: "complete"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# HEURISTICS (Decision Rules)
-# ═══════════════════════════════════════════════════════════════════════════════
-heuristics:
-  - id: H_FUSION_001
-    name: "Sempre Contar, Nunca Assumir"
-    rule: "Executar comandos de contagem para CADA squad"
-    rationale: "IAs erram ao extrapolar de um squad para outros"
-    applies_to: ["phase_1"]
-
-  - id: H_FUSION_002
-    name: "Maior Ganha (Dedup)"
-    rule: "Em duplicatas, agent com mais linhas vence"
-    rationale: "Linhas = proxy para completude"
-    applies_to: ["phase_2"]
-    override: "Humano pode escolher diferente em quality mode"
-
-  - id: H_FUSION_003
-    name: "Escopo Strict"
-    rule: "Na dúvida, EXCLUIR do escopo"
-    rationale: "Mais fácil adicionar depois do que remover"
-    applies_to: ["phase_3"]
-
-  - id: H_FUSION_004
-    name: "Idempotency Always"
-    rule: "Operações devem ser seguras para re-executar"
-    rationale: "Permite recovery de falhas parciais"
-    applies_to: ["phase_4"]
-
-  - id: H_FUSION_005
-    name: "Validate Before Load"
-    rule: "Nunca criar estrutura final sem validação"
-    rationale: "Erros são mais fáceis de corrigir no workspace"
-    applies_to: ["phase_5"]
-
-  - id: H_FUSION_006
-    name: "Parallel Run Before Cutover"
-    rule: "Manter fontes até integration test passar"
-    rationale: "Pattern Strangler Fig - rollback fácil"
-    applies_to: ["phase_7", "phase_8"]
-
-  - id: H_FUSION_007
-    name: "Provenance Sempre"
-    rule: "Todo componente deve ser rastreável à origem"
-    rationale: "Debugging e auditoria futura"
-    applies_to: ["all"]
-
-  - id: H_FUSION_008
-    name: "Log Tudo"
-    rule: "Cada decisão registrada no audit log"
-    rationale: "Reprodutibilidade e accountability"
-    applies_to: ["all"]
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# QUICK REFERENCE
-# ═══════════════════════════════════════════════════════════════════════════════
-quick_reference:
-  phases_summary:
-    - "Phase 0: Init - Setup workspace e backup"
-    - "Phase 1: Discovery - Inventário COMPLETO"
-    - "Phase 2: Deduplication - Resolver duplicatas"
-    - "Phase 3: Scope - Filtrar por domínio"
-    - "Phase 4: Collection - Copiar para workspace"
-    - "Phase 5: Validation - Quality gates"
-    - "Phase 6: Structure - Criar squad final"
-    - "Phase 7: Integration - Testar funcionamento"
-    - "Phase 7.5: Command Sync - Sincronizar .claude/commands/"
-    - "Phase 8: Cleanup - Remover fontes (opcional)"
-
-  checkpoints:
-    yolo_mode: "Nenhum (decisões automáticas)"
-    quality_mode:
-      - "After Phase 1 (inventário)"
-      - "After Phase 2 (duplicatas)"
-      - "After Phase 3 (escopo)"
-      - "After Phase 5 (validação)"
-      - "After Phase 7 (integração)"
-      - "After Phase 7.5 (command sync)"
-      - "Before Phase 8 (cleanup)"
-
-  rollback_points:
-    - "Phase 0-3: Trivial (apenas análise)"
-    - "Phase 4: Delete workspace, retry"
-    - "Phase 5: Fix issues, re-validate"
-    - "Phase 6: Delete target squad, workspace intact"
-    - "Phase 7: Keep sources, don't cleanup"
-    - "Phase 7.5: Re-sync commands from squads/"
-    - "Phase 8: Restore from backup"
-
-  time_estimates:
-    yolo_mode: "15-30 minutos"
-    quality_mode: "45-90 minutos"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# CHANGELOG
-# ═══════════════════════════════════════════════════════════════════════════════
-changelog:
-  - version: "2.1.0"
-    date: "2026-02-04"
-    changes:
-      - "Adicionado Phase 7.5: Command Sync (IDE Integration)"
-      - "Sincronização automática de .claude/commands/"
-      - "Remoção automática de commands dos squads fonte"
-      - "Atualizado quick_reference com nova fase"
-
-  - version: "2.0.0"
-    date: "2026-02-03"
-    changes:
-      - "Reescrita completa baseada em research de boas práticas"
-      - "Adicionado patterns: Three-Way Merge, Expand-Contract, ETL, Strangler Fig, Entity Resolution"
-      - "8 fases com checkpoints detalhados"
-      - "Heuristics documentadas"
-      - "Anti-patterns documentados"
-      - "Audit log integrado"
-      - "Provenance tracking"
-      - "Idempotency garantida"
-
-  - version: "1.0.0"
-    date: "2026-02-03"
-    changes:
-      - "Versão inicial"