cc-viewer 1.6.182 → 1.6.183

package/concepts/pt-BR/Tool-TaskList.md

@@ -1,56 +1,62 @@
 # TaskList
 
-## Definição
+Retorna toda tarefa na equipe atual (ou sessão) em forma resumida. Use-o para examinar o trabalho pendente, decidir o que pegar a seguir e evitar criar duplicatas.
 
-Lista todas as tarefas na lista de tarefas, para visualizar o progresso geral e trabalho disponível.
+## Quando usar
+
+- No início de uma sessão para ver o que já está rastreado.
+- Antes de chamar `TaskCreate`, para confirmar que o trabalho ainda não foi capturado.
+- Ao decidir qual tarefa reivindicar a seguir como colega de equipe ou subagente.
+- Para verificar relações de dependência em toda a equipe de relance.
+- Periodicamente durante sessões longas para ressincronizar com colegas de equipe que podem ter reivindicado, concluído ou adicionado tarefas.
+
+`TaskList` é somente leitura e barato; chame-o livremente sempre que precisar de um panorama.
 
 ## Parâmetros
 
-Sem parâmetros.
+`TaskList` não recebe parâmetros. Ele sempre retorna o conjunto completo de tarefas para o contexto ativo.
 
-## Conteúdo Retornado
+## Formato da resposta
 
-Informações resumidas de cada tarefa:
-- `id` — Identificador da tarefa
-- `subject` — Descrição curta
-- `status` — Status: `pending`, `in_progress` ou `completed`
-- `owner` — Responsável (ID do agent), vazio indica não atribuído
-- `blockedBy` — Lista de IDs de tarefas não concluídas que bloqueiam esta tarefa
+Cada tarefa na lista é um resumo, não o registro completo. Espere aproximadamente:
 
-## Cenários de Uso
+- `id` — identificador estável para uso com `TaskGet` / `TaskUpdate`.
+- `subject` — título curto imperativo.
+- `status` — um de `pending`, `in_progress`, `completed`, `deleted`.
+- `owner` — handle do agente ou colega, ou vazio quando não reivindicado.
+- `blockedBy` — array de IDs de tarefa que precisam completar primeiro.
 
-**Adequado para:**
-- Ver quais tarefas estão disponíveis (status pending, sem owner, não bloqueadas)
-- Verificar o progresso geral do projeto
-- Encontrar tarefas bloqueadas
-- Encontrar a próxima tarefa após concluir uma
+Para a descrição completa, critérios de aceitação ou metadata de uma tarefa específica, continue com `TaskGet`.
 
-## Observações
+## Exemplos
 
-- Prefira processar tarefas em ordem de ID (menor ID primeiro), pois tarefas anteriores geralmente fornecem contexto para as posteriores
-- Tarefas com `blockedBy` não podem ser reivindicadas até que as dependências sejam resolvidas
-- Use TaskGet para obter detalhes completos de uma tarefa específica
+### Exemplo 1
 
-## Texto original
+Verificação rápida de status.
 
-<textarea readonly>Use this tool to list all tasks in the task list.
+```
+TaskList()
+```
 
-## When to Use This Tool
+Examine a saída em busca de qualquer coisa `in_progress` sem `owner` (trabalho parado) e qualquer coisa `pending` com `blockedBy` vazio (pronta para pegar).
 
-- To see what tasks are available to work on (status: 'pending', no owner, not blocked)
-- To check overall progress on the project
-- To find tasks that are blocked and need dependencies resolved
-- After completing a task, to check for newly unblocked work or claim the next available task
-- **Prefer working on tasks in ID order** (lowest ID first) when multiple tasks are available, as earlier tasks often set up context for later ones
+### Exemplo 2
 
-## Output
+Colega escolhendo a próxima tarefa.
 
