cc-viewer 1.6.182 → 1.6.183

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

@@ -1,56 +1,41 @@
 # Read
 
-## Definição
+Carrega o conteúdo de um único arquivo do sistema de arquivos local. Suporta texto comum, código fonte, imagens, PDFs e notebooks Jupyter, retornando resultados com números de linha começando em 1 no estilo `cat -n`.
 
-Lê conteúdo de arquivo do sistema de arquivos local. Suporta arquivos de texto, imagens, PDF e Jupyter notebook.
+## Quando usar
+
+- Ler um arquivo fonte em um caminho conhecido antes de editar ou analisar
+- Inspecionar arquivos de configuração, lockfiles, logs ou artefatos gerados
+- Visualizar screenshots ou diagramas que o usuário colou na conversa
+- Extrair um intervalo específico de páginas de um manual em PDF longo
+- Abrir um notebook `.ipynb` para revisar células de código, markdown e outputs de células em conjunto
 
 ## Parâmetros
 
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `file_path` | string | Sim | Caminho absoluto do arquivo |
-| `offset` | number | Não | Número da linha inicial (para leitura segmentada de arquivos grandes) |
-| `limit` | number | Não | Número de linhas a ler (para leitura segmentada de arquivos grandes) |
-| `pages` | string | Não | Intervalo de páginas do PDF (ex: "1-5", "3", "10-20"), aplicável apenas a PDF |
+- `file_path` (string, obrigatório): Caminho absoluto do arquivo alvo. Caminhos relativos são rejeitados.
+- `offset` (integer, opcional): Número de linha (começando em 1) para começar a ler. Útil para arquivos grandes quando pareado com `limit`.
+- `limit` (integer, opcional): Número máximo de linhas a retornar a partir de `offset`. O padrão é 2000 linhas do topo do arquivo quando omitido.
+- `pages` (string, opcional): Intervalo de páginas para arquivos PDF, por exemplo `"1-5"`, `"3"` ou `"10-20"`. Obrigatório para PDFs com mais de 10 páginas; máximo de 20 páginas por requisição.
+
+## Exemplos
+
+### Exemplo 1: Ler um arquivo pequeno inteiro
+Chame `Read` apenas com `file_path` definido como `/Users/me/project/src/index.ts`. Até 2000 linhas são retornadas com números de linha, o que geralmente é suficiente para contexto de edição.
 
-## Cenários de Uso
+### Exemplo 2: Paginar por um log longo
+Use `offset: 5001` e `limit: 500` em um arquivo de log de muitos milhares de linhas para recuperar uma janela estreita sem desperdiçar tokens de contexto.
 
-**Adequado para:**
-- Ler arquivos de código, configuração e outros arquivos de texto
-- Visualizar arquivos de imagem (Claude é um modelo multimodal)
-- Ler documentos PDF
-- Ler Jupyter notebooks (retorna todas as células e saídas)
-- Ler múltiplos arquivos em paralelo para obter contexto
+### Exemplo 3: Extrair páginas específicas de PDF
+Para um PDF de 120 páginas em `/tmp/spec.pdf`, defina `pages: "8-15"` para extrair apenas o capítulo de que você precisa. Omitir `pages` em um PDF grande produz um erro.
 
-**Não adequado para:**
-- Ler diretórios — deve usar o comando `ls` do Bash
-- Exploração aberta da base de código — deve usar Task (tipo Explore)
+### Exemplo 4: Visualizar uma imagem
+Passe o caminho absoluto de um screenshot PNG ou JPG. A imagem é renderizada visualmente para que o Claude Code possa raciocinar sobre ela diretamente.
 
 ## Observações
 
