specrails-desktop 2.64.2 → 2.65.0

package/docs/guide/pt/getting-started/3-try-the-sample-project.md

@@ -0,0 +1,35 @@
+# Experimentar o projeto de exemplo
+
+Queres ver uma spec tornar-se uma alteração revista antes de apontar o specrails ao teu próprio código? O **projeto de exemplo** é um pequeno jogo web do galo com três specs já escritas. Demora alguns minutos e termina num **pacote de revisão** real.
+
+## Começar
+
+No ecrã de boas-vindas, clica em **Experimente num projeto de exemplo** (ao lado de **Adicionar o teu primeiro projeto**). O diálogo diz-te, antes de acontecer qualquer coisa:
+
+- **O que é criado**: um pequeno jogo web no seu próprio repositório git, com três specs já no teu quadro.
+- **Onde**: por defeito `~/Specrails Samples/tic-tac-toe`, dentro da tua pasta pessoal. Podes mudar a pasta; uma pasta existente nunca é substituída.
+- **Quanto custaria uma execução**: uma estimativa como «≈ $0,30–$1 · cerca de 3–5 min». Só aparece em dólares quando o teu fornecedor fatura por utilização. Com um plano de subscrição indica que não há custo extra, e com um motor local não há custo de API.
+
+Criar o exemplo não custa nada e não executa nada. Clica em **Criar projeto de exemplo** e chegas ao Quadro.
+
+## Os três passos
+
+Um pequeno cartão guia aponta para o Quadro real, passo a passo. Podes fechá-lo a qualquer momento; reduz-se a uma pílula **Projeto de exemplo** de onde **Mostrar guia** o traz de volta.
+
+1. **A spec.** As três specs foram escritas para ti. Cada uma diz o que construir e como saber que está concluída.
+2. **O rail.** Clica em **Executar a primeira spec**. O exemplo está preparado para ser barato e limitado: modo rápido, o modelo mais barato disponível e um limite suave por execução (a execução pára e pergunta antes de ultrapassar $1). Se tiveres um motor local configurado, podes escolhê-lo, sem custo de API.
+3. **A revisão.** Nada é integrado sozinho. Quando a execução termina, um **pacote de revisão** mostra o que mudou e deixa-te aceitar ou descartar.
+
+## Nenhum fornecedor de IA pronto?
+
+Antes de te oferecer a execução, o specrails verifica se há um fornecedor instalado e com sessão iniciada. Se não houver, vês **Ver uma execução gravada**: a repetição de uma execução concluída que termina num pacote de revisão. Está claramente identificada como gravação; nada corre e nada é cobrado. Instala um fornecedor ou inicia sessão e escolhe **Verificar novamente** para passar a uma execução real.
+
+## Depois, o teu próprio projeto
+
+O guia termina com **Agora adiciona o teu próprio projeto**. Quando terminares com o exemplo, **Remover exemplo** remove-o com um clique. A pasta fica no disco, a menos que marques **Eliminar também a pasta do exemplo**, o que não pode ser desfeito.
+
+## Rever o tour da plataforma
+
+O tour já não está no ecrã de boas-vindas. Abre **Docs** e escolhe **Rever o tour**, ou abre a paleta de comandos e escreve «Rever o tour». Também está em **Definições ▸ Aparência**.
+
+Seguinte: [Adicionar o teu primeiro projeto](adding-your-first-project).

package/docs/guide/pt/getting-started/{4-the-dashboard-tour.md → 5-the-dashboard-tour.md}

@@ -37,11 +37,15 @@ Uma faixa fina percorre o fundo da janela. É pequena, mas prática:
 - **Gasto total** (à direita) — um total acumulado do que gastou, para que o custo esteja sempre a um relance de distância.
 - **Botão do terminal** (à direita ao fundo) — abre o painel de terminal integrado. Carregue em **Cmd+J** (macOS) ou **Ctrl+J** (Windows/Linux) para o alternar a qualquer momento. É uma shell completa, aberta diretamente na pasta do seu projeto.
 
-## Alguns atalhos úteis
+## Alguns atalhos úteis {#shortcuts}
 
-- **Cmd/Ctrl+B** — afixar ou recolher as barras laterais.
+- **Cmd/Ctrl+B** — afixar ou recolher a barra lateral esquerda; **Option+Cmd+B** (**Ctrl+Alt+B**) faz o mesmo com a direita.
 - **Cmd/Ctrl+J** — alternar o painel de terminal.
-- **Cmd/Ctrl+K** — abrir a pesquisa.
+- **Cmd/Ctrl+K** — a paleta de comandos: pesquise missões, projetos e jobs e **execute ações**. Digite um verbo ("nova", "lançar", "mover", "trocar") ou comece com **>** para listar ações: Nova spec (também em Explorar), Lançar ou Mover uma spec, Abrir sua revisão, Entregar ou Pausar um Flow, Nova missão, Trocar tema, Alternar entre os modos Missão e Quadro, Abrir as configurações do app ou do projeto em uma seção, Executar um loop, alternar as barras laterais, Voltar ou Avançar, Desfazer a última alteração e Excluídos recentemente. Ações que precisam de uma escolha (um rail, um status, um tema, uma seção) abrem uma segunda página; **Backspace** com a pesquisa vazia volta. Cada ação mostra seu atalho de teclado, então a paleta ensina as teclas. Ela só oferece o que funciona onde você está e segue as mesmas regras dos botões (uma spec que não pode ser lançada não é oferecida). Com a pesquisa vazia, lista suas **Ações recentes** e **Lugares recentes**.
+- **Cmd+[ / Cmd+]** (**Alt+← / Alt+→** no Windows/Linux), os botões **←  →** da barra de título ou os botões voltar/avançar do mouse — voltam ou avançam pelos lugares onde você esteve: specs, missões, jobs, projetos e painéis em tela cheia. Clique com o botão direito (ou pressione e segure) um botão para ver os últimos lugares.
+- **Cmd+Shift+I** (**Ctrl+Alt+I** no Windows e no Linux) ou o botão **Pendências** na barra de título — a lista **Pendências**: tudo o que espera por você em todos os seus projetos, numa só lista agrupada por projeto. Reúne revisões prontas para decidir, perguntas que um agente está aguardando, execuções que falharam ou ficaram bloqueadas, execuções pausadas pelo orçamento diário e atualizações do Jira que não puderam sincronizar. Cada linha tem a ação principal ali mesmo (**Abrir revisão**, **Responder**, **Retomar**, **Tentar novamente**) mais **Adiar** (1 hora ou até amanhã) e **Concluído**. Um item adiado ou concluído volta sozinho se o estado dele mudar. O botão mostra quantos itens aguardam e uma notificação de limite do provedor abre a lista. A lista também é um link (`?inbox=1`) e uma ação da paleta de comandos.
+- **M** — com um cartão de spec em foco no quadro, abre um seletor para o mover para um estado ou um rail, o equivalente de arrastar e largar com o teclado. Funciona também com uma seleção múltipla, e a paleta oferece-o como **Mover a spec em foco…**.
+- **?** — a folha de atalhos. Digite na caixa de pesquisa para filtrar os atalhos e encontrar páginas e seções deste guia, que abrem no guia sem sair da sua tela. Os pequenos ícones **ⓘ** e os links **Saiba mais** ao lado das configurações, dos rails, do Flow, do seletor de contexto e dos orçamentos abrem o guia na seção correspondente do mesmo modo.
 
 ## Para onde ir a seguir
 

package/docs/guide/pt/getting-started/6-universal-search.md