-Returns a summary of each task:
-- **id**: Task identifier (use with TaskGet, TaskUpdate)
-- **subject**: Brief description of the task
-- **status**: 'pending', 'in_progress', or 'completed'
-- **owner**: Agent ID if assigned, empty if available
-- **blockedBy**: List of open task IDs that must be resolved first (tasks with blockedBy cannot be claimed until dependencies resolve)
+```
+TaskList()
+# Filter to: status == pending AND blockedBy is empty AND owner is empty.
+# Among those, prefer the lower ID (tasks are typically numbered in
+# creation order, so lower IDs are older and usually higher priority).
+TaskGet(taskId: "<chosen id>")
+TaskUpdate(taskId: "<chosen id>", status: "in_progress", owner: "<your handle>")
+```
+
+## Observações
 
-Use TaskGet with a specific task ID to view full details including description and comments.
-</textarea>
+- Heurística de colega: quando várias tarefas `pending` estão desbloqueadas e sem owner, escolha o ID mais baixo. Isso mantém o trabalho em FIFO e evita que dois agentes peguem a mesma tarefa de alto perfil.
+- Respeite `blockedBy`: não comece uma tarefa cujos bloqueadores ainda estão `pending` ou `in_progress`. Trabalhe o bloqueador primeiro ou coordene com seu owner.
+- `TaskList` é o único mecanismo de descoberta de tarefas. Não há busca; se a lista for longa, examine estruturalmente (por status, depois por owner).
+- Tarefas excluídas ainda podem aparecer na lista com status `deleted` para rastreabilidade. Ignore-as para fins de planejamento.
+- A lista reflete o estado vivo da equipe, então colegas podem adicionar ou reivindicar tarefas entre chamadas. Liste novamente antes de reivindicar se tempo passou.

package/concepts/pt-BR/Tool-TaskOutput.md

@@ -1,40 +1,50 @@
 # TaskOutput
 
-## Definição
+Busca a saída acumulada de uma tarefa em segundo plano em execução ou concluída — um comando de shell em segundo plano, um agente local ou uma sessão remota. Use quando precisar inspecionar o que uma tarefa de longa duração produziu até agora.
 
-Obtém a saída de tarefas em segundo plano em execução ou concluídas. Aplicável a shells em segundo plano, agents assíncronos e sessões remotas.
+## Quando usar
+
+- Uma sessão remota (por exemplo um sandbox na nuvem) está rodando e você precisa do stdout dela.
+- Um agente local foi despachado em segundo plano e você quer progresso parcial antes que ele retorne.
+- Um comando de shell em segundo plano está rodando há tempo suficiente para que você queira verificar sem pará-lo.
+- Você precisa confirmar que uma tarefa em segundo plano está de fato progredindo antes de esperar mais ou chamar `TaskStop`.
+
+Não recorra a `TaskOutput` reflexivamente. Para a maior parte do trabalho em segundo plano há um caminho mais direto — veja as observações abaixo.
 
 ## Parâmetros
 
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `task_id` | string | Sim | ID da tarefa |
-| `block` | boolean | Sim | Se deve bloquear aguardando a conclusão da tarefa, padrão `true` |
-| `timeout` | number | Sim | Tempo máximo de espera (milissegundos), padrão 30000, máximo 600000 |
+- `task_id` (string, obrigatório): O identificador da tarefa retornado quando o trabalho em segundo plano foi iniciado. Não é o mesmo que um `taskId` da lista de tarefas; este é o handle de execução para a execução específica.
+- `block` (boolean, opcional): Quando `true` (padrão), espera até que a tarefa produza nova saída ou termine antes de retornar. Quando `false`, retorna imediatamente com o que está bufferizado.
+- `timeout` (number, opcional): Máximo de milissegundos para bloquear antes de retornar. Só significativo quando `block` é `true`. Padrão `30000`, máximo `600000`.
 
-## Cenários de Uso
+## Exemplos
 
-**Adequado para:**
-- Verificar o progresso de agents em segundo plano iniciados via Task (`run_in_background: true`)
-- Obter resultados de execução de comandos Bash em segundo plano
-- Aguardar a conclusão de tarefas assíncronas e obter a saída
+### Exemplo 1
 