-- O caminho deve ser absoluto, não relativo
-- Por padrão, lê as primeiras 2000 linhas do arquivo
-- Linhas com mais de 2000 caracteres serão truncadas
-- A saída usa formato `cat -n`, com números de linha começando em 1
-- PDFs grandes (mais de 10 páginas) devem especificar o parâmetro `pages`, máximo de 20 páginas por vez
-- Ler um arquivo inexistente retorna erro (não causa crash)
-- Pode chamar múltiplos Read em paralelo em uma única mensagem
-
-## Texto original
-
-<textarea readonly>Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-
-Usage:
-- The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- Any lines longer than 2000 characters will be truncated
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
-- This tool can read PDF files (.pdf). For large PDFs (more than 10 pages), you MUST provide the pages parameter to read specific page ranges (e.g., pages: "1-5"). Reading a large PDF without the pages parameter will fail. Maximum 20 pages per request.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
-- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
-- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
-- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.</textarea>
+- Sempre prefira caminhos absolutos. Se o usuário fornecer um, confie nele como está.
+- Linhas com mais de 2000 caracteres são truncadas; trate o conteúdo retornado como possivelmente cortado para dados extremamente largos.
+- Lendo múltiplos arquivos independentes? Dispare várias chamadas `Read` na mesma resposta para que rodem em paralelo.
+- `Read` não pode listar diretórios. Use uma chamada `Bash` `ls` ou a ferramenta `Glob` em vez disso.
+- Ler um arquivo existente, mas vazio retorna um aviso de sistema em vez de bytes do arquivo, então trate esse sinal explicitamente.
+- Um `Read` bem-sucedido é necessário antes de você poder usar `Edit` no mesmo arquivo na sessão atual.

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

@@ -0,0 +1,73 @@
+# RemoteTrigger
+
+Chama a API de gatilhos remotos do claude.ai para gerenciar tarefas agendadas e execuções de gatilho sob demanda. O token OAuth é tratado internamente pela ferramenta e nunca é exposto ao modelo ou ao shell.
+
+## Quando usar
+
+- Gerenciar agentes remotos (gatilhos) no claude.ai, incluindo listagem, inspeção e atualização dos gatilhos existentes
+- Criar uma nova tarefa automatizada baseada em cron que execute um agente Claude em um agendamento recorrente
+- Disparar um gatilho existente sob demanda sem aguardar a próxima execução agendada
+- Listar ou auditar todos os gatilhos atuais para revisar sua configuração e status
+- Atualizar configurações de gatilho, como agendamento, carga útil ou descrição, sem precisar recriar o gatilho
+
+## Parâmetros
+
+- `action` (string, obrigatório): a operação a executar — um de `list`, `get`, `create`, `update` ou `run`
+- `trigger_id` (string, obrigatório para `get`, `update` e `run`): o identificador do gatilho a ser operado; deve corresponder ao padrão `^[\w-]+$` (apenas caracteres de palavra e hífens)
+- `body` (object, obrigatório para `create` e `update`; opcional para `run`): a carga útil da requisição enviada à API
+
+## Exemplos
+
+### Exemplo 1: listar todos os gatilhos
+
+```json
+{
+  "action": "list"
+}
+```
+
+Chama `GET /v1/code/triggers` e retorna um array JSON de todos os gatilhos associados à conta autenticada.
+
+### Exemplo 2: criar um novo gatilho que é executado toda manhã de dia útil
+
+```json
+{
+  "action": "create",
+  "body": {
+    "name": "weekday-morning-report",
+    "schedule": "0 8 * * 1-5",
+    "description": "Gerar um resumo diário em cada dia útil às 08:00 UTC"
+  }
+}
+```
+
+Chama `POST /v1/code/triggers` com o corpo fornecido e retorna o objeto do gatilho recém-criado, incluindo o `trigger_id` atribuído.
+
+### Exemplo 3: disparar um gatilho sob demanda
+
+```json
+{
+  "action": "run",
+  "trigger_id": "my-report-trigger"
+}
+```
+
+Chama imediatamente `POST /v1/code/triggers/my-report-trigger/run`, ignorando o horário agendado.
+
+### Exemplo 4: buscar um único gatilho
+
+```json
+{
+  "action": "get",
+  "trigger_id": "my-report-trigger"
+}
+```
+
+Chama `GET /v1/code/triggers/my-report-trigger` e retorna a configuração completa do gatilho.
+
+## Observações
+
+- O token OAuth é injetado em processo pela ferramenta — nunca copie, cole ou registre tokens manualmente; fazer isso cria um risco de segurança e é desnecessário ao usar esta ferramenta.
+- Prefira esta ferramenta em vez de `curl` puro ou outros clientes HTTP para todas as chamadas à API de gatilhos; o uso direto de HTTP ignora a injeção segura do token e pode expor credenciais.
+- A ferramenta retorna a resposta JSON bruta da API; o chamador é responsável por analisar a resposta e tratar os códigos de status de erro.
+- O valor de `trigger_id` deve corresponder ao padrão `^[\w-]+$` — apenas caracteres alfanuméricos, sublinhados e hífens são permitidos; espaços ou caracteres especiais farão com que a requisição falhe.

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

