---
name: delegate
description: Delegação inteligente de tarefas para sub-agentes especializados. Analisa requisitos e encaminha para o agente adequado com contexto. Usar quando "delegate", "delegar", "subagent", "ajuda especializada", ou análises multi-domínio complexas.
---

# /delegate - Delegação com Testes e KB Integrados

Delega tarefas de desenvolvimento para outros chats com workflow completo: timer, **auto-consulta Dify KB**, implementação, **testes automáticos**, e report unificado.

## Novidade v3.0: Auto-Consulta Dify KB

Antes de delegar, a skill consulta automaticamente a knowledge base para enriquecer o contexto do agente delegado.

```
/delegate #1429 /path "Implementar feature"
        │
        ▼
┌─────────────────────────────────────────────────────────┐
│  PRÉ-DELEGAÇÃO (automático)                             │
├─────────────────────────────────────────────────────────┤
│  1. Detectar tipo de trabalho (WP, PHP, MCP, etc.)      │
│  2. Carregar agent-knowledge-config.json                │
│  3. Verificar consultation_protocol do agente           │
│  4. Consultar Dify KB com query_template + {task}       │
│  5. Verificar cache (evitar consultas repetidas)        │
│  6. Enriquecer template com conhecimento relevante      │
└─────────────────────────────────────────────────────────┘
        │
        ▼
    DELEGAÇÃO ENRIQUECIDA
```

## Workflow v2.0

```
/delegate #1429 /path "Implementar feature"
        │
        ▼
┌─────────────────────────────────────────────────────────┐
│  CHAT DELEGADO (executa tudo automaticamente)           │
├─────────────────────────────────────────────────────────┤
│  1. start_timer (AikTop)                                │
│  2. IMPLEMENTAR                                         │
│     - Desenvolver funcionalidade                        │
│     - Actualizar CHANGELOG.md                           │
│     - Commits por etapa                                 │
│  3. TESTAR ←── NOVO: integrado no fluxo                 │
│     - Executar testes funcionais                        │
│     - Verificar edge cases                              │
│     - Testar regressões                                 │
│     - Se falhar → corrigir → testar novamente           │
│  4. FINALIZAR                                           │
│     - Commit final + push                               │
│     - Status → "Em Testes" (3)                          │
│     - Comentário com report unificado                   │
│     - stop_timer                                        │
└─────────────────────────────────────────────────────────┘
        │
        ▼
    @Emanuel recebe notificação
```

---

## Protocolo de Auto-Consulta Dify KB

### 1. Mapeamento Agente → Datasets

Ficheiro: `~/.claude/agents/agent-knowledge-config.json`

| Tipo de Trabalho | Agente | Datasets Prioritários |
|------------------|--------|----------------------|
| WordPress | `wordpress-plugin-developer` | Wordpress, Elementor, Crocoblock |
| PHP/APIs | `php-fullstack-engineer` | APIs, MCP, Backend |
| MCP | `mcp-protocol-developer` | MCP Servers, Claude Code |
| Marketing | `marketing-planning-expert` | Marketing Digital, SEO |
| CRM | `crm-admin-specialist` | Perfex CRM |

### 2. Fluxo de Consulta

```javascript
// 1. Detectar agente baseado no path/contexto
const agent = detectAgent(path, task);  // e.g., "wordpress-plugin-developer"

// 2. Carregar configuração
const config = require('~/.claude/agents/agent-knowledge-config.json');
const protocol = config.agents[agent]?.consultation_protocol;

// 3. Se tem protocolo de consulta
if (protocol?.auto_consult) {
  // 4. Construir query
  const query = protocol.query_template.replace('{task}', task);

  // 5. Verificar cache primeiro
  const cacheKey = generateHash(query, protocol.priority_datasets);
  const cached = checkCache(cacheKey);

  if (cached) {
    // Cache hit - usar resultado
    return cached.result;
  }

  // 6. Consultar Dify KB (paralelo)
  const results = await Promise.all(
    protocol.priority_datasets.map(id =>
      mcp__notebooklm__notebook_query, mcp__dify-kb__dify_kb_retrieve_segments({
        dataset_id: id,
        query: query,
        top_k: protocol.top_k || 3
      })
    )
  );

  // 7. Gravar em cache
  saveToCache(cacheKey, results);

  // 8. Retornar conhecimento agregado
  return aggregateResults(results);
}
```

### 3. Enriquecimento do Template

O conhecimento recuperado é adicionado ao template de delegação:

```markdown
### Contexto da Knowledge Base (Auto-Consultado)

**Query:** {query_used}
**Datasets consultados:** {dataset_names}
**Cache:** HIT/MISS

#### Conhecimento Relevante:
{kb_results_formatted}

---
```

### 4. Métricas Automáticas

Cada delegação com consulta KB grava:
```sql
INSERT INTO tblskill_agent_metrics (
  type, name, duration_ms, status, staff_id,
  kb_consulted, kb_cache_hit, tool_calls
) VALUES (
  'skill', '/delegate', {ms}, 'completed', 25,
  1, {0_ou_1}, {n}
);
```

