@neetru/cli 2.20.3 → 2.22.0

package/dist/commands/code.js

@@ -8,16 +8,16 @@ 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 { applyUnifiedPatch, getGitDiff, getProjectOverview, listFiles, readFileContext, renderColoredDiff, runCodeTool, truncateForGateway, } from '../lib/code-agent-files.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 { 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';
 import { printBox, printEvent, printAssistantText, printPatchPreview, patchSummaryRows, renderHeader, renderInteractiveHelp, renderSessionStatus, renderPromptLabel, printFileSample, printFilePicker, printSessionList, startTurnSpinner, summarizeToolResult, } from '../lib/code-agent-ui.js';
 import { runInkSession } from '../lib/code-agent-tui.js';
 import { configureSubagentRunner, startSubagent, stopSubagent, stopAllSubagents, listSubagents, getSubagentResult, getApplicablePatch, onSubagentSettled, } from '../lib/code-agent-subagents.js';
-const SYSTEM_PROMPT = buildSystemPrompt();
 /** Spinner inerte pro modo silencioso (subagentes) — nunca escreve no terminal. */
 const NOOP_TURN_SPINNER = { update: () => { }, stop: () => { } };
 function asOptionalString(value) {
@@ -44,6 +44,7 @@ export function resolveSettings(opts) {
     });
     const provider = resolveCodeProvider(asOptionalString(opts.provider), config.get('gatewayProvider'), model.model);
     const ultracode = opts.ultracode === true;
+    const objectiveMode = opts.goal === true || opts.objective === true || ultracode;
     const effort = ultracode
         ? ULTRACODE_EFFORT
         : resolveCodeEffort(asOptionalString(opts.effort), config.get('gatewayEffort'));
