@neetru/cli 2.19.0 → 2.20.0

package/dist/commands/code.js

@@ -9,13 +9,16 @@ 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 { 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, resolveCodeProvider, } from '../lib/code-agent-settings.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 { buildSystemPrompt } from '../lib/code-agent-tools.js';
-import { printBox, printEvent, printAssistantText, printPatchPreview, patchSummaryRows, renderHeader, renderInteractiveHelp, renderSessionStatus, renderPromptLabel, printFileSample, printFilePicker, printSessionList, startTurnSpinner, summarizeToolResult, toolDetail, } from '../lib/code-agent-ui.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) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
@@ -38,23 +41,25 @@ export function resolveSettings(opts) {
         envModel: process.env.NEETRU_CODE_MODEL,
         configuredGatewayModel: config.get('gatewayModel'),
     });
-    const provider = resolveCodeProvider(asOptionalString(opts.provider), config.get('gatewayProvider'));
+    const provider = resolveCodeProvider(asOptionalString(opts.provider), config.get('gatewayProvider'), model.model);
+    const ultracode = opts.ultracode === true;
+    const effort = ultracode
+        ? ULTRACODE_EFFORT
+        : resolveCodeEffort(asOptionalString(opts.effort), config.get('gatewayEffort'));
     return {
         cwd,
         files: normalizeFiles(opts.file),
         model: model.model,
         provider,
         modelWarning: model.warning,
-        maxTurns: parseBoundedNumber(opts.maxTurns, DEFAULT_CODE_MAX_TURNS, {
-            min: 1,
-            max: 30,
-            integer: true,
-        }),
-        maxTokens: parseBoundedNumber(opts.maxTokens, DEFAULT_CODE_MAX_TOKENS, {
-            min: 256,
-            max: 32_768,
-            integer: true,
-        }),
+        // GAP-M1-18: `--ultracode` sobrepoe `--max-turns`/`--max-tokens`
+        // explicitos — e um preset "tudo pra cima", nao so um default alternativo.
+        maxTurns: ultracode
+            ? ULTRACODE_MAX_TURNS
+            : parseBoundedNumber(opts.maxTurns, DEFAULT_CODE_MAX_TURNS, { min: 1, max: 30, integer: true }),
+        maxTokens: ultracode
+            ? ULTRACODE_MAX_TOKENS
+            : parseBoundedNumber(opts.maxTokens, DEFAULT_CODE_MAX_TOKENS, { min: 256, max: 32_768, integer: true }),
         temperature: parseBoundedNumber(opts.temperature, DEFAULT_CODE_TEMPERATURE, {
             min: 0,
             max: 2,
@@ -62,6 +67,8 @@ export function resolveSettings(opts) {
         apply: opts.apply !== false && opts.plan !== true,
         yes: opts.yes === true,
         timeoutMs: 120_000,
+        effort,
+        ultracode,
     };
 }
 async function runReviewCommand(settings, confirm, history) {
@@ -107,34 +114,38 @@ async function defaultConfirm(question) {
     }
 }
 /**
- * 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.
+ * Chama o AI Gateway atualizando o `spinner` compartilhado da tarefa inteira
+ * (nao cria um spinner proprio por chamada) — o indicador de progresso fica
+ * vivo e continuo entre turnos, so o `detail` muda. 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 (no-op em
+ * pipe/CI/teste, `startTurnSpinner` ja trata isso).
  *
  * 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.
+ * funcionar, so a experiencia visual. O aviso de fallback e um evento REAL
+ * (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) {
-    const spinner = startTurnSpinner('AI Gateway');
+async function callGatewayWithProgress(settings, messages, spinner, baseDetail, silent = false) {
     try {
         const content = await streamGatewayChat(settings, messages, (_delta, total) => {
-            spinner.update(`${total} char(s) recebido(s)`);
+            spinner.update(`${baseDetail} · ${total} char(s) recebido(s)`);
         });
-        spinner.stop();
-        return content;
+        return { content, spinner };
     }
     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)');
+        // silent (subagente): sem aviso de fallback e sem novo spinner — a saida
+        // visual pertence so a tarefa em primeiro plano.
+        if (!silent) {
+            printEvent('warn', 'Streaming falhou, tentando sem streaming', error instanceof Error ? error.message : String(error));
+        }
+        const fallbackSpinner = silent ? NOOP_TURN_SPINNER : startTurnSpinner('neetru code');
+        fallbackSpinner.update(`${baseDetail} · sem stream`);
         try {
             const content = await callGateway(settings, messages);
-            fallbackSpinner.stop();
-            return content;
+            return { content, spinner: fallbackSpinner };
         }
         catch (fallbackError) {
             fallbackSpinner.stop();
@@ -155,10 +166,16 @@ async function callGatewayWithProgress(settings, messages) {
  * 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 = [], onState) {
+export async function runAgentTask(task, settings, confirm, history = [], onState, options = {}) {
     if (!getActiveTokenSync()) {
         throw new Error('Sessao Neetru ausente ou expirada. Rode `neetru login`.');
     }
+    const { silent = false, signal } = options;
+    // silent (subagente): nada vai pro terminal enquanto roda — o resultado é
+    // CAPTURADO no retorno e consultado depois. `emit` vira no-op e o spinner é
+    // inerte, senão a saída colidiria com o spinner da tarefa em primeiro plano.
+    const emit = silent ? (() => { }) : printEvent;
+    const makeSpinner = () => (silent ? NOOP_TURN_SPINNER : startTurnSpinner('neetru code'));
     const machine = new CodeAgentStateMachine();
     const goto = (next) => {
         machine.transition(next);
@@ -172,8 +189,23 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
         role: 'user',
         content: isFirstTurn ? buildInitialPrompt(task, settings) : task,
     });
+    // Um unico spinner vivo pra tarefa inteira (nao uma linha por evento) —
+    // achado de uso real: turno/tool-call/tool-result como linhas permanentes
+    // poluiam o historico. O detail acumula "turno X/Y" + estagio atual;
+    // avisos/erros REAIS (compactacao, fallback de streaming) continuam
+    // aparecendo como linha permanente via printEvent, pausando o spinner
+    // pra nao interlear as duas saidas.
+    let spinner = makeSpinner();
     try {
         for (let turn = 1; turn <= settings.maxTurns; turn++) {
+            // 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
+            // acontece antes de iniciar o proximo turno.
+            if (signal?.aborted) {
+                spinner.stop();
+                return { kind: 'aborted' };
+            }
             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
@@ -183,7 +215,9 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             // 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)`);
+                spinner.stop();
+                emit('warn', 'Historico compactado automaticamente', `${autoCompacted} mensagem(ns) antiga(s) removida(s)`);
+                spinner = makeSpinner();
             }
             // Rede de seguranca contra loop de tool-calls que nunca conclui (achado
             // em producao: "oi" gastou os 8 turnos so chamando tools e falhou com
@@ -196,16 +230,19 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
                         'texto usando o que voce ja sabe — nao peca mais NEETRU_TOOL nem proponha patch.',
                 });
             }
-            printEvent('wait', 'AI Gateway', `turno ${turn}/${settings.maxTurns}`);
-            const content = await callGatewayWithProgress(settings, messages);
+            const baseDetail = `turno ${turn}/${settings.maxTurns}`;
+            spinner.update(baseDetail);
+            const gatewayResult = await callGatewayWithProgress(settings, messages, spinner, baseDetail, silent);
+            spinner = gatewayResult.spinner;
+            const content = gatewayResult.content;
             messages.push({ role: 'assistant', content });
             const tool = parseToolRequest(content);
             if (tool) {
                 goto('tool_requested');
-                printEvent('tool', tool.tool, toolDetail(tool));
+                spinner.update(`${baseDetail} · ${tool.tool}`);
                 goto('tool_running');
-                const result = runCodeTool(settings.cwd, tool);
-                printEvent('ok', 'contexto local', summarizeToolResult(result));
+                const result = await runCodeTool(settings.cwd, tool, { settings, confirm });
+                spinner.update(`${baseDetail} · ${summarizeToolResult(result)}`);
                 messages.push({
                     role: 'user',
                     content: truncateForGateway(`Resultado da tool ${tool.tool}:\n\n${result}`),
@@ -214,217 +251,432 @@ export async function runAgentTask(task, settings, confirm, history = [], onStat
             }
             const patch = extractPatch(content);
             if (patch) {
+                spinner.stop();
                 goto('patch_ready');
-                console.log();
-                printPatchPreview(patch);
+                if (!silent) {
+                    console.log();
+                    printPatchPreview(patch);
+                }
                 if (!settings.apply) {
-                    printEvent('warn', 'Patch nao aplicado', '--plan/--no-apply');
+                    // Subagentes SEMPRE caem aqui (apply forçado a false): propõem o
+                    // patch, nunca aplicam. Quem aplica é a sessão principal via /agents.
+                    emit('warn', 'Patch nao aplicado', '--plan/--no-apply');
                     goto('aborted');
-                    return;
+                    return { kind: 'patch', patch };
                 }
                 const approved = settings.yes || (await (async () => {
                     goto('awaiting_confirm');
                     return confirm('\nAplicar este patch? [y/N] ');
                 })());
                 if (!approved) {
-                    printEvent('warn', 'Patch nao aplicado');
+                    emit('warn', 'Patch nao aplicado');
                     goto('aborted');
-                    return;
+                    return { kind: 'aborted' };
                 }
                 applyUnifiedPatch(settings.cwd, patch);
                 logAppliedPatch(settings.cwd, patchSummaryRows(patch)[0] ?? 'arquivos: nao detectado');
-                printEvent('ok', 'Patch aplicado', 'git apply');
+                emit('ok', 'Patch aplicado', 'git apply');
                 goto('applied');
-                return;
+                return { kind: 'applied', patch };
+            }
+            spinner.stop();
+            if (!silent) {
+                console.log();
+                printAssistantText(content);
             }
-            console.log();
-            printAssistantText(content);
             goto('idle');
-            return;
+            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();
         if (machine.state !== 'failed' && machine.state !== 'aborted' && machine.state !== 'applied') {
             goto('failed');
         }
         throw error;
     }
 }
+// O REPL (runInteractive) chama startSubagent; o orquestrador chama de volta
+// runAgentTask via este runner injetado. Injeção (não import) mantém o grafo de
+// imports unidirecional: commands/code.ts -> code-agent-subagents.ts, sem ciclo.
+configureSubagentRunner(runAgentTask);
 function printFileSampleForSettings(settings) {
     const all = listFiles(settings.cwd);
     printFileSample(all.slice(0, 60), all.length);
 }
+function formatSubagentDuration(s) {
+    const end = s.finishedAt ?? Date.now();
+    const secs = Math.max(0, Math.round((end - s.startedAt) / 1000));
+    return `${secs}s`;
+}
+function formatSubagentRow(s) {
+    const patchTag = s.hasPatch ? ' (patch)' : '';
+    return `#${s.id} [${s.status}] ${formatSubagentDuration(s)}${patchTag} — ${s.task}`;
+}
+/**
+ * `/agents ...` — controla os subagentes (fan-out de subtarefas). Todo o texto,
+ * nomenclatura e fluxo aqui é próprio; a inspiração é só o princípio geral de
+ * orquestração (disparar, listar, parar, coletar, aplicar sob confirmação).
+ *
+ * `apply` reaproveita EXATAMENTE o mesmo caminho de confirmação de um patch
+ * normal (preview + confirm + applyUnifiedPatch + logAppliedPatch) — um patch de
+ * subagente nunca é aplicado automaticamente.
+ */
+async function runAgentsCommand(line, settings, confirm) {
+    const afterCmd = line.trim().slice('/agents'.length).trim();
+    const spaceIdx = afterCmd.indexOf(' ');
+    const sub = (spaceIdx === -1 ? afterCmd : afterCmd.slice(0, spaceIdx)).toLowerCase();
+    const arg = spaceIdx === -1 ? '' : afterCmd.slice(spaceIdx + 1).trim();
+    const idArg = arg.replace(/^#/, '').trim();
+    switch (sub) {
+        case '':
+        case 'list': {
+            const all = listSubagents();
+            if (all.length === 0) {
+                printEvent('ok', 'Nenhum subagente', 'use /agents start <tarefa>');
+                return;
+            }
+            printBox('subagentes', all.map(formatSubagentRow));
+            return;
+        }
+        case 'start': {
+            if (!arg) {
+                printEvent('warn', 'Uso', '/agents start <tarefa>');
+                return;
+            }
+            try {
+                const id = startSubagent(arg, settings);
+                printEvent('ok', 'Subagente iniciado', `#${id}: ${arg}`);
+            }
+            catch (error) {
+                printEvent('error', 'Nao foi possivel iniciar subagente', error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        case 'stop': {
+            if (!idArg) {
+                printEvent('warn', 'Uso', '/agents stop <id>');
+                return;
+            }
+            const ok = stopSubagent(idArg);
+            printEvent(ok ? 'ok' : 'warn', ok ? 'Sinal de parada enviado' : 'Subagente nao esta em execucao', `#${idArg}`);
+            return;
+        }
+        case 'result': {
+            if (!idArg) {
+                printEvent('warn', 'Uso', '/agents result <id>');
+                return;
+            }
+            const record = getSubagentResult(idArg);
+            if (!record) {
+                printEvent('warn', 'Subagente nao encontrado', `#${idArg}`);
+                return;
+            }
+            if (record.status === 'running') {
+                printEvent('ok', 'Ainda em execucao', `#${idArg}`);
+                return;
+            }
+            if (record.status === 'stopped') {
+                printEvent('warn', 'Subagente parado', `#${idArg}`);
+                return;
+            }
+            if (record.error || record.status === 'failed') {
+                printEvent('error', 'Subagente falhou', record.error ?? `#${idArg}`);
+                return;
+            }
+            const outcome = record.outcome;
+            if (outcome?.kind === 'patch' && outcome.patch) {
+                printEvent('ok', 'Patch proposto', `#${idArg} — /agents apply ${idArg} pra aplicar`);
+                printPatchPreview(outcome.patch);
+            }
+            else if (outcome?.kind === 'text') {
+                printAssistantText(outcome.text ?? '(sem texto)');
+            }
+            else {
+                printEvent('warn', 'Sem resultado aplicavel', `#${idArg}`);
+            }
+            return;
+        }
+        case 'apply': {
+            if (!idArg) {
+                printEvent('warn', 'Uso', '/agents apply <id>');
+                return;
+            }
+            const record = getSubagentResult(idArg);
+            if (!record) {
+                printEvent('warn', 'Subagente nao encontrado', `#${idArg}`);
+                return;
+            }
+            const patch = getApplicablePatch(idArg);
+            if (!patch) {
+                printEvent('warn', 'Nada pra aplicar', `#${idArg} (${record.status}${record.outcome ? `, ${record.outcome.kind}` : ''})`);
+                return;
+            }
+            console.log();
+            printPatchPreview(patch);
+            const approved = settings.yes || (await confirm('\nAplicar patch do subagente? [y/N] '));
+            if (!approved) {
+                printEvent('warn', 'Patch nao aplicado');
+                return;
+            }
+            try {
+                applyUnifiedPatch(settings.cwd, patch);
+                logAppliedPatch(settings.cwd, patchSummaryRows(patch)[0] ?? 'arquivos: nao detectado');
+                printEvent('ok', 'Patch aplicado', `git apply · subagente #${idArg}`);
+            }
+            catch (error) {
+                printEvent('error', 'Falha ao aplicar patch', error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        default:
+            printEvent('warn', 'Subcomando desconhecido', 'use: start | list | stop | result | apply');
+    }
+}
 async function runInteractive(settings) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         throw new Error('Modo interativo exige terminal TTY. Use: neetru code "tarefa".');
     }
+    // Resolvido ANTES do app Ink montar (I/O assincrono) — usado no banner
+    // dentro de onStart (sincrono, roda ja com a sessao interativa no ar).
+    const { resolveSessionEmail } = await import('../lib/auth.js');
+    const sessionEmail = await resolveSessionEmail().catch(() => null);
     let history = [];
-    await runInkSession({
-        initialPromptLabel: renderPromptLabel(settings),
-        statusLine: '/help comandos  ·  /exit sai  ·  Ctrl+C cancela',
-        onStart: () => {
-            renderHeader(settings, 'interactive');
-            if (settings.modelWarning)
-                log.warn(settings.modelWarning);
-        },
-        onLine: async (line, ctx) => {
-            const lower = line.toLowerCase();
-            if (lower === '/exit' || lower === '/sair' || lower === 'exit' || lower === 'quit')
-                return 'exit';
-            if (lower === '/clear') {
-                history = [];
+    // 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
+    // interlear. Registrado 1x por sessão; cancelado ao sair.
+    const unsubscribeSettled = onSubagentSettled((s) => {
+        if (s.status === 'done') {
+            printEvent('ok', s.hasPatch ? 'Subagente concluiu (patch proposto)' : 'Subagente concluiu', s.hasPatch ? `#${s.id} — /agents apply ${s.id}` : `#${s.id} — /agents result ${s.id}`);
+        }
+        else if (s.status === 'stopped') {
+            printEvent('warn', 'Subagente parado', `#${s.id}`);
+        }
+        else {
+            printEvent('error', 'Subagente falhou', `#${s.id} — /agents result ${s.id}`);
+        }
+    });
+    try {
+        await runInkSession({
+            initialPromptLabel: renderPromptLabel(settings),
+            statusLine: '/help comandos  ·  /exit sai  ·  Ctrl+C cancela',
+            onStart: () => {
+                log.banner(sessionEmail);
                 renderHeader(settings, 'interactive');
-                printEvent('ok', 'Conversa limpa');
-                return 'continue';
-            }
-            if (lower === '/files') {
-                printFileSampleForSettings(settings);
-                return 'continue';
-            }
-            if (lower === '/pick') {
-                const all = listFiles(settings.cwd);
-                const shown = all.slice(0, 60);
-                printFilePicker(shown, all.length);
-                if (shown.length === 0)
+                if (settings.modelWarning)
+                    log.warn(settings.modelWarning);
+            },
+            onLine: async (line, ctx) => {
+                const lower = line.toLowerCase();
+                if (lower === '/exit' || lower === '/sair' || lower === 'exit' || lower === 'quit')
+                    return 'exit';
+                if (lower === '/agents' || lower.startsWith('/agents ')) {
+                    await runAgentsCommand(line, settings, async (question) => {
+                        const answer = await ctx.askLine(question);
+                        return /^(y|yes|s|sim)$/i.test(answer.trim());
+                    });
                     return 'continue';
-                const answer = await ctx.askLine('Numero(s) separado(s) por virgula (Enter cancela): ');
-                const raw = answer.trim();
-                if (!raw) {
-                    printEvent('warn', 'Cancelado');
+                }
+                if (lower === '/clear') {
+                    history = [];
+                    renderHeader(settings, 'interactive');
+                    printEvent('ok', 'Conversa limpa');
                     return '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 (lower === '/files') {
+                    printFileSampleForSettings(settings);
+                    return 'continue';
                 }
-                if (picked.length === 0) {
-                    printEvent('warn', 'Nenhum arquivo valido selecionado');
+                if (lower === '/pick') {
+                    const all = listFiles(settings.cwd);
+                    const shown = all.slice(0, 60);
+                    printFilePicker(shown, all.length);
+                    if (shown.length === 0)
+                        return 'continue';
+                    const answer = await ctx.askLine('Numero(s) separado(s) por virgula (Enter cancela): ');
+                    const raw = answer.trim();
+                    if (!raw) {
+                        printEvent('warn', 'Cancelado');
+                        return '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');
+                        return '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(', '));
                     return '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(', '));
-                return 'continue';
-            }
-            if (lower === '/overview' || lower === '/visao') {
-                printBox('visao do projeto', getProjectOverview(settings.cwd).split(/\r?\n/));
-                return 'continue';
-            }
-            if (lower === '/diff') {
-                const diff = getGitDiff(settings.cwd);
-                if (diff === '(sem diff)') {
-                    printEvent('ok', 'Sem diff local');
+                if (lower === '/overview' || lower === '/visao') {
+                    printBox('visao do projeto', getProjectOverview(settings.cwd).split(/\r?\n/));
+                    return 'continue';
                 }
-                else if (diff.startsWith('ERRO:')) {
-                    printEvent('error', 'git diff', diff);
+                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');
+                    }
+                    return 'continue';
                 }
-                else {
-                    printBox('diff atual', ['git diff -- .']);
-                    process.stdout.write(renderColoredDiff(diff));
-                    if (!diff.endsWith('\n'))
-                        process.stdout.write('\n');
+                if (lower === '/review') {
+                    await runReviewCommand(settings, async (question) => {
+                        const answer = await ctx.askLine(question);
+                        return /^(y|yes|s|sim)$/i.test(answer.trim());
+                    }, history);
+                    return 'continue';
                 }
-                return 'continue';
-            }
-            if (lower === '/review') {
-                await runReviewCommand(settings, async (question) => {
-                    const answer = await ctx.askLine(question);
-                    return /^(y|yes|s|sim)$/i.test(answer.trim());
-                }, history);
-                return 'continue';
-            }
-            if (lower === '/save') {
-                const saved = saveCodeSession(settings, history);
-                printEvent('ok', 'Sessao salva', saved);
-                return 'continue';
-            }
-            if (lower === '/resume') {
-                const sessions = listCodeSessions(settings.cwd);
-                printSessionList(sessions);
-                if (sessions.length === 0)
+                if (lower === '/save') {
+                    const saved = saveCodeSession(settings, history);
+                    printEvent('ok', 'Sessao salva', saved);
                     return 'continue';
-                if (history.length > 0) {
-                    const overwrite = await ctx.askLine('Conversa atual sera substituida. Continuar? [y/N] ');
-                    if (!/^(y|yes|s|sim)$/i.test(overwrite.trim())) {
+                }
+                if (lower === '/resume') {
+                    const sessions = listCodeSessions(settings.cwd);
+                    printSessionList(sessions);
+                    if (sessions.length === 0)
+                        return 'continue';
+                    if (history.length > 0) {
+                        const overwrite = await ctx.askLine('Conversa atual sera substituida. Continuar? [y/N] ');
+                        if (!/^(y|yes|s|sim)$/i.test(overwrite.trim())) {
+                            printEvent('warn', 'Cancelado');
+                            return 'continue';
+                        }
+                    }
+                    const answer = await ctx.askLine('Numero da sessao (Enter cancela): ');
+                    const idx = Number.parseInt(answer.trim(), 10);
+                    if (!Number.isInteger(idx) || idx < 1 || idx > sessions.length) {
                         printEvent('warn', 'Cancelado');
                         return '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));
+                    }
+                    return 'continue';
                 }
-                const answer = await ctx.askLine('Numero da sessao (Enter cancela): ');
-                const idx = Number.parseInt(answer.trim(), 10);
-                if (!Number.isInteger(idx) || idx < 1 || idx > sessions.length) {
-                    printEvent('warn', 'Cancelado');
+                if (lower === '/compact') {
+                    const removed = compactCodeHistory(history);
+                    printEvent('ok', 'Historico compactado', `${removed} mensagem(ns) removida(s)`);
+                    return 'continue';
+                }
+                if (lower === '/status' || lower === '/context') {
+                    renderSessionStatus(settings, history);
+                    return 'continue';
+                }
+                if (lower === '/model') {
+                    printBox('modelo', [settings.model]);
+                    return 'continue';
+                }
+                if (lower === '/effort' || lower.startsWith('/effort ')) {
+                    const arg = line.trim().slice('/effort'.length).trim().toLowerCase();
+                    if (!arg) {
+                        printEvent('ok', 'Effort atual', settings.effort ?? 'default do provider');
+                        return 'continue';
+                    }
+                    const next = resolveCodeEffort(arg);
+                    if (!next) {
+                        printEvent('warn', 'Nivel invalido', 'use: low | medium | high');
+                        return 'continue';
+                    }
+                    settings.effort = next;
+                    printEvent('ok', 'Effort atualizado', next);
+                    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;
+                        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'));
+                        printEvent('ok', 'Ultracode desligado', `voltou pro default (${DEFAULT_CODE_MAX_TURNS} turnos)`);
+                    }
+                    return 'continue';
+                }
+                if (lower === '/plan') {
+                    settings.apply = false;
+                    printEvent('ok', 'Modo plano', 'patches nao serao aplicados');
+                    return 'continue';
+                }
+                if (lower === '/apply') {
+                    settings.apply = true;
+                    settings.yes = false;
+                    printEvent('ok', 'Modo aplicar', 'pedira confirmacao antes do git apply');
+                    return 'continue';
+                }
+                if (lower === '/yes') {
+                    settings.apply = true;
+                    settings.yes = true;
+                    printEvent('warn', 'Auto-aplicar ativo', 'patches validos serao aplicados sem pergunta');
+                    return 'continue';
+                }
+                if (lower === '/no') {
+                    settings.yes = false;
+                    printEvent('ok', 'Confirmacao manual ativa');
+                    return 'continue';
+                }
+                if (lower === '/help' || lower === '/ajuda') {
+                    renderInteractiveHelp();
                     return 'continue';
                 }
-                const picked = sessions[idx - 1];
                 try {
-                    history = loadCodeSession(settings.cwd, picked.file);
-                    printEvent('ok', 'Sessao retomada', `${picked.file} (${history.length} mensagem(ns))`);
+                    await runAgentTask(line, settings, async (question) => {
+                        const answer = await ctx.askLine(question);
+                        return /^(y|yes|s|sim)$/i.test(answer.trim());
+                    }, history);
                 }
                 catch (error) {
-                    printEvent('error', 'Falha ao retomar sessao', error instanceof Error ? error.message : String(error));
+                    printEvent('error', 'Falha', error instanceof Error ? error.message : String(error));
                 }
+                // GAP-M1-18: checkpoint automatico apos cada turno (sucesso OU falha —
+                // a conversa ate aqui e valida de qualquer jeito) pra sessao longa
+                // sobreviver a fechar o terminal sem lembrar de `/save`. Silencioso
+                // (sem printEvent) e best-effort — nunca deve virar ruido visual nem
+                // interromper a sessao.
+                autoSaveCodeSession(settings, history);
                 return 'continue';
-            }
-            if (lower === '/compact') {
-                const removed = compactCodeHistory(history);
-                printEvent('ok', 'Historico compactado', `${removed} mensagem(ns) removida(s)`);
-                return 'continue';
-            }
-            if (lower === '/status' || lower === '/context') {
-                renderSessionStatus(settings, history);
-                return 'continue';
-            }
-            if (lower === '/model') {
-                printBox('modelo', [settings.model]);
-                return 'continue';
-            }
-            if (lower === '/plan') {
-                settings.apply = false;
-                printEvent('ok', 'Modo plano', 'patches nao serao aplicados');
-                return 'continue';
-            }
-            if (lower === '/apply') {
-                settings.apply = true;
-                settings.yes = false;
-                printEvent('ok', 'Modo aplicar', 'pedira confirmacao antes do git apply');
-                return 'continue';
-            }
-            if (lower === '/yes') {
-                settings.apply = true;
-                settings.yes = true;
-                printEvent('warn', 'Auto-aplicar ativo', 'patches validos serao aplicados sem pergunta');
-                return 'continue';
-            }
-            if (lower === '/no') {
-                settings.yes = false;
-                printEvent('ok', 'Confirmacao manual ativa');
-                return 'continue';
-            }
-            if (lower === '/help' || lower === '/ajuda') {
-                renderInteractiveHelp();
-                return 'continue';
-            }
-            try {
-                await runAgentTask(line, 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));
-            }
-            return 'continue';
-        },
-    });
+            },
+        });
+    }
+    finally {
+        unsubscribeSettled();
+        // Ao sair da sessão, corta subagentes ainda em execução — sem isso ficariam
+        // órfãos consumindo o AI Gateway em background depois do REPL fechar.
+        stopAllSubagents();
+    }
 }
 function runDoctor(settings) {
     const token = getActiveTokenSync();