-**Não adequado para:**
-- Tarefas em primeiro plano — tarefas em primeiro plano retornam resultados diretamente, sem necessidade desta ferramenta
+Espiar uma sessão remota sem bloquear.
 
-## Observações
+```
+TaskOutput(task_id: "sess_01HXYZ...", block: false)
+```
+
+Retorna qualquer stdout/stderr que foi produzido desde que a tarefa começou (ou desde sua última chamada `TaskOutput`, dependendo do runtime).
 
-- `block: true` bloqueia até a tarefa ser concluída ou atingir timeout
-- `block: false` é usado para verificação não-bloqueante do estado atual
-- O ID da tarefa pode ser encontrado via comando `/tasks`
-- Aplicável a todos os tipos de tarefa: shells em segundo plano, agents assíncronos, sessões remotas
+### Exemplo 2
 
-## Texto original
+Esperar brevemente por um agente local emitir mais saída.
+
+```
+TaskOutput(
+  task_id: "agent_01ABCD...",
+  block: true,
+  timeout: 10000
+)
+```
+
+## Observações
 
-<textarea readonly>- Retrieves output from a running or completed task (background shell, agent, or remote session)
-- Takes a task_id parameter identifying the task
-- Returns the task output along with status information
-- Use block=true (default) to wait for task completion
-- Use block=false for non-blocking check of current status
-- Task IDs can be found using the /tasks command
-- Works with all task types: background shells, async agents, and remote sessions</textarea>
+- Comandos bash em segundo plano: `TaskOutput` está efetivamente depreciado para este caso de uso. Quando você inicia uma tarefa de shell em segundo plano, o resultado já inclui o caminho para seu arquivo de saída — leia esse caminho diretamente com a ferramenta `Read`. `Read` dá acesso aleatório, offsets de linha e uma visão estável; `TaskOutput` não.
+- Agentes locais (a ferramenta `Agent` despachada em segundo plano): quando o agente termina, o resultado da ferramenta `Agent` já contém sua resposta final. Use-a diretamente. Não dê `Read` no arquivo de transcript simbólico — ele contém o fluxo completo de chamadas de ferramenta e transbordará a janela de contexto.
+- Sessões remotas: `TaskOutput` é a forma correta e muitas vezes única de fazer stream da saída. Prefira `block: true` com um `timeout` modesto em vez de loops de polling apertados.
+- Um `task_id` desconhecido, ou uma tarefa cuja saída foi coletada pelo garbage collector, retorna um erro. Despache o trabalho novamente se ainda precisar dele.
+- `TaskOutput` não para a tarefa. Use `TaskStop` para terminar.

package/concepts/pt-BR/Tool-TaskStop.md

@@ -1,32 +1,45 @@
 # TaskStop
 
-## Definição
+Para uma tarefa em segundo plano em execução — um comando de shell, um agente despachado ou uma sessão remota — por seu handle de execução. Use-o para liberar recursos, cancelar trabalho que não é mais útil ou se recuperar quando uma tarefa está travada.
 
-Para uma tarefa em segundo plano que está em execução.
+## Quando usar
+
+- Um comando de shell em segundo plano rodou mais do que o esperado e você não precisa mais do resultado.
+- Um agente local está em loop ou parou e precisa ser cortado.
+- O usuário mudou de direção e o trabalho em segundo plano para a direção anterior deve ser abandonado.
+- Uma sessão remota está prestes a atingir o timeout ou está segurando um recurso que você precisa.
+- Você precisa de um estado limpo antes de iniciar uma nova execução da mesma tarefa.
+
+Prefira deixar o trabalho em segundo plano de vida curta terminar sozinho. `TaskStop` é para casos em que continuar a execução não tem valor ou é ativamente prejudicial.
 
 ## Parâmetros
 
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `task_id` | string | Não | ID da tarefa em segundo plano a parar |
-| `shell_id` | string | Não | Descontinuado, use `task_id` em vez disso |
+- `task_id` (string, obrigatório): O handle de execução retornado quando a tarefa em segundo plano foi iniciada. Este é o mesmo identificador aceito por `TaskOutput`, não um `taskId` da lista de tarefas.
 