@@ -70,13 +71,16 @@ export function resolveSettings(opts) {
         timeoutMs: 120_000,
         effort,
         ultracode,
+        objectiveMode,
     };
 }
 async function runReviewCommand(settings, confirm, history) {
     const previousApply = settings.apply;
     const previousYes = settings.yes;
+    const previousObjectiveMode = settings.objectiveMode;
     settings.apply = false;
     settings.yes = false;
+    settings.objectiveMode = false;
     try {
         await runAgentTask([
             'Revise as mudancas atuais do projeto.',
@@ -87,6 +91,7 @@ async function runReviewCommand(settings, confirm, history) {
     finally {
         settings.apply = previousApply;
         settings.yes = previousYes;
+        settings.objectiveMode = previousObjectiveMode;
     }
 }
 function buildInitialPrompt(task, settings) {
@@ -94,13 +99,17 @@ function buildInitialPrompt(task, settings) {
     for (const file of settings.files) {
         fileBlocks.push(readFileContext(settings.cwd, file));
     }
+    const modeBlock = settings.apply
+        ? ''
+        : 'Modo plano ativo: pesquise e leia o necessario, mas nao escreva arquivo, nao execute codigo e nao proponha NEETRU_PATCH. Entregue um plano para aprovacao.';
     return truncateForGateway([
         `Tarefa do usuario:\n${task}`,
         `Cwd: ${settings.cwd}`,
+        modeBlock,
         fileBlocks.length
             ? `Contexto inicial de arquivos:\n\n${fileBlocks.join('\n\n')}`
             : 'Nenhum arquivo foi anexado inicialmente. Use NEETRU_TOOL para pedir contexto local.',
-    ].join('\n\n'));
+    ].filter(Boolean).join('\n\n'));
 }
 async function defaultConfirm(question) {
     if (!process.stdin.isTTY)
@@ -128,11 +137,11 @@ async function defaultConfirm(question) {
  * (nao progresso normal), entao para o spinner pra nao interlear com o
  * `printEvent` e abre um novo pra continuar depois.
  */
-async function callGatewayWithProgress(settings, messages, spinner, baseDetail, silent = false) {
+async function callGatewayWithProgress(settings, messages, spinner, baseDetail, silent = false, signal) {
     try {
         const content = await streamGatewayChat(settings, messages, (_delta, total) => {
             spinner.update(`${baseDetail} · ${total} char(s) recebido(s)`);
-        });
+        }, signal);
         return { content, spinner };
     }
     catch (error) {
@@ -145,7 +154,7 @@ async function callGatewayWithProgress(settings, messages, spinner, baseDetail,
         const fallbackSpinner = silent ? NOOP_TURN_SPINNER : startTurnSpinner('neetru code');
         fallbackSpinner.update(`${baseDetail} · sem stream`);
         try {
-            const content = await callGateway(settings, messages);
+            const content = await callGateway(settings, messages, signal);
             return { content, spinner: fallbackSpinner };
         }
         catch (fallbackError) {
@@ -173,22 +182,128 @@ function delay(ms, signal) {
     });
 }
 export async function callGatewayWithProgressRetrying(settings, messages, spinner, baseDetail, silent, signal) {
+    let activeSpinner = spinner;
     for (let attempt = 0;; attempt++) {
         try {
-            return await callGatewayWithProgress(settings, messages, spinner, baseDetail, silent);
+            return await callGatewayWithProgress(settings, messages, activeSpinner, baseDetail, silent, signal);
         }
         catch (error) {
             if (!isProviderPoolUnavailable(error) || attempt >= POOL_RETRY_DELAYS_MS.length || signal?.aborted) {
                 throw error;
             }
             const waitMs = POOL_RETRY_DELAYS_MS[attempt];
-            spinner.update(`${baseDetail} · pool de IA sem capacidade, tentando de novo em ${Math.round(waitMs / 1000)}s`);
+            // `callGatewayWithProgress` ja parou o spinner recebido (streaming e o
+            // fallback sem stream falharam) antes de lancar — atualizar ELE aqui
+            // nao aparece na tela (achado do Codex review, 2026-07-11). Cria um
+            // spinner novo so pra mostrar a contagem regressiva do retry.
+            activeSpinner = silent ? NOOP_TURN_SPINNER : startTurnSpinner('neetru code');
+            activeSpinner.update(`${baseDetail} · pool de IA sem capacidade, tentando de novo em ${Math.round(waitMs / 1000)}s`);
             await delay(waitMs, signal);
-            if (signal?.aborted)
+            if (signal?.aborted) {
+                activeSpinner.stop();
                 throw error;
+            }
         }
     }
 }
+// 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.
+const MAX_CONSECUTIVE_PATCH_REPAIRS = 3;
+// 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))
+        return 'done';
+    if (/^NEETRU_BLOCKED\b/i.test(trimmed))
+        return 'blocked';
+    return 'partial';
+}
+function stripObjectiveMarker(content) {
+    return content
+        .replace(/^\s*NEETRU_DONE\b[:\s-]*/i, '')
+        .replace(/^\s*NEETRU_BLOCKED\b[:\s-]*/i, '')
+        .trim();
+}
+function buildObjectiveContinuationPrompt(turn, maxTurns) {
+    return [
+        `Modo objetivo: sua resposta anterior parece um avanco parcial, nao uma conclusao marcada.`,
+        `Continue trabalhando no mesmo objetivo sem pedir nova instrucao ao usuario.`,
+        `Se houver proxima acao util, use NEETRU_TOOL ou responda com NEETRU_PATCH.`,
+        `Se estiver realmente concluido, responda com NEETRU_DONE seguido do resumo final.`,
+        `Se estiver bloqueado por informacao/credencial/decisao externa, responda com NEETRU_BLOCKED seguido do motivo.`,
+        `Turno atual: ${turn}/${maxTurns}.`,
+    ].join('\n');
+}
+function applyInteractiveCodeMode(settings, mode) {
+    settings.apply = true;
+    settings.yes = mode === 'accept' || mode === 'auto';
+    settings.objectiveMode = mode === 'auto';
+}
+function currentInteractiveCodeMode(settings) {
+    if (settings.apply && settings.yes && settings.objectiveMode)
+        return 'auto';
+    if (settings.apply && settings.yes)
+        return 'accept';
+    return 'manual';
+}
+function cycleInteractiveCodeMode(settings) {
+    if (!settings.apply) {
+        applyInteractiveCodeMode(settings, 'manual');
+        return 'manual';
+    }
+    const current = currentInteractiveCodeMode(settings);
+    const next = current === 'manual' ? 'accept' : current === 'accept' ? 'auto' : 'manual';
+    applyInteractiveCodeMode(settings, next);
+    return next;
+}
+function formatInteractiveCodeMode(settings) {
+    if (!settings.apply)
+        return 'plano';
+    if (settings.yes && settings.objectiveMode)
+        return 'auto';
+    if (settings.yes)
+        return 'aceita mudancas';
+    if (settings.objectiveMode)
+        return 'manual + objetivo';
+    return 'manual';
+}
+function formatCodeStatusLine(settings) {
+    return `/help comandos  ·  Shift+Tab modo: ${formatInteractiveCodeMode(settings)}  ·  /exit sai  ·  Ctrl+C cancela`;
+}
+function refreshStatusLine(ctx, settings) {
+    ctx.setStatusLine?.(formatCodeStatusLine(settings));
+}
+function buildObjectiveTurnPrompt(task, settings) {
+    const blocks = [task];
+    if (!settings.apply) {
+        blocks.push('Modo plano ativo: use apenas leitura/pesquisa, nao escreva arquivo, nao execute codigo, nao publique nada e nao proponha NEETRU_PATCH. Entregue um plano para aprovacao.');
+    }
+    if (settings.objectiveMode) {
+        blocks.push('Modo objetivo esta ligado nesta tarefa. Continue usando tools/patches enquanto houver proxima acao util. ' +
+            'Finalize texto apenas com NEETRU_DONE quando concluir ou NEETRU_BLOCKED quando houver bloqueio real.');
+    }
+    return blocks.length === 1 ? task : truncateForGateway(blocks.join('\n\n'));
+}
 /**
  * `history` e mutado e reaproveitado entre chamadas: e o que da ao modo
  * interativo memoria de conversa entre turnos do REPL (como Claude Code/Codex),
@@ -219,11 +334,19 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
     };
     const messages = history;
     const isFirstTurn = messages.length === 0;
-    if (isFirstTurn)
-        messages.push({ role: 'system', content: SYSTEM_PROMPT });
+    if (isFirstTurn) {
+        messages.push({
+            role: 'system',
+            content: buildSystemPrompt({
+                skills: loadCodeSkills(settings.cwd),
+                objectiveMode: settings.objectiveMode,
+                planMode: !settings.apply,
+            }),
+        });
+    }
     messages.push({
         role: 'user',
-        content: isFirstTurn ? buildInitialPrompt(task, settings) : task,
+        content: isFirstTurn ? buildInitialPrompt(task, settings) : buildObjectiveTurnPrompt(task, settings),
     });
     // Um unico spinner vivo pra tarefa inteira (nao uma linha por evento) —
     // achado de uso real: turno/tool-call/tool-result como linhas permanentes
@@ -232,8 +355,31 @@ 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;
     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 canOfferExtension = !silent && turnLimitExtensionsUsed < MAX_TURN_LIMIT_EXTENSIONS;
+                const shouldExtend = 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++;
+                settings.maxTurns += TURN_LIMIT_EXTENSION;
+                emit('ok', '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
@@ -260,10 +406,12 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             // "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) {
+                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. 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',
-                    content: '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.',
+                    content: finalTurnInstruction,
                 });
             }
             const baseDetail = `turno ${turn}/${settings.maxTurns}`;
@@ -274,6 +422,7 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             messages.push({ role: 'assistant', content });
             const tool = parseToolRequest(content);
             if (tool) {
+                patchRepairStreak = 0;
                 goto('tool_requested');
                 spinner.update(`${baseDetail} · ${tool.tool}`);
                 goto('tool_running');
@@ -287,6 +436,43 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             }
             const patch = extractPatch(content);
             if (patch) {
+                // Codex review (2026-07-11): antes, um patch invalido (hunk header
+                // sem numeros de linha, etc.) so era detectado DEPOIS do usuario
+                // confirmar "Aplicar este patch? [y/N]" — gastava a interacao numa
+                // resposta fadada a falhar. Valida ANTES de pedir confirmacao; se
+                // invalido, devolve o erro ao modelo pra corrigir o diff (consome um
+                // turno, como uma tool call) em vez de expor o usuario a isso. So
+                // roda quando `settings.apply` (modo plano nunca aplica de verdade).
+                if (settings.apply) {
+                    const checkError = checkPatchApplies(settings.cwd, patch);
+                    if (checkError) {
+                        patchRepairStreak++;
+                        // 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({
+                            role: 'user',
+                            content: truncateForGateway(`O patch proposto NAO pode ser aplicado (git apply --check falhou):\n\n${checkError}\n\n` +
+                                'Corrija o diff (confira os hunk headers "@@ -a,b +c,d @@") e responda de novo com NEETRU_PATCH.'),
+                        });
+                        continue;
+                    }
+                }
                 spinner.stop();
                 goto('patch_ready');
                 if (!silent) {
@@ -315,6 +501,34 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
                 goto('applied');
                 return { kind: 'applied', patch };
             }
+            if (settings.objectiveMode) {
+                const objectiveState = classifyObjectiveText(content);
+                const cleanContent = objectiveState === 'partial' ? content : stripObjectiveMarker(content);
+                if (objectiveState === 'partial' && turn < settings.maxTurns) {
+                    patchRepairStreak = 0;
+                    spinner.stop();
+                    if (!silent) {
+                        emit('ok', 'Avanco parcial', 'modo objetivo continuara trabalhando');
+                    }
+                    messages.push({
+                        role: 'user',
+                        content: truncateForGateway(buildObjectiveContinuationPrompt(turn + 1, settings.maxTurns)),
+                    });
+                    goto('idle');
+                    spinner = makeSpinner();
+                    continue;
+                }
+                spinner.stop();
+                if (!silent) {
+                    console.log();
+                    if (objectiveState === 'partial') {
+                        emit('warn', 'Limite do modo objetivo atingido', `${settings.maxTurns} turno(s)`);
+                    }
+                    printAssistantText(cleanContent || content);
+                }
+                goto('idle');
+                return { kind: 'text', text: cleanContent || content };
+            }
             spinner.stop();
             if (!silent) {
                 console.log();
@@ -323,9 +537,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();
@@ -481,6 +692,53 @@ async function runAgentsCommand(line, settings, confirm) {
             printEvent('warn', 'Subcomando desconhecido', 'use: start | list | stop | result | apply');
     }
 }
+function runSkillsCommand(line, settings) {
+    const args = line.trim().slice('/skills'.length).trim();
+    const [subRaw, ...rest] = args.split(/\s+/).filter(Boolean);
+    const sub = (subRaw ?? 'list').toLowerCase();
+    if (sub === 'init') {
+        const results = installAllBuiltinSkills(settings.cwd);
+        printBox('skills init', results.map((r) => `${r.name}${r.created ? '' : ' (ja existia)'} — ${r.path}`));
+        return;
+    }
+    if (sub === 'show') {
+        const rawName = rest.join(' ');
+        if (!rawName) {
+            printEvent('warn', 'Uso', '/skills show <nome>');
+            return;
+        }
+        let name;
+        try {
+            name = normalizeSkillName(rawName);
+        }
+        catch (error) {
+            printEvent('warn', 'Nome de skill invalido', error instanceof Error ? error.message : String(error));
+            return;
+        }
+        const skill = loadCodeSkills(settings.cwd).find((item) => item.name === name);
+        if (!skill) {
+            printEvent('warn', 'Skill nao encontrada', name);
+            return;
+        }
+        printBox(`skill ${skill.name}`, [
+            `descricao: ${skill.description}`,
+            `fonte: ${skill.relativePath}`,
+            '',
+            ...skill.body.split(/\r?\n/).slice(0, 80),
+            ...(skill.body.split(/\r?\n/).length > 80 ? ['[TRUNCADO: use read_file para ver o SKILL.md completo]'] : []),
+        ]);
+        return;
+    }
+    if (sub !== 'list') {
+        printEvent('warn', 'Subcomando desconhecido', 'use: /skills | /skills init | /skills show <nome>');
+        return;
+    }
+    const skills = loadCodeSkills(settings.cwd);
+    printBox('skills', [
+        `raiz local: ${CODE_SKILLS_ROOT}`,
+        ...skills.map((skill) => `${skill.name}${skill.builtin ? ' (builtin)' : ''} — ${skill.description} — ${skill.relativePath}`),
+    ]);
+}
 async function runInteractive(settings) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         throw new Error('Modo interativo exige terminal TTY. Use: neetru code "tarefa".');
@@ -490,6 +748,33 @@ async function runInteractive(settings) {
     const { resolveSessionEmail } = await import('../lib/auth.js');
     const sessionEmail = await resolveSessionEmail().catch(() => null);
     let history = [];
+    let pendingPlanTask = null;
+    // Limite de mensagens preservadas ao reconstruir o system prompt (troca de
+    // modo). Nao e so `/approve`: TODO toggle de modo (Shift+Tab, /goal,
+    // /ultracode, /plan, /auto, /apply, /yes, /no) chama isto — sem avisar
+    // quando corta, uma sessao que troca de modo varias vezes perde contexto
+    // silenciosamente a cada troca (achado revisando o codigo, 2026-07-13).
+    const RESET_SYSTEM_PROMPT_KEEP_LAST = 12;
+    const resetSystemPromptForCurrentMode = () => {
+        if (history.length === 0)
+            return;
+        const nonSystem = history.filter((message) => message.role !== 'system');
+        const carried = nonSystem.slice(-RESET_SYSTEM_PROMPT_KEEP_LAST);
+        if (nonSystem.length > carried.length) {
+            printEvent('warn', 'Contexto reduzido ao trocar de modo', `mantidas as ultimas ${carried.length} mensagem(ns) de ${nonSystem.length}`);
+        }
+        history = [
+            {
+                role: 'system',
+                content: buildSystemPrompt({
+                    skills: loadCodeSkills(settings.cwd),
+                    objectiveMode: settings.objectiveMode,
+                    planMode: !settings.apply,
+                }),
+            },
+            ...carried,
+        ];
+    };
     // Notificação de conclusão de subagente: UMA linha permanente quando termina
     // (sucesso/falha/parado). Enquanto rodam, subagentes são silenciosos — o
     // LineBuffer do Ink commita esta única linha acima do prompt/spinner sem
@@ -508,7 +793,13 @@ async function runInteractive(settings) {
     try {
         await runInkSession({
             initialPromptLabel: renderPromptLabel(settings),
-            statusLine: '/help comandos  ·  /exit sai  ·  Ctrl+C cancela',
+            statusLine: formatCodeStatusLine(settings),
+            onShiftTab: () => {
+                cycleInteractiveCodeMode(settings);
+                resetSystemPromptForCurrentMode();
+                printEvent('ok', 'Modo atualizado', formatInteractiveCodeMode(settings));
+                return formatCodeStatusLine(settings);
+            },
             onStart: () => {
                 log.banner(sessionEmail);
                 renderHeader(settings, 'interactive');
@@ -526,10 +817,16 @@ async function runInteractive(settings) {
                     });
                     return 'continue';
                 }
+                if (lower === '/skills' || lower.startsWith('/skills ')) {
+                    runSkillsCommand(line, settings);
+                    return 'continue';
+                }
                 if (lower === '/clear') {
                     history = [];
+                    pendingPlanTask = null;
                     renderHeader(settings, 'interactive');
                     printEvent('ok', 'Conversa limpa');
+                    refreshStatusLine(ctx, settings);
                     return 'continue';
                 }
                 if (lower === '/files') {
@@ -655,42 +952,91 @@ async function runInteractive(settings) {
                     printEvent('ok', 'Effort atualizado', next);
                     return 'continue';
                 }
+                if (lower === '/goal' || lower === '/objective' || lower === '/objetivo') {
+                    settings.objectiveMode = !settings.objectiveMode;
+                    resetSystemPromptForCurrentMode();
+                    printEvent(settings.objectiveMode ? 'ok' : 'warn', settings.objectiveMode ? 'Modo objetivo ligado' : 'Modo objetivo desligado', settings.objectiveMode ? 'continua ate NEETRU_DONE/NEETRU_BLOCKED ou limite' : 'uma resposta final encerra o turno');
+                    refreshStatusLine(ctx, settings);
+                    return 'continue';
+                }
                 if (lower === '/ultracode') {
                     settings.ultracode = !settings.ultracode;
                     if (settings.ultracode) {
                         settings.maxTurns = ULTRACODE_MAX_TURNS;
                         settings.maxTokens = ULTRACODE_MAX_TOKENS;
                         settings.effort = ULTRACODE_EFFORT;
+                        settings.objectiveMode = true;
                         printEvent('ok', 'Ultracode ligado', `${ULTRACODE_MAX_TURNS} turnos · ${ULTRACODE_MAX_TOKENS} tokens · effort ${ULTRACODE_EFFORT}`);
                     }
                     else {
                         settings.maxTurns = DEFAULT_CODE_MAX_TURNS;
                         settings.maxTokens = DEFAULT_CODE_MAX_TOKENS;
                         settings.effort = resolveCodeEffort(undefined, config.get('gatewayEffort'));
+                        settings.objectiveMode = false;
                         printEvent('ok', 'Ultracode desligado', `voltou pro default (${DEFAULT_CODE_MAX_TURNS} turnos)`);
                     }
+                    resetSystemPromptForCurrentMode();
+                    refreshStatusLine(ctx, settings);
                     return 'continue';
                 }
                 if (lower === '/plan') {
                     settings.apply = false;
-                    printEvent('ok', 'Modo plano', 'patches nao serao aplicados');
+                    settings.yes = false;
+                    settings.objectiveMode = false;
+                    pendingPlanTask = null;
+                    resetSystemPromptForCurrentMode();
+                    printEvent('ok', 'Modo plano', 'somente leitura/pesquisa; escrita e execucao bloqueadas');
+                    refreshStatusLine(ctx, settings);
+                    return 'continue';
+                }
+                if (lower === '/approve' || lower === '/aprovar' || lower === '/approved') {
+                    applyInteractiveCodeMode(settings, 'auto');
+                    refreshStatusLine(ctx, settings);
+                    printEvent('ok', 'Plano aprovado', 'entrando em auto mode');
+                    if (!pendingPlanTask) {
+                        return 'continue';
+                    }
+                    const approvedTask = pendingPlanTask;
+                    pendingPlanTask = null;
+                    resetSystemPromptForCurrentMode();
+                    try {
+                        await runAgentTask(`Plano aprovado pelo usuario. Execute agora em auto mode a tarefa planejada: ${approvedTask}`, settings, async (question) => {
+                            const answer = await ctx.askLine(question);
+                            return /^(y|yes|s|sim)$/i.test(answer.trim());
+                        }, history);
+                    }
+                    catch (error) {
+                        printEvent('error', 'Falha', error instanceof Error ? error.message : String(error));
+                    }
+                    autoSaveCodeSession(settings, history);
+                    return 'continue';
+                }
+                if (lower === '/auto') {
+                    applyInteractiveCodeMode(settings, 'auto');
+                    resetSystemPromptForCurrentMode();
+                    printEvent('ok', 'Auto mode ativo', 'sem confirmacao para patches, shell_exec, git_push e gh_pr_create');
+                    refreshStatusLine(ctx, settings);
                     return 'continue';
                 }
                 if (lower === '/apply') {
-                    settings.apply = true;
-                    settings.yes = false;
+                    applyInteractiveCodeMode(settings, 'manual');
+                    resetSystemPromptForCurrentMode();
                     printEvent('ok', 'Modo aplicar', 'pedira confirmacao antes do git apply');
+                    refreshStatusLine(ctx, settings);
                     return 'continue';
                 }
                 if (lower === '/yes') {
-                    settings.apply = true;
-                    settings.yes = true;
+                    applyInteractiveCodeMode(settings, 'accept');
+                    resetSystemPromptForCurrentMode();
                     printEvent('warn', 'Auto-aplicar ativo', 'patches validos serao aplicados sem pergunta');
+                    refreshStatusLine(ctx, settings);
                     return 'continue';
                 }
                 if (lower === '/no') {
-                    settings.yes = false;
+                    applyInteractiveCodeMode(settings, 'manual');
+                    resetSystemPromptForCurrentMode();
                     printEvent('ok', 'Confirmacao manual ativa');
+                    refreshStatusLine(ctx, settings);
                     return 'continue';
                 }
                 if (lower === '/help' || lower === '/ajuda') {
@@ -698,10 +1044,18 @@ async function runInteractive(settings) {
                     return 'continue';
                 }
                 try {
-                    await runAgentTask(line, settings, async (question) => {
+                    const wasPlanMode = !settings.apply;
+                    const outcome = await runAgentTask(line, settings, async (question) => {
                         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;
+                    }
                 }
                 catch (error) {
                     printEvent('error', 'Falha', error instanceof Error ? error.message : String(error));
@@ -735,7 +1089,7 @@ function runDoctor(settings) {
     console.log(`  Core API:     ${chalk.dim(apiUrl)}`);
     console.log(`  AI Gateway:   ${chalk.dim(AI_GATEWAY_CHAT_PATH)}`);
     console.log(`  git:          ${git.status === 0 ? chalk.green('ok') : chalk.red('falhou')}`);
-    console.log(`  modo patch:   ${settings.apply ? 'aplica com confirmacao' : 'somente plano'}`);
+    console.log(`  modo patch:   ${formatInteractiveCodeMode(settings)}`);
     console.log();
     if (!token || git.status !== 0)
         setSafeExitCode(1);