@neetru/cli 2.14.0 → 2.16.0

package/dist/commands/code.js

@@ -3,146 +3,18 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
-import { apiRequest } from '../lib/api-client.js';
 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 { applyUnifiedPatch, listFiles, readFileContext, renderColoredDiff, runCodeTool, } from '../lib/code-agent-files.js';
+import { applyUnifiedPatch, getGitDiff, getProjectOverview, listFiles, readFileContext, renderColoredDiff, runCodeTool, truncateForGateway, } from '../lib/code-agent-files.js';
+import { compactCodeHistory, compactHistoryToFit, MAX_HISTORY_TOTAL_CHARS, saveCodeSession, listCodeSessions, loadCodeSession, logAppliedPatch, CodeAgentStateMachine, } from '../lib/code-agent-session.js';
 import { DEFAULT_CODE_MAX_TOKENS, DEFAULT_CODE_MAX_TURNS, DEFAULT_CODE_TEMPERATURE, parseBoundedNumber, resolveCodeModel, } from '../lib/code-agent-settings.js';
-const AI_GATEWAY_CHAT_PATH = '/api/cli/v1/ai/chat';
-const UI_MIN_WIDTH = 72;
-const UI_MAX_WIDTH = 110;
-const SYSTEM_PROMPT = `
-Voce e o Neetru Code, um assistente local de codificacao da Neetru.
-Voce conversa com modelos do AI Gateway do Neetru Core, normalmente Groq/NVIDIA.
-Nao use Anthropic/Claude como caminho assumido.
-
-Voce nao tem tool calling nativo. Use exatamente estes protocolos textuais:
-
-NEETRU_TOOL {"tool":"read_file","path":"caminho/relativo.ext"}
-NEETRU_TOOL {"tool":"list_files","pattern":"texto opcional"}
-NEETRU_TOOL {"tool":"search","query":"texto literal"}
-
-Regras:
-- Peca arquivos antes de alterar codigo quando faltar contexto.
-- Nunca invente conteudo de arquivo.
-- Peca uma tool por resposta, no maximo.
-- Quando estiver pronto para alterar, responda somente com um diff aplicavel por git:
-
-NEETRU_PATCH
-diff --git a/path b/path
-...
-NEETRU_END
-
-- Nao coloque explicacao dentro do bloco NEETRU_PATCH.
-- Se a tarefa nao exigir alteracao, responda em texto curto.
-`.trim();
-function stripAnsi(text) {
-    return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
-}
-function visibleLength(text) {
-    return Array.from(stripAnsi(text)).length;
-}
-function padVisible(text, width) {
-    return `${text}${' '.repeat(Math.max(0, width - visibleLength(text)))}`;
-}
-function terminalWidth() {
-    const raw = process.stdout.columns ?? 88;
-    return Math.max(UI_MIN_WIDTH, Math.min(UI_MAX_WIDTH, raw));
-}
-function truncateMiddle(text, max) {
-    if (visibleLength(text) <= max)
-        return text;
-    if (max <= 5)
-        return text.slice(0, max);
-    const clean = stripAnsi(text);
-    const left = Math.ceil((max - 3) / 2);
-    const right = Math.floor((max - 3) / 2);
-    return `${clean.slice(0, left)}...${clean.slice(clean.length - right)}`;
-}
-function wrapPlain(text, width) {
-    const clean = stripAnsi(text);
-    if (clean.length <= width)
-        return [clean];
-    const out = [];
-    let rest = clean;
-    while (rest.length > width) {
-        const slice = rest.slice(0, width + 1);
-        const breakAt = Math.max(slice.lastIndexOf(' '), slice.lastIndexOf('/'), slice.lastIndexOf('\\'));
-        const idx = breakAt > Math.floor(width * 0.45) ? breakAt : width;
-        out.push(rest.slice(0, idx).trimEnd());
-        rest = rest.slice(idx).trimStart();
-    }
-    if (rest)
-        out.push(rest);
-    return out;
-}
-function printBox(title, rows = []) {
-    const width = terminalWidth();
-    const inner = width - 2;
-    const label = title ? ` ${title} ` : '';
-    const top = `+${label}${'-'.repeat(Math.max(0, inner - visibleLength(label)))}+`;
-    console.log(chalk.dim(top));
-    for (const row of rows) {
-        const wrapped = wrapPlain(row, inner - 2);
-        for (const line of wrapped) {
-            console.log(chalk.dim('| ') + padVisible(truncateMiddle(line, inner - 2), inner - 2) + chalk.dim(' |'));
-        }
-    }
-    console.log(chalk.dim(`+${'-'.repeat(inner)}+`));
-}
-function printDivider(label) {
-    const width = terminalWidth();
-    if (!label) {
-        console.log(chalk.dim('-'.repeat(width)));
-        return;
-    }
-    const title = ` ${label} `;
-    console.log(chalk.dim(`${title}${'-'.repeat(Math.max(0, width - visibleLength(title)))}`));
-}
-function printEvent(kind, title, detail) {
-    const colors = {
-        wait: chalk.cyan,
-        tool: chalk.blue,
-        ok: chalk.green,
-        warn: chalk.yellow,
-        error: chalk.red,
-    };
-    const tag = colors[kind](kind.toUpperCase().padEnd(5));
-    const suffix = detail ? chalk.dim(`  ${detail}`) : '';
-    console.log(`${tag} ${chalk.bold(title)}${suffix}`);
-}
-function toolDetail(tool) {
-    if (!tool)
-        return '';
-    if (tool.tool === 'read_file' && typeof tool.path === 'string')
-        return tool.path;
-    if (tool.tool === 'list_files' && typeof tool.pattern === 'string' && tool.pattern)
-        return tool.pattern;
-    if (tool.tool === 'search' && typeof tool.query === 'string')
-        return tool.query;
-    return '';
-}
-function summarizeToolResult(result) {
-    const lines = result.split(/\r?\n/).filter(Boolean).length;
-    const chars = result.length;
-    return `${lines} linha(s), ${chars} char(s)`;
-}
-function printAssistantText(content) {
-    printDivider('assistant');
-    process.stdout.write(`${content.trim()}\n`);
-    printDivider();
-}
-function printPatchPreview(patch) {
-    const files = Array.from(patch.matchAll(/^diff --git a\/(.+?) b\//gm)).map((m) => m[1]);
-    printBox('patch proposto', [
-        files.length ? `arquivos: ${files.join(', ')}` : 'arquivos: nao detectado',
-        'aplicacao: git apply depois de confirmacao',
-    ]);
-    process.stdout.write(renderColoredDiff(patch));
-}
+import { callGateway, streamGatewayChat, AI_GATEWAY_CHAT_PATH } from '../lib/code-agent-gateway.js';
+import { buildSystemPrompt } from '../lib/code-agent-tools.js';
+import { printBox, printEvent, printAssistantText, printPatchPreview, patchSummaryRows, renderHeader, renderInteractiveHelp, renderSessionStatus, renderPrompt, printFileSample, printFilePicker, printSessionList, startTurnSpinner, summarizeToolResult, toolDetail, } from '../lib/code-agent-ui.js';
+const SYSTEM_PROMPT = buildSystemPrompt();
 function asOptionalString(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
@@ -189,59 +61,35 @@ export function resolveSettings(opts) {
         timeoutMs: 120_000,
     };
 }
-function renderHeader(settings, mode = 'oneshot') {
-    console.log();
-    printBox('Neetru Code', [
-        `AI Gateway  ${AI_GATEWAY_CHAT_PATH}`,
-        `Model       ${settings.model}`,
-        `Workspace   ${truncateMiddle(settings.cwd, terminalWidth() - 18)}`,
-        `Mode        ${mode} | patch ${settings.apply ? 'confirm' : 'plan-only'} | turns ${settings.maxTurns} | tokens ${settings.maxTokens}`,
-    ]);
-    if (settings.modelWarning)
-        log.warn(settings.modelWarning);
-    console.log();
-}
-function renderInteractiveHelp() {
-    printBox('controles', [
-        '/files  listar arquivos do workspace',
-        '/model  mostrar modelo atual',
-        '/clear  limpar tela e esquecer o historico da conversa',
-        '/help   mostrar estes controles',
-        '/exit   sair',
-    ]);
-    console.log(chalk.dim('Digite uma tarefa em linguagem natural para a IA inspecionar e propor patch.'));
-    console.log();
+async function runReviewCommand(settings, confirm, history) {
+    const previousApply = settings.apply;
+    const previousYes = settings.yes;
+    settings.apply = false;
+    settings.yes = false;
+    try {
+        await runAgentTask([
+            'Revise as mudancas atuais do projeto.',
+            'Use NEETRU_TOOL {"tool":"git_status"} e NEETRU_TOOL {"tool":"git_diff"} se precisar de contexto.',
+            'Nao proponha patch automaticamente. Liste achados por severidade, com arquivo/linha quando possivel.',
+        ].join('\n'), settings, confirm, history);
+    }
+    finally {
+        settings.apply = previousApply;
+        settings.yes = previousYes;
+    }
 }
 function buildInitialPrompt(task, settings) {
     const fileBlocks = [];
     for (const file of settings.files) {
         fileBlocks.push(readFileContext(settings.cwd, file));
     }
-    return [
+    return truncateForGateway([
         `Tarefa do usuario:\n${task}`,
         `Cwd: ${settings.cwd}`,
         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');
-}
-async function callGateway(settings, messages) {
-    const response = await apiRequest(AI_GATEWAY_CHAT_PATH, {
-        method: 'POST',
-        body: {
-            model: settings.model,
-            messages,
-            stream: false,
-            maxTokens: settings.maxTokens,
-            temperature: settings.temperature,
-        },
-        timeoutMs: settings.timeoutMs,
-    });
-    const content = response.choices?.[0]?.message?.content;
-    if (typeof content !== 'string') {
-        throw new Error('AI Gateway retornou resposta sem choices[0].message.content.');
-    }
-    return content;
+    ].join('\n\n'));
 }
 async function defaultConfirm(question) {
     if (!process.stdin.isTTY)
@@ -255,17 +103,64 @@ async function defaultConfirm(question) {
         rl.close();
     }
 }
+/**
+ * Chama o AI Gateway mostrando progresso ao vivo — spinner animado + cor
+ * rotativa + tempo decorrido (`startTurnSpinner`, code-agent-ui.ts) em vez de
+ * ficar estatico durante respostas longas. Cobre TANTO o streaming quanto o
+ * fallback sem stream (antes o fallback ficava mudo do aviso ate a resposta
+ * chegar ou o timeout estourar). So anima em TTY real — em saida
+ * nao-interativa (pipe/CI/teste) isso so poluiria o log.
+ *
+ * Fallback: qualquer falha no streaming (rede, formato inesperado) refaz a
+ * chamada sem streaming — a corretude do turno nunca depende do streaming
+ * funcionar, so a experiencia visual.
+ */
+async function callGatewayWithProgress(settings, messages) {
+    const spinner = startTurnSpinner('AI Gateway');
+    try {
+        const content = await streamGatewayChat(settings, messages, (_delta, total) => {
+            spinner.update(`${total} char(s) recebido(s)`);
+        });
+        spinner.stop();
+        return content;
+    }
+    catch (error) {
+        spinner.stop();
+        printEvent('warn', 'Streaming falhou, tentando sem streaming', error instanceof Error ? error.message : String(error));
+        const fallbackSpinner = startTurnSpinner('AI Gateway (sem stream)');
+        try {
+            const content = await callGateway(settings, messages);
+            fallbackSpinner.stop();
+            return content;
+        }
+        catch (fallbackError) {
+            fallbackSpinner.stop();
+            throw fallbackError;
+        }
+    }
+}
 /**
  * `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),
  * em vez de cada linha digitada virar uma requisicao amnesica. O one-shot
  * (`neetru code "tarefa"`) chama sem `history` — cada `runAgentTask` comeca do
  * zero, igual sempre foi.
+ *
+ * `onState` (opcional): observa a maquina de estados da sessao (Fase 2,
+ * NEETRU_CODE_ARCHITECTURE.md) — usado por testes pra verificar a sequencia
+ * idle -> thinking -> tool_requested -> tool_running -> ... sem mockar o
+ * AI Gateway inteiro. Cada chamada de runAgentTask e um ciclo completo
+ * (comeca e termina em idle/applied/failed/aborted).
  */
-export async function runAgentTask(task, settings, confirm, history = []) {
+export async function runAgentTask(task, settings, confirm, history = [], onState) {
     if (!getActiveTokenSync()) {
         throw new Error('Sessao Neetru ausente ou expirada. Rode `neetru login`.');
     }
+    const machine = new CodeAgentStateMachine();
+    const goto = (next) => {
+        machine.transition(next);
+        onState?.(next);
+    };
     const messages = history;
     const isFirstTurn = messages.length === 0;
     if (isFirstTurn)
@@ -274,54 +169,78 @@ export async function runAgentTask(task, settings, confirm, history = []) {
         role: 'user',
         content: isFirstTurn ? buildInitialPrompt(task, settings) : task,
     });
-    for (let turn = 1; turn <= settings.maxTurns; turn++) {
-        printEvent('wait', 'AI Gateway', `turno ${turn}/${settings.maxTurns}`);
-        const content = await callGateway(settings, messages);
-        messages.push({ role: 'assistant', content });
-        const tool = parseToolRequest(content);
-        if (tool) {
-            printEvent('tool', tool.tool, toolDetail(tool));
-            const result = runCodeTool(settings.cwd, tool);
-            printEvent('ok', 'contexto local', summarizeToolResult(result));
-            messages.push({
-                role: 'user',
-                content: `Resultado da tool ${tool.tool}:\n\n${result}`,
-            });
-            continue;
-        }
-        const patch = extractPatch(content);
-        if (patch) {
-            console.log();
-            printPatchPreview(patch);
-            if (!settings.apply) {
-                printEvent('warn', 'Patch nao aplicado', '--plan/--no-apply');
-                return;
+    try {
+        for (let turn = 1; turn <= settings.maxTurns; turn++) {
+            goto('thinking');
+            // 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
+            // provider (HTTP 413) mesmo com cada mensagem individual dentro do
+            // limite. `/compact` manual continua existindo pro usuario forcar
+            // antes disso se quiser.
+            const autoCompacted = compactHistoryToFit(messages, MAX_HISTORY_TOTAL_CHARS);
+            if (autoCompacted > 0) {
+                printEvent('warn', 'Historico compactado automaticamente', `${autoCompacted} mensagem(ns) antiga(s) removida(s)`);
             }
-            const approved = settings.yes || (await confirm('\nAplicar este patch? [y/N] '));
-            if (!approved) {
-                printEvent('warn', 'Patch nao aplicado');
+            printEvent('wait', 'AI Gateway', `turno ${turn}/${settings.maxTurns}`);
+            const content = await callGatewayWithProgress(settings, messages);
+            messages.push({ role: 'assistant', content });
+            const tool = parseToolRequest(content);
+            if (tool) {
+                goto('tool_requested');
+                printEvent('tool', tool.tool, toolDetail(tool));
+                goto('tool_running');
+                const result = runCodeTool(settings.cwd, tool);
+                printEvent('ok', 'contexto local', summarizeToolResult(result));
+                messages.push({
+                    role: 'user',
+                    content: truncateForGateway(`Resultado da tool ${tool.tool}:\n\n${result}`),
+                });
+                continue;
+            }
+            const patch = extractPatch(content);
+            if (patch) {
+                goto('patch_ready');
+                console.log();
+                printPatchPreview(patch);
+                if (!settings.apply) {
+                    printEvent('warn', 'Patch nao aplicado', '--plan/--no-apply');
+                    goto('aborted');
+                    return;
+                }
+                const approved = settings.yes || (await (async () => {
+                    goto('awaiting_confirm');
+                    return confirm('\nAplicar este patch? [y/N] ');
+                })());
+                if (!approved) {
+                    printEvent('warn', 'Patch nao aplicado');
+                    goto('aborted');
+                    return;
+                }
+                applyUnifiedPatch(settings.cwd, patch);
+                logAppliedPatch(settings.cwd, patchSummaryRows(patch)[0] ?? 'arquivos: nao detectado');
+                printEvent('ok', 'Patch aplicado', 'git apply');
+                goto('applied');
                 return;
             }
-            applyUnifiedPatch(settings.cwd, patch);
-            printEvent('ok', 'Patch aplicado', 'git apply');
+            console.log();
+            printAssistantText(content);
+            goto('idle');
             return;
         }
-        console.log();
-        printAssistantText(content);
-        return;
+        goto('failed');
+        throw new Error(`Limite de turnos atingido (${settings.maxTurns}) sem resposta final.`);
     }
-    throw new Error(`Limite de turnos atingido (${settings.maxTurns}) sem resposta final.`);
-}
-function printFileSample(settings) {
-    const files = listFiles(settings.cwd).slice(0, 60);
-    if (files.length === 0) {
-        printEvent('warn', 'Nenhum arquivo encontrado');
-        return;
+    catch (error) {
+        if (machine.state !== 'failed' && machine.state !== 'aborted' && machine.state !== 'applied') {
+            goto('failed');
+        }
+        throw error;
     }
-    printBox('arquivos', [
-        ...files,
-        ...(files.length === 60 ? ['... lista truncada em 60 arquivos.'] : []),
-    ]);
+}
+function printFileSampleForSettings(settings) {
+    const all = listFiles(settings.cwd);
+    printFileSample(all.slice(0, 60), all.length);
 }
 async function runInteractive(settings) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -329,11 +248,13 @@ async function runInteractive(settings) {
     }
     renderHeader(settings, 'interactive');
     renderInteractiveHelp();
+    if (settings.modelWarning)
+        log.warn(settings.modelWarning);
     let history = [];
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     try {
         for (;;) {
-            const line = (await rl.question(chalk.cyan('> '))).trim();
+            const line = (await rl.question(renderPrompt(settings))).trim();
             if (!line)
                 continue;
             const lower = line.toLowerCase();
@@ -344,16 +265,139 @@ async function runInteractive(settings) {
                 process.stdout.write('\x1B[2J\x1B[H');
                 renderHeader(settings, 'interactive');
                 renderInteractiveHelp();
+                printEvent('ok', 'Conversa limpa');
                 continue;
             }
             if (lower === '/files') {
-                printFileSample(settings);
+                printFileSampleForSettings(settings);
+                continue;
+            }
+            if (lower === '/pick') {
+                const all = listFiles(settings.cwd);
+                const shown = all.slice(0, 60);
+                printFilePicker(shown, all.length);
+                if (shown.length === 0)
+                    continue;
+                const answer = await rl.question('Numero(s) separado(s) por virgula (Enter cancela): ');
+                const raw = answer.trim();
+                if (!raw) {
+                    printEvent('warn', 'Cancelado');
+                    continue;
+                }
+                const picked = [];
+                for (const part of raw.split(',')) {
+                    const idx = Number.parseInt(part.trim(), 10);
+                    if (Number.isInteger(idx) && idx >= 1 && idx <= shown.length) {
+                        picked.push(shown[idx - 1]);
+                    }
+                }
+                if (picked.length === 0) {
+                    printEvent('warn', 'Nenhum arquivo valido selecionado');
+                    continue;
+                }
+                const blocks = picked.map((file) => readFileContext(settings.cwd, file));
+                history.push({
+                    role: 'user',
+                    content: truncateForGateway(`Arquivos anexados manualmente via /pick:\n\n${blocks.join('\n\n')}`),
+                });
+                printEvent('ok', 'Arquivo(s) anexado(s) ao contexto', picked.join(', '));
+                continue;
+            }
+            if (lower === '/overview' || lower === '/visao') {
+                printBox('visao do projeto', getProjectOverview(settings.cwd).split(/\r?\n/));
+                continue;
+            }
+            if (lower === '/diff') {
+                const diff = getGitDiff(settings.cwd);
+                if (diff === '(sem diff)') {
+                    printEvent('ok', 'Sem diff local');
+                }
+                else if (diff.startsWith('ERRO:')) {
+                    printEvent('error', 'git diff', diff);
+                }
+                else {
+                    printBox('diff atual', ['git diff -- .']);
+                    process.stdout.write(renderColoredDiff(diff));
+                    if (!diff.endsWith('\n'))
+                        process.stdout.write('\n');
+                }
+                continue;
+            }
+            if (lower === '/review') {
+                await runReviewCommand(settings, async (question) => {
+                    const answer = await rl.question(question);
+                    return /^(y|yes|s|sim)$/i.test(answer.trim());
+                }, history);
+                continue;
+            }
+            if (lower === '/save') {
+                const saved = saveCodeSession(settings, history);
+                printEvent('ok', 'Sessao salva', saved);
+                continue;
+            }
+            if (lower === '/resume') {
+                const sessions = listCodeSessions(settings.cwd);
+                printSessionList(sessions);
+                if (sessions.length === 0)
+                    continue;
+                if (history.length > 0) {
+                    const overwrite = await rl.question('\nConversa atual sera substituida. Continuar? [y/N] ');
+                    if (!/^(y|yes|s|sim)$/i.test(overwrite.trim())) {
+                        printEvent('warn', 'Cancelado');
+                        continue;
+                    }
+                }
+                const answer = await rl.question('Numero da sessao (Enter cancela): ');
+                const idx = Number.parseInt(answer.trim(), 10);
+                if (!Number.isInteger(idx) || idx < 1 || idx > sessions.length) {
+                    printEvent('warn', 'Cancelado');
+                    continue;
+                }
+                const picked = sessions[idx - 1];
+                try {
+                    history = loadCodeSession(settings.cwd, picked.file);
+                    printEvent('ok', 'Sessao retomada', `${picked.file} (${history.length} mensagem(ns))`);
+                }
+                catch (error) {
+                    printEvent('error', 'Falha ao retomar sessao', error instanceof Error ? error.message : String(error));
+                }
+                continue;
+            }
+            if (lower === '/compact') {
+                const removed = compactCodeHistory(history);
+                printEvent('ok', 'Historico compactado', `${removed} mensagem(ns) removida(s)`);
+                continue;
+            }
+            if (lower === '/status' || lower === '/context') {
+                renderSessionStatus(settings, history);
                 continue;
             }
             if (lower === '/model') {
                 printBox('modelo', [settings.model]);
                 continue;
             }
+            if (lower === '/plan') {
+                settings.apply = false;
+                printEvent('ok', 'Modo plano', 'patches nao serao aplicados');
+                continue;
+            }
+            if (lower === '/apply') {
+                settings.apply = true;
+                settings.yes = false;
+                printEvent('ok', 'Modo aplicar', 'pedira confirmacao antes do git apply');
+                continue;
+            }
+            if (lower === '/yes') {
+                settings.apply = true;
+                settings.yes = true;
+                printEvent('warn', 'Auto-aplicar ativo', 'patches validos serao aplicados sem pergunta');
+                continue;
+            }
+            if (lower === '/no') {
+                settings.yes = false;
+                printEvent('ok', 'Confirmacao manual ativa');
+                continue;
+            }
             if (lower === '/help' || lower === '/ajuda') {
                 renderInteractiveHelp();
                 continue;
@@ -378,9 +422,12 @@ function runDoctor(settings) {
     const apiUrl = config.get('neetruApiUrl') ?? 'https://api.neetru.com';
     const git = spawnSync('git', ['--version'], { cwd: settings.cwd, encoding: 'utf8' });
     renderHeader(settings, 'doctor');
+    if (settings.modelWarning)
+        log.warn(settings.modelWarning);
     console.log(chalk.bold('Doctor'));
     console.log(`  token Neetru: ${token ? chalk.green('ok') : chalk.red('ausente')}`);
     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();
@@ -423,6 +470,8 @@ export async function runCodeCommand(promptParts, opts = {}) {
             return;
         }
         renderHeader(settings, 'oneshot');
+        if (settings.modelWarning)
+            log.warn(settings.modelWarning);
         await runAgentTask(task, settings, defaultConfirm);
     }
     catch (error) {