@@ -0,0 +1,56 @@
+# ScheduleWakeup
+
+Agenda quando retomar o trabalho no modo dinâmico `/loop`. A ferramenta permite que o Claude gerencie autonomamente o ritmo das iterações de uma tarefa, dormindo pelo intervalo escolhido e depois disparando novamente com o mesmo prompt do loop.
+
+## Quando usar
+
+- Para autogerenciar o ritmo de uma tarefa dinâmica `/loop` onde o intervalo de iteração depende do estado do trabalho em vez de um relógio fixo
+- Para aguardar a conclusão de uma compilação longa, implantação ou execução de testes antes de verificar os resultados
+- Para inserir ticks ociosos entre iterações quando não há sinal específico para monitorar no momento
+- Para executar um loop autônomo sem prompt do usuário — passe o sentinel literal `<<autonomous-loop-dynamic>>` como `prompt`
+- Para sondar um processo cujo estado está prestes a mudar (use um atraso curto para manter o cache quente)
+
+## Parâmetros
+
+- `delaySeconds` (número, obrigatório): Segundos até a retomada. O runtime limita automaticamente o valor a `[60, 3600]`, portanto a limitação manual não é necessária.
+- `reason` (string, obrigatório): Uma frase curta explicando o atraso escolhido. Exibida ao usuário e registrada na telemetria. Seja específico — "verificando compilação longa do bun" é mais útil do que "aguardando."
+- `prompt` (string, obrigatório): O input `/loop` a disparar ao acordar. Passe a mesma string em cada turno para que o próximo disparo repita a tarefa. Para um loop autônomo sem prompt do usuário, passe o sentinel literal `<<autonomous-loop-dynamic>>`.
+
+## Exemplos
+
+### Exemplo 1: atraso curto para verificar novamente um sinal que muda rapidamente (manter o cache quente)
+
+Uma compilação acabou de ser iniciada e normalmente termina em dois a três minutos.
+
+```json
+{
+  "delaySeconds": 120,
+  "reason": "verificando compilação do bun com conclusão esperada em ~2 min",
+  "prompt": "verificar status da compilação e relatar erros"
+}
+```
+
+120 segundos mantém o contexto da conversa no cache de prompts da Anthropic (TTL 5 min), tornando o próximo acordar mais rápido e barato.
+
+### Exemplo 2: tick ocioso longo (aceitar cache miss, amortizar em uma espera mais longa)
+
+Uma migração de banco de dados está em execução e normalmente leva 20–40 minutos.
+
+```json
+{
+  "delaySeconds": 1200,
+  "reason": "migração normalmente leva 20–40 min; verificando em 20 min",
+  "prompt": "verificar status da migração e continuar se concluída"
+}
+```
+
+O cache estará frio ao acordar, mas a espera de 20 minutos amortiza com folga o custo do único cache miss. Sondar a cada 5 minutos pagaria o mesmo custo de miss 4 vezes sem nenhum benefício.
+
+## Observações
+
+- **TTL de cache de 5 minutos**: O cache de prompts da Anthropic expira após 300 segundos. Atrasos abaixo de 300 s mantêm o contexto quente; atrasos acima de 300 s incorrem em cache miss no próximo acordar.
+- **Evite exatamente 300 s**: É o pior dos dois mundos — você paga o cache miss sem obter uma espera significativamente mais longa. Ou reduza para 270 s (manter cache quente) ou comprometa-se com 1200 s ou mais (um miss compra uma espera muito mais longa).
+- **Padrão para ticks ociosos**: Quando não há sinal específico para monitorar, use **1200–1800 s** (20–30 min). Isso permite que o loop verifique periodicamente sem queimar o cache 12 vezes por hora sem motivo.
+- **Limitação automática**: O runtime limita `delaySeconds` a `[60, 3600]`. Valores abaixo de 60 tornam-se 60; valores acima de 3600 tornam-se 3600. Não é necessário tratar esses limites manualmente.
+- **Omita a chamada para encerrar o loop**: Se você pretende parar as iterações, não chame ScheduleWakeup. Simplesmente omitir a chamada encerra o loop.
+- **Passe o mesmo `prompt` a cada turno**: O campo `prompt` deve conter a instrução `/loop` original em cada invocação para que o próximo acordar saiba qual tarefa retomar.

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