@@ -0,0 +1,34 @@
+# Busca universal (⌘K)
+
+Pressione **⌘K** (**Ctrl+K** no Windows e no Linux) para buscar quase tudo no Specrails em um só lugar: missões, specs, logs de jobs, arquivos, configurações e este guia. Digite uma consulta comum para buscar missões, projetos, specs e jobs recentes como sempre, ou comece com um **prefixo** para buscar em uma única fonte.
+
+## Prefixos
+
+| Digite | Busca | Enter abre |
+| --- | --- | --- |
+| `#` | Specs: título, resumo, descrição, etiquetas, notas de fora do escopo, adendos e comentários. `#12` encontra a spec 12. | A spec |
+| `@` | Missões: título e conteúdo da conversa. | A missão |
+| `/` | Configurações (do Desktop e do projeto) pelo nome ou pelo jeito que você as chamaria. | A janela de configurações nesse bloco, visível e com foco |
+| `f:` | Arquivos do projeto, por nome ou caminho. | O arquivo no explorador de código |
+| `log:` | Logs de jobs: comandos, nomes de loops, títulos de fases e diagnósticos de falha. | O job |
+| `?` | Este guia: títulos de páginas e cabeçalhos. | O guia nesse cabeçalho |
+
+Ao digitar um prefixo, ele vira uma **etiqueta** na caixa de busca e a caixa guarda só a sua consulta. Pressione **Backspace** com a caixa vazia (ou clique no × da etiqueta) para remover o escopo. Com a caixa vazia, a paleta lista os prefixos sob a caixa; clique em um para começar. `>` continua listando ações, como antes.
+
+## Destaques
+
+Os resultados mostram um trecho curto em torno da primeira ocorrência, com o texto correspondente destacado. A busca ignora maiúsculas e acentos, então `revisao` encontra «Revisão».
+
+## Configurações
+
+`/` conhece os principais blocos de configurações, no seu idioma: tema, idioma, editor, orçamentos, notificações, webhooks, atualizações, branch, ambiente, telemetria, regras e mais. As configurações do projeto aparecem quando há um projeto aberto. Escolha uma e a janela certa abre nesse bloco. Sem prefixo, uma correspondência forte (três ou mais caracteres) acrescenta até três configurações aos resultados normais. `/budget` também encontra o painel de Orçamento (limites, projeção, e se…), onde ficam os limites semanal e mensal. Um comando com barra, como `/implement`, aparece sob as configurações, em um grupo próprio, então o prefixo `/` nunca o esconde.
+
+## Logs de jobs
+
+`log:` busca em um índice compacto, não na saída bruta de uma execução: o comando, o nome do loop, os títulos das fases e o diagnóstico curto de uma execução que falhou, foi bloqueada ou travou. Nunca guarda fluxos de tokens nem a saída de ferramentas, então continua pequeno e rápido. É mantido por projeto e guarda as execuções mais recentes.
+
+## Bom saber
+
+- `#`, `f:` e `log:` buscam no projeto ativo; abra um projeto primeiro.
+- O escopo de arquivos respeita as regras de exclusão do explorador de código.
+- Cada grupo mostra só os melhores resultados; refine a consulta para restringir.

package/docs/guide/pt/insights/1-analytics-and-cost-tracking.md

@@ -6,15 +6,17 @@ Abra-a a partir da barra lateral direita (tem a etiqueta **Analytics**). Tudo o
 
 ## O que conta como gasto
 
-O Specrails regista cinco tipos de atividade de IA, a que chamamos *superfícies*. Cada uma tem uma cor consistente em todos os gráficos, para a identificar num relance:
+O Specrails etiqueta cada execução de IA com uma *superfície*: a parte da app que gerou o gasto. As superfícies principais têm uma cor fixa e um chip de filtro próprio, para que as identifique num relance:
 
-- **Job** — um rail de pipeline a correr Architect → Developer → Reviewer → Ship.
+- **Job** — um job do pipeline em fila (Architect → Developer → Reviewer → Ship), incluindo as execuções Freestyle.
+- **Loop** — cada passo de IA de uma execução de loop. Os rails correm como loops por omissão, por isso a maior parte do gasto dos rails aparece aqui.
 - **Quick spec** — uma spec gerada pelo caminho rápido de Add Spec.
 - **Explore spec** — uma conversa de Explore em que dá forma a uma spec à medida que conversa.
 - **AI edit** — um refinamento assistido por IA sobre um agente ou ficheiro.
-- **File summary** — os resumos em linguagem simples que dão vida ao Code explorer.
+- **SMASH** — a divisão de uma spec épica em specs mais pequenas.
+- **File summary** — os resumos em linguagem simples e as histórias de ficheiros que dão vida ao Code explorer.
 
-Há um par de coisas que, propositadamente, *não* são registadas: tanto o chat lateral como o assistente de configuração arrancam CLIs de IA, mas nunca aparecem nos seus gastos. Assim, o painel reflete trabalho real e repetível, em vez de conversa ocasional.
+Também são registadas superfícies menores, sem chip próprio: o chat da barra lateral, o lançador de specs do OpenSpec, as propostas de specs, o Agent Studio e o chat de configuração antigo. As missões fixadas ao projeto também contam para o seu gasto. Nada que execute uma CLI de IA fica de fora, por isso os totais refletem toda a atividade de IA do projeto.
 
 ## Ler o painel
 
@@ -76,3 +78,15 @@ As exportações respeitam os filtros de período e superfície que tiver aplica
 ## Sempre em direto
 
 Não precisa de atualizar a página. Quando uma nova invocação é registada em qualquer ponto do projeto, o painel aberto volta a carregar-se discretamente pouco depois, para que o medidor de consumo acompanhe o trabalho à medida que vai terminando.
+
+## Orçamentos diários {#daily-budget}
+
+Defina um orçamento diário para limitar quanto um dia pode custar. Todos os limites (diário, semanal, mensal e por execução) são editados em um único lugar: **Análises → Orçamento**. **Configurações → Avançado** e **Configurações do projeto → Orçamento** apenas mostram o limite diário atual, com um botão **Abrir Orçamento** que leva até lá.
+
+Quando o gasto registrado do dia atinge um orçamento, a fila se pausa sozinha, os rails e as execuções de loops se recusam a iniciar com *Orçamento diário atingido*, e uma execução de loop em andamento para entre etapas, pausada pelo orçamento. Aumente ou remova o orçamento, ou espere a redefinição diária, e depois retome.
+
+O orçamento do projeto conta o seu dia local; o de todo o app conta o dia UTC. O alerta de custo por job é uma configuração separada.
+
+**Limites semanais, mensais e por execução.** Os limites mais longos funcionam do mesmo jeito. Abra **Análises → Orçamento** para definir um limite **semanal** e um **mensal**, por projeto e para o app inteiro, e um **limite flexível por execução** (*pausar e perguntar em $X*). As semanas começam na segunda-feira e os meses no dia 1, no seu horário local. Um limite semanal ou mensal pausa as filas, recusa inícios e deixa em pausa os loops em andamento exatamente como o orçamento diário; aumente-o ou remova-o ali, ou espere o reinício. Quando o custo informado de uma execução chega ao limite por execução, ela pausa, e **Retomar** pergunta se deve continuar sem o limite ou aumentá-lo. Atingir qualquer limite também adiciona um item **Aumentar limite** à caixa de entrada.
+
+O painel de Orçamento mostra hoje, esta semana e este mês em relação a cada limite. A **projeção** para o fim do mês é uma estimativa (a média dos últimos 14 dias completos vezes os dias restantes, mais o que você já gastou) e nunca é somada ao gasto faturado. **E se** recalcula os últimos 30 dias de uso de tokens registrado com outro modelo, pela tabela de preços do app, e diz *Sem preço* para um modelo sem preço. Em um plano de assinatura não há custo em dólares por uso, então o painel mostra turnos e limites do plano no lugar de dólares.