-## Cenários de Uso
+## Exemplos
 
-**Adequado para:**
-- Encerrar tarefas de longa duração que não são mais necessárias
-- Cancelar tarefas em segundo plano iniciadas por engano
+### Exemplo 1
 
-## Observações
+Parar um comando de shell em segundo plano descontrolado.
+
+```
+TaskStop(task_id: "bash_01HXYZ...")
+```
 
-- Retorna status de sucesso ou falha
-- O parâmetro `shell_id` está descontinuado, deve-se usar `task_id`
+O comando recebe um sinal de término; a saída bufferizada escrita até agora permanece legível em seu caminho de saída.
 
-## Texto original
+### Exemplo 2
+
+Cancelar um agente despachado após uma correção de rumo do usuário.
+
+```
+TaskStop(task_id: "agent_01ABCD...")
+```
+
+## Observações
 
-<textarea readonly>
-- Stops a running background task by its ID
-- Takes a task_id parameter identifying the task to stop
-- Returns a success or failure status
-- Use this tool when you need to terminate a long-running task
-</textarea>
+- `TaskStop` solicita terminação; não garante desligamento instantâneo. Tarefas bem comportadas saem prontamente, mas um processo fazendo I/O bloqueante pode levar um momento para se encerrar.
+- Parar uma tarefa não exclui sua saída. Para tarefas de shell em segundo plano, o arquivo de saída no disco é preservado e ainda legível com `Read`. Para agentes e sessões, qualquer saída capturada antes da parada ainda é acessível via `TaskOutput`.
+- Um `task_id` desconhecido, ou uma tarefa que já terminou, retorna um erro ou no-op. Isso é seguro — você pode chamar `TaskStop` defensivamente sem verificar o status primeiro.
+- Se você pretende reiniciar o mesmo trabalho, pare a tarefa antiga antes de despachar a nova para evitar duas execuções paralelas competindo por recursos compartilhados (arquivos, portas, linhas de banco de dados).
+- `TaskStop` não afeta entradas na lista de tarefas da equipe. Para cancelar uma tarefa rastreada, atualize seu status para `deleted` com `TaskUpdate`.

package/concepts/pt-BR/Tool-TaskUpdate.md

@@ -1,123 +1,70 @@
 # TaskUpdate
 
-## Definição
+Modifica uma tarefa existente — seu status, conteúdo, ownership, metadata ou arestas de dependência. É assim que tarefas progridem em seu ciclo de vida e como o trabalho é repassado entre Claude Code, colegas de equipe e subagentes.
 
-Atualiza o status, conteúdo ou dependências de uma tarefa na lista de tarefas.
+## Quando usar
 
-## Parâmetros
-
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `taskId` | string | Sim | ID da tarefa a atualizar |
-| `status` | enum | Não | Novo status: `pending` / `in_progress` / `completed` / `deleted` |
-| `subject` | string | Não | Novo título |
-| `description` | string | Não | Nova descrição |
-| `activeForm` | string | Não | Texto no gerúndio exibido quando em andamento |
-| `owner` | string | Não | Novo responsável pela tarefa (nome do agent) |
-| `metadata` | object | Não | Metadados a mesclar (definir como null para excluir chave) |
-| `addBlocks` | string[] | Não | Lista de IDs de tarefas bloqueadas por esta tarefa |
-| `addBlockedBy` | string[] | Não | Lista de IDs de tarefas pré-requisito que bloqueiam esta tarefa |
-
-## Fluxo de Status
-
-```
-pending → in_progress → completed
-```
-
-`deleted` pode ser atingido a partir de qualquer status, removendo permanentemente a tarefa.
-
-## Cenários de Uso
-
-**Adequado para:**
-- Marcar tarefa como `in_progress` ao iniciar o trabalho
-- Marcar tarefa como `completed` após concluir o trabalho
-- Definir dependências entre tarefas
-- Atualizar conteúdo da tarefa quando requisitos mudam
-
-**Regras importantes:**
-- Só marcar como `completed` quando a tarefa estiver totalmente concluída
-- Manter como `in_progress` ao encontrar erros ou bloqueios
-- Não marcar como `completed` quando testes falham, implementação está incompleta ou há erros não resolvidos
-
-## Observações
-
-- Antes de atualizar, deve-se obter o status mais recente da tarefa via TaskGet para evitar dados desatualizados
-- Após concluir uma tarefa, chamar TaskList para encontrar a próxima tarefa disponível
+- Transicionar uma tarefa pelo fluxo de status à medida que você trabalha nela.
+- Reivindicar uma tarefa atribuindo-se (ou outro agente) como `owner`.
+- Refinar o `subject` ou `description` quando aprender mais sobre o problema.
+- Registrar dependências recém-descobertas com `addBlocks` / `addBlockedBy`.
+- Anexar `metadata` estruturada como IDs de tickets externos ou dicas de prioridade.
 