@@ -1,41 +1,68 @@
 # SendMessage
 
-## Definição
+Entrega uma mensagem de um membro da equipe para outro dentro de uma equipe ativa, ou faz broadcast para todos os colegas de uma vez. Este é o único canal que os colegas de equipe podem ouvir — qualquer coisa escrita na saída de texto normal é invisível para eles.
 
-Envia mensagens entre agents dentro de uma equipe. Usado para comunicação direta, broadcast e mensagens de protocolo (solicitações/respostas de encerramento, aprovação de planos).
+## Quando usar
+
+- Atribuir uma tarefa ou repassar um subproblema para um colega de equipe nomeado durante a colaboração em equipe.
+- Solicitar status, achados intermediários ou uma revisão de código de outro agente.
+- Transmitir uma decisão, restrição compartilhada ou anúncio de encerramento para toda a equipe via `*`.
+- Responder a um prompt de protocolo, como um pedido de encerramento ou um pedido de aprovação de plano do líder da equipe.
+- Fechar o ciclo ao final de uma tarefa delegada para que o líder possa marcar o item como completo.
 
 ## Parâmetros
 
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|-----------|------|-------------|-----------|
-| `to` | string | Sim | Destinatário: nome do integrante, ou `"*"` para broadcast a todos |
-| `message` | string / object | Sim | Mensagem de texto ou objeto de protocolo estruturado |
-| `summary` | string | Não | Prévia de 5-10 palavras exibida na interface |
+- `to` (string, obrigatório): O `name` do colega de equipe alvo registrado na equipe, ou `*` para fazer broadcast para todos os colegas de uma vez.
+- `message` (string ou object, obrigatório): Texto comum para comunicação normal, ou um objeto estruturado para respostas de protocolo como `shutdown_response` e `plan_approval_response`.
+- `summary` (string, opcional): Um preview de 5–10 palavras mostrado no log de atividade da equipe para mensagens de texto comum. Obrigatório para mensagens longas em string; ignorado quando `message` é um objeto de protocolo.
+
+## Exemplos
+
+### Exemplo 1: Repasse direto de tarefa
+
+```
+SendMessage(
+  to="db-lead",
+  message="Please audit prisma/schema.prisma and list any model missing createdAt/updatedAt timestamps. Reply when done.",
+  summary="Audit schema for missing timestamps"
+)
+```
 
-## Tipos de mensagem
+### Exemplo 2: Broadcast de uma restrição compartilhada
 
-### Texto simples
-Mensagens diretas entre integrantes para coordenação, atualizações de status e discussões sobre tarefas.
+```
+SendMessage(
+  to="*",
+  message="Reminder: do not touch files under legacy/ — that subtree is frozen until the migration PR lands.",
+  summary="Freeze legacy/ during migration"
+)
+```
 
-### Solicitação de encerramento
-Solicita que um integrante encerre de forma ordenada: `{ type: "shutdown_request", reason: "..." }`
+### Exemplo 3: Resposta de protocolo
 
-### Resposta de encerramento
-O integrante aprova ou rejeita o encerramento: `{ type: "shutdown_response", approve: true/false }`
+Responda a um pedido de encerramento do líder usando uma mensagem estruturada:
 
-### Resposta de aprovação de plano
-Aprova ou rejeita o plano de um integrante: `{ type: "plan_approval_response", approve: true/false }`
+```
+SendMessage(
+  to="leader",
+  message={ "type": "shutdown_response", "ready": true, "final_report": "All assigned diff chunks committed on branch refactor-crew/db-lead." }
+)
+```
 
-## Broadcast vs. Direto
+### Exemplo 4: Resposta de aprovação de plano
 
-- **Direto** (`to: "nome-do-integrante"`): Enviar a um integrante específico — preferido para a maioria das comunicações
-- **Broadcast** (`to: "*"`): Enviar a todos os integrantes — usar com moderação, apenas para anúncios críticos em nível de equipe
+```
+SendMessage(
+  to="leader",
+  message={ "type": "plan_approval_response", "approved": true, "notes": "LGTM, but please split step 4 into migration + backfill." }
+)
+```
 
-## Ferramentas relacionadas
+## Observações
 