---

## Uso

```bash
/delegate <task_id> <path> [instruções]
```

**Exemplos:**
```bash
/delegate #1429 /home/ealmeida/mcp-servers/mcp-desk-crm-sql-v3
/delegate #1447 /home/ealmeida/mcp-servers/mcp-moloni "Implementar endpoints facturação"
```

---

## Template de Delegação

```markdown
---
## Tarefa Delegada: #[ID] - [NOME]

**Desk:** https://desk.descomplicar.pt/admin/tasks/view/[ID]
**Projecto:** [NOME_PROJECTO]
**Path:** [PATH]

---

### WORKFLOW OBRIGATÓRIO

#### 1. INICIAR (primeiro passo)
```
start_timer(task_id=[ID], staff_id=25, note="[CONTEXTO]")
```

#### 2. IMPLEMENTAR
- Desenvolver funcionalidade conforme descrição
- Manter CHANGELOG.md actualizado
- Commits ao terminar cada etapa:
  ```bash
  git commit -m "feat/fix: descrição (#[ID])"
  ```

#### 3. TESTAR (obrigatório antes de concluir)

Executar testes e registar resultados:

| Tipo | O Que Testar |
|------|--------------|
| **Funcional** | A feature funciona como esperado? |
| **Edge cases** | Inputs inválidos, limites, erros? |
| **Regressão** | Funcionalidades existentes continuam OK? |

**Se teste falhar:**
1. Corrigir o problema
2. Commit da correcção
3. Testar novamente
4. Repetir até passar

#### 4. FINALIZAR

**4.1 Commit final + push:**
```bash
git add -A && git commit -m "feat: [descrição] (#[ID])" && git push
```

**4.2 Status "Em Testes":**
```
update_task(task_id=[ID], status=3)
```

**4.3 Report unificado:**
```
add_task_comment(task_id=[ID], content="
## Report de Execução

**Trabalho Realizado:**
- [item 1]
- [item 2]

**Testes Executados:**
| Teste | Status |
|-------|--------|
| [Funcional: descrição] | ✅/❌ |
| [Edge case: descrição] | ✅/❌ |
| [Regressão: descrição] | ✅/❌ |

**Taxa de Sucesso:** X/Y (Z%)

**Ficheiros Modificados:**
- [ficheiro]

**Commits:**
- [hash] - descrição

**Bugs/Notas:**
- [se houver]

@Emanuel Almeida
")
```

**4.4 Parar timer:**
```
stop_timer(task_id=[ID], staff_id=25, note="Concluído: [resumo]")
```

---

### Contexto
[INSTRUÇÕES ESPECÍFICAS]

---
*Delegado via /delegate v2.0 - [DATA]*
```

---

## Referência Rápida

### Staff IDs
| ID | Nome | Uso |
|----|------|-----|
| 1 | Emanuel Almeida | Trabalho directo |
| 25 | AikTop | Trabalho delegado IA |

### Status
| ID | Nome |
|----|------|
| 1 | Não iniciado |
| 4 | Em Curso |
| 3 | Em Testes |
| 5 | Terminado |

### Auto-Stop Timer
- Inactividade >15 min → timer pára automaticamente
- Implementado via hooks

---

## Changelog

### v3.0.0 (2026-02-03)
- **NEW:** Auto-consulta Dify KB antes de delegação
- Detecta agente baseado em path/contexto
- Carrega consultation_protocol de agent-knowledge-config.json
- Consulta paralela de datasets prioritários
- Cache layer (24h TTL) evita consultas repetidas
- Template enriquecido com conhecimento relevante
- Métricas automáticas de KB consulted/cache hit

### v2.0.0 (2026-01-27)
- **BREAKING:** Testes integrados no workflow (não separados)
- Report unificado inclui resultados de testes
- Ciclo corrigir→testar até passar
- Eliminada dependência de /test-plan

### v1.0.0 (2026-01-27)
- Versão inicial
- Template estruturado
- Timer AikTop
- Status "Em Testes"

---

**Versão:** 3.0.0 | **Autor:** Descomplicar® | **Data:** 2026-02-03

---


## Quando NÃO Usar

- Para tarefas fora do domínio de especialização desta skill
- Quando outra skill mais específica está disponível
- Para operações que requerem confirmação manual do utilizador


## Exemplos

### Exemplo 1: Uso Básico
```
Input: [descrição da tarefa]
Output: [resultado esperado]
```

### Exemplo 2: Uso Avançado
```
Input: [caso complexo]
Output: [resultado detalhado]
```

---

## Healing Log

Registo de erros conhecidos e como evitá-los. Lido automaticamente antes de executar.

```jsonl
{"date":"","issue":"","fix":"","source":"user|auto"}
```

*Adicionar nova linha após cada erro corrigido.*