-## Texto original
-
-<textarea readonly>Use this tool to update a task in the task list.
-
-## When to Use This Tool
-
-**Mark tasks as resolved:**
-- When you have completed the work described in a task
-- When a task is no longer needed or has been superseded
-- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
-- After resolving, call TaskList to find your next task
-
-- ONLY mark a task as completed when you have FULLY accomplished it
-- If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-- When blocked, create a new task describing what needs to be resolved
-- Never mark a task as completed if:
-  - Tests are failing
-  - Implementation is partial
-  - You encountered unresolved errors
-  - You couldn't find necessary files or dependencies
-
-**Delete tasks:**
-- When a task is no longer relevant or was created in error
-- Setting status to `deleted` permanently removes the task
+## Parâmetros
 
-**Update task details:**
-- When requirements change or become clearer
-- When establishing dependencies between tasks
+- `taskId` (string, obrigatório): A tarefa a modificar. Obtenha de `TaskList` ou `TaskCreate`.
+- `status` (string, opcional): Um de `pending`, `in_progress`, `completed`, `deleted`.
+- `subject` (string, opcional): Título imperativo de substituição.
+- `description` (string, opcional): Descrição detalhada de substituição.
+- `activeForm` (string, opcional): Texto de spinner em gerúndio de substituição.
+- `owner` (string, opcional): Handle do agente ou colega assumindo responsabilidade pela tarefa.
+- `metadata` (object, opcional): Chaves de metadata a mesclar na tarefa. Defina uma chave como `null` para excluí-la.
+- `addBlocks` (array of strings, opcional): IDs de tarefas que esta tarefa bloqueia.
+- `addBlockedBy` (array of strings, opcional): IDs de tarefas que devem ser concluídas antes desta.
 
-## Fields You Can Update
+## Fluxo de status
 
-- **status**: The task status (see Status Workflow below)
-- **subject**: Change the task title (imperative form, e.g., "Run tests")
-- **description**: Change the task description
-- **activeForm**: Present continuous form shown in spinner when in_progress (e.g., "Running tests")
-- **owner**: Change the task owner (agent name)
-- **metadata**: Merge metadata keys into the task (set a key to null to delete it)
-- **addBlocks**: Mark tasks that cannot start until this one completes
-- **addBlockedBy**: Mark tasks that must complete before this one can start
+O ciclo de vida é deliberadamente linear: `pending` → `in_progress` → `completed`. `deleted` é terminal e usado para retratar tarefas que nunca serão trabalhadas.
 
-## Status Workflow
+- Defina `in_progress` no momento em que você realmente começar o trabalho, não antes. Apenas uma tarefa por vez deve estar `in_progress` para um determinado owner.
+- Defina `completed` apenas quando o trabalho estiver totalmente concluído — critérios de aceitação atendidos, testes passando, saída gravada. Se um bloqueio surgir, mantenha a tarefa `in_progress` e adicione uma nova tarefa descrevendo o que precisa ser resolvido.
+- Nunca marque uma tarefa como `completed` quando testes estão falhando, a implementação está parcial ou você atingiu erros não resolvidos.
+- Use `deleted` para tarefas que são canceladas ou duplicadas; não reaproveite uma tarefa para trabalho não relacionado.
 