-| Ferramenta | Finalidade |
-|------------|------------|
-| `TeamCreate` | Criar uma nova equipe |
-| `TeamDelete` | Remover equipe ao concluir |
-| `Agent` | Iniciar integrantes que entram na equipe |
-| `TaskCreate` / `TaskUpdate` / `TaskList` | Gerenciar a lista de tarefas compartilhada |
+- Sua saída de texto comum do assistente NÃO é transmitida para colegas de equipe. Se você quer que outro agente veja algo, precisa passar por `SendMessage`. Este é o erro mais comum em workflows de equipe.
+- Broadcast (`to: "*"`) é caro — ele acorda todo colega de equipe e consome o contexto deles. Reserve-o para anúncios que afetam genuinamente a todos. Prefira envios direcionados.
+- Mantenha mensagens concisas e orientadas à ação. Inclua os caminhos de arquivo, restrições e formato de resposta esperado que o destinatário precisa; lembre-se de que eles não têm memória compartilhada com você.
+- Objetos de mensagem de protocolo (`shutdown_response`, `plan_approval_response`) têm formas fixas. Não misture campos de protocolo em mensagens de texto comum ou vice-versa.
+- Mensagens são assíncronas. O destinatário receberá a sua no próximo turno dele; não presuma que leu ou agiu sobre ela até que responda.
+- Um `summary` bem escrito torna o log de atividade da equipe fácil de examinar para o líder — trate-o como o assunto de um commit.

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

@@ -1,56 +1,47 @@
 # Skill
 
-## Definição
+Invoca uma skill nomeada dentro da conversa atual. Skills são pacotes pré-configurados de capacidades — conhecimento de domínio, workflows e, às vezes, acesso a ferramentas — que o harness expõe ao assistente via avisos de sistema.
 
-Executa uma skill (habilidade) na conversa principal. Skills são capacidades especializadas que o usuário pode invocar através de slash commands (ex: `/commit`, `/review-pr`).
+## Quando usar
 
-## Parâmetros
+- O usuário digita um slash command como `/review` ou `/init` — slash commands são skills e devem ser executadas por esta ferramenta.
+- O usuário descreve uma tarefa que corresponde às condições de gatilho de uma skill anunciada (por exemplo, pedir para escanear transcripts em busca de prompts de permissão repetidos corresponde a `fewer-permission-prompts`).
+- O propósito declarado de uma skill é uma correspondência direta para o arquivo, pedido ou contexto da conversa atual.
+- Workflows especializados e repetíveis estão disponíveis como skills e o procedimento canônico é preferível a uma abordagem ad hoc.
+- O usuário pergunta "quais skills estão disponíveis" — liste os nomes anunciados e invoque apenas quando confirmarem.
 
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `skill` | string | Sim | Nome da skill (ex: "commit", "review-pr", "pdf") |
-| `args` | string | Não | Argumentos da skill |
+## Parâmetros
 
-## Cenários de Uso
+- `skill` (string, obrigatório): O nome exato de uma skill listada no aviso atual de skills disponíveis. Para skills com namespace de plugin, use o formato totalmente qualificado `plugin:skill` (por exemplo `skill-creator:skill-creator`). Não inclua barra inicial.
+- `args` (string, opcional): Argumentos em texto livre passados para a skill. O formato e a semântica são definidos pela documentação de cada skill.
 
-**Adequado para:**
-- O usuário digitou um slash command no formato `/<skill-name>`
-- A solicitação do usuário corresponde à funcionalidade de uma skill registrada
+## Exemplos
 
-**Não adequado para:**
-- Comandos CLI integrados (ex: `/help`, `/clear`)
-- Skills que já estão em execução
-- Nomes de skills que não estão na lista de skills disponíveis
+### Exemplo 1: Executar uma skill de revisão na branch atual
 
-## Observações
+```
+Skill(skill="review")
+```
 
-- Após ser invocada, a skill se expande em um prompt completo
-- Suporta nomes totalmente qualificados (ex: `ms-office-suite:pdf`)
-- A lista de skills disponíveis é fornecida nas mensagens system-reminder
-- Quando a tag `<command-name>` é vista, significa que a skill já foi carregada e deve ser executada diretamente sem chamar esta ferramenta novamente
-- Não mencione uma skill sem realmente invocar a ferramenta
+A skill `review` empacota os passos para revisar um pull request contra a branch base atual. Invocá-la carrega o procedimento de revisão definido no harness no turno.
 
-## Texto original
+### Exemplo 2: Invocar uma skill com namespace de plugin com argumentos
 