package/docs/guide/pt/insights/2-the-integrated-terminal.md

@@ -1,4 +1,4 @@
-# O terminal integrado
+# O terminal integrado {#integrated-terminal}
 
 O Specrails tem um terminal a sério mesmo lá dentro — o painel que sobe a partir do fundo da janela, tal como o do VS Code ou do Cursor. Corre a sua shell real, na pasta real do seu projeto, para poder correr `git`, `npm`, testes ou o que precisar sem sair da aplicação.
 

package/docs/guide/pt/insights/3-code-explorer.md

@@ -1,4 +1,4 @@
-# Code explorer
+# Code explorer {#code-explorer}
 
 A secção **Code** dá-lhe uma janela amigável e só de leitura para o seu repositório — pensada especialmente para quem quer perceber o que a IA tem andado a construir sem viver dentro de um editor. Tem uma árvore de ficheiros à esquerda, um visualizador de código à direita e, por cima do código, um resumo em linguagem simples do que cada ficheiro faz na prática.
 

package/docs/guide/pt/integrations/1-ai-providers.md

@@ -1,4 +1,4 @@
-# Providers de IA (Claude, Codex)
+# Providers de IA (Claude, Codex) {#ai-providers}
 
 ## Os dois providers
 

package/docs/guide/pt/integrations/2-plugins.md

@@ -1,4 +1,4 @@
-# Plugins (Integrações)
+# Plugins (Integrações) {#plugins}
 
 A secção **Integrações** é um marketplace por projeto de extras opcionais que ampliam o que a IA consegue fazer. Cada projeto decide de forma independente que plugins quer — instalar um plugin num projeto nunca afeta outro.
 

package/docs/guide/pt/integrations/3-jira-integration.md

@@ -15,7 +15,7 @@ Todas as escritas de retorno passam por uma fila de saída (outbox) durável e r
 
 ## Conectar um quadro
 
-Conecta-se a partir da página **Definições** de um projeto (há também um passo opcional "Configurar Jira" no final do assistente de Adicionar Projeto). O assistente de ligação guia-o através de:
+Conecta-se a partir da página **Plugins** na barra lateral esquerda: clique em **Instalar** no cartão do Jira e escolha o projeto. O assistente de ligação guia-o através de:
 
 1. **Testar** — introduza o URL e as credenciais do seu Jira, e o Specrails verifica a ligação.
 2. **Escolher um projeto** — escolha com que projeto Jira sincronizar.
@@ -52,7 +52,7 @@ Por isso pode experimentar à vontade — ligue, corra uns quantos rails, deslig
 
 ## No dia a dia
 
-Uma vez conectada, a página de Definições do projeto mostra um **cartão de ligação** onde pode:
+Uma vez conectada, o cartão do Jira na página **Plugins** passa a **Gerir**. Escolha aí o projeto para abrir o seu **cartão de ligação**, onde pode:
 
 - **Sincronizar agora** — forçar um polling imediato em vez de esperar pelo temporizador.
 - **Tentar dead-letters de novo** — voltar a correr quaisquer escritas de retorno que tenham ficado presas.
@@ -69,4 +69,4 @@ As specs apoiadas no Jira mostram um **selo com a chave Jira** (como `PROJ-123`)
 
 ## Desligar
 
-Se alguma vez quiser recuar por completo, basta **Desligar** nas Definições. As suas specs voltam ao comportamento apenas local, e os metadados do Jira ficam simplesmente sem uso — nada é destruído.
+Se alguma vez quiser recuar por completo, basta **Desligar** no cartão de ligação. As suas specs voltam ao comportamento apenas local, e os metadados do Jira ficam simplesmente sem uso — nada é destruído.

package/docs/guide/pt/integrations/4-mobile-companion.md

@@ -1,4 +1,4 @@
-# A app companion para telemóvel
+# A app companion para telemóvel {#mobile-companion}
 
 O Specrails tem uma app companion para telemóvel para que possa ficar de olho nos seus rails enquanto está longe da secretária — ver trabalhos a correr, vê-los terminar e manter-se a par sem estar sentado em frente ao painel.
 

package/docs/guide/pt/integrations/5-mcp-server.md

@@ -1,4 +1,4 @@
-# Controlar o Specrails a partir de qualquer IA (servidor MCP)
+# Controlar o Specrails a partir de qualquer IA (servidor MCP) {#mcp-server}
 
 > **For agents (English):** use the [current connection runbook](../../../agents/mcp.md) for Claude and Codex. It includes verified bridge discovery, registration and read-only checks.
 

package/docs/guide/pt/integrations/6-agent-chat.md

@@ -33,6 +33,8 @@ O agente pode mexer na aplicação inteira, então você decide quanta liberdade
 
 Comece em **Observa** e suba o nível apenas quando quiser que o agente aja. Se ele tentar algo acima do nível atual, ele para e diz exatamente qual nível ativar — nunca contorna o limite. Isso é separado dos níveis de Ajustes ▸ MCP, que regem os assistentes *externos*; o nível aqui é só para este agente interno da aplicação.
 
+Subir o nível **para Autônomo** nunca acontece com um só toque: Shift+Tab a partir de Opera mostra um aviso com **Mudar para Autônomo**, e um novo Shift+Tab volta para Observa. Baixar o nível é sempre imediato.
+
 ## Algumas coisas que você pode pedir
 
 Quando estiver em **Opera**, experimente:
@@ -47,16 +49,21 @@ Quando estiver em **Opera**, experimente:
 
 As respostas chegam de forma fluida e já formatadas (títulos, tabelas, listas), cada uma com um pequeno botão de **copiar**. Uma etiqueta de status embaixo mostra o que o agente está fazendo agora — *Pensando…*, *MCP · jobs*, *Terminal* — para que você sempre saiba o estado dele.
 
+Os blocos de código mostram a linguagem e têm o próprio botão de **copiar**. Se você rolar para cima enquanto o agente ainda escreve, a pílula **Novas mensagens** aparece acima da caixa — clique nela para voltar à resposta mais recente.
+
 ## Detalhes práticos
 
 - **Super specs a partir de uma conversa.** Peça ao agente para *moldar* uma spec com você em vez de gerá-la de uma vez: ele lê primeiro o código real, faz algumas perguntas e mostra o rascunho em evolução como um cartão ao vivo dentro da conversa. Quando você diz sim, ele cria a spec e — por padrão — a enriquece em segundo plano com uma **Contract Layer** (caminhos de arquivo exatos, formas de dados, invariantes) para que os agentes que implementam não improvisem. Diga "sem contract layer" para pular o enriquecimento.
 - **Clique no que ele menciona.** Em uma missão fixada a um projeto, os números de spec (`#12`) e os ids de job/execução nas respostas do agente são chips clicáveis: uma spec abre o modal de detalhe do quadro e um id de job abre a visão do job ao vivo. Se a referência não existir mais, você verá um aviso discreto de "não encontrado".