-Status progresses: `pending` → `in_progress` → `completed`
+## Exemplos
 
-Use `deleted` to permanently remove a task.
+### Exemplo 1
 
-## Staleness
+Reivindicar uma tarefa e começá-la.
 
-Make sure to read a task's latest state using `TaskGet` before updating it.
+```
+TaskUpdate(
+  taskId: "t_01HXYZ...",
+  status: "in_progress",
+  owner: "main-agent"
+)
+```
 
-## Examples
+### Exemplo 2
 
-Mark task as in progress when starting work:
-```json
-{"taskId": "1", "status": "in_progress"}
-```
+Finalizar o trabalho e registrar uma dependência de acompanhamento.
 
-Mark task as completed after finishing work:
-```json
-{"taskId": "1", "status": "completed"}
 ```
-
-Delete a task:
-```json
-{"taskId": "1", "status": "deleted"}
+TaskUpdate(
+  taskId: "t_01HXYZ...",
+  status: "completed"
+)
+
+TaskUpdate(
+  taskId: "t_01FOLLOWUP...",
+  addBlockedBy: ["t_01HXYZ..."]
+)
 ```
 
-Claim a task by setting owner:
-```json
-{"taskId": "1", "owner": "my-name"}
-```
+## Observações
 
-Set up task dependencies:
-```json
-{"taskId": "2", "addBlockedBy": ["1"]}
-```
-</textarea>
+- `metadata` mescla chave por chave; passar `null` para uma chave a remove. Chame `TaskGet` primeiro se não tiver certeza do conteúdo atual.
+- `addBlocks` e `addBlockedBy` anexam arestas; não removem as existentes. Editar o grafo destrutivamente requer um workflow dedicado — consulte o owner da equipe antes de reescrever dependências.
+- Mantenha `activeForm` em sincronia quando alterar `subject` para que o texto do spinner continue lendo naturalmente.
+- Não marque uma tarefa como `completed` para silenciá-la. Se o usuário cancelou o trabalho, use `deleted` com uma breve justificativa em `description`.
+- Leia o último estado de uma tarefa com `TaskGet` antes de atualizar — colegas podem tê-la alterado entre sua última leitura e sua escrita.

package/concepts/pt-BR/Tool-TeamCreate.md

@@ -1,38 +1,53 @@
 # TeamCreate
 
-## Definição
+Estabelece uma nova equipe de colaboração com uma lista de tarefas compartilhada e canal de mensagens entre agentes. Uma equipe é a primitiva de coordenação para trabalho multiagente — a sessão principal atua como líder e dispara colegas nomeados via a ferramenta `Agent`.
 
-Cria uma nova equipe para coordenar múltiplos agents trabalhando em um projeto. As equipes permitem execução paralela de tarefas por meio de uma lista de tarefas compartilhada e troca de mensagens entre agents.
+## Quando usar
+
+- O usuário solicita explicitamente uma equipe, swarm, crew ou colaboração multiagente.
+- Um projeto tem vários fluxos de trabalho claramente independentes que se beneficiam de especialistas dedicados (por exemplo frontend, backend, testes, docs).
+- Você precisa de uma lista de tarefas compartilhada persistente que múltiplos agentes atualizam conforme progridem.
+- Você quer colegas nomeados e endereçáveis que podem trocar mensagens via `SendMessage` em vez de chamadas de subagente únicas.
+
+NÃO use para uma única busca delegada ou um fan-out paralelo único — chamadas simples de `Agent` são mais leves e suficientes.
 
 ## Parâmetros
 
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|-----------|------|-------------|-----------|
-| `team_name` | string | Sim | Nome para a nova equipe |
-| `description` | string | Não | Descrição / propósito da equipe |
-| `agent_type` | string | Não | Tipo / papel do líder da equipe |
+- `team_name` (string, obrigatório): Identificador único para a equipe. Usado como nome do diretório sob `~/.claude/teams/` e como argumento `team_name` ao disparar colegas.
+- `description` (string, obrigatório): Declaração curta do objetivo da equipe. Mostrada a cada colega no spawn e escrita na configuração da equipe.
+- `agent_type` (string, opcional): Persona de subagente padrão aplicada aos colegas que não a sobrescrevem. Valores típicos são `general-purpose`, `Explore` ou `Plan`.
+
+## Exemplos
+
+### Exemplo 1: Criar uma equipe de refatoração
 