-<textarea readonly>Execute a skill within the main conversation
+```
+Skill(
+  skill="skill-creator:skill-creator",
+  args="create a skill that summarizes git log for a given date range"
+)
+```
 
-When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+Roteia o pedido pelo ponto de entrada do plugin `skill-creator` para que o workflow de autoria seja acionado.
 
-When users reference a "slash command" or "/<something>" (e.g., "/commit", "/review-pr"), they are referring to a skill. Use this tool to invoke it.
-
-How to invoke:
-- Use this tool with the skill name and optional arguments
-- Examples:
-  - `skill: "pdf"` - invoke the pdf skill
-  - `skill: "commit", args: "-m 'Fix bug'"` - invoke with arguments
-  - `skill: "review-pr", args: "123"` - invoke with arguments
-  - `skill: "ms-office-suite:pdf"` - invoke using fully qualified name
+## Observações
 
-Important:
-- Available skills are listed in system-reminder messages in the conversation
-- When a skill matches the user's request, this is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
-- NEVER mention a skill without actually calling this tool
-- Do not invoke a skill that is already running
-- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
-- If you see a <command-name> tag in the current conversation turn, the skill has ALREADY been loaded - follow the instructions directly instead of calling this tool again
-</textarea>
+- Invoque apenas skills cujos nomes aparecem literalmente no aviso de sistema de skills disponíveis, ou skills que o usuário digitou diretamente como `/name` em sua mensagem. Nunca adivinhe ou invente nomes de skill a partir de memória ou dados de treinamento — se a skill não está anunciada, não chame esta ferramenta.
+- Quando o pedido de um usuário corresponde a uma skill anunciada, chamar `Skill` é pré-requisito bloqueante: invoque-a antes de gerar qualquer outra resposta sobre a tarefa. Não descreva o que a skill faria — execute-a.
+- Nunca mencione uma skill pelo nome sem realmente invocá-la. Anunciar uma skill sem chamar a ferramenta é enganoso.
+- Não use `Skill` para comandos de CLI embutidos como `/help`, `/clear`, `/model` ou `/exit`. Esses são tratados diretamente pelo harness.
+- Não reinvoque uma skill que já está rodando no turno atual. Se você ver uma tag `<command-name>` no turno atual, a skill já foi carregada — siga suas instruções no local em vez de chamar a ferramenta de novo.
+- Se várias skills puderem se aplicar, escolha a mais específica. Para mudanças de configuração como adicionar permissões ou hooks, prefira `update-config` em vez de uma abordagem genérica de settings.
+- A execução de uma skill pode introduzir novos avisos de sistema, ferramentas ou restrições para o restante do turno. Releia o estado da conversa depois que uma skill terminar antes de prosseguir.

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

@@ -1,78 +1,56 @@
 # TaskCreate
 
-## Definição
+Cria uma nova tarefa na lista de tarefas da equipe atual (ou na lista de tarefas da sessão quando nenhuma equipe está ativa). Use-o para capturar itens de trabalho que devem ser rastreados, delegados ou revisitados depois.
 
-Cria entradas estruturadas na lista de tarefas, para rastrear progresso, organizar tarefas complexas e mostrar o andamento do trabalho ao usuário.
+## Quando usar
 
-## Parâmetros
-
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `subject` | string | Sim | Título curto da tarefa, usar forma imperativa (ex: "Fix authentication bug") |
-| `description` | string | Sim | Descrição detalhada, incluindo contexto e critérios de aceitação |
-| `activeForm` | string | Não | Texto no gerúndio exibido quando em andamento (ex: "Fixing authentication bug") |
-| `metadata` | object | Não | Metadados arbitrários anexados à tarefa |
-
-## Cenários de Uso
-
-**Adequado para:**
-- Tarefas complexas de múltiplas etapas (mais de 3 etapas)
-- O usuário forneceu múltiplos itens a fazer
-- Rastrear trabalho no modo de planejamento
-- O usuário solicitou explicitamente o uso de lista de tarefas
-
-**Não adequado para:**
-- Tarefa única e simples
-- Operações simples de até 3 etapas
-- Consultas puramente conversacionais ou informativas
+- O usuário descreve um trabalho de múltiplos passos que se beneficia de rastreamento explícito.
+- Você está quebrando um grande pedido em unidades menores que podem ser concluídas separadamente.
+- Um acompanhamento é descoberto no meio de uma tarefa e não deve ser esquecido.
+- Você precisa de um registro durável de intenção antes de repassar o trabalho a um colega ou subagente.
+- Você está operando em modo de plano e quer que cada passo do plano seja representado como uma tarefa concreta.
 