-- **O cartão de implementação, sempre à vista.** Quando o agente implementa specs, um cartão ao vivo acompanha o trabalho — e enquanto ele precisar de algo de você (criar a PR, publicá-la, tentar de novo, descartar) fica **fixado logo acima da caixa de mensagem**, por mais que a conversa role; no lugar dele no histórico aparece um marcador discreto de "fixado acima". Vários cartões ativos se empilham como pequenos chips (clique em um para trazê-lo à frente), e um chevron minimiza o cartão para uma barra fina. Quando a PR é publicada — ou o trabalho é mesclado ou descartado — o cartão volta ao seu lugar no histórico da conversa.
+- **Uma faixa para as suas execuções.** Quando o agente lança trabalho, uma única faixa logo acima da caixa de mensagem o acompanha: o que a execução está fazendo, em palavras simples ("Escrevendo a spec a partir das suas alterações"), quantas execuções terminaram, o tempo e o custo real até agora (`—` até o provedor faturar). Quando uma execução precisa de você (criar a PR, tentar de novo, voltar ao Flow), a faixa avisa com um ícone e palavras e oferece essa única ação; clique na faixa para abrir o cartão completo da execução logo acima (Esc o fecha). Com várias execuções, a faixa mostra primeiro a que precisa de você e um pequeno seletor ("Rail 1 · Rail 2 · +1"). A conversa guarda só o que aconteceu ("Iniciado em Rail 1", "Rail 1 falhou: …", "Entregue: PR #812"), e cada linha abre a sua execução. As missões que aguardam a sua decisão mostram um ponto na lista de missões. As ações que iniciam uma nova execução paga (**Relançar**, **Recuperar e tentar novamente**) ou que outras pessoas veem (Criar PR, Publicar) nunca disparam a partir da faixa: ela abre o cartão com o foco nesse botão, para que você confirme ali.
+- **A faixa pelo teclado.** **⌥R** (**Alt+R** no Windows/Linux) pula da caixa de mensagem para a faixa da missão em que você está; pressione de novo para mostrar ou ocultar os detalhes da execução, e **Esc** leva você de volta para onde estava. Fora de um campo de texto, **⌥[** e **⌥]** alternam entre execuções. Com a faixa em foco, **P** pausa ou retoma um Flow e **H** o passa a um rail; essas letras não fazem nada em outro lugar. Pressione **?** para ver a lista completa.
 - **Histórico de prompts.** Com a caixa vazia, pressione **↑**/**↓** para percorrer o que você perguntou antes (mostrado esmaecido enquanto rola); comece a digitar para editar, ou pressione Enter para enviar.
 - **Edite a fila.** Enviou mais enquanto o agente estava ocupado? Enquanto houver mensagens na fila, **↑**/**↓** percorre *essas* mensagens: a caixa mostra a selecionada, você a edita ali mesmo e **Enter a salva de volta na fila** (Esc cancela; seu rascunho não enviado volta intacto).
+- **Responda com uma tecla.** Quando o agente oferece opções, cada chip tem um número: pressione **⌥1**…**⌥9** (**Alt+1**…**Alt+9** no Windows/Linux) com a caixa vazia para escolher uma.
+- **Desfaça a exclusão de uma mensagem na fila.** Ao excluir uma mensagem da fila, **Desfazer** aparece por alguns segundos e a devolve à fila.
 - **Minimize sem perder nada.** Clique no ✕ para devolver o painel à bolha — a conversa continua rodando. Reabra e você chega na mensagem mais recente; nada é redigitado.
 - **Nova conversa.** O botão **+** inicia um fio limpo; o histórico vive no nível da aplicação, acima de qualquer projeto individual.
-- **Troque de missão.** O seletor de missões ao lado do seletor de projeto lista suas conversas da mais recente para a mais antiga — um ponto pulsante marca aquelas em que o agente ainda está trabalhando, e um pequeno selo conta as mensagens na fila. A busca aparece quando a lista passa de oito, e o ícone de lixeira de cada linha exclui uma missão após uma confirmação rápida em linha — mesmo uma em andamento (ele avisa primeiro e depois para o agente).
+- **Troque de missão.** O seletor de missões ao lado do seletor de projeto lista suas conversas da mais recente para a mais antiga — um ponto pulsante marca aquelas em que o agente ainda está trabalhando, e um pequeno selo conta as mensagens na fila. A busca aparece quando a lista passa de oito, e o ícone de lixeira de cada linha exclui uma missão na hora e mostra **Desfazer** (ou pressione **⌘Z**) por alguns segundos; depois a missão espera 30 dias em **Excluídos recentemente**, nas configurações do projeto. Uma missão em que o agente ainda está trabalhando pergunta antes, porque parar o agente não pode ser desfeito.
 - **Encontre uma missão de qualquer lugar.** Pressione **⌘K** (ou o botão **Pesquisar** da barra lateral no modo Agente) e digite qualquer fragmento de que se lembre — uma palavra do título *ou* do que foi dito lá dentro. As missões coincidem na hora por título a partir da memória e, um instante depois, chegam as coincidências por conteúdo com o trecho destacado, mais o projeto fixado e quando teve atividade pela última vez. No modo Agente as missões são o primeiro grupo; no quadro ficam logo depois de Projetos. Enter abre a missão.
 
 ## Cards de lançamento e cards de execução
@@ -69,10 +76,10 @@ As respostas chegam de forma fluida e já formatadas (títulos, tabelas, listas)
 
 ## Subagentes
 
-Alguns provedores podem distribuir partes de uma tarefa para **subagentes**: ajudantes que trabalham em paralelo e continuam depois que o agente responde. Os subagentes vêm **desativados por padrão** porque multiplicam o custo de um pedido.
+Alguns provedores podem distribuir partes de uma tarefa para **subagentes**: ajudantes que trabalham em paralelo e continuam depois que o agente responde. Os subagentes vêm **ativados por padrão**; desative-os por projeto se quiser conter o custo, porque multiplicam o custo de um pedido.
 
-- **Ative por projeto.** Abra **Configurações → Subagentes** do projeto e ative **Permitir subagentes neste projeto**. Vale para missões, exploração e refinamentos do projeto; os pipelines de Implement nunca são afetados. Missões sem projeto seguem **Configurações do app → Provedores de IA → Permitir subagentes em missões sem projeto**.
-- **Escolha quem os executa.** Em **Executar sub-agentes com**, a opção padrão **Igual ao agente da missão** deixa o próprio CLI da missão iniciá-los nativamente: é o mais rápido, e eles compartilham o cache de prompt. Escolha um provedor, modelo e esforço para combinar provedores — por exemplo, uma missão em Codex com subagentes em Claude. Missões que já usam esse provedor continuam nativas com esse modelo; com outro provedor, o Specrails inicia cada subagente por conta própria, que começa a frio e pode custar mais, mas dá mais controle e mostra o custo real de cada um. O Specrails pede confirmação antes da troca, e esses subagentes exibem um selo do provedor na missão.
+- **Desative por projeto.** Abra **Configurações → Subagentes** do projeto e desative **Permitir subagentes neste projeto**. Vale para missões, exploração e refinamentos do projeto; os pipelines de Implement nunca são afetados. Missões sem projeto seguem **Configurações do app → Provedores de IA → Permitir subagentes em missões sem projeto**.
+- **Escolha quem os executa.** Em **Executar subagentes com**, a opção padrão **Igual ao agente da missão** deixa o próprio CLI da missão iniciá-los nativamente: é o mais rápido, e eles compartilham o cache de prompt. Escolha um provedor, modelo e esforço para combinar provedores — por exemplo, uma missão em Codex com subagentes em Claude. Missões que já usam esse provedor continuam nativas com esse modelo; com outro provedor, o Specrails inicia cada subagente por conta própria, que começa a frio e pode custar mais, mas dá mais controle e mostra o custo real de cada um. O Specrails pede confirmação antes da troca, e esses subagentes exibem um selo do provedor na missão.
 - **Acompanhe o trabalho.** Os agentes iniciados por uma resposta aparecem como uma linha compacta abaixo dela. Ela fica aberta enquanto trabalham e, quando todos terminam, se recolhe num resumo com o tempo e os tokens totais. Expanda uma linha para ler o resultado e o custo, ou acompanhar a atividade ao vivo. Cada lançamento fica no seu ponto da conversa, então os seguintes nunca se misturam com os anteriores. Pare um agente em execução pela linha dele, ou todos pela linha de resumo.
 - **O agente continua sozinho.** Quando os agentes em segundo plano terminam, o agente continua e publica o que encontraram, marcado como *Continuou após os agentes em segundo plano*.
 - **Mudar a configuração é seguro.** Uma missão com agentes em execução aplica a mudança quando eles terminam; ela avisa e oferece **Parar agentes e aplicar agora**.