-## O que é criado
+```
+TeamCreate(
+  team_name="refactor-crew",
+  description="Refactor the data access layer from raw SQL to Prisma, including migrations and tests.",
+  agent_type="general-purpose"
+)
+```
 
-- **Arquivo de configuração da equipe**: `~/.claude/teams/{team-name}/config.json` — armazena lista de membros e metadados
-- **Diretório da lista de tarefas**: `~/.claude/tasks/{team-name}/` — lista de tarefas compartilhada para todos os integrantes
+Após a criação, dispare colegas com `Agent` usando `team_name: "refactor-crew"` e valores distintos de `name` como `db-lead`, `migrations` e `tests`.
 
-Equipes têm correspondência 1:1 com listas de tarefas.
+### Exemplo 2: Criar uma equipe de investigação
 
-## Fluxo de trabalho da equipe
+```
+TeamCreate(
+  team_name="perf-investigation",
+  description="Identify and rank the top three performance regressions introduced in the last release.",
+  agent_type="Explore"
+)
+```
 
-1. **TeamCreate** — criar a equipe e sua lista de tarefas
-2. **TaskCreate** — definir tarefas para a equipe
-3. **Agent** (com `team_name` + `name`) — iniciar integrantes que entram na equipe
-4. **TaskUpdate** — atribuir tarefas aos integrantes via `owner`
-5. Integrantes trabalham nas tarefas e se comunicam via **SendMessage**
-6. Encerrar integrantes ao concluir, depois **TeamDelete** para limpeza
+Cada colega disparado herda `Explore` como persona padrão, combinando com a natureza investigativa e somente leitura do trabalho.
 
-## Ferramentas relacionadas
+## Observações
 
-| Ferramenta | Finalidade |
-|------------|------------|
-| `TeamDelete` | Remover equipe e diretórios de tarefas |
-| `SendMessage` | Comunicação entre agents dentro da equipe |
-| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Gerenciar a lista de tarefas compartilhada |
-| `Agent` | Iniciar integrantes que entram na equipe |
+- Apenas uma equipe pode ser liderada por vez em uma dada sessão. Finalize ou exclua a equipe atual antes de criar outra.
+- Uma equipe tem relação 1:1 com uma lista de tarefas compartilhada. O líder é dono da criação, atribuição e fechamento de tarefas; colegas atualizam o status das tarefas em que estão trabalhando.
+- A configuração da equipe é persistida em `~/.claude/teams/{team_name}/config.json`, e o diretório de tarefas fica junto. Esses arquivos sobrevivem entre sessões até serem explicitamente removidos com `TeamDelete`.
+- Colegas são disparados usando a ferramenta `Agent` com `team_name` correspondente mais um `name` distinto. O `name` torna-se o endereço usado por `SendMessage`.
+- Escolha um `team_name` que seja seguro para sistema de arquivos (letras, dígitos, hífens, underscores). Evite espaços ou barras.
+- Escreva a `description` para que um colega totalmente novo, lendo-a do zero, entenda o objetivo da equipe sem mais contexto. Ela se torna parte do prompt de inicialização de cada colega.

package/concepts/pt-BR/Tool-TeamDelete.md

@@ -1,30 +1,44 @@
 # TeamDelete
 
-## Definição
+Desmonta a equipe atualmente ativa, removendo seu diretório de configuração e diretório de tarefas compartilhadas. Esta é a contraparte de limpeza para `TeamCreate` e é tipicamente chamada depois que o objetivo da equipe foi alcançado e todos os colegas foram encerrados.
 