-## Observações
-
-- Todas as tarefas criadas têm status inicial `pending`
-- `subject` usa forma imperativa ("Run tests"), `activeForm` usa gerúndio ("Running tests")
-- Após criar a tarefa, pode-se definir dependências (blocks/blockedBy) via TaskUpdate
-- Antes de criar, deve-se chamar TaskList para verificar se há tarefas duplicadas
-
-## Texto original
+Evite `TaskCreate` para ações triviais de passo único, conversa pura ou qualquer coisa que possa ser concluída em duas ou três chamadas diretas de ferramenta.
 
-<textarea readonly>Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
+## Parâmetros
 
-## When to Use This Tool
+- `subject` (string, obrigatório): Título curto imperativo, por exemplo `Fix login redirect on Safari`. Mantenha abaixo de cerca de oitenta caracteres.
+- `description` (string, obrigatório): Contexto detalhado — o problema, as restrições, critérios de aceitação e quaisquer arquivos ou links que um leitor futuro precisará. Escreva como se um colega fosse pegar isso do zero.
+- `activeForm` (string, opcional): Texto do spinner em gerúndio mostrado enquanto a tarefa está `in_progress`, por exemplo `Fixing login redirect on Safari`. Espelhe o `subject`, mas no gerúndio.
+- `metadata` (object, opcional): Dados estruturados arbitrários anexados à tarefa. Usos comuns: labels, dicas de prioridade, IDs de tickets externos ou configuração específica do agente.
 
-Use this tool proactively in these scenarios:
+Tarefas recém-criadas sempre começam com status `pending` e sem owner. Dependências (`blocks`, `blockedBy`) não são definidas no momento da criação — aplique-as depois com `TaskUpdate`.
 
-- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-- Plan mode - When using plan mode, create a task list to track the work
-- User explicitly requests todo list - When the user directly asks you to use the todo list
-- User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-- After receiving new instructions - Immediately capture user requirements as tasks
-- When you start working on a task - Mark it as in_progress BEFORE beginning work
-- After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+## Exemplos
 
-## When NOT to Use This Tool
+### Exemplo 1
 
-Skip using this tool when:
-- There is only a single, straightforward task
-- The task is trivial and tracking it provides no organizational benefit
-- The task can be completed in less than 3 trivial steps
-- The task is purely conversational or informational
+Capturar um relatório de bug que o usuário acabou de submeter.
 
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+```
+TaskCreate(
+  subject: "Repair broken PDF export on Windows",
+  description: "Users on Windows 11 report the export button produces a 0-byte file. Reproduce with sample doc in test/fixtures/export/, then fix the code path in src/export/pdf.ts. Acceptance: export writes a valid PDF and the existing export test suite passes.",
+  activeForm: "Repairing broken PDF export on Windows"
+)
+```
 
-## Task Fields
+### Exemplo 2
 
-- **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
-- **description**: Detailed description of what needs to be done, including context and acceptance criteria
-- **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
+Dividir um épico em unidades rastreadas no início de uma sessão.
 
-**IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status `pending`.
+```
+TaskCreate(
+  subject: "Draft migration plan for auth service",
+  description: "Produce a written plan covering rollout stages, rollback strategy, and monitoring. Output: docs/auth-migration.md.",
+  activeForm: "Drafting migration plan for auth service",
+  metadata: { "priority": "P1", "linearId": "AUTH-214" }
+)
+```
 
-## Tips
+## Observações
 
-- Create tasks with clear, specific subjects that describe the outcome
-- Include enough detail in the description for another agent to understand and complete the task
-- After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
-- Check TaskList first to avoid creating duplicate tasks
-</textarea>
+- Escreva o `subject` na voz imperativa e o `activeForm` no gerúndio para que a interface leia naturalmente quando a tarefa transitar para `in_progress`.
+- Chame `TaskList` antes de criar para evitar duplicatas — a lista de equipe é compartilhada com colegas e subagentes.
+- Não inclua segredos ou credenciais em `description` ou `metadata`; registros de tarefa são visíveis para qualquer um com acesso à equipe.
+- Depois da criação, mova a tarefa pelo seu ciclo de vida com `TaskUpdate`. Não deixe trabalho silenciosamente abandonado em `in_progress`.

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