package/docs/guide/pt/integrations/8-flow-mode.md

@@ -0,0 +1,69 @@
+# Flow: construir primeiro, spec depois {#flow-mode}
+
+O Flow é uma forma de construir com um agente quando você ainda não sabe exatamente o que quer. Você conversa com o agente na sua missão, ele escreve e executa código de verdade no próprio branch do Flow (uma cópia à parte do seu projeto) e, quando o resultado estiver certo, você clica em **Passar a um rail**: um rail assume suas alterações, deriva a spec e executa a verificação, a revisão e a entrega de sempre.
+
+O Implement serve para delegar um trabalho que você já sabe descrever. O Flow serve para descobri-lo.
+
+## Como um Flow começa
+
+Você nunca precisa pedir o Flow pelo nome. Quando você descreve algo exploratório ou visual ("quero experimentar…", "não sei como deve ficar"), a missão mostra um cartão com dois caminhos:
+
+- **Flow**: construir junto com o agente agora; a spec vem no fim.
+- **Spec + Implement**: combinar primeiro uma spec com o agente e depois passá-la a um rail.
+
+Os dois caminhos têm o mesmo peso e aparecem sempre na mesma ordem: nenhum é recomendado, quem escolhe é você. Em **Por que o agente pergunta**, o agente explica em uma frase o que o levou a perguntar, e não insiste, seja qual for o caminho escolhido ou se você clicar em **Agora não**.
+
+Escolher o Flow abre uma confirmação: o Specrails cria uma cópia à parte do projeto no próprio branch do Flow, onde o agente pode escrever código, e seu branch principal não é alterado. Clique em **Iniciar Flow**. No board aparece uma spec provisória com a etiqueta **Em Flow** (clique nela para voltar à missão).
+
+Se o seu Specrails Core ainda não consegue executar o Flow, o botão fica desativado e o cartão lista o que falta. Normalmente basta atualizar o Specrails Core.
+
+## Começar um Flow a partir de uma spec existente
+
+Qualquer spec pode ser construída em Flow, não só uma ideia nova. Flow e Implement continuam sendo duas formas iguais de trabalhar nela:
+
+- no quadro, clique com o botão direito numa spec e escolha **Começar em Flow** (ao lado de arrastá-la para um rail); no detalhe da spec, **Começar em Flow** fica ao lado de **Mover para rail**;
+- numa missão, quando você pede para implementar uma spec sem citar um rail, o agente mostra o mesmo cartão de dois caminhos para essa spec: **Flow** trabalha nela com você e **Spec + Implement** a lança num rail;
+- um cartão de lançamento em rail com uma única spec também oferece **Começar em Flow** ao lado do lançamento.
+
+A própria spec fica **Em Flow**: nenhuma spec provisória é criada e o primeiro turno do agente recebe a spec (critérios de aceitação, Contract Layer, itens fora do escopo e addenda abertos). Iniciado pelo quadro, o Flow abre na missão da própria spec ou numa missão nova com o nome da spec. Num projeto com vários repositórios Git, quando a spec não indica exatamente um deles, um pequeno diálogo pergunta antes onde o Flow é executado: só aparecem os repositórios Git, o repositório da spec (ou, se não houver, o principal) vem pré-selecionado e as setas mudam a escolha. **Começar em Flow** fica desativado, com o motivo ao passar o mouse, quando a spec já está em Flow, concluída ou cancelada, está num rail ou o Flow não está disponível.
+
+**Descartar** devolve a spec exatamente como estava, com o status anterior: sua spec nunca é apagada. Quando o Flow é entregue, a spec é reescrita a partir do que foi construído e, antes, o texto original fica guardado como comentário, **Original spec before Flow**, para que nada se perca. Uma spec já vinculada ao Jira atualiza a mesma issue e a move para o status mapeado para revisão; nenhuma segunda issue é criada.
+
+## Enquanto você está em Flow
+
+O modo Flow aparece onde você olhar, com a cor própria do Flow: o compositor mostra um chip **Flow** ao lado do de autonomia e a dica *Diga ao agente o que mudar neste Flow…*; o título da missão indica **Em Flow**, assim como a linha dela na lista de missões. A conversa marca onde você entrou e saiu do Flow, e as respostas do agente escritas em Flow levam uma pequena marca **Flow** ao lado do horário.
+
+A faixa logo acima do compositor mostra o Flow em uma linha curta: o estado, **Flow · 7 arquivos**, **Pausar Flow** e a ação principal, **Passar a um rail**. Quando uma ação não está disponível (o Flow ainda está salvando, há outra ação em andamento), passar o mouse sobre ela explica o motivo. Abra a linha pela seta, como qualquer outra execução, para ver o resto:
+
+- o **branch** (clique para copiar o nome), as **alterações** com as linhas adicionadas e removidas (clique para listar cada arquivo alterado com o estado e os +/−) e o **custo até agora**, conforme cobrado pelo provedor. Mostra `—` até que um turno tenha custo informado, e nunca uma estimativa; um `*` indica um total que deixa de fora turnos sem preço, com uma nota dizendo quantos;
+- **Pré-visualizar** enquanto a app do Flow estiver rodando (veja abaixo);
+- **Descartar**, separado, apaga as alterações do Flow, o branch dele e a spec provisória. A confirmação lista o que você perde: os arquivos alterados com os +/−, o branch e a spec.
+
+**Pausar Flow** para o agente e mantém suas alterações e a spec. A linha passa então a mostrar **Retomar Flow**.
+
+Você pode escrever enquanto o agente trabalha: no Flow, sua mensagem **interrompe** a etapa atual (o botão de enviar vira um raio) e o agente continua na hora com a nova informação. Enquanto o Flow está aberto, a faixa de git abaixo do compositor sai do caminho: o painel do Flow já mostra o branch dele.
+
+## Experimentar a app
+
+O próprio agente do Flow roda o typecheck e os testes para verificar o trabalho. Quando há algo para experimentar, ele pergunta com três opções: **Start the app**, **Start and expose on the local network** ou **Not now**. Expor a app permite abri-la em um celular na mesma Wi-Fi ou VPN, e qualquer pessoa nessa rede pode acessá-la.
+
+Quando a app está no ar, o agente passa os endereços como links e o painel do Flow mostra **Pré-visualizar** com um ponto verde: abre a app no seu navegador. O menu tem o endereço de rede e **Parar app**. A app roda a partir da cópia do Flow, nunca do seu checkout principal, e o Specrails a encerra quando você pausa, descarta ou entrega o Flow.
+
+## Passar a um rail {#flow-hand-off}
+
+Quando estiver satisfeito com o resultado, clique em **Passar a um rail**. A linha passa a mostrar **Pronto para virar uma PR** e abre uma única linha acima: *Rail 2 vai transformar seus 7 arquivos alterados em uma PR revisada. Se falhar, seu trabalho fica a salvo.* Clique em **Lançar**, ou em **Ainda não** para voltar ao Flow; **Esc** equivale a **Ainda não**; um clique fora só recolhe a linha, e a faixa continua em **Pronto para virar uma PR** com **Lançar**. Se o motor da sua conversa não puder fazer a passagem a um rail nesta máquina, uma nota logo abaixo da linha avisa e o motor padrão do rail é usado.
+
+O rail, o motor, o modelo e o esforço já vêm escolhidos (um rail livre e o motor da sua conversa). Para mudá-los, abra **Ajustar opções**; ali você também vê o que mudou. O custo até agora aparece na linha principal. Suas escolhas são mantidas se você clicar em **Ainda não** e passar a um rail mais tarde. Enquanto a passagem a um rail é iniciada, a faixa mostra o lançamento sem lacunas e depois acompanha a execução etapa por etapa. Se o limite de revisão ou um orçamento for atingido, a linha avisa e nada é lançado. Se a execução não aparecer em 45 segundos, a faixa para de girar e mostra **Ainda passando a Rail 2…** com **Atualizar**, que verifica de novo e continua esperando até a execução aparecer.
+
+O rail deriva a spec e a respectiva mudança de spec a partir do que você construiu, verifica e revisa, e o cartão de entrega aparece na missão como em qualquer execução.
+
+Se a execução falhar por um motivo técnico, o trabalho volta sozinho para este Flow, intacto: o cartão diz em palavras simples o que falhou (os códigos ficam em **Detalhes técnicos**) e o agente recebe o erro e o explica. Se a revisão pedir alterações, o cartão oferece **Voltar ao Flow** ou **Relançar**. Quando a entrega se conclui, a missão fecha o Flow com um resumo: o pull request, a spec reescrita a partir do que você construiu, a mudança de spec arquivada e a issue do Jira, se houver.
+
+## Bom saber
+
+- O Flow só escreve no próprio branch. Fora do Flow, as missões continuam somente leitura.
+- Um Flow por missão de cada vez. A pausa sobrevive a uma reinicialização da app.
+- Se a cópia do projeto do Flow desaparecer, o Flow fica marcado como **precisa de revisão** (só para informação, nada a decidir) e nada é apagado.
+- A faixa nunca troca a execução que você está vendo. Se outra passar a precisar de você nesse meio-tempo, o nome dela no seletor da faixa mostra **precisa de você**.
+- O Jira não recebe nada enquanto você está em Flow nem se você o descartar.
+- O custo do Flow aparece em Análises como uma superfície própria, **Flow**, e dentro do bloco de missões do agente.

