@neetru/cli 2.20.3 → 2.21.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 Convenção: [Keep a Changelog](https://keepachangelog.com/) + [SemVer](https://semver.org/).
 
+## [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.
+
+### Adicionado
+
+- **Skills locais do `neetru code`** — skills vivem em `.neetru/code/skills/<nome>/SKILL.md` (frontmatter `name`/`description`). Nova ferramenta `NEETRU_TOOL {"tool":"create_skill","name":"...","description":"..."}` (pede confirmação, respeita `--yes`). Comando `/skills` (lista carregadas), `/skills init` (materializa as skills builtin em disco), `/skills show <nome>`. O system prompt carrega as skills disponíveis no início da sessão (`src/lib/code-agent-skills.ts`).
+- **3 skills builtin** (sempre carregadas, mesmo sem `.neetru/code/skills/` local) — `skill-creator`, `design-excellence` (cores/contraste/tipografia/layout/estados de UI) e `structured-programming` (funções pequenas e coesas, sem abstração prematura, erro tratado só na fronteira). `/skills init` materializa as 3 de uma vez (`installAllBuiltinSkills`).
+- **Validação de patch ANTES da confirmação** — `checkPatchApplies` (`code-agent-files.ts`) roda `git apply --check` assim que o modelo propõe um patch, antes de mostrar "Aplicar este patch? [y/N]". Se inválido, o erro volta pro modelo pedindo um diff corrigido.
+- **Modo plano / modo objetivo / auto mode / `/approve`** — 4 modos reais agora (`somente plano`, `manual`, `aceita mudanças`, `auto`), com Shift+Tab ciclando entre eles. Modo plano bloqueia toda ferramenta que escreve/executa/publica (`PLAN_MODE_BLOCKED_TOOLS`); modo objetivo (`/goal`, `--goal`/`--objective`) continua trabalhando entre turnos até `NEETRU_DONE`/`NEETRU_BLOCKED`/limite, em vez de parar em toda resposta parcial; `/approve` aprova um plano e entra em auto mode executando a tarefa planejada; `/auto` entra direto em auto mode. Auto mode (`yes && objectiveMode`) é o único em que `git_push`/`gh_pr_create`/`shell_exec`/`create_skill` rodam sem confirmação — nos demais modos essas 4 ferramentas continuam confirmando sempre.
+- **Ferramentas de pesquisa externa** — `web_search`/`web_fetch` (DuckDuckGo HTML + fetch genérico, com bloqueio de host privado/SSRF) e `github_search`/`github_repo` (API pública do GitHub) em `code-agent-web-tools.ts`.
+
+### Corrigido
+
+- **`thinking -> thinking` inválido no loop de auto-correção de patch** — auto-transição faltava em `VALID_TRANSITIONS`.
+- **P1 (Codex-rescue, confirmado por leitura direta) — preview de confirmação não sanitizava texto do modelo** — `shell_exec`/`gh_pr_create`/`git_commit` interpolavam `command`/`title`/`body`/`message` crus no prompt `[y/N]`; um valor "repetido" de conteúdo de arquivo lido (prompt injection) podia usar ESC/CR pra reescrever visualmente o que aparece na tela, tornando a confirmação tecnicamente real mas enganosa. Nova `sanitizeForPreview()` (`code-agent-git-tools.ts`) remove C0/C1 antes de montar a preview — só a preview muda, o valor original continua sendo o que roda após aprovado.
+- **P2 (Codex-rescue, confirmado por leitura direta) — `/agents stop` não cancelava a chamada de rede em voo** — o `AbortSignal` do subagente só era checado nas bordas do turno; `callGateway`/`streamGatewayChat` nunca recebiam esse signal, então parar um subagente cortava só o PRÓXIMO turno, não a requisição HTTP já em andamento. `streamGatewayChat` agora combina (`AbortSignal.any`) o timeout interno com o signal do chamador; `callGateway` encaminha pro `apiRequest`.
+- **P2 (Codex-rescue, confirmado por leitura direta) — contagem regressiva do retry (GAP-M1-21) não aparecia na tela** — `callGatewayWithProgress` já para o spinner recebido antes de lançar (streaming + fallback sem stream falharam); o wrapper de retry atualizava esse MESMO spinner morto pra mostrar "tentando de novo em Ns". Agora cria um spinner novo pra cada rodada de retry.
+- **Cabeçalho/`​/status` não distinguiam "aceita mudanças" de "auto"** — `renderHeader`/`renderSessionStatus` ainda usavam a lógica binária antiga (`apply`×`yes`) e mostravam os dois modos como "auto-aplica", apesar de terem garantias de confirmação diferentes. Nova `formatPatchMode()` (`code-agent-ui.ts`) reflete os 4 estados reais.
+- **Troca de modo truncava o histórico pra 12 mensagens em silêncio** — Shift+Tab e todo comando de modo (`/goal`, `/ultracode`, `/plan`, `/approve`, `/auto`, `/apply`, `/yes`, `/no`) reconstroem o system prompt preservando só as últimas 12 mensagens; agora avisa quando isso de fato corta contexto.
+- Doc comments perdidos em `InkSessionContext` (`code-agent-tui.tsx`) restaurados.
+
 ## [2.20.3] — 2026-07-11 (`neetru code` — HOTFIX: erro real de patch mascarado por "Transicao de estado invalida")
 
 > Reportado ao vivo: usuário aprovou um patch, `git apply` rejeitou (hunk header malformado no diff gerado pelo modelo), mas em vez do erro real apareceu `Falha  Transicao de estado invalida: awaiting_confirm -> failed`.

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,104 @@ 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;
+            }
         }
     }
 }
+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 +310,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
@@ -260,10 +359,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}`;
@@ -287,6 +388,26 @@ 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) {
+                        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 +436,33 @@ 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) {
+                    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();
@@ -481,6 +629,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 +685,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 +730,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 +754,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 +889,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 +981,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 +1026,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);