@@ -1,56 +1,47 @@
 # TaskGet
 
-## Definição
+Busca o registro completo de uma única tarefa por ID, incluindo sua descrição, status atual, owner, metadata e arestas de dependência. Use quando o resumo retornado por `TaskList` não for suficiente para agir sobre a tarefa.
 
-Obtém os detalhes completos de uma tarefa através do ID da tarefa.
+## Quando usar
 
-## Parâmetros
-
-| Parâmetro | Tipo | Obrigatório | Descrição |
-|------|------|------|------|
-| `taskId` | string | Sim | ID da tarefa a obter |
-
-## Conteúdo Retornado
+- Você pegou uma tarefa de `TaskList` e precisa da descrição completa antes de começar a trabalhar.
+- Você está prestes a marcar uma tarefa como `completed` e quer reverificar os critérios de aceitação.
+- Você precisa inspecionar quais tarefas esta `blocks` ou é `blockedBy` para decidir o próximo passo.
+- Você está investigando histórico — quem é o owner, que metadata foi anexada, quando mudou de estado.
+- Um colega ou sessão anterior referenciou um ID de tarefa e você precisa do contexto.
 
-- `subject` — Título da tarefa
-- `description` — Requisitos detalhados e contexto
-- `status` — Status: `pending`, `in_progress` ou `completed`
-- `blocks` — Lista de tarefas bloqueadas por esta tarefa
-- `blockedBy` — Lista de tarefas pré-requisito que bloqueiam esta tarefa
+Prefira `TaskList` quando só precisa de uma varredura de alto nível; reserve `TaskGet` para o registro específico que você pretende ler com cuidado ou modificar.
 
-## Cenários de Uso
+## Parâmetros
 
-**Adequado para:**
-- Obter a descrição completa e contexto da tarefa antes de iniciar o trabalho
-- Entender as dependências da tarefa
-- Obter requisitos completos após ser atribuído a uma tarefa
+- `taskId` (string, obrigatório): O identificador da tarefa retornado por `TaskCreate` ou `TaskList`. IDs são estáveis durante toda a vida da tarefa.
 
-## Observações
+## Exemplos
 
-- Após obter a tarefa, deve-se verificar se a lista `blockedBy` está vazia antes de iniciar o trabalho
-- Use TaskList para ver o resumo de todas as tarefas
+### Exemplo 1
 
-## Texto original
+Consultar uma tarefa que você acabou de ver na lista.
 
-<textarea readonly>Use this tool to retrieve a task by its ID from the task list.
+```
+TaskGet(taskId: "t_01HXYZ...")
+```
 
-## When to Use This Tool
+Campos típicos na resposta: `id`, `subject`, `description`, `activeForm`, `status`, `owner`, `blocks`, `blockedBy`, `metadata`, `createdAt`, `updatedAt`.
 
-- When you need the full description and context before starting work on a task
-- To understand task dependencies (what it blocks, what blocks it)
-- After being assigned a task, to get complete requirements
+### Exemplo 2
 
-## Output
+Resolver dependências antes de começar.
 
-Returns full task details:
-- **subject**: Task title
-- **description**: Detailed requirements and context
-- **status**: 'pending', 'in_progress', or 'completed'
-- **blocks**: Tasks waiting on this one to complete
-- **blockedBy**: Tasks that must complete before this one can start
+```
+TaskGet(taskId: "t_01HXYZ...")
+# Inspect blockedBy — if any referenced task is still pending
+# or in_progress, work on the blocker first.
+```
 
-## Tips
+## Observações
 
-- After fetching a task, verify its blockedBy list is empty before beginning work.
-- Use TaskList to see all tasks in summary form.
-</textarea>
+- `TaskGet` é somente leitura e seguro para chamar repetidamente; não altera status ou ownership.
+- Se `blockedBy` não estiver vazio e contém tarefas que não estão `completed`, não comece esta tarefa — resolva os bloqueadores primeiro (ou coordene com o owner deles).
+- O campo `description` pode ser longo. Leia-o completamente antes de agir; passar os olhos leva a critérios de aceitação perdidos.
+- Um `taskId` desconhecido ou excluído retorna um erro. Rode `TaskList` novamente para pegar um ID atual.
+- Se você está prestes a editar uma tarefa, chame `TaskGet` primeiro para evitar sobrescrever campos que um colega acabou de alterar.