package/docs/guide/pt/pipeline/1-rails-and-jobs.md

@@ -37,13 +37,14 @@ Você pode ter vários rails para organizar o trabalho em pistas nomeadas (uma p
 | **Seletor de Loop** | O Loop que este rail roda — um embutido (`Implement` / `Freestyle` / `SDD Quick (OpenSpec)`) ou um loop personalizado. Veja a tabela abaixo. Persistido por rail. |
 | **▶ Play / ■ Stop** | Iniciar ou cancelar. |
 
-### O que um rail roda: Loops
+### O que um rail roda: Loops {#rail-loops}
 
 Um rail roda um **Loop** — a receita do trabalho. Dois loops são **embutidos** e cobrem os casos comuns:
 
 | Loop embutido | Comando | O que faz |
 |------|---------|--------------|
 | **Implement** | `/specrails:implement` | Um job cobrindo todas as specs do rail. Roda o pipeline completo Architect → Developer → Reviewer → Ship. O padrão do dia a dia. |
+| **Freestyle** | Freestyle | O provedor do rail implementa cada spec de forma autônoma, **sem** o pipeline; depois a verificação e o Loop Decider refinam o resultado até tudo passar. Uma execução independente por spec. Funciona com Claude, Codex, Gemini, Kimi e motores locais; o chat interativo dentro do job é exclusivo do Claude. |
 
 Para rodar várias specs, coloque as relacionadas (até 3) num único rail — o `Implement` executa-as como um só job agregado — ou distribua specs independentes por vários rails: cada rail com git roda em paralelo na sua própria worktree isolada.
 
@@ -85,6 +86,25 @@ Se algo parecer errado:
 - **Autopausa por orçamento** — defina um orçamento diário e a fila se pausa sozinha quando o gasto do dia atinge o teto.
 - **Tudo** — feche o app desktop, ou rode `specrails-desktop stop`.
 
+## Integrar localmente com alterações sem commit
+
+**Integrar localmente** junta uma entrega aprovada no seu branch de integração (por exemplo `main`) neste computador, sem PR. Não precisa de um checkout limpo:
+
+- As alterações sem commit que não tocam nos ficheiros entregues ficam onde estão.
+- Se as suas alterações tocam nos mesmos ficheiros, o Specrails guarda-as num git stash chamado `specrails: before integrating #N (…)`, integra e volta a colocá-las. O aviso diz *Guardei as suas alterações locais, integrei #N e restaurei-as.*
+- Se ao voltar a colocá-las houver conflitos com o código integrado, o Specrails deixa o branch exatamente como integrado e **mantém o stash**: nada se perde. O cartão mostra *As suas alterações locais estão guardadas num stash* com os ficheiros em conflito, **Restaurar as minhas alterações** (nova tentativa, por exemplo depois de alterar o código) e o nome do stash para copiar. Depois, o Specrails restaura-as ele próprio num novo branch `specrails/restore-local-<id>`, num worktree separado: se aí se aplicarem sem conflitos, faz commit; caso contrário, um resolvedor de conflitos com IA trabalha apenas dentro desse worktree, mantendo a sua intenção e o código integrado, e o Specrails faz commit do resultado. O cartão lista os ficheiros restaurados; **Trazê-las de volta para <branch>** coloca-as no seu branch (só então o stash é descartado) e **Descartar o branch restaurado** remove o branch e mantém o stash. Uma missão é apenas informada; nunca tem de executar nada. As skills e comandos OpenSpec gerados pelo Specrails (por exemplo `.claude/skills/openspec-*/SKILL.md`) não contam como alterações suas: num conflito mantêm a versão integrada.
+- Os ficheiros ignorados nunca vão para o stash: se algum colidir com a entrega, o Specrails pede-lhe que o mova primeiro.
+- Se a app parar entre guardar e restaurar, restaura as suas alterações da próxima vez que o projeto abrir (só se o mesmo branch estiver em checkout).
+
+## Previsão de tempo e custo {#launch-forecast}
+
+Antes de clicar em Iniciar, um rail pode mostrar quanto tempo execuções como esta costumam levar e, quando faz sentido, quanto costumam custar, por exemplo *Normalmente 6–9 min · $2–4 em execuções como esta*.
+
+O intervalo é a metade central do seu próprio histórico: do percentil 25 ao 75 das execuções concluídas neste projeto com o mesmo loop ou comando e o mesmo motor. Precisa de pelo menos 5 execuções comparáveis. Até lá, a linha diz *Ainda sem histórico suficiente* em vez de um palpite. Só entram custos informados pelo provedor; custos estimados ficam de fora. É uma estimativa, nunca uma cobrança.
+
+O valor em dólares só aparece quando se sabe que o motor cobra por uso (por exemplo, uma chave de API). Em um plano de assinatura, ou enquanto o modo de cobrança ainda não é conhecido, só o tempo aparece. Quando o rail tem várias specs, o intervalo vale para uma spec e diz isso com *(por spec)*. Se o gasto de hoje mais o topo do intervalo puder atingir o seu orçamento diário, a linha acrescenta *Pode pausar no orçamento* com um link para as configurações de orçamento. Se o orçamento de hoje já acabou, Iniciar pede confirmação antes, porque a execução ficaria em pausa até ser reiniciado.
+
+
 ## Para onde ir agora
 
 - [O Loop Builder](the-loop-builder) — o que um rail roda, e como construir seus próprios loops.

package/docs/guide/pt/pipeline/2-the-job-detail-view.md

@@ -107,6 +107,18 @@ Se a [telemetria](../settings/customizing) estava ativada para o job, aparece um
 
 Útil para partilhar uma execução com um colega de equipa, ou para abrir um relatório de bug preciso.
 
+## Quando uma execução falha
+
+Quando um job falha, para ou fica bloqueado, o estado final começa com um **cartão de diagnóstico** que diz em linguagem clara o que aconteceu, por exemplo *Os testes falharam na fase Reviewer após 4 rodadas de correção*, e por quê quando o app sabe:
+
+- **Testes falharam**: as verificações continuam falhando após as rodadas de correção.
+- **Limite do provedor**: o limite de uso do provedor de IA foi atingido. O cartão cita quando ele é redefinido, com as palavras do próprio provedor.
+- **Ambiente**: a máquina não consegue executar as verificações (credenciais, uma ferramenta ausente, um comando de preparação que falha). *Corrigir o ambiente* mostra exatamente o que executar ou mudar.
+- **Bloqueada**, **sem tempo**, **em silêncio** e **parou inesperadamente** nomeiam o limite ou o processo que interrompeu a execução.
+- **Causa desconhecida**: o app não adivinha. Mostra o fim do registro para você mesmo ler.
+
+Sob o diagnóstico há até três remédios ordenados, e só os que podem funcionar aqui: **Retomar a partir de** a fase que parou, **Executar novamente**, **Editar a spec e relançar** (os adendos da spec levam sua mudança para a próxima execução), **Corrigir o ambiente** e **Abrir o registro na falha**. A mesma causa aparece como um rótulo de uma linha na [lista de pendências](../getting-started/the-dashboard-tour), e o cartão de execução da missão mostra o mesmo cartão.
+
 ## Para onde ir a seguir
 
 - [Rails e jobs](rails-and-jobs) — lançar e enfileirar.

package/docs/guide/pt/pipeline/3-reviewing-a-delivery.md

@@ -0,0 +1,43 @@
+<!-- guide-revision: mission-first-v1 -->
+
+# Revise uma entrega no app {#review-a-delivery}
+
+Uma entrega pronta para revisão tem duas visões: **Resumo** (o veredito, as evidências e os botões de decisão) e **Alterações** (o que a entrega realmente mudou). Abra a revisão pelo botão **Revisar** da entrega e escolha **Alterações**.
+
+## Leia as alterações
+
+A lista de arquivos à esquerda mostra cada arquivo alterado com seu estado (adicionado, modificado, excluído, renomeado), suas contagens de linhas `+` e `−` e uma marca quando você o dá como visto. O diff à direita carrega um arquivo por vez, então uma alteração grande continua fluida. Alterne entre os layouts **Unificado** e **Dividido**; o Specrails lembra da sua escolha. Um arquivo muito grande mostra suas primeiras linhas com **Carregar o diff completo do arquivo**; um arquivo binário é listado como binário.
+
+As alterações são medidas a partir do ponto em que a entrega se separou da branch base, então o que chegou à base depois não aparece. Se a entrega ainda não tem uma branch combinada, você pode escolher a branch de qual spec ler.
+
+## Notas do revisor sobre o código
+
+Os achados do revisor, os riscos apontados e os comentários de revisão que a execução devia resolver aparecem sob a linha a que se referem. Notas que não indicam arquivo nem linha ficam listadas acima da lista de arquivos, então nada fica escondido. Entregas antigas, e revisores que não indicaram um lugar, mostram seus achados nessa lista.
+
+## Peça ao agente para mudar algo
+
+Selecione linhas clicando nos números (Shift-clique amplia o intervalo), escolha **Pedir uma mudança ao agente** e descreva a mudança. O Specrails salva como feedback de revisão na spec, com o arquivo, o intervalo de linhas e o código selecionado, e mostra uma mensagem com um link para a spec. A próxima execução dessa spec o receberá. Para iniciá-la agora, use **Pedir alterações** no Resumo. Aqui não há threads de comentários entre pessoas; converse com sua equipe no GitHub.
+
+## Abra no seu editor
+
+**Abrir no editor** abre o arquivo, na linha selecionada, no VS Code, no Cursor ou em uma IDE da JetBrains. Escolha o editor em **Configurações → Código → Editor**. O arquivo abre a partir da sua própria cópia do projeto, onde a branch da revisão pode não estar ativa.
+
+## Escolha o que acontece com uma entrega {#pr-decision}
+
+Uma execução concluída pede uma só coisa: o que fazer com o resultado. O cartão mostra um botão principal para o próximo passo (criar o PR, publicá-lo ou verificá-lo) e, ao lado, **Revisar**, que abre o pacote de revisão em linguagem simples. Todo o resto fica em **Mais ações**:
+
+- **Mudar para o branch** coloca o branch na pasta do seu projeto para você testá-lo.
+- **Integrar localmente** mescla o resultado no seu branch base neste computador. Não precisa de GitHub e você confirma antes.
+- **Descartar** remove o resultado e o seu branch. Você confirma antes.
+
+Se uma ação falhar, o aviso diz o que não deu certo e oferece **Repetir**.
+
+## Teclado
+
+| Tecla | Ação |
+| --- | --- |
+| `j` / `k` | Arquivo alterado seguinte / anterior |
+| `n` / `p` | Nota do revisor seguinte / anterior |
+| `v` | Marcar o arquivo como visto |
+
+As teclas são ignoradas enquanto você digita em um campo. Marcar como visto é privado: se o arquivo mudar numa revisão posterior, ele mostra **Alterado desde que você viu** e volta a contar como não visto.

package/docs/guide/pt/pipeline/4-picking-an-engine-per-rail.md

@@ -1,4 +1,4 @@
-# Escolher um motor por rail
+# Escolher um motor por rail {#provider-capabilities}
 
 ## Quando o seletor aparece
 
@@ -19,7 +19,7 @@ Os quatro correm o pipeline standard **Implement**:
 | Motor | Recorra a ele quando… | Notas |
 |--------|--------------------|-------|
 | **Claude** | Precisa de custo nativo, interação persistente ou tool policy rigorosa. | Perfis, Freestyle e transformações estruturadas. |
-| **Codex** | Prefere o Codex CLI da OpenAI ou quer comparar implementações entre fornecedores. | `codex` ≥ 0.128.0. Sem reporte de custo nativo — a app preenche o custo a partir da sua tabela de preços. Os perfis não se aplicam. |
+| **Codex** | Prefere o Codex CLI da OpenAI ou quer comparar implementações entre fornecedores. | `codex` ≥ 0.128.0. Sem reporte de custo nativo — a app preenche o custo a partir da sua tabela de preços. Os perfis não se aplicam. O Freestyle funciona, sem chat interativo. |
 
 ## Um fluxo de trabalho prático
 

package/docs/guide/pt/pipeline/5-the-loop-builder.md

@@ -1,4 +1,4 @@
-# O Loop Builder
+# O Loop Builder {#loop-builder}
 
 ## Workflows Core
 

package/docs/guide/pt/settings/1-themes.md

@@ -1,4 +1,4 @@
-# Temas
+# Temas {#themes}
 
 Deixe o Specrails com a cara que mais gosta. A aplicação já vem com cinco temas cuidadosamente afinados, entre os quais pode alternar num instante — sem reiniciar, sem recompilar, sem nada para configurar.
 

package/docs/guide/pt/settings/3-pipeline-telemetry-and-diagnostics.md

@@ -1,4 +1,4 @@
-# Telemetria do pipeline e diagnóstico
+# Telemetria do pipeline e diagnóstico {#telemetry}
 
 A telemetria regista os diagnósticos do pipeline localmente. Está **ativada por omissão** nos projetos sem uma preferência guardada. Pode desativá-la por projeto; as escolhas guardadas explicitamente são respeitadas.
 
@@ -20,7 +20,7 @@ A partir desse momento, os jobs do pipeline desse projeto passam a registar tele
 
 ### O que é abrangido
 
-A telemetria aplica-se aos **jobs do pipeline** (as execuções em rail Architect → Developer → Reviewer → Ship que estão em fila). Sessões interativas como o chat e o assistente de configuração ficam intencionalmente de fora — a telemetria destina-se às execuções de pipeline repetíveis e inspecionáveis, não a conversas pontuais.
+A telemetria aplica-se aos jobs que passam pela **fila de jobs** do projeto: as execuções do pipeline da CLI (os rails quando os Loops estão desativados e os comandos `implement` enviados a partir da CLI `specrails-desktop`). As execuções de loop — a forma predefinida como os rails correm — e as sessões interativas como o chat, o Explore e as missões não são instrumentadas.
 
 ## Onde ficam os dados
 

package/docs/guide/pt/settings/5-project-environment.md

@@ -1,4 +1,4 @@
-# Ambiente do projeto
+# Ambiente do projeto {#project-environment}
 
 Alguns projetos precisam de uma credencial durante a execução, como `NODE_AUTH_TOKEN` para pacotes npm privados. Em **Configurações do projeto → Ambiente**, adicione os **nomes** das variáveis de que seus rails e loops precisam. O Specrails guarda apenas os nomes, nunca os valores.
 

package/docs/guide/pt/settings/6-updates.md

@@ -0,0 +1,24 @@
+# Atualizações {#updates}
+
+O Specrails mantém duas coisas atualizadas: o próprio app **Specrails Desktop** e o framework **specrails-core** usado pelos seus projetos. Ambos ficam em **Configurações ▸ Atualizações**.
+
+## Canal de atualização
+
+Escolha com que rapidez você recebe novas versões:
+
+- **Mais recente** (padrão): cada versão assim que é publicada. Você recebe novidades e correções primeiro.
+- **Estável**: apenas versões que passaram pelo menos uma semana em Mais recente com CI verde e depois foram promovidas pelos mantenedores. Escolha se sua equipe prefere menos atualizações, bem testadas.
+
+O canal vale para o app e para o specrails-core. Se o specrails-core ainda não tiver versão estável, o Core segue Mais recente e o cartão do Core avisa.
+
+No Estável, se nenhuma versão tiver sido promovida ainda, **Verificar atualizações** avisa em vez de oferecer uma versão de Mais recente.
+
+## Como as atualizações chegam
+
+- **Specrails Desktop** verifica ao iniciar e a cada 6 horas. Quando há uma atualização, aparece um cartão para baixar, instalar e reiniciar. Você também pode clicar em **Verificar atualizações**.
+- **specrails-core** nunca se atualiza sozinho. Clique em **Procurar atualizações** no cartão do Core e depois em **Atualizar**. Seus projetos passam para o novo framework sem reiniciar o app.
+
+## Bom saber
+
+- Trocar de Mais recente para Estável nunca faz downgrade. Você fica na sua versão até o Estável alcançá-la.
+- Toda atualização é assinada e verificada antes de ser instalada, nos dois canais.

package/docs/guide/pt/settings/7-existing-projects.md

@@ -0,0 +1,33 @@
+# Trabalhar em um projeto existente {#existing-projects}
+
+Estes recursos ajudam as execuções a respeitar um projeto que já existe: o que uma spec deixa de fora, as perguntas do arquiteto antes de planejar, quais requisitos um teste realmente comprova, como descrever o código antigo antes de mudá-lo e as regras que sua equipe já escreveu. Cada um precisa de uma versão do specrails-core que o suporte; até lá, o interruptor fica desativado com um aviso para atualizar o Core.
+
+## Fora do escopo
+
+Cada spec pode listar o que deliberadamente **não** muda. Quick e Explore preenchem isso para você; na janela da spec aparece como **Fora do escopo** abaixo da descrição, um item por linha, e pode ser editado como qualquer outro campo. Os agentes recebem isso com a spec a cada lançamento.
+
+## Perguntas do arquiteto no Jira
+
+Em **Configurações ▸ Ancoragem em projetos existentes**, ative **Publicar esclarecimentos do arquiteto no Jira**. Quando uma execução para porque o arquiteto precisa de uma resposta, ou segue com suposições, o Specrails as publica como um comentário na issue do Jira vinculada. Responda a esse comentário no Jira: a resposta é adicionada à spec como esclarecimento e a próxima execução da spec a lê. Você ainda pode responder a uma execução pausada pelo app.
+
+## Requisitos demonstrados
+
+Quando um teste nomeia o requisito que comprova (`[spec:<capacidade>/<requisito>]` no título), a página de revisão mostra **Requisitos demonstrados X/Y**: quais requisitos um teste aprovado comprova, quais ainda não têm teste e quais a própria mudança tocou. A análise mostra o mesmo por loop. Para a CI falhar quando um requisito alterado não tem teste, adicione `specrails-core pipeline trace --check --tests-passed` depois dos seus testes.
+
+A biblioteca de loops também oferece **Varredura de drift**, um loop somente leitura que compara o que cada spec diz com o que o código faz e lista cada contradição. Não altera nada.
+
+## Baseline ao tocar
+
+Ative **Baseline ao tocar** para que uma mudança que alcança código que nenhuma spec descreve comece descrevendo-o: testes de como o código se comporta hoje, comprovados no código inalterado, e uma spec curta do que existe. A página de revisão mostra **Spec criada por onde o trabalho passou** com o módulo, os requisitos e os testes, e o custo aparece à parte. Se esses testes falharem no código inalterado, a execução para antes de editar o módulo e informa isso.
+
+## Regras do projeto {#project-rules}
+
+**Configurações ▸ Regras do projeto** lista as verificações que seu projeto já executa (lint, tipos, testes, CI) e cada regra escrita em arquivos como `CLAUDE.md` ou `AGENTS.md`, classificadas em:
+
+- **Aplicada**: uma verificação já a garante.
+- **Automatizável**: uma verificação poderia. **Criar spec** a transforma em spec com um clique.
+- **Somente humana**: alguém precisa olhar. Elas aparecem em cada página de revisão em **Precisa de olhos humanos**.
+
+As regras que o Core ainda não conseguiu classificar (por exemplo, logo após adicionar o projeto, quando o inventário roda offline) aparecem como **Não classificada**; **Refazer inventário** com um provedor configurado as classifica.
+
+**Refazer inventário** atualiza a lista. Quando um projeto ainda não tem comandos de verificação, as configurações do agent runtime oferecem essas verificações primeiro.