> ## Documentation Index
> Fetch the complete documentation index at: https://docs.evolutionfoundation.com.br/llms.txt
> Use this file to discover all available pages before exploring further.

# Visão Geral das Rotinas

> ADWs (AI Developer Workflows) que rodam em uma agenda

# Visão Geral das Rotinas

Rotinas são workflows automatizados (ADWs — AI Developer Workflows) que rodam em uma agenda. Existem dois tipos:

* **Rotinas de IA** — invocam o Claude Code CLI com um agente para tarefas de raciocínio (relatórios, análise, decisões). Custam tokens por execução.
* **Rotinas sistemáticas** — scripts Python puros que executam operações determinísticas (chamadas de API, operações em arquivo, transformações de dados). Sem IA, sem tokens, sem custo, rodam em segundos.

## Core vs Custom

```
ADWs/routines/
  good_morning.py       # Core (vem com o repo, hardcoded em scheduler.py)
  end_of_day.py         # Core
  memory_sync.py        # Core
  memory_lint.py        # Core
  weekly_review.py      # Core
  examples/             # Rotinas de exemplo (versionadas com o repo)
    community_daily.py
    financial_pulse.py
    ...
  custom/               # Criadas pelo usuário (gitignored), agendadas via routines.yaml
    my_routine.py
    ...
```

**Rotinas core** vêm com o repo e cobrem o loop diário essencial: good\_morning, end\_of\_day, memory\_sync, memory\_lint e weekly\_review. Suas agendas estão hardcoded em `scheduler.py` — elas NÃO vêm de `config/routines.yaml`. Veja [Rotinas Core](core-routines) para uma explicação detalhada de cada uma.

> **Descoberta dinâmica:** as rotinas são descobertas dinamicamente varrendo os arquivos de script. O agente é extraído do docstring de cada script (padrão `via AgentName`). Sem mapeamentos hardcoded — adicione um script novo e ele fica automaticamente disponível no dashboard, na API e no `make run`.

> **Nota:** a manutenção de memória segue o padrão LLM Wiki. A rotina `memory_sync` (diária) cuida do ingest com propagação de referências cruzadas (atualizando arquivos de memória relacionados quando um deles muda). A rotina `memory_lint` (semanal) faz health checks: detecta contradições, dados desatualizados, arquivos órfãos e gaps de cobertura. As duas rotinas atualizam `memory/index.md` (catálogo) e `memory/log.md` (log de operações).

**Rotinas de exemplo** ficam em `ADWs/routines/examples/` e são versionadas com o repo. São implementações de referência para integrações comuns (Discord, Stripe, YouTube, etc).

**Rotinas custom** ficam em `ADWs/routines/custom/` e são gitignored. Copie dos exemplos ou crie as suas. Apenas rotinas custom vão em `config/routines.yaml`. A skill `create-routine` ajuda a gerá-las.

## ADW Runner

Todas as rotinas usam `ADWs/runner.py`, que oferece:

* **`run_skill(skill, log_name, timeout, agent)`** — executa uma skill via Claude Code CLI (rotina de IA)
* **`run_claude(prompt, log_name, timeout, agent)`** — executa um prompt cru (rotina de IA)
* **`run_script(func, log_name, timeout)`** — executa uma função Python pura (rotina sistemática, sem IA)
* **`banner(title, subtitle)`** — imprime um header estilizado
* **`summary(results, title)`** — imprime resumo de execução com stats de custo/tokens

O runner cuida de:

* Invocar `claude --print --dangerously-skip-permissions --output-format json` (rotinas de IA)
* Executar funções Python diretamente com proteção de timeout (rotinas sistemáticas)
* Logar em arquivos JSONL (`ADWs/logs/YYYY-MM-DD.jsonl`)
* Salvar logs detalhados (`ADWs/logs/detail/`)
* Acumular métricas por rotina (`ADWs/logs/metrics.json`)
* Output rico no terminal com indicadores de progresso

## Como um Script de Rotina Funciona

Toda rotina segue o mesmo padrão:

```python theme={null}
#!/usr/bin/env python3
"""ADW: Financial Pulse -- Snapshot financeiro diário via Flux"""

import sys, os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
    os.path.abspath(__file__)))))
from runner import run_skill, banner, summary

def main():
    banner("Financial Pulse", "Stripe - Omie - MRR - Churn | @flux")
    results = []
    results.append(run_skill(
        "fin-daily-pulse",
        log_name="financial-pulse",
        timeout=600,
        agent="flux-finance"
    ))
    summary(results, "Financial Pulse")

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nCancelado.")
```

Elementos-chave:

1. Importe o runner de `ADWs/runner.py`
2. Imprima um banner com o nome da rotina
3. Chame `run_skill()` com nome da skill, log name, timeout e agente
4. Imprima um resumo

Para rotinas multi-passo, anexe vários resultados na lista.

## config/routines.yaml

Este arquivo define a agenda das **rotinas custom apenas**. Rotinas core (good\_morning, end\_of\_day, memory\_sync, weekly\_review) estão hardcoded em `scheduler.py` e não precisam de entrada aqui.

