@neetru/cli 2.21.0 → 2.24.0

package/CHANGELOG.md

@@ -2,6 +2,72 @@
 
 Convenção: [Keep a Changelog](https://keepachangelog.com/) + [SemVer](https://semver.org/).
 
+## [2.24.0] — 2026-07-13 (contexto dev-local: `neetru dev use/status/sync`)
+
+> Trabalho do Codex nesta sessão (mesmo repo, frente separada do `neetru code`).
+
+### Adicionado
+
+- **Contexto de projeto local** (`.neetru/dev.json`) com 2 modos: `core-product` (projeto ligado a produto/workspace do Core) e `prototype` (rascunho local ainda não cadastrado). Comandos novos: `neetru dev use --product <slug> [--sync]`, `neetru dev use --prototype <nome>`, `neetru dev status`, `neetru dev sync --write-db`.
+- `dev up`/`dev exec` agora leem esse contexto automaticamente pra decidir `corePath`, emuladores padrão e mostrar em qual produto/protótipo a sessão está.
+- `dev sync` busca workspace/tenant dev ativo e bancos dev-local do Core; `--write-db` mescla em `.neetru/db.json`.
+
+### Docs
+
+- README documenta os 4 comandos novos + o arquivo `.neetru/dev.json`.
+
+49 testes novos passando, build limpo. Ver seção abaixo para o restante do que entrou nesta versão (Objective Runtime Controller + hardening de segurança do `neetru code`).
+
+## [2.23.0] — 2026-07-13 (`neetru code` — multi-tool por turno, auto-extensao silenciosa em auto mode, HOTFIX render loop no autocomplete)
+
+> Sessão com trabalho concorrente Claude+Codex sobre o mesmo turn-loop de `runAgentTask`. Codex: múltiplas `NEETRU_TOOL` por resposta (leitura/pesquisa em lote, mutação continua 1 por vez), auto mode estende o limite de turnos automaticamente sem perguntar `[y/N]` (respeitando o mesmo teto `MAX_TURN_LIMIT_EXTENSIONS`), e `NEETRU_DONE`/`NEETRU_BLOCKED` sem texto não vazam mais crus na UI. Eu: HOTFIX de um crash real reportado ao vivo no autocomplete (2.22.0, ver abaixo).
+
+### Adicionado
+
+- **Múltiplas ferramentas por resposta** — o modelo pode pedir até 5 `NEETRU_TOOL` na mesma resposta (`parseToolRequests`); leitura/pesquisa roda em lote, mas ferramentas que escrevem/executam/publicam (`write_file`, `git_*`, `shell_exec`, etc. — `SINGLE_ACTION_TOOLS`) continuam limitadas a uma por resposta, as demais voltam com erro claro pedindo pra tentar de novo no próximo turno.
+- **Auto mode estende o limite de turnos sem perguntar** — dentro do mesmo teto `MAX_TURN_LIMIT_EXTENSIONS` (2) já existente; fora do auto mode continua perguntando `[y/N]` a um humano de verdade (ou falhando direto em subagente/não-interativo).
+
+### Corrigido
+
+- **HOTFIX (2.22.0 → 2.22.1, achado em uso real ao vivo): "Maximum update depth exceeded" ao digitar `/agents` ou `/skills`** — o dropdown do autocomplete usava `key={s.word}` no JSX, mas vários comandos compartilham a mesma 1ª palavra (`/agents start|list|stop|result|apply` todos têm `word="/agents"`; `/skills`/`/skills init`/`/skills show` idem). Key duplicada disparava o warning de dev do React; como `console.error` é redirecionado pro `LineBuffer` (que chama `setState`), o próprio warning disparava outro render, que warnava de novo — loop infinito, painel travava ao abrir. Corrigido pra `key={s.cmd}` (esse sim único em toda a lista) + teste de regressão garantindo que `cmd` nunca colide.
+- `NEETRU_DONE`/`NEETRU_BLOCKED` sem nenhum texto depois do marcador não vazam mais crus pro usuário — caem em "Concluido."/"Bloqueado." como fallback.
+- **Ainda não estava corrigido apesar da alegação**: a redação "NEETRU_DONE se concluiu o máximo possível" (última chamada, quando o limite de turnos se aproxima) misturava "fiz o que deu" com "objetivo realmente concluído" — o modelo podia marcar uma tarefa incompleta como terminada só por ter ficado sem turnos. `NEETRU_DONE` agora exige conclusão REAL; sem isso, cai em texto normal resumindo o progresso.
+
+### Segurança (achados de revisão de segurança sobre os commits desta sessão)
+
+- **HIGH — escrita através de symlink escapava do projeto**: `resolveInside` só revalidava o realpath quando o ALVO já existia; `write_file`/`append_file` para um arquivo NOVO dentro de uma pasta symlinkada apontando pra fora do cwd escapavam da checagem por completo (o arquivo-alvo em si nunca existe antes da escrita). Corrigido pra resolver o realpath do ancestral EXISTENTE mais próximo do alvo, não só do alvo.
+- **HIGH — SSRF via redirecionamento em `web_fetch`**: validava só a URL inicial e seguia redirecionamento automaticamente (`redirect: 'follow'`); um domínio público podia redirecionar pra `169.254.169.254`/localhost/IP privado sem revalidar. Trocado pra `redirect: 'manual'` com revalidação a cada salto (máx. 5) + resolução de DNS também validada contra rede privada/link-local (best-effort — não é prova contra DNS rebinding sem um dispatcher fixando o IP).
+- **Médio — `web_fetch` só checava o limite de tamanho DEPOIS de carregar o corpo inteiro**: `content-length` era validado, mas a resposta inteira já tinha sido lida antes da checagem de tamanho real disparar. Agora lê em chunks e aborta assim que passa do limite.
+
+### Adicionado — Objective Runtime Controller (`code-agent-budget.ts`, novo módulo)
+
+> Pedido direto do usuário após um transcript real de sessão travada: o modelo ficava repetindo "avanço parcial" em modo objetivo sem nunca chamar tool nem propor patch, e `settings.maxTurns` — um CONTADOR, não um sinal de progresso — não enxergava isso. Design pesquisado (arquitetura documentada do Claude Code: modos de permissão, loop context→ação→verificação, bloqueio-com-motivo em vez de `[y/N]`) e sintetizado via 3 propostas independentes + 3 rodadas de verificação adversarial antes de implementar — a 1ª síntese tinha 4 problemas reais (edge de estado faltando, promessa falsa de segurança do tsc + bug real de `pendingPlanTask`, colisão com o mecanismo de patch-repair já testado, import circular), todos corrigidos e reverificados antes do código ser escrito.
+
+- **2 novas dimensões de orçamento, ortogonais a `maxTurns`**: `noProgress` (turnos consecutivos em modo objetivo sem tool call nem patch — o modelo só descreve avanço) e `repeatedErrors` (total CUMULATIVO de patches inválidos na sessão inteira — nunca reseta, ao contrário do `patchRepairStreak` local que já existia e continua intacto; pega o padrão que o mecanismo antigo não pega: erra 3x, muda de estratégia, reseta, erra 3x de novo, indefinidamente sem convergir).
+- **Novo outcome `budget_exceeded`** em `AgentTaskOutcome` — nunca se estende (nem em auto mode, diferente do limite de turnos): as duas dimensões são sinal de que o modelo não está CONVERGINDO, não de que faltou tempo.
+- **Checkpoint roda logo após `goto('thinking')`** no loop — só precisou de 1 edge nova na máquina de estados (`thinking -> budget_exceeded`) em vez de enumerar os 3 estados alcançáveis no topo do loop, porque todos já têm edge legal pra `thinking` hoje.
+- `MAX_CONSECUTIVE_PATCH_REPAIRS`/`MAX_TOOLS_PER_TURN`/`SINGLE_ACTION_TOOLS` migraram de `commands/code.ts` pra `code-agent-budget.ts` (evita um import circular: o novo módulo não pode importar essas constantes DE VOLTA de `code.ts` já que `code.ts` importa `decideBudgetAction`/`BudgetTracker` de lá).
+- Os dois pontos que comparavam `outcome.kind` com `if/else` (não pegos por `tsc` — nenhum é um `switch` exaustivo hoje) viraram `switch` com `const _exhaustive: never = outcome.kind` no `default`, fechando de vez um bug real e independente: em modo plano, um outcome `'aborted'` deixava `pendingPlanTask` num estado obsoleto (nem atualizado, nem limpo) — `/approve` executaria um plano errado depois. Corrigido preservando um plano anterior ainda válido quando o turno atual não produziu nem plano nem execução real.
+
+1051 testes passando, tsc limpo (isolado das mudanças desta sessão — um arquivo novo e não relacionado de outra frente de trabalho em andamento no mesmo repo tem 2 erros de tipo pré-existentes, fora do escopo desta mudança).
+
+> Feedback direto do uso real (transcript colado pelo usuário): um modelo preso reescrevendo o mesmo diff quebrado gastava o orçamento de turnos INTEIRO em correções de patch e a sessão inteira falhava com "Limite de turnos atingido" sem chance de continuar. Diagnóstico confirmado por revisão de código (Codex): o problema é arquitetural — o CLI depende só de `NEETRU_PATCH` (unified diff cru gerado pelo modelo) como único caminho de escrita.
+
+### Adicionado
+
+- **Autocomplete de slash commands** — digitar `/` na sessão interativa lista os comandos, narrowing conforme digita (substring, não só prefixo), setas ↑/↓ navegam, Tab ou Enter (quando a sugestão ainda não é o texto exato) completa em vez de submeter. Fonte única (`SLASH_COMMANDS` em `code-agent-ui.ts`) compartilhada com `/help`, pra nunca ficar desalinhada.
+- **3 ferramentas deterministicas de escrita** (`code-agent-write-tools.ts`) — `write_file` (cria/sobrescreve um arquivo inteiro), `append_file` (adiciona ao final), `replace_in_file` (troca um trecho exato, com detecção de ocorrência ambígua e `"replace_all":true` explícito). Viram o caminho PRINCIPAL pra criar/editar UM arquivo por vez; `NEETRU_PATCH` vira fallback só pra diff multi-arquivo/multi-hunk num único turno. Mesmo tier de confirmação de `git_commit`/`git_branch` (local/reversível, `--yes` dispensa a pergunta); path sempre resolvido via `resolveInside` (contenção + symlink real path) e escrita em arquivo de segredo (.env/chave) bloqueada, espelhando o bloqueio de leitura. Bloqueadas em modo plano.
+
+### Corrigido
+
+- **Loop de patch inválido gastava o orçamento de turnos inteiro** — cada tentativa de correção consumia 1 turno igual a qualquer outro; um modelo preso no mesmo erro nunca sobrava turno pra nada. Depois de 3 tentativas SEGUIDAS de patch inválido, o loop para de pedir "corrija o diff" e força o modelo a mudar de estratégia (explicar em texto, ou — com as novas ferramentas de escrita — usar `write_file`/`replace_in_file` no arquivo específico).
+- **"Limite de turnos atingido" matava a sessão sem chance de continuar** — esgotar `maxTurns` agora pergunta "Continuar mais N turnos?" antes de falhar, mas SÓ quando há um humano de verdade (`!silent`) — subagentes e sessões não-interativas (sem TTY) continuam falhando direto, sem regressão de comportamento nem risco de loop custando dinheiro sem supervisão.
+- **Achado testando a própria correção acima: a extensão de turnos podia rodar PARA SEMPRE** — um `confirm` que sempre aprova (script/automação, ou um `confirm` de teste ingênuo) mantinha um modelo genuinamente preso (nunca conclui, nunca bloqueia) estendendo o limite indefinidamente — travou de verdade um worker de teste até estourar memória. Novo teto `MAX_TURN_LIMIT_EXTENSIONS` (2): depois disso, falha direto mesmo que a extensão continue sendo aprovada.
+
+### Docs
+
+- System prompt (`buildSystemPrompt`) atualizado pra orientar o modelo a preferir write_file/append_file/replace_in_file sobre NEETRU_PATCH pra mudança de um arquivo só, e a abandonar um diff que já falhou 2-3 vezes em vez de insistir.
+
 ## [2.21.0] — 2026-07-13 (`neetru code` — skills, modo objetivo/plano/auto, ferramentas web/GitHub + hardening pós-review)
 
 > Sessão com trabalho concorrente Claude+Codex no mesmo repo. Codex implementou skills, patch pre-check, modo objetivo/plano/auto, `/approve`/`/auto` e as ferramentas `web_search`/`web_fetch`/`github_search`/`github_repo`. Um Codex-review dedicado (`codex-rescue`) auditou os 4 commits anteriores (2.20.1-2.20.3 + o `feat` de base); os achados P1/P2 confirmados por leitura direta do código + os achados adicionais encontrados nesta revisão foram corrigidos nesta mesma versão, antes da publicação.

package/README.md

@@ -111,8 +111,25 @@ neetru dev up --skip-core
 neetru dev exec "npm run test:integration"
 ```
 
+Contexto do projeto local:
+
+```bash
+# Projeto ligado a um produto já existente no Core:
+neetru dev use --product meu-produto --sync
+
+# Protótipo local ainda não cadastrado no Core:
+neetru dev use --prototype meu-rascunho
+
+# Ver o contexto efetivo que dev up/dev exec vão usar:
+neetru dev status
+
+# Sincronizar bancos dev-local do Core para .neetru/db.json:
+neetru dev sync --write-db
+```
+
 > `neetru dev` (sem subcomando) mantém o modo legado: banco Docker local + watch de schema.
 > Flags: `--only firestore,auth,functions`, `--core-port 9003`, `--core-path <dir>`.
+> O arquivo `.neetru/dev.json` guarda o contexto local: produto Core ou protótipo, Core path e emuladores padrão.
 
 ## Configuração
 

package/dist/commands/code.js

@@ -7,11 +7,12 @@ import { config } from '../lib/config.js';
 import { getActiveTokenSync } from '../lib/token-resolver.js';
 import { log } from '../utils/logger.js';
 import { setSafeExitCode } from '../utils/safe-exit.js';
-import { parseToolRequest, extractPatch } from '../lib/code-agent-protocol.js';
+import { parseToolRequests, extractPatch } from '../lib/code-agent-protocol.js';
 import { applyUnifiedPatch, checkPatchApplies, getGitDiff, getProjectOverview, listFiles, readFileContext, renderColoredDiff, runCodeTool, truncateForGateway, } from '../lib/code-agent-files.js';
 import { compactCodeHistory, compactHistoryToFit, MAX_HISTORY_TOTAL_CHARS, saveCodeSession, autoSaveCodeSession, listCodeSessions, loadCodeSession, logAppliedPatch, CodeAgentStateMachine, } from '../lib/code-agent-session.js';
 import { DEFAULT_CODE_MAX_TOKENS, DEFAULT_CODE_MAX_TURNS, DEFAULT_CODE_TEMPERATURE, ULTRACODE_EFFORT, ULTRACODE_MAX_TOKENS, ULTRACODE_MAX_TURNS, parseBoundedNumber, resolveCodeEffort, resolveCodeModel, resolveCodeProvider, } from '../lib/code-agent-settings.js';
 import { callGateway, streamGatewayChat, AI_GATEWAY_CHAT_PATH } from '../lib/code-agent-gateway.js';
+import { createBudgetTracker, decideBudgetAction, MAX_CONSECUTIVE_PATCH_REPAIRS, MAX_TOOLS_PER_TURN, SINGLE_ACTION_TOOLS, } from '../lib/code-agent-budget.js';
 import { CliApiError } from '../lib/api-client.js';
 import { buildSystemPrompt } from '../lib/code-agent-tools.js';
 import { CODE_SKILLS_ROOT, installAllBuiltinSkills, loadCodeSkills, normalizeSkillName } from '../lib/code-agent-skills.js';
@@ -206,6 +207,32 @@ export async function callGatewayWithProgressRetrying(settings, messages, spinne
         }
     }
 }
+// 2026-07-13 (achado em uso real, transcript colado pelo usuario): um modelo
+// preso repetindo o MESMO diff quebrado ("corrupt patch") gastava o
+// orcamento de turnos INTEIRO so em correcoes de patch — cada tentativa
+// invalida consome 1 turno igual a qualquer outro, entao 3-4 tentativas
+// seguidas ja fecham a sessao inteira sem sobrar turno pra nada. Depois de
+// N tentativas seguidas, para de pedir "corrija o diff" (que nao esta
+// funcionando) e forca o modelo a mudar de estrategia: explicar em texto em
+// vez de insistir no mesmo formato.
+// (MAX_CONSECUTIVE_PATCH_REPAIRS/MAX_TOOLS_PER_TURN/SINGLE_ACTION_TOOLS agora
+// vivem em code-agent-budget.ts — evita um ciclo de import com o Objective
+// Runtime Controller, que consome esse modulo; ver comentario la.)
+// Limite de turnos "duro demais" era a outra metade da mesma reclamacao:
+// ao esgotar `maxTurns` a sessao INTEIRA falhava com um erro opaco, sem
+// chance do usuario (que esta ali, na sessao interativa) simplesmente pedir
+// mais turnos pra terminar algo que estava proximo. So oferece a extensao
+// quando ha um humano de verdade pra perguntar — subagentes (`silent`) e
+// modo nao-interativo sem TTY (`defaultConfirm` ja retorna false) continuam
+// falhando direto, sem regressao de comportamento.
+const TURN_LIMIT_EXTENSION = 6;
+// Teto de extensoes por tarefa — sem isso, um `confirm` que sempre aprova
+// (script/automacao, ou um humano otimista demais) mantem um modelo preso
+// num loop que nunca conclui rodando PARA SEMPRE, um turno estendido atras
+// do outro (achado rodando os testes: um mock de tool-loop infinito com
+// confirm sempre-true travou o worker de teste ate estourar memoria).
+// Depois do teto, falha direto — nao pergunta mais, mesmo que aprovassem.
+const MAX_TURN_LIMIT_EXTENSIONS = 2;
 function classifyObjectiveText(content) {
     const trimmed = content.trimStart();
     if (/^NEETRU_DONE\b/i.test(trimmed))
@@ -220,6 +247,22 @@ function stripObjectiveMarker(content) {
         .replace(/^\s*NEETRU_BLOCKED\b[:\s-]*/i, '')
         .trim();
 }
+function objectiveDisplayText(state, content) {
+    if (state === 'done')
+        return stripObjectiveMarker(content) || 'Concluido.';
+    if (state === 'blocked')
+        return stripObjectiveMarker(content) || 'Bloqueado.';
+    return content;
+}
+function isAutoMode(settings) {
+    return settings.apply === true && settings.yes === true && settings.objectiveMode === true;
+}
+function canAutoExtendTurnLimit(settings, silent, usedExtensions) {
+    return !silent && isAutoMode(settings) && usedExtensions < MAX_TURN_LIMIT_EXTENSIONS;
+}
+function extendTurnLimit(settings) {
+    settings.maxTurns += TURN_LIMIT_EXTENSION;
+}
 function buildObjectiveContinuationPrompt(turn, maxTurns) {
     return [
         `Modo objetivo: sua resposta anterior parece um avanco parcial, nao uma conclusao marcada.`,
@@ -331,8 +374,33 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
     // aparecendo como linha permanente via printEvent, pausando o spinner
     // pra nao interlear as duas saidas.
     let spinner = makeSpinner();
+    let patchRepairStreak = 0;
+    let turnLimitExtensionsUsed = 0;
+    const budgetTracker = createBudgetTracker();
     try {
-        for (let turn = 1; turn <= settings.maxTurns; turn++) {
+        for (let turn = 1;; turn++) {
+            if (turn > settings.maxTurns) {
+                // Rede de seguranca virou pergunta em vez de falha direta (achado em
+                // uso real): so faz sentido quando ha um humano de verdade podendo
+                // responder — `confirm` ja retorna false sem TTY/em subagentes
+                // (`silent`), preservando o comportamento antigo nesses casos. Teto
+                // de MAX_TURN_LIMIT_EXTENSIONS: mesmo aprovado, nao pergunta pra
+                // sempre — um modelo genuinamente preso (nunca conclui, nunca
+                // bloqueia) nao pode virar loop infinito so porque alguem/algo
+                // aprovou a extensao uma vez.
+                spinner.stop();
+                const autoExtend = canAutoExtendTurnLimit(settings, silent, turnLimitExtensionsUsed);
+                const canOfferExtension = !silent && !autoExtend && turnLimitExtensionsUsed < MAX_TURN_LIMIT_EXTENSIONS;
+                const shouldExtend = autoExtend || (canOfferExtension && (await confirm(`\nLimite de ${settings.maxTurns} turno(s) atingido sem concluir. Continuar mais ${TURN_LIMIT_EXTENSION} turno(s)? [y/N] `)));
+                if (!shouldExtend) {
+                    goto('failed');
+                    throw new Error(`Limite de turnos atingido (${settings.maxTurns}) sem resposta final.`);
+                }
+                turnLimitExtensionsUsed++;
+                extendTurnLimit(settings);
+                emit('ok', autoExtend ? 'Limite de turnos estendido automaticamente' : 'Limite de turnos estendido', `+${TURN_LIMIT_EXTENSION} (agora ${settings.maxTurns} no total)`);
+                spinner = makeSpinner();
+            }
             // Cancelamento cooperativo: verificado na fronteira de cada turno. A
             // chamada de rede em voo tem timeout proprio (code-agent-gateway.ts), que
             // este modulo nao controla sem editar aquele arquivo — o corte efetivo
@@ -342,6 +410,24 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
                 return { kind: 'aborted' };
             }
             goto('thinking');
+            // Objective Runtime Controller (2026-07-13) — checkpoint de orcamento
+            // logo APOS goto('thinking') de proposito: os 3 estados alcancaveis no
+            // topo do loop (idle/thinking/tool_running, via os `continue` do loop)
+            // ja tem edge legal pra 'thinking' hoje, entao colocar o checkpoint
+            // AQUI exige so UMA edge nova na maquina de estados (thinking ->
+            // budget_exceeded), em vez de enumerar as 3. Nunca estende (nem em
+            // auto mode, diferente do limite de turnos acima): noProgress/
+            // repeatedErrors sao sinal de que o modelo nao esta CONVERGINDO, nao
+            // de que faltou tempo — estender so prolongaria a mesma falha.
+            const budgetDecision = decideBudgetAction(budgetTracker, options.budgetOverrides);
+            if (budgetDecision.exceeded) {
+                spinner.stop();
+                if (!silent) {
+                    emit('warn', 'Orcamento do modo objetivo excedido', `${budgetDecision.dimension} — ${budgetDecision.reason}`);
+                }
+                goto('budget_exceeded');
+                return { kind: 'budget_exceeded', dimension: budgetDecision.dimension, reason: budgetDecision.reason };
+            }
             // GAP-M1-15: auto-compact por TAMANHO antes de cada chamada — sem isso
             // uma sessao com varias tool results grandes (cada uma ate
             // MAX_GATEWAY_SAFE_CHARS) estoura o limite de payload TOTAL do
@@ -358,9 +444,16 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             // em producao: "oi" gastou os 8 turnos so chamando tools e falhou com
             // "Limite de turnos atingido"). No ultimo turno permitido, forca o
             // modelo a responder AGORA em vez de so descobrir isso ao falhar.
-            if (turn === settings.maxTurns) {
+            if (turn === settings.maxTurns && !canAutoExtendTurnLimit(settings, silent, turnLimitExtensionsUsed)) {
+                // 2026-07-13 (achado do Codex review): a redacao antiga ("NEETRU_DONE
+                // se concluiu o maximo possivel") misturava "fiz o que deu" com
+                // "objetivo realmente concluido" — o modelo podia marcar NEETRU_DONE
+                // so por estar sem turnos, reportando uma tarefa incompleta como
+                // terminada. NEETRU_DONE agora exige conclusao REAL; sem isso, texto
+                // normal resumindo o progresso (cai no classificador 'partial', que
+                // ja avisa "Limite do modo objetivo atingido" em vez de fingir feito).
                 const finalTurnInstruction = settings.objectiveMode
-                    ? 'Este e o ultimo turno disponivel. Responda AGORA com NEETRU_DONE se concluiu o maximo possivel, ou NEETRU_BLOCKED se ha bloqueio real. Nao peca mais NEETRU_TOOL nem proponha patch.'
+                    ? 'Este e o ultimo turno disponivel. Se o objetivo esta REALMENTE concluido, responda com NEETRU_DONE. Se ha um bloqueio real (falta de informacao/credencial/decisao externa), responda com NEETRU_BLOCKED. Caso contrario — se ainda falta trabalho mas o tempo acabou — responda em texto normal resumindo o progresso ate aqui, SEM usar NEETRU_DONE (nao esta concluido so porque o tempo acabou). Nao peca mais NEETRU_TOOL nem proponha patch.'
                     : 'Este e o ultimo turno disponivel. Responda AGORA com uma conclusao em texto usando o que voce ja sabe — nao peca mais NEETRU_TOOL nem proponha patch.';
                 messages.push({
                     role: 'user',
@@ -373,16 +466,40 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             spinner = gatewayResult.spinner;
             const content = gatewayResult.content;
             messages.push({ role: 'assistant', content });
-            const tool = parseToolRequest(content);
-            if (tool) {
-                goto('tool_requested');
-                spinner.update(`${baseDetail} · ${tool.tool}`);
-                goto('tool_running');
-                const result = await runCodeTool(settings.cwd, tool, { settings, confirm });
-                spinner.update(`${baseDetail} · ${summarizeToolResult(result)}`);
+            const tools = parseToolRequests(content);
+            if (tools.length > 0) {
+                patchRepairStreak = 0;
+                budgetTracker.noProgressStreak = 0; // acao real (tool) — nao e "so texto"
+                const selectedTools = tools.slice(0, MAX_TOOLS_PER_TURN);
+                const results = [];
+                let singleActionSeen = false;
+                for (const [index, tool] of selectedTools.entries()) {
+                    const isSingleAction = SINGLE_ACTION_TOOLS.has(tool.tool);
+                    if (isSingleAction && singleActionSeen) {
+                        results.push(`--- Resultado da tool ${index + 1}/${selectedTools.length}: ${tool.tool} ---\n` +
+                            `ERRO: apenas uma ferramenta que escreve, executa codigo ou publica pode rodar por resposta. ` +
+                            `Peca esta acao novamente no proximo turno se ainda for necessaria.`);
+                        continue;
+                    }
+                    if (isSingleAction)
+                        singleActionSeen = true;
+                    if (index > 0)
+                        goto('thinking');
+                    goto('tool_requested');
+                    spinner.update(`${baseDetail} · tool ${index + 1}/${selectedTools.length}: ${tool.tool}`);
+                    goto('tool_running');
+                    const result = await runCodeTool(settings.cwd, tool, { settings, confirm });
+                    spinner.update(`${baseDetail} · tool ${index + 1}/${selectedTools.length}: ${summarizeToolResult(result)}`);
+                    results.push(`--- Resultado da tool ${index + 1}/${selectedTools.length}: ${tool.tool} ---\n${result}`);
+                }
+                if (tools.length > selectedTools.length) {
+                    results.push(`--- Ferramentas ignoradas ---\n` +
+                        `A resposta pediu ${tools.length} ferramentas; o limite por turno e ${MAX_TOOLS_PER_TURN}. ` +
+                        `Peca as restantes no proximo turno se ainda forem necessarias.`);
+                }
                 messages.push({
                     role: 'user',
-                    content: truncateForGateway(`Resultado da tool ${tool.tool}:\n\n${result}`),
+                    content: truncateForGateway(`Resultados das tools:\n\n${results.join('\n\n')}`),
                 });
                 continue;
             }
@@ -398,6 +515,29 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
                 if (settings.apply) {
                     const checkError = checkPatchApplies(settings.cwd, patch);
                     if (checkError) {
+                        patchRepairStreak++;
+                        // Cumulativo, NUNCA reseta (nem quando patchRepairStreak reseta
+                        // 2 linhas abaixo) — pega o padrao que o streak local nao pega:
+                        // erra 3x, muda de estrategia (streak reseta), volta a errar 3x,
+                        // reseta de novo, indefinidamente sem convergir. Ver
+                        // code-agent-budget.ts.
+                        budgetTracker.repeatedErrorTotal++;
+                        // 3+ tentativas seguidas de patch invalido: pedir "corrija o
+                        // diff" de novo claramente nao esta funcionando (achado em uso
+                        // real — o mesmo erro se repetia turno apos turno ate esgotar o
+                        // limite). Muda de estrategia em vez de insistir no mesmo pedido.
+                        if (patchRepairStreak >= MAX_CONSECUTIVE_PATCH_REPAIRS) {
+                            spinner.update(`${baseDetail} · patch invalido varias vezes, mudando de estrategia`);
+                            emit('warn', 'Patch invalido varias vezes seguidas — pedindo explicacao em texto', `${patchRepairStreak} tentativas · ultimo erro: ${checkError.slice(0, 200)}`);
+                            messages.push({
+                                role: 'user',
+                                content: truncateForGateway(`Ja foram ${patchRepairStreak} tentativas seguidas de patch invalido (ultimo erro: ${checkError.slice(0, 200)}). ` +
+                                    'Pare de tentar gerar um diff neste turno. Descreva em texto claro, para o usuario, exatamente o ' +
+                                    'que precisa mudar (arquivo, trecho, motivo) — sem NEETRU_PATCH desta vez.'),
+                            });
+                            patchRepairStreak = 0;
+                            continue;
+                        }
                         spinner.update(`${baseDetail} · patch invalido, pedindo correcao`);
                         emit('warn', 'Patch nao aplicavel, pedindo correcao ao modelo', checkError.slice(0, 300));
                         messages.push({
@@ -408,6 +548,7 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
                         continue;
                     }
                 }
+                budgetTracker.noProgressStreak = 0; // patch valido — acao real, nao "so texto"
                 spinner.stop();
                 goto('patch_ready');
                 if (!silent) {
@@ -438,8 +579,19 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             }
             if (settings.objectiveMode) {
                 const objectiveState = classifyObjectiveText(content);
-                const cleanContent = objectiveState === 'partial' ? content : stripObjectiveMarker(content);
-                if (objectiveState === 'partial' && turn < settings.maxTurns) {
+                const displayContent = objectiveDisplayText(objectiveState, content);
+                if (objectiveState === 'partial' &&
+                    (turn < settings.maxTurns || canAutoExtendTurnLimit(settings, silent, turnLimitExtensionsUsed))) {
+                    if (turn >= settings.maxTurns) {
+                        turnLimitExtensionsUsed++;
+                        extendTurnLimit(settings);
+                        emit('ok', 'Limite de turnos estendido automaticamente', `+${TURN_LIMIT_EXTENSION} (agora ${settings.maxTurns} no total)`);
+                    }
+                    patchRepairStreak = 0;
+                    // Chegar aqui significa: sem tool call, sem patch (os dois ramos
+                    // anteriores no loop ja fazem `continue`/`return` antes disto) —
+                    // "sem progresso" e definicional pra este turno.
+                    budgetTracker.noProgressStreak++;
                     spinner.stop();
                     if (!silent) {
                         emit('ok', 'Avanco parcial', 'modo objetivo continuara trabalhando');
@@ -458,10 +610,10 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
                     if (objectiveState === 'partial') {
                         emit('warn', 'Limite do modo objetivo atingido', `${settings.maxTurns} turno(s)`);
                     }
-                    printAssistantText(cleanContent || content);
+                    printAssistantText(displayContent);
                 }
                 goto('idle');
-                return { kind: 'text', text: cleanContent || content };
+                return { kind: 'text', text: displayContent };
             }
             spinner.stop();
             if (!silent) {
@@ -471,9 +623,6 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             goto('idle');
             return { kind: 'text', text: content };
         }
-        spinner.stop();
-        goto('failed');
-        throw new Error(`Limite de turnos atingido (${settings.maxTurns}) sem resposta final.`);
     }
     catch (error) {
         spinner.stop();
@@ -581,17 +730,44 @@ async function runAgentsCommand(line, settings, confirm) {
                 return;
             }
             const outcome = record.outcome;
-            if (outcome?.kind === 'patch' && outcome.patch) {
-                printEvent('ok', 'Patch proposto', `#${idArg} — /agents apply ${idArg} pra aplicar`);
-                printPatchPreview(outcome.patch);
-            }
-            else if (outcome?.kind === 'text') {
-                printAssistantText(outcome.text ?? '(sem texto)');
-            }
-            else {
+            if (!outcome) {
                 printEvent('warn', 'Sem resultado aplicavel', `#${idArg}`);
+                return;
+            }
+            // switch exaustivo (nao if/else) de proposito: um `outcome.kind` novo
+            // sem `case` aqui quebra `tsc --noEmit` de verdade (assign pro `never`
+            // no default), ao contrario do if/else que isto substitui — ver
+            // achado do Codex review 2026-07-13 (a promessa antiga de "o tsc pega"
+            // era falsa pra if/else). Todo `case` (inclusive `default`) termina em
+            // `return` — isto e o ULTIMO statement de `case 'result':` no switch
+            // externo (`switch (sub)` acima); sem `return` em todo ramo, cair do
+            // switch interno cairia direto no proximo `case` do switch externo.
+            switch (outcome.kind) {
+                case 'patch':
+                    if (outcome.patch) {
+                        printEvent('ok', 'Patch proposto', `#${idArg} — /agents apply ${idArg} pra aplicar`);
+                        printPatchPreview(outcome.patch);
+                    }
+                    else {
+                        printEvent('warn', 'Sem resultado aplicavel', `#${idArg}`);
+                    }
+                    return;
+                case 'text':
+                    printAssistantText(outcome.text ?? '(sem texto)');
+                    return;
+                case 'budget_exceeded':
+                    printEvent('warn', 'Subagente parou por orcamento excedido', `${outcome.dimension ?? '?'} — ${outcome.reason ?? `#${idArg}`}`);
+                    return;
+                case 'applied':
+                case 'aborted':
+                    printEvent('warn', 'Sem resultado aplicavel', `#${idArg}`);
+                    return;
+                default: {
+                    const _exhaustive = outcome.kind;
+                    printEvent('warn', 'Sem resultado aplicavel', `#${idArg}`);
+                    return;
+                }
             }
-            return;
         }
         case 'apply': {
             if (!idArg) {
@@ -986,12 +1162,41 @@ async function runInteractive(settings) {
                         const answer = await ctx.askLine(question);
                         return /^(y|yes|s|sim)$/i.test(answer.trim());
                     }, history);
-                    if (wasPlanMode && (outcome.kind === 'text' || outcome.kind === 'patch')) {
-                        pendingPlanTask = line;
-                        printEvent('ok', 'Plano aguardando aprovacao', 'use /approve para entrar em auto mode e executar');
-                    }
-                    else if (!wasPlanMode) {
-                        pendingPlanTask = null;
+                    // switch exaustivo (2026-07-13, Objective Runtime Controller): o
+                    // if/else antigo so cobria 'text'/'patch' explicitamente e
+                    // `!wasPlanMode`; um outcome 'aborted' EM modo plano nao caia em
+                    // nenhum ramo, deixando pendingPlanTask parado num valor antigo —
+                    // achado real do Codex review. `budget_exceeded` teria o mesmo gap.
+                    switch (outcome.kind) {
+                        case 'text':
+                        case 'patch':
+                            if (wasPlanMode) {
+                                pendingPlanTask = line;
+                                printEvent('ok', 'Plano aguardando aprovacao', 'use /approve para entrar em auto mode e executar');
+                            }
+                            else {
+                                pendingPlanTask = null;
+                            }
+                            break;
+                        case 'applied':
+                        case 'aborted':
+                        case 'budget_exceeded':
+                            // Nenhum destes produz um plano novo. So limpa pendingPlanTask
+                            // quando NAO estavamos em modo plano (a tarefa rodou de verdade).
+                            // Em modo plano, um turno que nao produziu plano (abortado,
+                            // orcamento excedido) NAO pode apagar um plano anterior ainda
+                            // valido esperando /approve — senao um Ctrl+C numa pergunta nao
+                            // relacionada destruiria um plano aprovavel (achado da 2a rodada
+                            // de revisao adversarial: a correcao ingenua deste mesmo bug
+                            // introduzia esta regressao especificamente pro caso 'aborted').
+                            if (!wasPlanMode)
+                                pendingPlanTask = null;
+                            break;
+                        default: {
+                            const _exhaustive = outcome.kind;
+                            if (!wasPlanMode)
+                                pendingPlanTask = null;
+                        }
                     }
                 }
                 catch (error) {