swarm-tree-orchestration

Name: swarm-tree-orchestration
Author: Renat0z

Recursive tree decomposition orchestrator squad — decomposes complex tasks into a tree where each leaf has max 2 sub-tasks, plans the complete tree before execution, launches waves via TaskCreate, and integrates results. Inherits Context Factory, UxIxR scoring, circuit breaker, and fitToBudget.

53installs

SAFE

npx squads add Renat0z/squads/swarm-tree-orchestration -y

Squads são publicados por terceiros. O squads.sh não garante segurança nem funcionalidade. Use por sua conta e risco. Ler Termos

00 agentes

00 tarefas

00 workflows

Swarm Tree Orchestration Squad

Decomposição recursiva em árvore — planeja a árvore COMPLETA antes de executar.

Pipeline de 2 fases: planejamento total → execução em ondas via TaskCreate, com scoring UxIxR, circuit breaker e integração automática.

/sto

O Problema com Tarefas Complexas

Você sabe o que acontece quando um agente tenta executar uma tarefa enorme diretamente.

Ele começa, perde o fio, produz código incompleto, ou simplesmente trava no meio.

A causa: Sem planejamento prévio, o agente não sabe o escopo real, não gerencia dependências entre sub-tarefas e desperdiça contexto.

O Swarm Tree Orchestration Squad resolve isso com uma regra simples:

Planejar a árvore COMPLETA antes de executar qualquer folha.

Antes e Depois

	🐌 Execução Direta	⚡ Swarm Tree
Planejamento	Nenhum	Árvore completa antes de executar
Dependências	Ignoradas	Grafo de dependências explícito
Paralelismo	Zero	Ondas paralelas via TaskCreate
Falhas	Reinicia do zero	Delta relaunch do checkpoint
Validação	Nenhuma	Circuit breaker antes de cada TaskCreate
Integração	Manual	Automática (imports, refs, LEI ZERO)

Como Funciona

┌────────────────────────────────────────────────┐
│              FASE 1 — PLANEJAMENTO             │
│                                                │
│  P0: Setup .swarm-tree/                        │
│  P1: TaskDecomposer → rawTree (recursivo)      │
│  P2: NodeScorer → UxIxR scoring + dep graph    │
│  P3: TreeOrchestrator → tree.json + context    │
│  P4: ContextComposer → prompts por nó          │
│  P5: TreeValidator → WBS + circuit breaker     │
│  P6: Apresentação para validação do usuário    │
└───────────────────────┬────────────────────────┘
                        │ usuário valida
                        ▼
┌────────────────────────────────────────────────┐
│              FASE 2 — EXECUÇÃO                 │
│                                                │
│  WaveDispatcher → ondas paralelas via          │
│  TaskCreate (respeitando dependências)         │
│                    │                           │
│  Poll unificado + reactive dispatch            │
│                    │                           │
│  TreeIntegrator → valida artefatos +           │
│  corrige imports + gera relatório final        │
└────────────────────────────────────────────────┘

Agentes

	Nome	Arquétipo	Papel
🌳	TreeOrchestrator	Flow_Master	Roteador puro — coordena lifecycle completo
🔀	TaskDecomposer	Builder	Decomposição recursiva (Golden Rule: ≤2 tarefas/folha)
📊	NodeScorer	Guardian	Scoring UxIxR + grafo de dependências
🧩	ContextComposer	Builder	Context Factory + fitToBudget
🌊	WaveDispatcher	Flow_Master	Execução em ondas + polling + delta relaunch
🛡️	TreeValidator	Guardian	Circuit breaker + validação WBS
🔗	TreeIntegrator	Balancer	Integração + relatório final

Tasks

Task	Agente	Camada
`decomposeTask()`	TaskDecomposer	Organism
`groupSubtasks()`	TaskDecomposer	Molecule
`scoreNodes()`	NodeScorer	Organism
`buildDependencyGraph()`	NodeScorer	Organism
`generateTreePlan()`	TreeOrchestrator	Organism
`composeContext()`	ContextComposer	Organism
`validateCircuitBreaker()`	TreeValidator	Molecule
`dispatchWave()`	WaveDispatcher	Organism
`integrateTree()`	TreeIntegrator	Organism
`analyzeTree()`	TreeValidator	Organism
`resumeTree()`	TreeOrchestrator	Organism