```yaml theme={null}
daily:
  - name: "Community Pulse"
    script: community_daily.py
    time: "20:00"
    enabled: true

  - name: "Sync Meetings"
    script: sync_meetings.py
    interval: 30          # A cada 30 minutos em vez de horário fixo
    enabled: true

weekly:
  - name: "Financial Weekly"
    script: financial_weekly.py
    day: friday
    time: "07:30"
    enabled: true

  - name: "Linear Review"
    script: linear_review.py
    days: [monday, wednesday, friday]   # Múltiplos dias
    time: "09:00"
    enabled: true

monthly:
  - name: "Monthly Close"
    script: monthly_close.py
    day: 1                # Dia do mês
    time: "08:00"
    enabled: true
```

Campos:

* `name`: nome de exibição
* `script`: arquivo Python em `ADWs/routines/custom/` (ou `ADWs/routines/examples/`)
* `time`: horário de execução (formato 24h, fuso local)
* `interval`: roda a cada N minutos (em vez de horário fixo)
* `day`: dia da semana (weekly) ou dia do mês (monthly)
* `days`: array para agendas semanais multi-dia
* `enabled`: ativa/desativa sem deletar

## Scheduler

Inicie o scheduler com:

```bash theme={null}
make scheduler
```

Isso roda `scheduler.py`, que tem rotinas core hardcoded e também lê `config/routines.yaml` para rotinas custom. O scheduler roda em primeiro plano e mostra progresso em tempo real.

O dashboard também inicia/para o scheduler pela página **Services**.

## Criando Rotinas Custom

### Usando a skill

```
/create-routine
```

A skill `create-routine` conduz por:

1. O que a rotina faz
2. Qual agente roda
3. Qual skill invoca
4. A agenda (daily/weekly/monthly)

Ela gera o script Python e atualiza `config/routines.yaml`. Sem mudanças no Makefile — rotinas são descobertas dinamicamente.

### Manualmente

1. Crie `ADWs/routines/custom/my_routine.py` seguindo o padrão acima
2. Adicione uma entrada em `config/routines.yaml`

## Execução Manual

Rotinas core têm targets dedicados no make. Todas as rotinas (core e custom) podem ser executadas pelo runner dinâmico:

```bash theme={null}
# Targets core
make morning         # Briefing matinal
make eod             # End of day
make memory          # Sincronização de memória
make memory-lint     # Lint de memória
make weekly          # Revisão semanal

# Runner dinâmico (qualquer rotina por ID)
make run R=fin-pulse        # Pulso financeiro
make run R=community        # Pulso da comunidade
make run R=licensing-month  # Licenciamento mensal

# Listar todas as rotinas disponíveis
make list-routines
```

Ou execute o script Python diretamente:

```bash theme={null}
python3 ADWs/routines/custom/community_daily.py
```

## Scheduled Tasks (Pontuais)

Para ações que devem rodar **uma vez** em horário específico (não recorrentes), use **Scheduled Tasks** em vez de rotinas. Veja [Scheduled Tasks](scheduled-tasks) para detalhes.

```
"Post no LinkedIn sexta 10h" → scheduled task (pontual)
"Verificar comunidade todo dia às 20h" → rotina (recorrente)
```

## Agent Teams (Experimental, Opt-in)

Versões multi-agente paralelas de rotinas de consolidação. Em vez de um agente coletando dados sequencialmente, Agent Teams spawnam teammates específicos de domínio que trabalham em paralelo — cada um na sua janela de contexto.

**Trade-off:** \~3-5x mais tokens, mas execução mais rápida e cada agente usa expertise do próprio domínio.

| Target | Equivalente normal | Líder | Teammates |
| - | - | - | - |
| `make team-strategy` | `make run R=strategy-digest` | @sage | @atlas, @flux, @pulse, @pixel |
| `make team-dashboard` | `make run R=dashboard` | @clawdia | @atlas, @flux, @pulse, @dex |
| `make team-weekly` | `make run R=weekly-review` | @clawdia | @atlas, @flux, @pulse |

Scripts ficam em `ADWs/routines/teams/`. Estes **nunca são agendados** — execute manualmente quando quiser velocidade ou análise cruzada de domínios mais rica.

Requer a flag experimental (já habilitada em `.claude/settings.json`):

```json theme={null}
{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }
```

Como funciona:

1. O agente líder (ex., @sage) cria um time de agentes
2. Cada teammate é spawnado usando o tipo de agente correspondente (ex., `atlas-project`)
3. Teammates coletam dados de domínio em paralelo
4. O líder espera todos os teammates e depois sintetiza os achados na saída final

Métricas de execuções de team aparecem como `team-strategy-digest`, `team-dashboard`, etc. em `metrics.json`, separadas das execuções normais — facilitando comparação de custo e velocidade.

## Logs e Métricas

### Arquivos de log

```
ADWs/logs/
  2026-04-08.jsonl           # Log JSONL diário (uma linha por execução)
  metrics.json               # Métricas acumuladas por rotina
  detail/                    # stdout/stderr completos por execução
    20260408-200000-community-daily.log
```

### Visualizando logs

```bash theme={null}
make logs            # Últimas entradas JSONL
make logs-detail     # Listar arquivos de log detalhado
make logs-tail       # Mostrar o último log completo
make metrics         # Tabela de métricas por rotina
make clean-logs      # Remover logs com mais de 30 dias
```

### Formato de métricas

`metrics.json` acompanha por rotina:

* Total de execuções, sucessos, falhas, taxa de sucesso
* Duração média
* Custo total e médio (USD)
* Tokens de entrada/saída totais
* Timestamp da última execução


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.