-Remove uma equipe e seus diretórios de tarefas associados quando o trabalho de colaboração multi-agent é concluído. Esta é a contrapartida de limpeza do TeamCreate.
+## Quando usar
 
-## Comportamento
+- A equipe concluiu seu trabalho e o relatório final foi entregue ao usuário.
+- A equipe foi criada por engano ou seu escopo mudou tão drasticamente que começar do zero é mais limpo do que continuar.
+- Você precisa criar uma nova equipe, mas uma já está ativa — exclua a antiga primeiro, já que apenas uma equipe pode ser liderada por vez.
+- Uma equipe ficou obsoleta entre sessões e seu estado persistido sob `~/.claude/teams/` não é mais necessário.
 
-- Remove o diretório da equipe: `~/.claude/teams/{team-name}/`
-- Remove o diretório de tarefas: `~/.claude/tasks/{team-name}/`
-- Limpa o contexto da equipe da sessão atual
+NÃO chame enquanto colegas de equipe ainda estão rodando — desligue-os primeiro via `SendMessage` com um `shutdown_request`, espere cada `shutdown_response` e então exclua.
 
-**Importante**: TeamDelete falhará se a equipe ainda tiver integrantes ativos. Os integrantes devem ser encerrados graciosamente primeiro via solicitações de shutdown do SendMessage.
+## Parâmetros
 
-## Uso típico
+`TeamDelete` não recebe parâmetros em sua invocação típica. Opera sobre a equipe atualmente ativa de propriedade da sessão que chama.
 
-TeamDelete é chamado no final de um fluxo de trabalho de equipe:
+## Exemplos
 
-1. Todas as tarefas estão concluídas
-2. Integrantes são encerrados via `SendMessage` com `shutdown_request`
-3. **TeamDelete** remove os diretórios de equipe e tarefas
+### Exemplo 1: Encerramento rotineiro após sucesso
 
-## Ferramentas relacionadas
+1. Faça broadcast de um pedido de encerramento para a equipe:
+   ```
+   SendMessage(to="*", message={ "type": "shutdown_request" })
+   ```
+2. Espere cada colega responder com um `shutdown_response`.
+3. Chame `TeamDelete()` para remover o diretório da equipe e o diretório de tarefas.
 
-| Ferramenta | Finalidade |
-|------------|------------|
-| `TeamCreate` | Criar uma nova equipe e sua lista de tarefas |
-| `SendMessage` | Comunicar com integrantes / enviar solicitações de shutdown |
-| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Gerenciar a lista de tarefas compartilhada |
-| `Agent` | Iniciar integrantes que entram na equipe |
+### Exemplo 2: Substituindo uma equipe mal configurada
+
+Se `TeamCreate` foi chamado com o `agent_type` ou `description` errados, primeiro garanta que nenhum colega foi disparado ainda (ou desligue-os), então:
+
+```
+TeamDelete()
+TeamCreate(team_name="...", description="...", agent_type="...")
+```
+
+## Observações
+
+- `TeamDelete` falha se qualquer colega ainda estiver ativo. A resposta de erro lista os colegas ativos — envie a cada um um `shutdown_request` via `SendMessage`, aguarde o `shutdown_response` e tente novamente.
+- A exclusão é irreversível do ponto de vista da ferramenta. A configuração da equipe em `~/.claude/teams/{team_name}/config.json` e seu diretório de tarefas são removidos do disco. Se precisar preservar a lista de tarefas, exporte ou copie o diretório antes de excluir.
+- Apenas a sessão líder que criou a equipe pode excluí-la. Um colega disparado não pode chamar `TeamDelete` em sua própria equipe.
+- Excluir a equipe não reverte quaisquer mudanças de sistema de arquivos que os colegas fizeram no repositório. Essas são edições comuns rastreadas pelo git e devem ser revertidas separadamente se indesejadas.
+- Depois que `TeamDelete` retorna com sucesso, a sessão está livre para chamar `TeamCreate` novamente para uma nova equipe.