Workflows

Nome	Padrão	Descrição
`tree_planning_flow`	Pipeline	Fase 1: decomposição → scoring → planejamento → composição → validação
`tree_execution_flow`	Loop	Fase 2: ondas → polling → integração
`tree_analysis_flow`	Pipeline	Auditoria de árvore existente
`tree_resume_flow`	Pipeline	Retomada após falha a partir de checkpoint

Comandos

Comando	O que faz
/sto *orchestrate-tree TASK="..."	Lifecycle completo: planejar + executar + integrar
/sto *plan-tree TASK="..."	Apenas fase 1: gera árvore para revisão
/sto *resume-tree	Retoma execução interrompida do checkpoint
/sto *analyze-tree	Audita árvore existente para anti-padrões

Golden Rule

Nó com ≤2 sub-tarefas  →  executor (folha)
Nó com >2 sub-tarefas  →  coordenador (delega recursivamente)

Toda folha tem no máximo 2 tarefas. O circuit breaker bloqueia qualquer violação.

Scoring UxIxR

Score	Estratégia	Modelo	Budget
1.0–3.0	Lean	haiku	3.000 tok
3.1–6.0	Standard	sonnet	5.000 tok
6.1–8.0	Rich	sonnet	8.000 tok
8.1–10.0	Critical	opus	12.000 tok

FAQ

O squad funciona com qualquer tipo de tarefa?

Sim. O TaskDecomposer aceita qualquer descrição de tarefa e aplica a decomposição recursiva. Quanto mais específica a tarefa, mais precisa a árvore gerada.

O que acontece se uma folha falhar?

O WaveDispatcher aplica delta relaunch: lê o checkpoint da folha, lista os arquivos já criados, e reexecuta com um prompt de continuação. Máximo 2 tentativas por folha.

Posso inspecionar o plano antes da execução?

Sim. Use *plan-tree para gerar apenas a fase 1 e revisar tree.json antes de autorizar a execução.

Como retomar uma execução interrompida?

Use *resume-tree com o caminho para

.swarm-tree/tree-plan/tree.json

. O squad identifica folhas completas, falhas e pendentes automaticamente.

Criado por nirvana-squads-creator-lite · MIT License

orchestration · recursive-decomposition · task-tree · multi-agent · wbs · context-factory · wave-execution · circuit-breaker

Avaliações

0 avaliações

Nenhuma avaliação ainda. Seja o primeiro a avaliar este squad!

More from Renat0z

brainstormind

Workflow Diverge+Converge — swarm de 24 agentes gera 200+ ideias, filtra Top 3, depois refina o melhor insight em design validado. Pipeline de 6 fases com gate interativo, context-manifest pattern, shared macros. ~65% menos tokens que abordagem naive.

3View →

win proposal deal

Propostas comerciais que fecham — 4 agentes IA analisam seu prospect, desenham 3 opcoes de escopo, precificam com win-rate preditivo e entregam proposta persuasiva pronta em minutos

1View →

token-optimizer

Analisa squads AIOS existentes e produz otimizacoes priorizadas por ROI — qualidade, velocidade e economia de tokens — usando TOKEN-OPTIMIZATION-GUIDE.md como base de conhecimento.

2View →

nirvana squads creator lite

Token-optimized squad generator — 5-phase pipeline with live tech verification, context-manifest pattern, shared macros, and consolidated agents. ~70% fewer tokens than v1.

0View →

design 3d experience

Squad para planejar e construir experiencias 3D web imersivas — do briefing estrategico ao deploy otimizado com Three.js, React Three Fiber, GSAP e scroll-driven narratives

0View →

video factory remotion

End-to-end programmatic video creation squad — from briefing to rendered MP4. 5 specialized agents orchestrate storyboard, assets, voiceover+SFX+BGM, Remotion composition (3-layer audio), and render pipeline with post-processing.

4View →