dmux-workflows
affaan-m/ECC
Organize sessões paralelas de agentes de IA usando o dmux, um gerenciador de painéis do tmux para conjuntos de agentes como o Claude Code e o Codex.
...Expandir tudoFluxos de trabalho do dmux
Orquestre sessões paralelas de agentes de IA usando o dmux, um gerenciador de painéis do tmux para conjuntos de agentes.
Quando ativar
- Execução de várias sessões de agentes em paralelo
- Coordenar o trabalho entre o Claude Code, o Codex e outros conjuntos de agentes
- Tarefas complexas que se beneficiam do paralelismo do tipo “dividir para conquistar”
- O usuário diz “executar em paralelo”, “dividir este trabalho”, “usar o dmux” ou “multi-agente”
O que é o dmux
O dmux é uma ferramenta de orquestração baseada no tmux que gerencia painéis de agentes de IA:
- Pressione
npara criar um novo painel com um prompt - Pressione
mpara mesclar a saída do painel de volta à sessão principal - Compatível com: Claude Code, Codex, OpenCode, Cline, Gemini, Qwen
Instalação: Instale o dmux a partir de seu repositório após revisar o pacote. Consulte github.com/standardagents/dmux
Início rápido
# Inicie a sessão do dmux
dmux
# Crie painéis de agente (pressione 'n' no dmux e, em seguida, digite o prompt)
# Painel 1: “Implemente o middleware de autenticação em src/auth/”
# Painel 2: “Escreva testes para o serviço de usuário”
# Painel 3: “Atualize a documentação da API”
# Cada painel executa sua própria sessão de agente
# Pressione ‘m’ para mesclar os resultados de volta
Padrões de fluxo de trabalho
Padrão 1: Pesquisa + Implementação
Divida a pesquisa e a implementação em trilhas paralelas:
Painel 1 (Pesquisa): “Pesquise as melhores práticas para limitação de taxa no Node.js.
Verifique as bibliotecas atuais, compare abordagens e registre as conclusões em
/tmp/rate-limit-research.md”
Painel 2 (Implementação): “Implemente um middleware de limitação de taxa para nossa API Express.
Comece com um token bucket básico; vamos refinar depois que a pesquisa for concluída.”
# Após a conclusão do Painel 1, mescle as descobertas no contexto do Painel 2
Padrão 2: Recurso de múltiplos arquivos
Paralelize o trabalho entre arquivos independentes:
Painel 1: “Crie o esquema do banco de dados e as migrações para o recurso de faturamento”
Painel 2: “Crie os endpoints da API de faturamento em src/api/billing/”
Painel 3: “Crie os componentes da interface do painel de controle de faturamento”
# Mescle tudo e, em seguida, faça a integração no painel principal
Padrão 3: Ciclo de teste + correção
Execute os testes em um painel, corrija em outro:
Painel 1 (Observador): “Execute o conjunto de testes no modo de observação. Quando os testes falharem,
resuma as falhas.”
Painel 2 (Corretor): “Corrija os testes com falha com base na saída de erros do painel 1”
Padrão 4: Harness cruzado
Use diferentes ferramentas de IA para diferentes tarefas:
Painel 1 (Claude Code): “Analise a segurança do módulo de autenticação”
Painel 2 (Codex): “Reestruture as funções utilitárias para melhorar o desempenho”
Painel 3 (Claude Code): “Escreva testes E2E para o fluxo de finalização de compra”
Padrão 5: Pipeline de revisão de código
Perspectivas de revisão paralelas:
Painel 1: “Revisar src/api/ em busca de vulnerabilidades de segurança”
Painel 2: “Revisar src/api/ em busca de problemas de desempenho”
Painel 3: “Revisar src/api/ em busca de lacunas na cobertura de testes”
# Mesclar todas as revisões em um único relatório
Melhores práticas
- Apenas tarefas independentes. Não paralelize tarefas que dependam do resultado umas das outras.
- Limites claros. Cada painel deve trabalhar com arquivos ou aspectos distintos.
- Faça a fusão de forma estratégica. Analise os resultados de cada painel antes da fusão para evitar conflitos.
- Use git worktrees. Para trabalhos propensos a conflitos de arquivos, use worktrees separadas por painel.
- Consciência dos recursos. Cada painel usa tokens de API — mantenha o total de painéis abaixo de 5 a 6.
Integração com Git Worktree
Para tarefas que envolvem arquivos sobrepostos:
# Crie worktrees para isolamento
git worktree add -b feat/auth ../feature-auth HEAD
git worktree add -b feat/billing ../feature-billing HEAD
# Execute agentes em worktrees separadas
# Painel 1: cd ../feature-auth && claude
# Painel 2: cd ../feature-billing && claude
# Mescle os branches quando terminar
git merge feat/auth
git merge feat/billing
Ferramentas complementares
| Ferramenta | O que faz | Quando usar |
|---|---|---|
| dmux | Gerenciamento de painéis do tmux para agentes | Sessões paralelas de agentes |
| Superset | IDE de terminal para mais de 10 agentes paralelos | Orquestração em grande escala |
| Ferramenta Claude Code Task | Geração de subagentes dentro do processo | Paralelismo programático dentro de uma sessão |
| Codex multiagente | Funções de agente integradas | Trabalho paralelo específico do Codex |
Auxiliar do ECC
O ECC agora inclui um auxiliar para orquestração externa de painéis do tmux com árvores de trabalho do Git separadas:
node scripts/orchestrate-worktrees.js plan.json --execute
Exemplo de plan.json:
{
"sessionName": "skill-audit",
"baseRef": "HEAD",
"launcherCommand": "codex exec --cwd {worktree_path} --task-file {task_file}",
"workers": [
{ "name": "docs-a", "task": "Corrigir as habilidades 1 a 4 e redigir notas de transferência." },
{ "name": "docs-b", "task": "Corrigir as habilidades 5 a 8 e redigir notas de transferência." }
]
}
O auxiliar:
- Cria uma árvore de trabalho do Git baseada em ramificação para cada trabalhador
- Opcionalmente, sobrepõe
os seedPathsselecionados do checkout principal em cada árvore de trabalho do trabalhador - Grava os arquivos
task.md,handoff.mdestatus.mdespecíficos de cada trabalhador na pasta.orchestration// - Inicia uma sessão do tmux com um painel por trabalhador
- Executa cada comando do trabalhador em seu próprio painel
- Deixa o painel principal livre para o orquestrador
Use seedPaths quando os workers precisarem acessar arquivos locais alterados ou não rastreados que ainda não fazem parte do HEAD, como scripts locais de orquestração, rascunhos de planos ou documentos:
{
"sessionName": "workflow-e2e",
"seedPaths": [
"scripts/orchestrate-worktrees.js",
"scripts/lib/tmux-worktree-orchestrator.js",
".claude/plan/workflow-e2e-test.json"
],
"launcherCommand": "bash {repo_root}/scripts/orchestrate-codex-worker.sh {task_file} {handoff_file} {status_file}",
"workers": [
{ "name": "seed-check", "task": "Verificar se os arquivos inicializados estão presentes antes de iniciar o trabalho." }
]
}
Solução de problemas
- Painel não responde: Alterne diretamente para o painel ou inspecione-o com o comando
tmux capture-pane -pt.:0. - Conflitos de mesclagem: use git worktrees para isolar as alterações nos arquivos por painel.
- Alto uso de tokens: Reduza o número de painéis paralelos. Cada painel é uma sessão completa do agente.
- tmux não encontrado: Instale com
`brew install tmux` (macOS) ou`apt install tmux` (Linux).
---
name: dmux-workflows
description: Orchestrate parallel AI agent sessions using dmux, a tmux pane manager for agent harnesses like Claude Code and Codex.
---
# dmux Workflows
Orchestrate parallel AI agent sessions using dmux, a tmux pane manager for agent harnesses.
## When to Activate
- Running multiple agent sessions in parallel
- Coordinating work across Claude Code, Codex, and other harnesses
- Complex tasks that benefit from divide-and-conquer parallelism
- User says "run in parallel", "split this work", "use dmux", or "multi-agent"
## What is dmux
dmux is a tmux-based orchestration tool that manages AI agent panes:
- Press `n` to create a new pane with a prompt
- Press `m` to merge pane output back to the main session
- Supports: Claude Code, Codex, OpenCode, Cline, Gemini, Qwen
**Install:** Install dmux from its repository after reviewing the package. See [github.com/standardagents/dmux](https://github.com/standardagents/dmux)
## Quick Start
```bash
# Start dmux session
dmux
# Create agent panes (press 'n' in dmux, then type prompt)
# Pane 1: "Implement the auth middleware in src/auth/"
# Pane 2: "Write tests for the user service"
# Pane 3: "Update API documentation"
# Each pane runs its own agent session
# Press 'm' to merge results back
```
## Workflow Patterns
### Pattern 1: Research + Implement
Split research and implementation into parallel tracks:
```
Pane 1 (Research): "Research best practices for rate limiting in Node.js.
Check current libraries, compare approaches, and write findings to
/tmp/rate-limit-research.md"
Pane 2 (Implement): "Implement rate limiting middleware for our Express API.
Start with a basic token bucket, we'll refine after research completes."
# After Pane 1 completes, merge findings into Pane 2's context
```
### Pattern 2: Multi-File Feature
Parallelize work across independent files:
```
Pane 1: "Create the database schema and migrations for the billing feature"
Pane 2: "Build the billing API endpoints in src/api/billing/"
Pane 3: "Create the billing dashboard UI components"
# Merge all, then do integration in main pane
```
### Pattern 3: Test + Fix Loop
Run tests in one pane, fix in another:
```
Pane 1 (Watcher): "Run the test suite in watch mode. When tests fail,
summarize the failures."
Pane 2 (Fixer): "Fix failing tests based on the error output from pane 1"
```
### Pattern 4: Cross-Harness
Use different AI tools for different tasks:
```
Pane 1 (Claude Code): "Review the security of the auth module"
Pane 2 (Codex): "Refactor the utility functions for performance"
Pane 3 (Claude Code): "Write E2E tests for the checkout flow"
```
### Pattern 5: Code Review Pipeline
Parallel review perspectives:
```
Pane 1: "Review src/api/ for security vulnerabilities"
Pane 2: "Review src/api/ for performance issues"
Pane 3: "Review src/api/ for test coverage gaps"
# Merge all reviews into a single report
```
## Best Practices
1. **Independent tasks only.** Don't parallelize tasks that depend on each other's output.
2. **Clear boundaries.** Each pane should work on distinct files or concerns.
3. **Merge strategically.** Review pane output before merging to avoid conflicts.
4. **Use git worktrees.** For file-conflict-prone work, use separate worktrees per pane.
5. **Resource awareness.** Each pane uses API tokens — keep total panes under 5-6.
## Git Worktree Integration
For tasks that touch overlapping files:
```bash
# Create worktrees for isolation
git worktree add -b feat/auth ../feature-auth HEAD
git worktree add -b feat/billing ../feature-billing HEAD
# Run agents in separate worktrees
# Pane 1: cd ../feature-auth && claude
# Pane 2: cd ../feature-billing && claude
# Merge branches when done
git merge feat/auth
git merge feat/billing
```
## Complementary Tools
| Tool | What It Does | When to Use |
|------|-------------|-------------|
| **dmux** | tmux pane management for agents | Parallel agent sessions |
| **Superset** | Terminal IDE for 10+ parallel agents | Large-scale orchestration |
| **Claude Code Task tool** | In-process subagent spawning | Programmatic parallelism within a session |
| **Codex multi-agent** | Built-in agent roles | Codex-specific parallel work |
## ECC Helper
ECC now includes a helper for external tmux-pane orchestration with separate git worktrees:
```bash
node scripts/orchestrate-worktrees.js plan.json --execute
```
Example `plan.json`:
```json
{
"sessionName": "skill-audit",
"baseRef": "HEAD",
"launcherCommand": "codex exec --cwd {worktree_path} --task-file {task_file}",
"workers": [
{ "name": "docs-a", "task": "Fix skills 1-4 and write handoff notes." },
{ "name": "docs-b", "task": "Fix skills 5-8 and write handoff notes." }
]
}
```
The helper:
- Creates one branch-backed git worktree per worker
- Optionally overlays selected `seedPaths` from the main checkout into each worker worktree
- Writes per-worker `task.md`, `handoff.md`, and `status.md` files under `.orchestration/<session>/`
- Starts a tmux session with one pane per worker
- Launches each worker command in its own pane
- Leaves the main pane free for the orchestrator
Use `seedPaths` when workers need access to dirty or untracked local files that are not yet part of `HEAD`, such as local orchestration scripts, draft plans, or docs:
```json
{
"sessionName": "workflow-e2e",
"seedPaths": [
"scripts/orchestrate-worktrees.js",
"scripts/lib/tmux-worktree-orchestrator.js",
".claude/plan/workflow-e2e-test.json"
],
"launcherCommand": "bash {repo_root}/scripts/orchestrate-codex-worker.sh {task_file} {handoff_file} {status_file}",
"workers": [
{ "name": "seed-check", "task": "Verify seeded files are present before starting work." }
]
}
```
## Troubleshooting
- **Pane not responding:** Switch to the pane directly or inspect it with `tmux capture-pane -pt <session>:0.<pane-index>`.
- **Merge conflicts:** Use git worktrees to isolate file changes per pane.
- **High token usage:** Reduce number of parallel panes. Each pane is a full agent session.
- **tmux not found:** Install with `brew install tmux` (macOS) or `apt install tmux` (Linux).
Todos os arquivos
1 arquivosInstalar dmux-workflows
Baixe e descompacte os arquivos de habilidades no diretório .claude/skills/.
Baixar ZIPClone o repositório e copie os arquivos da habilidade para o seu projeto.
git clone https://github.com/affaan-m/ECC/tree/main/skills/dmux-workflows # Copy SKILL.md to your .claude/skills/ directory
Copiar





Lar
