terminal-smart-cli 0.98.1 → 0.99.0

package/bin/ts.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 // ⌁ Terminal Smart CLI — agente DevOps no seu terminal.
-// Fase 1: cliente do backend (chat, orquestração, uso). Docs: terminalsmart.com.br/cli
+// Cliente do backend (orquestração, uso); o chat roda com a IA do próprio usuário neste PC.
+// Docs: terminalsmart.com.br/cli
 'use strict';
 const pkg = require('../package.json');
 const config = require('../lib/config');
@@ -92,9 +93,14 @@ async function readStdin() {
   for await (const c of process.stdin) { d += c; if (d.length > 120000) break; }
   return d;
 }
+// Erros da IA local (lib/ia-local e lib/chat-local): a mensagem já diz o que fazer.
+const _CODIGOS_IA_LOCAL = new Set(['sem_ia_local', 'ia_local_indisponivel', 'nao_instalada', 'nao_logada', 'sessao_expirada',
+  'desatualizada', 'limite', 'timeout', 'execucao_insegura', 'falha_ia_local', 'sem_resposta', 'modo_invalido', 'saida_grande', 'falha_execucao']);
+function _erroIaLocal(e) { return !!(e && !(e instanceof ApiError) && _CODIGOS_IA_LOCAL.has(e.code)); }
 function fail(e) {
   if (JSON_OUT) { console.log(JSON.stringify({ ok: false, error: (e && e.message) || 'erro', code: e && e.code })); process.exit(1); }
-  if (e instanceof ApiError) {
+  if (_erroIaLocal(e)) console.error(ui.errLine(e.message));
+  else if (e instanceof ApiError) {
     if (e.code === 'auth') console.error(ui.errLine(T.session_expired));
     else if (e.code === 'conn') console.error(ui.errLine(T.err_conn));
     else if (e.code === 'no_credits') console.error(ui.errLine(T.no_credits));
@@ -112,10 +118,65 @@ function providerCapacityHint(e) {
   if (!active) return '';
   const provider = active.provedor || active.id || 'provedor particular';
   return cfg.lang === 'en'
-    ? `Your own ${provider} key has insufficient provider balance/capacity. Terminal Smart plan credits were not consumed. Add balance at the provider or run \`ts conectar nuvem\` to use your TS plan.`
-    : `Sua chave própria do ${provider} está sem saldo/capacidade no provedor. Os créditos do plano Terminal Smart não foram consumidos. Recarregue o provedor ou rode \`ts conectar nuvem\` para usar o plano TS.`;
+    ? `Your own ${provider} key has insufficient provider balance/capacity. Nothing was charged by Terminal Smart. Add balance at the provider, switch providers with \`ts conectar <provider>\` (or local Ollama) or use your subscription with \`ts ia conectar chatgpt|claude\`.`
+    : `Sua chave própria do ${provider} está sem saldo/capacidade no provedor. Nada foi cobrado pelo Terminal Smart. Adicione saldo no provedor, troque de provedor com \`ts conectar <provedor>\` (ou Ollama local) ou use sua assinatura com \`ts ia conectar chatgpt|claude\`.`;
 }
 
+// 402/teto de custo com a chave PRÓPRIA (BYOK) é saldo/limite do provedor, não falta da IA
+// do TS: a mensagem de "sem créditos legados" apontaria a causa errada. Mesma condição do
+// keyring.resolve para a execução ter rodado na chave do usuário.
+function byokNoBalanceHint(e) {
+  if (!e || !(e.code === 'no_credits' || Number(e.status) === 402)) return '';
+  let active = null;
+  try { active = require('../lib/keyring').ativo(); } catch (_) {}
+  if (!active || !(active.key || (require('../lib/providers').info(active.id) || {}).semChave)) return '';
+  return T.byok_no_balance(active.provedor || active.id || (cfg.lang === 'en' ? 'private provider' : 'provedor particular'));
+}
+
+// Falha do resumo automático (compactar_contexto bloqueado) não é bloqueio de política: é
+// perda da memória antiga. Linha amarela própria, igual no `ts agente` e no `ts meta`.
+function compactFailLine(name, blocked, detail) {
+  if (name !== 'compactar_contexto' || !blocked) return '';
+  return C.warn('▲ ' + (cfg.lang === 'en' ? 'context: ' : 'contexto: ') + (detail || ''));
+}
+
+// De onde vem a IA desta conta, em linguagem de produto: via sua assinatura (a CLI oficial do
+// ChatGPT/Codex ou do Claude logada NESTE PC), via sua chave (<provedor>) ou via Ollama local.
+// Só estado LOCAL — nenhuma consulta ao servidor. O critério é o do `ts agente`: o modo da conta
+// (`ts ia usar`) vale quando está SELECIONADO e a CLI exigida está pronta, e aí vence a chave
+// local. Modo selecionado sem a CLI pronta: o agente cancela a execução — sai um aviso (hint,
+// blocking), nunca "via sua assinatura". CLI logada com o modo automático e sem chave: a dica é
+// selecionar (ts ia usar), não conectar de novo. { via:null } = nenhuma IA própria (no agente
+// sobra o legado do TS; o chat não tem reserva).
+function _modoIaLocal() {
+  const m = String(cfg.personalModePreference || 'automatico').toLowerCase();
+  return require('../lib/ia-local').modoValido(m) ? m : 'automatico';
+}
+const _personalLabel = (mode) => require('../lib/ia-local').rotuloModo(mode);
+async function aiSource(_token, { timeoutMs = 3000 } = {}) {
+  const iaLocal = require('../lib/ia-local');
+  const mode = _modoIaLocal();
+  if (mode !== 'automatico') {
+    const st = await iaLocal.status({ prazoMs: timeoutMs });
+    if (iaLocal.pronto(mode, st)) return { via: T.via_subscription + ' (' + _personalLabel(mode) + ')', unknown: false };
+    const okC = iaLocal.pronto('chatgpt', st), okA = iaLocal.pronto('claude', st);
+    const falta = mode === 'chatgpt' || mode === 'claude' ? mode : (!okC && !okA ? 'chatgpt|claude' : !okC ? 'chatgpt' : 'claude');
+    return { via: null, unknown: false, blocking: true, hint: T.uso_ai_sub_disconnected(_personalLabel(mode), falta) };
+  }
+  let at = null;
+  try { at = require('../lib/keyring').ativo(); } catch (_) {}
+  if (at) return { via: at.id === 'ollama' ? T.via_ollama : T.via_key(at.id), unknown: false };
+  // automático e sem chave: alguma CLI da conta já logada neste PC? (só pelo arquivo, sem processo)
+  const st = await iaLocal.status({ rapido: true });
+  const logada = (p) => !!(st[p] && st[p].instalada && st[p].logada === true);
+  if (logada('chatgpt') || logada('claude')) {
+    return { via: null, unknown: false, hint: T.uso_ai_sub_not_selected(logada('chatgpt') && logada('claude') ? 'chatgpt|claude' : logada('chatgpt') ? 'chatgpt' : 'claude') };
+  }
+  return { via: null, unknown: false };
+}
+// texto da linha "IA em uso" quando não há IA própria confirmada
+const aiSourceMissing = (src) => C.warn(src && src.hint ? src.hint : src && src.unknown ? T.uso_ai_unknown : T.uso_ai_none);
+
 // ── Ajuda ────────────────────────────────────────────────────────────────────
 function help() {
   const out = [ui.banner(pkg.version, T.tagline)];
@@ -227,57 +288,89 @@ async function logout() {
   console.log(ui.okLine(T.logout_ok));
 }
 
-// ── Planos pessoais ChatGPT / Claude (mesma conta do Telegram/Web/App) ──────
-async function personalAiCmd(args = []) {
-  const token=needToken(); const en=cfg.lang === 'en'; const sub=String(args[0] || 'status').toLowerCase();
-  const label=p=>p === 'chatgpt' ? 'ChatGPT/Codex' : 'Claude';
-  const show=state=>{
-    if (JSON_OUT) { console.log(JSON.stringify(state)); return; }
-    console.log('\n' + ui.box([
-      `${en ? 'Mode' : 'Modo'}: ${state.mode || 'automatico'}`,
-      `ChatGPT/Codex: ${state.chatgpt ? 'conectado' : 'não conectado'}`,
-      `Claude: ${state.claude ? 'conectado' : 'não conectado'}`,
-      '', C.dim(en ? 'Personal subscriptions use 0 TS model credits.' : 'Assinaturas pessoais usam 0 créditos de modelo TS.'),
-    ], { title:'IA da conta' }) + '\n');
+// ── IA da sua conta: ChatGPT/Codex e Claude Code logados NESTE PC ────────────
+// Tudo local: o modo fica na config deste PC (`ts ia usar`) e o login é o oficial de cada CLI,
+// feito aqui no terminal. Nada disso passa pelo servidor do Terminal Smart.
+async function personalAiCmd(args = [], { interativo = true } = {}) {
+  const en = cfg.lang === 'en'; const sub = String(args[0] || 'status').toLowerCase();
+  const iaLocal = require('../lib/ia-local');
+  const label = (p) => iaLocal.nomeDe(p);
+  const ajuda = 'Use: ts ia status | conectar chatgpt|claude | usar automatico|chatgpt|claude|paralelo | desconectar chatgpt|claude';
+  const estado = (s) => !s.instalada ? (en ? 'not installed' : 'não instalado')
+    : s.detalhe ? (en ? 'installed · cannot run safely' : 'instalado · sem execução segura')
+      : s.logada === true ? (en ? 'installed · logged in' : 'instalado · logado')
+        : s.logada === false ? (en ? 'installed · not logged in' : 'instalado · não logado')
+          : (en ? 'installed · login not confirmed' : 'instalado · login não confirmado');
+  const show = async () => {
+    const mode = _modoIaLocal();
+    const st = await iaLocal.status();
+    if (JSON_OUT) { console.log(JSON.stringify({ ok: true, local: true, mode, chatgpt: st.chatgpt, claude: st.claude })); return; }
+    const lines = [
+      `${en ? 'Mode' : 'Modo'}: ${mode}`,
+      `ChatGPT/Codex (codex): ${estado(st.chatgpt)}`,
+      `Claude (claude): ${estado(st.claude)}`,
+    ];
+    if (mode !== 'automatico' && !iaLocal.pronto(mode, st)) {
+      const okC = iaLocal.pronto('chatgpt', st), okA = iaLocal.pronto('claude', st);
+      const falta = mode === 'paralelo' ? (!okC && !okA ? 'chatgpt|claude' : !okC ? 'chatgpt' : 'claude') : mode;
+      lines.push('', C.warn('▲ ' + T.uso_ai_sub_disconnected(_personalLabel(mode), falta)));
+    }
+    lines.push('', ...(en
+      ? ['Runs on this PC with your own account —', 'nothing goes through the Terminal Smart server and no TS credits are used.']
+      : ['Roda neste PC com a sua própria conta —', 'nada passa pelo servidor do Terminal Smart e não usa créditos do TS.']).map(l => C.dim(l)));
+    console.log('\n' + ui.box(lines, { title: en ? 'Your account AI (this PC)' : 'IA da sua conta (neste PC)' }) + '\n');
   };
-  if (sub === 'status') return show(await api('/api/personal-ai/status',{token}));
-  if (['usar','use','modo','mode'].includes(sub)) {
-    const mode=String(args[1] || '').toLowerCase();
-    const state=await api('/api/personal-ai/mode',{method:'POST',token,body:{mode}});
-    cfg = config.save({ forceTsCloud: mode === 'automatico' ? true : undefined, personalModePreference:mode });
-    show(state); return;
-  }
-  if (['desconectar','disconnect'].includes(sub)) {
-    const provider=String(args[1] || '').toLowerCase();
-    const state=await api('/api/personal-ai/disconnect',{method:'POST',token,body:{provider}}); show(state); return;
-  }
-  if (['conectar','connect'].includes(sub)) {
-    const provider=String(args[1] || '').toLowerCase();
-    if (!['chatgpt','claude'].includes(provider)) throw new Error('Use: ts ia conectar chatgpt|claude');
-    const login=await api('/api/personal-ai/login/start',{method:'POST',token,body:{provider}});
-    if (login.alreadyConnected) return show(await api('/api/personal-ai/status',{token}));
-    console.log('\n' + ui.box([
-      login.url,
-      ...(login.code ? ['', `${en ? 'Device code' : 'Código do aparelho'}: ${C.bold(login.code)}`] : []),
-      '', C.dim(en ? 'Open the official page and finish authorization.' : 'Abra a página oficial e conclua a autorização.'),
-    ], { title:`Login ${label(provider)}` }) + '\n');
-    if (process.env.TS_NO_BROWSER !== '1') try {
-      const { exec }=require('child_process'); const command=process.platform === 'win32' ? `start "" "${login.url}"` : process.platform === 'darwin' ? `open "${login.url}"` : `xdg-open "${login.url}"`;
-      exec(command,()=>{});
-    } catch (_) {}
-    if (provider === 'claude' && process.stdin.isTTY) {
-      const code=String(await ui.ask(en ? 'Paste the code returned by Claude: ' : 'Cole o código devolvido pelo Claude: ')).trim();
-      if (code) await api('/api/personal-ai/login/code',{method:'POST',token,body:{provider,code}});
+  const provedor = () => {
+    const p = String(args[1] || '').toLowerCase();
+    if (!['chatgpt', 'claude'].includes(p)) throw new Error(`Use: ts ia ${sub} chatgpt|claude`);
+    return p;
+  };
+  if (sub === 'status') return show();
+  if (['usar', 'use', 'modo', 'mode'].includes(sub)) {
+    const mode = String(args[1] || '').toLowerCase();
+    if (!iaLocal.modoValido(mode)) throw new Error('Use: ts ia usar automatico|chatgpt|claude|paralelo');
+    cfg = config.save({ personalModePreference: mode });
+    if (!JSON_OUT) console.log(ui.okLine((en ? 'AI mode saved on this PC: ' : 'modo da IA salvo neste PC: ') + C.bold(mode)));
+    return show();
+  }
+  if (['desconectar', 'disconnect'].includes(sub)) {
+    const p = provedor();
+    const passos = p === 'chatgpt'
+      ? [en ? 'Run the official logout on this PC:' : 'Rode o logout oficial neste PC:', '  ' + C.cyan('codex logout')]
+      : [en ? 'Log out with the official CLI on this PC:' : 'Saia pela CLI oficial neste PC:', '  ' + C.cyan('claude') + C.dim(en ? '  → type /logout' : '  → digite /logout')];
+    const mode = _modoIaLocal();
+    if (mode === p || mode === 'paralelo') passos.push('', C.dim(en ? `The "${mode}" mode stays selected; switch with \`ts ia usar automatico\`.` : `O modo "${mode}" continua escolhido; troque com \`ts ia usar automatico\`.`));
+    console.log('\n' + ui.box(passos, { title: (en ? 'Disconnect ' : 'Desconectar ') + label(p) }) + '\n');
+    return;
+  }
+  if (['conectar', 'connect'].includes(sub)) {
+    const p = provedor();
+    const st = await iaLocal.statusDe(p);
+    if (!st.instalada) { console.log(ui.infoLine(`${label(p)} ${en ? 'is not installed on this PC.' : 'não está instalado neste PC.'} ${iaLocal.comoInstalar(p)}`)); return; }
+    if (st.detalhe) throw new Error(`${label(p)}: ${st.detalhe}`);
+    if (st.logada === true) {
+      console.log(ui.okLine(`${label(p)} ${en ? 'is already logged in on this PC.' : 'já está logado neste PC.'}`) + C.dim(en ? `  To use it: ts ia usar ${p}` : `  Para usar: ts ia usar ${p}`));
+      return;
     }
-    for (let i=0;i<240;i++) {
-      await new Promise(resolve=>setTimeout(resolve,2500));
-      const state=await api(`/api/personal-ai/login/status?provider=${provider}`,{token});
-      if (state.connected) { console.log(ui.okLine(`${label(provider)} ${en ? 'connected' : 'conectado'}.`)); return; }
-      if (state.state === 'failed' || state.state === 'expired') throw new Error(state.error || 'O login não foi concluído.');
+    // no REPL (interativo:false) o login não abre aqui: o readline dele disputaria o teclado
+    if (p === 'claude' || !interativo || !process.stdin.isTTY || JSON_OUT) {
+      const passos = p === 'claude'
+        ? [`1. ${en ? 'Run' : 'Rode'} ${C.cyan('claude')} ${en ? 'in this terminal' : 'neste terminal'}`,
+          `2. ${en ? 'Type' : 'Digite'} ${C.cyan('/login')} ${en ? 'and finish in the browser' : 'e conclua no navegador'}`,
+          `3. ${en ? 'Leave with' : 'Saia com'} ${C.cyan('/exit')} ${en ? 'and run' : 'e rode'} ${C.cyan('ts ia usar claude')}`]
+        : [`1. ${en ? 'Run' : 'Rode'} ${C.cyan('codex login')} ${en ? 'in a terminal on this PC' : 'num terminal deste PC'}`,
+          `2. ${en ? 'Then run' : 'Depois rode'} ${C.cyan('ts ia usar chatgpt')}`];
+      console.log('\n' + ui.box([...passos, '', C.dim(en ? 'The login is the official one, on this PC — Terminal Smart never sees your password or token.' : 'O login é o oficial, neste PC — o Terminal Smart nunca vê sua senha nem seu token.')], { title: `Login ${label(p)}` }) + '\n');
+      return;
     }
-    throw new Error(en ? 'Login timed out.' : 'O login expirou.');
+    console.log(ui.infoLine(en ? 'Opening the official Codex login in this terminal…' : 'Abrindo o login oficial do Codex neste terminal…'));
+    await iaLocal.abrirLogin('chatgpt');
+    const depois = await iaLocal.statusDe('chatgpt');
+    if (depois.logada === false) throw new Error(en ? 'The login was not completed. Try again with `codex login`.' : 'O login não foi concluído. Tente de novo com `codex login`.');
+    console.log(ui.okLine(`${label(p)} ${en ? 'logged in on this PC.' : 'logado neste PC.'}`) + C.dim(en ? '  To use it: ts ia usar chatgpt' : '  Para usar: ts ia usar chatgpt'));
+    return;
   }
-  throw new Error('Use: ts ia status | conectar chatgpt|claude | usar automatico|chatgpt|claude|paralelo | desconectar chatgpt|claude');
+  throw new Error(ajuda);
 }
 
 // ── Chat ─────────────────────────────────────────────────────────────────────
@@ -352,7 +445,7 @@ async function imageCmd(args) {
   const selected = options.find(o => o.id === choice);
   if (!selected || selected.allowed === false) {
     throw new ApiError((selected && selected.upgradeRequired)
-      ? (en ? 'GPT Image 2 requires Basic or Pro.' : 'GPT Image 2 requer plano Básico ou Pro.')
+      ? (en ? 'GPT Image 2 is not available on your plan.' : 'GPT Image 2 não está disponível no seu plano.')
       : (en ? 'Invalid image option.' : 'Opção de imagem inválida.'), { code: 'plan_limit' });
   }
   if (choice === 'none') {
@@ -481,43 +574,17 @@ async function generateVideoCmd(args) {
     if (JSON_OUT) console.log(JSON.stringify(output)); else console.log('\n' + ui.okLine((en ? 'video saved: ' : 'vídeo salvo: ') + C.cyan(target)) + '\n  ' + C.dim(`${job.model} · ${job.charged} créditos · ${job.seconds}s`));
   } finally { spinner.stop(); }
 }
-// Envia uma mensagem na conversa ativa e devolve o texto (recria a conversa 1x se apagada na web).
-async function sendMessage(token, content) {
-  const memoryBus = require('../lib/memory-bus');
-  const memoryScope = memoryBus.scope(process.cwd());
-  const doStream = async (convId) => {
-    const sp = ui.spinner(T.thinking).start();
-    let buf = '', errMsg = null;
-    try {
-      await sse('/api/ia/chat', {
-        // Paridade com Web/App: o chat comum do CLI também declara o modo
-        // automático. Sem isso o backend tratava a chamada como legado e podia
-        // reutilizar um agente/modelo premium antigo, fora da equipe oficial.
-        token, body: { conversationId: convId, content, projectId: memoryScope.projectId, workstreamId: memoryScope.workstreamId, surface: 'cli', mode: 'auto' },
-        onEvent: (ev) => {
-          if (ev.delta) { buf += ev.delta; sp.text(`${T.receiving} ${fmtK(buf.length)}`); }
-          if (ev.error) errMsg = ev.error;
-          if (ev.tool) sp.text(String(ev.tool).slice(0, 64));
-        },
-      });
-    } catch (e) { sp.stop(); throw e; }
-    sp.stop();
-    if (errMsg && !buf) throw new ApiError(errMsg, {});
-    return buf;
-  };
-  let convId = await ensureConv(token);
-  try { return await doStream(convId); }
-  catch (e) {
-    if (e instanceof ApiError && e.status === 404) {
-      const scope = _convScope('chat');
-      const scopes = Object.assign({}, cfg.convScopes || {}); delete scopes[scope];
-      cfg = config.save({ convId: undefined, convScopes: scopes });
-      convId = await ensureConv(token); return doStream(convId);
-    }
-    throw e;
-  }
-}
-function printAnswer(text, ms) {
+// Chat LOCAL: a IA é a do usuário, neste PC — o modo da conta (`ts ia usar` → CLI oficial
+// logada aqui) ou, sem modo, a chave do `ts conectar` (inclusive Ollama). O histórico fica em
+// ~/.ts/chat, por pasta de trabalho. Nada da conversa vai ao servidor do Terminal Smart.
+function _chatLocal() { return require('../lib/chat-local').criarChatLocal(); }
+async function sendMessage(_token, content) {
+  const sp = JSON_OUT ? { stop() {} } : ui.spinner(T.thinking).start();
+  try {
+    const r = await _chatLocal().responder({ escopo: _convScope('chat'), conteudo: content, modo: _modoIaLocal(), lang: cfg.lang || 'pt' });
+    return r.texto;
+  } finally { sp.stop(); }
+}function printAnswer(text, ms) {
   const en = cfg.lang === 'en';
   const w = Math.min(process.stdout.columns || 80, 96);
   console.log('');
@@ -980,13 +1047,26 @@ async function chat(question) {
 // ── Modo conversa (REPL) — o modo PADRÃO do ts: digite naturalmente ──────────
 async function chatRepl() {
   const token = needToken();
-  // Cabeçalho: banner + conta + créditos (best-effort, não trava a entrada)
+  // Cabeçalho: banner + conta + DE ONDE VEM A IA (via sua assinatura/chave/Ollama local).
+  // Crédito só aparece como saldo LEGADO e só sem IA própria (best-effort, não trava a entrada).
   console.log(ui.banner(pkg.version, T.tagline));
-  try {
-    const cr = await api('/api/credits', { token, timeoutMs: 6000 });
-    const cred = (cr.unlimited || cr.granted < 0) ? T.uso_unlimited : T.repl_credits((cr.remaining ?? 0).toLocaleString('pt-BR'));
-    console.log('  ' + C.dim(T.repl_account(cfg.username || '?', cfg.plan || '?') + ' · ') + C.cyan(cred));
-  } catch (_) {}
+  {
+    // as duas consultas em PARALELO, com prazo curto e sem re-tentativa: sem rede, a entrada
+    // espera ~3 s (antes eram duas em sequência, com re-tentativas)
+    const [srcR, crR] = await Promise.allSettled([
+      aiSource(token, { timeoutMs: 3000 }),
+      api('/api/credits', { token, timeoutMs: 3000, retry: false }),
+    ]);
+    const src = srcR.status === 'fulfilled' ? srcR.value : { via: null, unknown: true };
+    let legacy = null;
+    if (!src.via && crR.status === 'fulfilled' && crR.value) {
+      const cr = crR.value, rest = Number(cr.remaining) || 0;
+      legacy = (cr.unlimited || cr.granted < 0) ? T.uso_unlimited : (rest > 0 ? T.repl_credits(rest.toLocaleString('pt-BR')) : null);
+    }
+    // modo selecionado sem a conta conectada: o agente não roda, então o aviso vence o saldo legado
+    const extra = src.via ? C.cyan(src.via) : (legacy && !src.blocking) ? C.cyan(legacy) : aiSourceMissing(src);
+    console.log('  ' + C.dim(T.repl_account(cfg.username || '?', cfg.plan || '?') + ' · ') + extra);
+  }
   console.log('  ' + C.dim(T.repl_hello) + '\n');
 
   // Onboarding: só na PRIMEIRA vez — depois a linha de dica do cabeçalho basta
@@ -1036,6 +1116,7 @@ async function chatRepl() {
     try {
       if (['/nova', '/new'].includes(low)) {
         _resetLocalAgentState(agentCwd);
+        _chatLocal().limpar(_convScope('chat'));
         await ensureConv(token, 'chat', process.cwd(), true);
         console.log(ui.okLine(T.new_conv) + '\n');
       } else if (['/ajuda', '/help', '/?'].includes(low)) {
@@ -1112,11 +1193,13 @@ async function chatRepl() {
       } else {
         const personalIntent = require('../lib/personal-ai-intent').parsePersonalAiIntent(msg);
         if (personalIntent) {
-          if (personalIntent.action === 'connect') await personalAiCmd(['conectar', personalIntent.provider]);
+          if (personalIntent.action === 'connect') await personalAiCmd(['conectar', personalIntent.provider], { interativo: false });
           else if (personalIntent.action === 'disconnect') await personalAiCmd(['desconectar', personalIntent.provider]);
           else if (personalIntent.action === 'use') await personalAiCmd(['usar', personalIntent.mode]);
           else if (personalIntent.action === 'status') await personalAiCmd(['status']);
-          else console.log(ui.infoLine('Para proteger credenciais, use o fluxo interativo de login exibido pelo CLI.'));
+          else console.log(ui.infoLine(cfg.lang === 'en'
+            ? 'Do not paste login codes or tokens here: the login is done in the official CLI on this PC (`ts ia conectar chatgpt|claude`).'
+            : 'Não cole códigos nem tokens de login aqui: o login é feito na CLI oficial neste PC (`ts ia conectar chatgpt|claude`).'));
           continue;
         }
         // ROTEADOR: linguagem natural pura — o sistema decide o caminho e AVISA
@@ -1151,7 +1234,8 @@ async function chatRepl() {
         }
       }
     } catch (e) {
-      if (e instanceof ApiError && e.code === 'conn') console.error(ui.errLine(T.err_conn));
+      if (_erroIaLocal(e)) console.error(ui.errLine(e.message));
+      else if (e instanceof ApiError && e.code === 'conn') console.error(ui.errLine(T.err_conn));
       else if (e instanceof ApiError && e.code === 'auth') { console.error(ui.errLine(T.session_expired)); break; }
       else if (e instanceof ApiError && e.code === 'no_credits') console.error(ui.errLine(T.no_credits));
       else if (e instanceof ApiError && e.code === 'plan_limit') console.error(ui.errLine(e.message));
@@ -1396,7 +1480,7 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   const token = needToken();
   // flags que levam VALOR: o filtro remove só a flag (começa com "-"), deixando o VALOR nos
   // words → tira o valor daqui pra ele não virar parte do texto da tarefa.
-  for (const flag of ['--modelo', '--model', '--output-format', '--orcamento-creditos', '--max-creditos', '--tempo-max-seg', '--max-tokens', '--ferramentas', '--tools']) {
+  for (const flag of ['--modelo', '--model', '--output-format', '--orcamento', '--orcamento-creditos', '--max-creditos', '--tempo-max-seg', '--max-tokens', '--ferramentas', '--tools']) {
     const _i = process.argv.findIndex(a => a === flag); const _v = _i >= 0 ? process.argv[_i + 1] : null;
     if (_v) { const j = words.indexOf(_v); if (j >= 0) words = words.slice(0, j).concat(words.slice(j + 1)); }
   }
@@ -1406,7 +1490,7 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   let _inlinePassos, _inlineYolo = false, _inlineMaxCredits, _inlineMaxSeconds, _inlineMaxTokens;
   task = task
     .replace(/(?:^|\s)--(?:passos|steps|max-passos)[\s=]+(\d{1,3})\b/gi, (_m, n) => { _inlinePassos = Number(n); return ' '; })
-    .replace(/(?:^|\s)--(?:orcamento-creditos|max-creditos)[\s=]+(\d{1,5})\b/gi, (_m, n) => { _inlineMaxCredits = Number(n); return ' '; })
+    .replace(/(?:^|\s)--(?:orcamento-creditos|max-creditos|orcamento)[\s=]+(\d{1,5})\b/gi, (_m, n) => { _inlineMaxCredits = Number(n); return ' '; })
     .replace(/(?:^|\s)--tempo-max-seg[\s=]+(\d{1,5})\b/gi, (_m, n) => { _inlineMaxSeconds = Number(n); return ' '; })
     .replace(/(?:^|\s)--max-tokens[\s=]+(\d{3,7})\b/gi, (_m, n) => { _inlineMaxTokens = Number(n); return ' '; })
     .replace(/(?:^|\s)--(?:yolo|full-auto|auto-tudo)\b/gi, () => { _inlineYolo = true; return ' '; })
@@ -1447,10 +1531,11 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   const _p = require('path'), _fs = require('fs'), _os = require('os'), _cr = require('crypto');
   const sessFile = _p.join(_os.homedir(), '.ts', 'agente', _cr.createHash('md5').update(process.cwd().toLowerCase()).digest('hex').slice(0, 12) + '.json');
   let priorMessages = null;
+  let priorContext = null; // medidor da última chamada da sessão anterior (folha de decisão em 95%)
   // cwd da sessão: o do REPL (cwdIn) tem prioridade; senão a pasta de lançamento.
   let startCwd = cwdIn || process.cwd();
   if (process.argv.includes('--continuar') || process.argv.includes('-c')) {
-    try { const s = JSON.parse(_fs.readFileSync(sessFile, 'utf8')); priorMessages = s.messages; if (!cwdIn && s.cwd) startCwd = s.cwd; if (!streamJson) console.log('  ' + C.dim((cfg.lang === 'en' ? '↻ resuming this folder\'s session (' : '↻ continuando a sessão desta pasta (') + (s.messages ? s.messages.length : 0) + ' msgs)')); }
+    try { const s = JSON.parse(_fs.readFileSync(sessFile, 'utf8')); priorMessages = s.messages; priorContext = s.context || null; if (!cwdIn && s.cwd) startCwd = s.cwd; if (!streamJson) console.log('  ' + C.dim((cfg.lang === 'en' ? '↻ resuming this folder\'s session (' : '↻ continuando a sessão desta pasta (') + (s.messages ? s.messages.length : 0) + ' msgs)')); }
     catch (_) { if (!streamJson) console.log('  ' + C.dim(cfg.lang === 'en' ? '(no prior session here — starting fresh)' : '(sem sessão anterior aqui — começando nova)')); }
   }
   // Retomada por linguagem natural depois de queda/restart. O estado parcial
@@ -1492,11 +1577,55 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   // 40min no PW). _hlog escreve SÍNCRONO no fd 1 (fs.writeSync), descarregando cada linha na
   // hora. No TTY segue o console.log normal (o spinner cuida do redesenho).
   const _hlog = (s) => { if (_noTTY && !streamJson) { try { require('fs').writeSync(1, s + '\n'); return; } catch (_) {} } console.log(s); };
+  // FOLHA DE DECISÃO: a sessão retomada já chegou a 95% do limite útil (ou chega com a
+  // mensagem nova). Com pessoa na frente: Compactar e continuar (padrão) / Começar sessão
+  // nova / Continuar assim. Sem TTY (--yes, --yolo, ACP, stream-json, pipe):
+  // compacta sozinho e avisa. No meio da execução quem cuida é a compactação automática.
+  let compactFirst = false;
+  // "Continuar assim": a execução não compacta pelo limiar (só no limite útil ou num 400 de contexto)
+  let noProactiveCompact = false;
+  // no stream-json o primeiro evento é SEMPRE system(init): o aviso espera e sai logo depois dele
+  let _autoCompactEvent = null;
+  if (Array.isArray(priorMessages) && priorMessages.length && priorContext) {
+    const en = cfg.lang === 'en';
+    // REPL alimentado por pipe também tem askFn, mas a "resposta" seria a próxima linha do
+    // pipe — por isso a pergunta exige terminal de verdade nos dois lados.
+    const interactive = !streamJson && !JSON_OUT && !YES && !YOLO && !_inlineYolo && !autoAllIn
+      && !!(process.stdin.isTTY && process.stdout.isTTY);
+    const dec = core.resumeContextDecision(priorContext, { extraTok: Math.ceil(String(task || '').length / 4), interactive });
+    const meterTxt = core.formatContextMeter(priorContext, cfg.lang);
+    if (dec.action === 'ask') {
+      console.log('\n  ' + C.warn('▲ ') + C.bold(en ? `This session is at ${dec.pct}% of the usable context` : `A sessão está em ${dec.pct}% do contexto útil`) + C.dim('  · ' + meterTxt));
+      console.log('  ' + C.cyan('1') + C.dim(en ? '  Compact and continue (default) — older history becomes a summary' : '  Compactar e continuar (padrão) — o histórico antigo vira um resumo'));
+      console.log('  ' + C.cyan('2') + C.dim(en ? '  Start a new session — the previous one is archived' : '  Começar sessão nova — a anterior fica arquivada'));
+      console.log('  ' + C.cyan('3') + C.dim(en ? '  Continue as is — the model may lose the start of the conversation' : '  Continuar assim — o modelo pode perder o começo da conversa'));
+      const choice = String(await ask(en ? 'choice (1/2/3) [1]: ' : 'escolha (1/2/3) [1]: ') || '').trim();
+      if (choice.startsWith('2')) {
+        const archived = sessFile.replace(/\.json$/, '') + '.arquivada-' + new Date().toISOString().replace(/[:.]/g, '-') + '.json';
+        try { _fs.renameSync(sessFile, archived); } catch (_) {}
+        priorMessages = null;
+        console.log('  ' + C.dim(en ? '→ new session; previous one archived at ' : '→ sessão nova; a anterior foi arquivada em ') + C.dim(archived) + '\n');
+      } else if (choice.startsWith('3')) {
+        noProactiveCompact = true;
+        console.log('  ' + C.dim(en ? '→ continuing without compacting' : '→ seguindo sem compactar') + '\n');
+      } else {
+        compactFirst = true;
+        console.log('  ' + C.dim(en ? '→ compacting before the first step' : '→ compactando antes do primeiro passo') + '\n');
+      }
+    } else if (dec.action === 'auto') {
+      compactFirst = true;
+      const note = en
+        ? `resumed session at ${dec.pct}% of the usable context — compacting automatically before continuing (no interactive terminal)`
+        : `sessão retomada em ${dec.pct}% do contexto útil — compactando sozinho antes de continuar (sem terminal interativo)`;
+      if (streamJson) _autoCompactEvent = core.AgentEvents.tool({ subtype: 'context_auto_compact', tool: 'compactar_contexto', detail: note });
+      else if (!JSON_OUT) _hlog('  ' + C.warn('▲ ' + note));
+    }
+  }
   const sp = (streamJson || _noTTY) ? { text() {}, start() {}, stop() {} } : ui.spinner(T.agent_thinking).start();
   if (_noTTY && !streamJson) _hlog('  ' + C.dim(T.agent_thinking));
   const t0 = Date.now();
   // STATUS LINE ao vivo (estilo Claude/Verboo): tempo · modelo · tokens · passo — atualiza a cada 1s.
-  const _live = { steps: 0, inTok: 0, outTok: 0, model: model || 'auto' };
+  const _live = { steps: 0, inTok: 0, outTok: 0, model: model || 'auto', compacting: false };
   const _fmtTime = (ms) => { const s = Math.floor(ms / 1000), m = Math.floor(s / 60); return m > 0 ? `${m}m${String(s % 60).padStart(2, '0')}s` : `${s}s`; };
   const _fmtTok = (n) => n >= 1000 ? (n / 1000).toFixed(1).replace('.0', '') + 'k' : String(n);
   const _statusLine = () => {
@@ -1504,11 +1633,15 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
     const parts = [_fmtTime(Date.now() - t0), String(_live.model).slice(0, 22)];
     if (tok > 0) parts.push('↓ ' + _fmtTok(tok) + ' tok');
     if (_live.steps > 0) parts.push('passo ' + _live.steps);
-    return T.agent_thinking + '  · ' + parts.join(' · '); // texto puro; o spinner aplica a cor
+    const head = _live.compacting ? (cfg.lang === 'en' ? 'summarizing history' : 'resumindo o histórico') : T.agent_thinking;
+    return head + '  · ' + parts.join(' · '); // texto puro; o spinner aplica a cor
   };
   const _liveTimer = (!_noTTY && !streamJson) ? setInterval(() => sp.text(_statusLine()), 1000) : null;
-  if (streamJson) _emit(core.AgentEvents.systemInit({ model: model || 'auto', cwd: startCwd, mode: plan ? 'plan' : readOnly ? 'ask' : 'agent' }));
-  // Mesmo agente de projeto e mesmo fluxo usados no Telegram, Web e App.
+  if (streamJson) {
+    _emit(core.AgentEvents.systemInit({ model: model || 'auto', cwd: startCwd, mode: plan ? 'plan' : readOnly ? 'ask' : 'agent' }));
+    if (_autoCompactEvent) _emit(_autoCompactEvent);
+  }
+  // Mesmo agente de projeto e mesmo fluxo usados na Web e no App.
   // É best-effort para o CLI continuar funcional durante indisponibilidade do backend.
   let sharedChannelPrompt = '';
   let sharedConversationId = null;
@@ -1528,34 +1661,29 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   }
   let personalSelectionRequired = false;
   try {
-    const personalState = await api('/api/personal-ai/status', { token });
-    // O modo é da CONTA e precisa ser idêntico no Telegram/Web/App/CLI. Uma
-    // preferência local antiga não pode vencer silenciosamente o estado remoto
-    // e consumir créditos TS quando a conta está em ChatGPT/Claude.
-    const selectedPersonal = personalState?.ok && personalState.mode !== 'automatico';
+    // O modo da conta é LOCAL (`ts ia usar`) e a IA roda na CLI oficial logada neste PC
+    // (lib/ia-local). Uma escolha explícita nunca cai em silêncio para os créditos TS: se a CLI
+    // exigida não está pronta, a execução é cancelada com o motivo.
+    const iaLocal = require('../lib/ia-local');
+    const modoLocal = _modoIaLocal();
+    const selectedPersonal = modoLocal !== 'automatico';
     personalSelectionRequired = selectedPersonal;
-    const personalReady = selectedPersonal
-      && (personalState.mode === 'chatgpt' ? personalState.chatgpt
-        : personalState.mode === 'claude' ? personalState.claude
-          : personalState.chatgpt && personalState.claude);
-    if (selectedPersonal && !personalReady) {
-      throw new Error(`modo ${personalState.mode} selecionado, mas a conta necessária não está conectada`);
-    }
-    if (personalReady) {
-      personalAgentMode = personalState.mode;
-      personalAgentLlm = require('../lib/personal-agent-llm').createPersonalAgentLlm({
-        api, token, mode:personalAgentMode, conversationId:sharedConversationId,
-        agentId:shared?.agent?.id || null,
-      });
-      if (!streamJson) _hlog('  ' + C.dim(`IA pessoal como executora local: ${personalAgentMode === 'chatgpt' ? 'ChatGPT/Codex' : personalAgentMode === 'claude' ? 'Claude' : 'ChatGPT/Codex + Claude'} · 0 créditos TS`));
+    if (selectedPersonal) {
+      const personalState = await iaLocal.status();
+      if (!iaLocal.pronto(modoLocal, personalState)) {
+        throw new Error(`modo ${modoLocal} selecionado, mas ${iaLocal.faltando(modoLocal, personalState)} — veja \`ts ia status\``);
+      }
+      personalAgentMode = modoLocal;
+      personalAgentLlm = require('../lib/personal-agent-llm').createPersonalAgentLlm({ mode:personalAgentMode });
+      if (!streamJson) _hlog('  ' + C.dim(`IA da sua conta como executora local: ${_personalLabel(personalAgentMode)} neste PC · ${T.via_subscription}`));
     }
   } catch (e) {
-    if (personalSelectionRequired || (cfg.personalModePreference && cfg.personalModePreference !== 'automatico')) {
-      if (!streamJson) _hlog('  ' + C.warn(`▲ IA pessoal indisponível (${String(e.message || e).slice(0, 120)}). Execução cancelada para não consumir créditos TS sem aviso.`));
+    if (personalSelectionRequired) {
+      if (!streamJson) _hlog('  ' + C.warn(`▲ IA pessoal indisponível (${String(e.message || e).slice(0, 160)}). Execução cancelada para não consumir créditos TS sem aviso.`));
       durableOps.interrupt(startCwd, 'personal_ai_unavailable');
       return;
     }
-    if (!streamJson) _hlog('  ' + C.warn('▲ não foi possível confirmar a IA da conta; usando o modo Automático do TS nesta execução (pode consumir créditos).'));
+    if (!streamJson) _hlog('  ' + C.warn('▲ não foi possível confirmar a IA da conta; seguindo com a sua chave, se houver, ou com a IA do Terminal Smart (créditos legados) nesta execução.'));
   }
   let out;
   const durableCwd = _wt ? _wt.base : startCwd;
@@ -1565,7 +1693,9 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
     // Pra missões grandes ("faça tudo de uma vez") sem o pára-e-continua.
     const _pi = process.argv.findIndex(a => a === '--passos' || a === '--steps' || a === '--max-passos');
     const _maxPassos = _pi >= 0 ? Number(process.argv[_pi + 1]) : (_inlinePassos ?? maxIterIn ?? undefined);
-    const _ci = process.argv.findIndex(a => a === '--orcamento-creditos' || a === '--max-creditos');
+    // --orcamento N (apelidos antigos: --orcamento-creditos / --max-creditos). Só limita
+    // a IA do Terminal Smart (créditos legados); com chave/assinatura própria não há cobrança do TS.
+    const _ci = process.argv.findIndex(a => a === '--orcamento' || a === '--orcamento-creditos' || a === '--max-creditos');
     const _ti = process.argv.findIndex(a => a === '--tempo-max-seg');
     const _tki = process.argv.findIndex(a => a === '--max-tokens');
     const _maxCredits = _ci >= 0 ? Number(process.argv[_ci + 1]) : _inlineMaxCredits;
@@ -1578,9 +1708,11 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
       keyOverride:personalAgentLlm ? { key:'personal-subscription', baseUrl:'personal://subscription', source:'personal', billingAuthoritative:true } : undefined,
       personalSubscription:!!personalAgentLlm,
       maxCredits: _maxCredits, maxDurationMs: _maxDurationMs || undefined, maxTokens: _maxTokens,
+      compactFirst, noProactiveCompact,
       onThinking: (p) => {
         if (p && typeof p === 'object') {
           _live.steps = p.steps ?? _live.steps; _live.inTok = p.inTok ?? _live.inTok; _live.outTok = p.outTok ?? _live.outTok;
+          _live.compacting = !!p.compacting;
           if (p.model && p.model !== 'smart') _live.model = p.model;
         }
         sp.text(_statusLine());
@@ -1590,6 +1722,8 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
         if (name && !blocked && !durableInternalStep) durableOps.toolStarted(durableCwd, name);
         if (streamJson) { _emit(core.AgentEvents.tool({ subtype: retry ? 'retry' : loop ? 'loop' : blocked ? 'blocked' : auto ? 'auto_approved' : 'started', tool: name, detail: detail || '' })); return; }
         sp.stop();
+        const _compactFail = compactFailLine(name, blocked, detail);
+        if (_compactFail) { _hlog('  ' + _compactFail); sp.start(); return; }
         const tag = auto ? C.warn('▲ auto') : retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('›');
         // nome AMIGÁVEL (Rodando no servidor…) em vez do técnico (executar_remoto); detalhe sem cortar palavra
         const _label = ui.friendlyTool(name, cfg.lang === 'en');
@@ -1610,18 +1744,14 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
         sp.start();
         return r;
       },
-      onRemote: ({ ttl }) => {
-        if (streamJson) { _emit(core.AgentEvents.tool({ subtype: 'approval_remote', ttl: ttl || 120 })); return; }
-        sp.stop();
-        _hlog('  ' + C.warn('▲') + ' ' + C.dim(T.agent_remote_wait(ttl || 120)));
-        sp.start();
-      },
     });
   } catch (e) {
     durableOps.interrupt(durableCwd, e && (e.code || e.message) || 'agent_error');
     if (_liveTimer) clearInterval(_liveTimer);
     sp.stop();
-    const hint = providerCapacityHint(e);
+    // saldo/limite do PROVEDOR da chave própria (BYOK) não é falta da IA do TS; no modo
+    // assinatura a execução não passou pela chave, então a dica não vale
+    const hint = providerCapacityHint(e) || (!personalAgentLlm ? byokNoBalanceHint(e) : '');
     if (hint) {
       const err = new ApiError(hint, { status: Number(e && e.status) || 402, code: 'byok_provider_capacity' });
       err.cause = e;
@@ -1638,7 +1768,12 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   // senão --continuar retomaria num diretório que o `ts worktrees clean` já apagou).
   if (onCwd && !_wt && effCwd !== startCwd) onCwd(effCwd);
   const persistCwd = _wt ? _wt.base : effCwd;
-  try { _fs.mkdirSync(_p.dirname(sessFile), { recursive: true }); _fs.writeFileSync(sessFile, JSON.stringify({ cwd: persistCwd, at: new Date().toISOString(), messages: (out.messages || []).slice(-60) })); } catch (_) {}
+  // corte seguro: preserva o resumo fixo da compactação e não começa numa resposta 'tool' órfã;
+  // context = medidor da última chamada, lido pela folha de decisão do próximo --continuar.
+  // Retorno sem histórico não apaga a sessão salva (o --continuar perderia tudo, até o resumo).
+  if (Array.isArray(out.messages) && out.messages.length) {
+    try { _fs.mkdirSync(_p.dirname(sessFile), { recursive: true }); _fs.writeFileSync(sessFile, JSON.stringify({ cwd: persistCwd, at: new Date().toISOString(), context: out.context || null, messages: core.safeTail(out.messages, 60) })); } catch (_) {}
+  }
   const secs = _fmtTime(Date.now() - t0); // tempo total já em min+seg (ex: 12m44s), não segundos crus
   // WORKTREE: commita o que mudou e prepara o resumo (merge/descarte).
   const _wtInfo = _wt ? _worktreeFinish(_wt) : null;
@@ -1657,10 +1792,10 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   // HEADLESS stream-json: fecha com assistant (texto) + result (métricas) e sai.
   if (streamJson) {
     _emit(core.AgentEvents.assistant(out.text || ''));
-    _emit(core.AgentEvents.result({ steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, needHuman: out.needHuman || null, guard: out.guard || null, observability: out.observability || null, duration_ms: Date.now() - t0, worktree: _wt ? { branch: _wt.branch, changed: (_wtInfo && _wtInfo.changed) || 0 } : null }));
+    _emit(core.AgentEvents.result({ steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, compaction: out.compaction || null, needHuman: out.needHuman || null, guard: out.guard || null, observability: out.observability || null, duration_ms: Date.now() - t0, worktree: _wt ? { branch: _wt.branch, changed: (_wtInfo && _wtInfo.changed) || 0 } : null }));
     return;
   }
-  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, result: out.text, steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context, needHuman: out.needHuman, guard: out.guard || null })); return; }
+  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, result: out.text, steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context, compaction: out.compaction || null, needHuman: out.needHuman, guard: out.guard || null })); return; }
   // BLOQUEIO HUMANO: o agente pediu uma ação que só o usuário faz — mostra o pedido
   // (antes o retorno vinha com texto vazio e o usuário via só um cabeçalho em branco).
   if (out.needHuman) {
@@ -1672,20 +1807,20 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
     return;
   }
   printAnswer(out.text);
-  // medidor de contexto: ocupação REAL da janela na última chamada (só aparece se >25%)
-  const _cx = out.context && out.context.window
-    ? (out.context.used / out.context.window > 0.25
-      ? '  ·  ' + (cfg.lang === 'en' ? 'context ' : 'contexto ') + Math.round(out.context.used / 1000) + 'k/' + Math.round(out.context.window / 1000) + 'k (' + Math.round(100 * out.context.used / out.context.window) + '%)'
-      : '')
-    : '';
-  // rodapé enriquecido: passos · créditos · tempo · MODELO · tokens (· contexto)
+  // medidor de contexto: ocupação da janela na ÚLTIMA chamada (não a soma do turno), sobre o
+  // limite útil, com o selo medido/≈estimado; amarelo a partir de 80% (perto da folha de 95%).
+  const _cxMeter = core.contextMeter(out.context);
+  const _cxTxt = core.formatContextMeter(out.context, cfg.lang);
+  const _cx = _cxTxt ? C.dim('  ·  ') + (_cxMeter.pct >= 80 ? C.warn(_cxTxt) : C.dim(_cxTxt)) : '';
+  // rodapé enriquecido: passos · via (ou créditos legados) · tempo · MODELO · tokens (· contexto)
   const _tokTot = (out.tokens && ((out.tokens.inTok || 0) + (out.tokens.outTok || 0))) || 0;
   const _extra = (out.model ? ' · ' + String(out.model).slice(0, 22) : '') + (_tokTot ? ' · ↓ ' + _fmtTok(_tokTot) + ' tok' : '');
-  // Com BYOK o gasto é na chave do usuário, não em crédito do TS — mostrar "créditos"
-  // aqui seria enganoso (nada foi cobrado). Troca pelo provedor que executou.
+  // Com assinatura ou chave própria nada é cobrado pelo TS — mostrar "créditos" aqui seria
+  // enganoso. Diz por onde a IA rodou; créditos só no caminho legado da IA do Terminal Smart.
   const _byok = require('../lib/keyring').ativo();
-  const _base = _byok ? T.agent_footer_byok(out.steps, _byok.id, secs) : T.agent_footer(out.steps, out.credits, secs);
-  console.log('  ' + C.dim(_base) + C.dim(_extra) + C.dim(_cx) + C.dim('  ·  ts agente --continuar "..." pra seguir') + '\n');
+  const _via = personalAgentLlm ? T.via_subscription : _byok ? (_byok.id === 'ollama' ? T.via_ollama : T.via_key(_byok.id)) : null;
+  const _base = _via ? T.agent_footer_via(out.steps, _via, secs) : T.agent_footer(out.steps, out.credits, secs);
+  console.log('  ' + C.dim(_base) + C.dim(_extra) + _cx + C.dim('  ·  ts agente --continuar "..." pra seguir') + '\n');
   _printWt();
 }
 
@@ -1774,7 +1909,7 @@ async function evalCmd(words) {
   // no teto padrão de uma missão só porque um provedor demorou a encerrar.
   const _evalSteps = Number(_val(['--passos', '--steps']));
   const _evalSeconds = Number(_val(['--tempo-max-seg', '--max-seconds']));
-  const _evalCredits = Number(_val(['--orcamento-creditos', '--max-creditos']));
+  const _evalCredits = Number(_val(['--orcamento', '--orcamento-creditos', '--max-creditos']));
   const evalLimits = {
     maxIter: Number.isFinite(_evalSteps) && _evalSteps > 0 ? Math.min(60, Math.floor(_evalSteps)) : undefined,
     maxDurationMs: Number.isFinite(_evalSeconds) && _evalSeconds > 0 ? Math.min(3600, _evalSeconds) * 1000 : undefined,
@@ -1813,7 +1948,7 @@ async function evalCmd(words) {
     if (models.length < 2) { _die(en ? '--modelos needs at least 2 models (comma-separated)' : '--modelos precisa de pelo menos 2 modelos (separados por vírgula)', 2); }
     if (!JSON_OUT) {
       console.log('\n  ' + ui.gradient('⌁ ' + (en ? 'Model Lab' : 'Model Lab')) + '  ' + C.bold(suite.name) + C.dim('  · ' + suite.cases.length + (en ? ' case(s) × ' : ' caso(s) × ') + models.length + (en ? ' models' : ' modelos')));
-      console.log('  ' + C.dim(en ? 'same suite on each executor; a fixed judge scores all (fair). Costs credits.' : 'mesma suíte em cada executor; um juiz fixo pontua todos (justo). Gasta créditos.') + '\n');
+      console.log('  ' + C.dim(en ? 'same suite on each executor; a fixed judge scores all (fair). Runs via your key or local Ollama (ts conectar); without one, on TS legacy credits.' : 'mesma suíte em cada executor; um juiz fixo pontua todos (justo). Roda via sua chave ou Ollama local (ts conectar); sem elas, nos créditos legados do TS.') + '\n');
     }
     const spM = JSON_OUT ? { start() {}, stop() {}, text() {} } : ui.spinner('…').start();
     let mx;
@@ -1823,7 +1958,7 @@ async function evalCmd(words) {
         onModel: ({ model, phase, row }) => { if (JSON_OUT) return; if (phase === 'start') spM.text((en ? 'testing ' : 'testando ') + model + '…'); else if (phase === 'done') { spM.stop(); console.log('  ' + C.cyan('◆') + ' ' + C.bold(model) + C.dim('  ' + row.passed + '/' + row.total + ' · score ' + row.avgScore + ' · ' + row.credits + ' cr') + (row.error ? C.err('  ' + row.error) : '')); spM.start(); } },
         onCase: ({ phase, id, pass, score }) => { if (!JSON_OUT && phase === 'done') { spM.stop(); console.log('      ' + (pass ? C.ok('✔') : C.err('✗')) + C.dim(' ' + id + ' ' + score)); spM.start(); } },
       });
-    } catch (e) { spM.stop(); if (e && (e.code === 'no_credits' || e.status === 402)) { console.error('\n' + ui.errLine(en ? 'AI limit reached — top up to run the bake-off.' : 'Limite de IA atingido — recarregue pra rodar o bake-off.')); process.exit(1); } throw e; }
+    } catch (e) { spM.stop(); if (e && (e.code === 'no_credits' || e.status === 402)) { console.error('\n' + ui.errLine(byokNoBalanceHint(e) || T.no_credits)); process.exit(1); } throw e; }
     spM.stop();
     if (JSON_OUT) { console.log(JSON.stringify(mx)); return; }
     // placar ordenado (qualidade → custo)
@@ -1839,7 +1974,7 @@ async function evalCmd(words) {
 
   if (!JSON_OUT) {
     console.log('\n  ' + ui.gradient('⌁ ' + (en ? 'Eval' : 'Avaliação')) + '  ' + C.bold(suite.name) + C.dim('  · ' + suite.cases.length + (en ? ' case(s)' : ' caso(s)')));
-    console.log('  ' + C.dim(en ? 'runs the real agent per case (costs credits), an AI judge scores each' : 'roda o agente de verdade por caso (gasta créditos); um juiz de IA pontua cada um') + '\n');
+    console.log('  ' + C.dim(en ? 'runs the real agent per case (via your key or local Ollama; without one, TS legacy credits), an AI judge scores each' : 'roda o agente de verdade por caso (via sua chave ou Ollama local; sem elas, créditos legados do TS); um juiz de IA pontua cada um') + '\n');
   }
   const sp = JSON_OUT ? { start() {}, stop() {}, text() {} } : ui.spinner('…').start();
   let res;
@@ -1859,8 +1994,8 @@ async function evalCmd(words) {
     });
   } catch (e) {
     sp.stop();
-    // teto de IA (free/plano) → CTA de upgrade limpo, nunca "HTTP 402" cru.
-    if (e && (e.code === 'no_credits' || e.status === 402)) { console.error('\n' + ui.errLine(en ? 'AI limit reached on this plan — top up or upgrade to run evals.' : 'Limite de IA do plano atingido — recarregue ou faça upgrade pra rodar evals.')); process.exit(1); }
+    // sem IA do TS disponível → explica como usar a IA própria, nunca "HTTP 402" cru.
+    if (e && (e.code === 'no_credits' || e.status === 402)) { console.error('\n' + ui.errLine(byokNoBalanceHint(e) || T.no_credits)); process.exit(1); }
     throw e;
   }
   sp.stop();
@@ -2087,7 +2222,7 @@ async function metaCmd() {
   if (goal && st0 && st0.status !== 'done') { console.error(ui.infoLine(T.meta_exists(st0.goal))); process.exit(2); }
   if (!goal && (!st0 || st0.status === 'done')) { console.error(ui.infoLine(T.meta_need)); process.exit(2); }
 
-  const yes = YES || !process.stdin.isTTY; // noturno/cron = autônomo (Telegram cobre o perigoso)
+  const yes = YES || !process.stdin.isTTY; // noturno/cron = autônomo (o perigoso é recusado sem alguém no terminal)
   console.log(ui.banner(pkg.version, T.tagline));
   if (st0 && st0.status !== 'done') {
     const d = st0.checklist.filter(i => i.passes).length;
@@ -2127,7 +2262,7 @@ async function metaCmd() {
           const rest = String(text).split('\n').slice(1).filter(Boolean);
           for (const l of rest) console.log('     ' + C.dim(l));
           console.log('');
-          metaMod.notify(token, text).catch(() => {}); // avisa no Telegram também
+          metaMod.notify(token, text).catch(() => {}); // aviso fora do terminal: virá pelo hub (hoje não envia nada)
           sp.start();
         },
         onChecklist: (itens) => { sp.stop(); console.log(_metaChecklistBox(itens) + '\n'); sp.start(); },
@@ -2135,12 +2270,13 @@ async function metaCmd() {
         onThinking: () => sp.text(T.agent_thinking),
         onStep: ({ name, detail, blocked, loop, retry, auto }) => {
           sp.stop();
-          console.log('    ' + (auto ? C.warn('▲ auto') : retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙')) + ' ' + name + (detail ? C.dim(' · ' + detail) : ''));
+          const _compactFail = compactFailLine(name, blocked, detail);
+          if (_compactFail) console.log('    ' + _compactFail);
+          else console.log('    ' + (auto ? C.warn('▲ auto') : retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙')) + ' ' + name + (detail ? C.dim(' · ' + detail) : ''));
           sp.start();
         },
         onStepDone: (e) => { sp.stop(); console.log(stepDoneLine(e, '      ')); sp.start(); },
         askApprove: async (payload) => { sp.stop(); const r = await askApproveRoute(payload); sp.start(); return r; },
-        onRemote: ({ ttl }) => { sp.stop(); console.log('    ' + C.warn('▲') + ' ' + C.dim(T.agent_remote_wait(ttl || 120))); sp.start(); },
         onRoundDone: ({ checklist, spent }) => {
           sp.stop();
           const d = checklist.filter(i => i.passes).length;
@@ -2238,7 +2374,6 @@ async function metaCmd() {
     for (const b of blocked) console.log('    ' + C.err('!') + ' ' + b.desc.slice(0, 80));
   }
   console.log('');
-  await new Promise(r => setTimeout(r, 1200)); // dá tempo do notify sair antes do exit
   if (st.status !== 'done') process.exit(3);
 }
 
@@ -2434,8 +2569,8 @@ async function sentinelaCmd(args) {
       }
       if (token) { try { await metaMod.notify(token, msg); } catch (_) {} }
       if (!quiet) console.log(msg);
-      // ── AUTOFIX (Incident Autopilot): conserto verificado + comando seguro → aprovação no Telegram → aplica → re-valida.
-      // NUNCA aplica sem OK humano (aprovação remota). Só quando o diagnóstico sobreviveu à refutação.
+      // ── AUTOFIX (Incident Autopilot): conserto verificado + comando seguro → aprovação no terminal → aplica → re-valida.
+      // NUNCA aplica sem OK humano. Só quando o diagnóstico sobreviveu à refutação.
       if (!r.verdict.ok && check.autofix && token && diagResult && diagResult.status === 'solved' && diagResult.verified && diagResult.fixCommand) {
         const applied = await _sentinelaAutofix(check, diagResult, r, token, quiet, en);
         if (applied != null) alerts++;
@@ -2492,33 +2627,36 @@ async function sentinelaCmd(args) {
 }
 function execSyncQuiet(c) { return require('child_process').execSync(c, { stdio: 'ignore', windowsHide: true }); }
 
-// AUTOFIX da sentinela (Incident Autopilot): propõe o conserto no Telegram, e SÓ aplica com
-// aprovação humana. Aplica no alvo (local ou ssh remoto), re-valida o check e reporta. Retorna
-// true/false se aplicou (consertou ou não), null se não houve aprovação/canal.
+// AUTOFIX da sentinela (Incident Autopilot): propõe o conserto e SÓ aplica com aprovação humana
+// LOCAL, no terminal. Aplica no alvo (local ou ssh remoto), re-valida o check e reporta. Retorna
+// true/false se aplicou (consertou ou não), null se não houve aprovação.
 async function _sentinelaAutofix(check, diag, r, token, quiet, en) {
   const sen = require('../lib/sentinela');
   const metaMod = require('../lib/meta');
   const cmd = String(diag.fixCommand).trim();
-  const alvo = check.target ? check.target.split(' ').pop() : os.hostname();
-  // 1) aprovação remota (mesmo canal do agente): /api/cli/approval/start → poll
-  let st = null;
-  try { st = await api('/api/cli/approval/start', { method: 'POST', token, body: { comando: `[sentinela ${check.nome}@${alvo}] ${cmd}`, host: alvo }, timeoutMs: 20000 }); } catch (_) { return null; }
-  if (!st || !st.success || !st.id) { // sem canal Telegram → só propõe e para
-    if (!quiet) console.log('  ' + C.dim(en ? 'autofix: no Telegram channel to approve — proposed only.' : 'autofix: sem canal Telegram pra aprovar — só proposto.'));
+  // o comando MOSTRADO (na aprovação e nos avisos) vai MASCARADO (`mysql -pSENHA`, `sshpass -p`,
+  // PGPASSWORD=…); o comando original só roda aqui. A máscara nunca esconde pedaço que o shell
+  // executa; se precisaria esconder, não há aprovação possível — quem aprova não veria o que
+  // roda. Os segredos do próprio ts (token de sessão, chaves, senha SSH, auth de MCP) são
+  // mascarados também pelo VALOR.
+  const shown = require('../lib/core').redactForApproval(cmd, { known: require('../lib/tools').knownSecretsFor([token]) });
+  if (shown.hidden) {
+    if (!quiet) console.log('  ' + C.dim(en ? 'autofix: the command carries a secret that cannot be masked without hiding part of what runs — proposed only.' : 'autofix: o comando traz um segredo que não dá para mascarar sem esconder parte do que roda — só proposto.'));
     return null;
   }
-  if (!quiet) console.log('  ' + C.warn('🔧 ') + C.dim((en ? 'autofix: sent to Telegram for approval — ' : 'autofix: enviei pro Telegram pra aprovar — ') + cmd.slice(0, 60)));
-  let approved = false;
-  const t0 = Date.now();
-  while (Date.now() - t0 < 150000) {
-    await new Promise(rs => setTimeout(rs, 3000));
-    let p = null;
-    try { p = await api('/api/cli/approval/poll', { method: 'POST', token, body: { id: st.id }, timeoutMs: 15000 }); } catch (_) { continue; }
-    if (p && p.status === 'approved') { approved = true; break; }
-    if (p && (p.status === 'denied' || p.status === 'expired')) break;
+  const cmdSafe = shown.text;
+  const alvo = check.target ? check.target.split(' ').pop() : os.hostname();
+  // 1) aprovação LOCAL: só com alguém no terminal. Pelo agendador (--quiet / sem TTY) o conserto
+  //    fica só proposto — o aviso pelo celular virá pelo hub.
+  if (quiet || !process.stdin.isTTY) {
+    try { await metaMod.notify(token, `🔧 [sentinela] ${check.nome}@${alvo}: conserto proposto e NÃO aplicado (sem aprovação no terminal). Comando proposto: ${cmdSafe}`); } catch (_) {}
+    if (!quiet) console.log('  ' + C.dim(en ? 'autofix: nobody at the terminal to approve — proposed only.' : 'autofix: ninguém no terminal para aprovar — só proposto.'));
+    return null;
   }
+  const dec = await askDestructive(cmdSafe, { en, warning: (en ? 'sentinel autofix on ' : 'conserto da sentinela em ') + `${check.nome}@${alvo}` });
+  const approved = dec === true || dec === 'all';
   if (!approved) {
-    try { await metaMod.notify(token, `⏹️ [sentinela] ${check.nome}: conserto NÃO aplicado (não aprovado). Comando proposto: ${cmd}`); } catch (_) {}
+    try { await metaMod.notify(token, `⏹️ [sentinela] ${check.nome}: conserto NÃO aplicado (não aprovado). Comando proposto: ${cmdSafe}`); } catch (_) {}
     if (!quiet) console.log('  ' + C.dim(en ? 'autofix: not approved — nothing applied.' : 'autofix: não aprovado — nada aplicado.'));
     return null;
   }
@@ -2528,8 +2666,8 @@ async function _sentinelaAutofix(check, diag, r, token, quiet, en) {
   const fixedOk = rr.verdict.ok;
   const rerun = ((rr.res.stdout || '') + (rr.res.stderr || '')).trim().split('\n').slice(0, 4).join('\n').slice(0, 300);
   const finalMsg = fixedOk
-    ? `✅ [sentinela] ${check.nome}: CONSERTADO por autofix. Apliquei \`${cmd}\` e o check voltou a passar.`
-    : `⚠️ [sentinela] ${check.nome}: autofix aplicado (\`${cmd}\`) mas o check AINDA falha (${rr.verdict.motivo}). Precisa de você.\n${rerun}`;
+    ? `✅ [sentinela] ${check.nome}: CONSERTADO por autofix. Apliquei \`${cmdSafe}\` e o check voltou a passar.`
+    : `⚠️ [sentinela] ${check.nome}: autofix aplicado (\`${cmdSafe}\`) mas o check AINDA falha (${rr.verdict.motivo}). Precisa de você.\n${require('../lib/tools').maskKnownSecrets(require('../lib/core').redactSecrets(rerun), [token])}`;
   try { await metaMod.notify(token, finalMsg); } catch (_) {}
   if (!quiet) console.log('  ' + (fixedOk ? C.ok('✔ ') + (en ? 'autofix worked — check passes again' : 'autofix funcionou — check voltou a passar') : C.err('✗ ') + (en ? 'applied but still failing' : 'aplicado mas ainda falha')) + C.dim((ap.code !== 0 ? ' (fix exit ' + ap.code + ')' : '')));
   return fixedOk;
@@ -3021,7 +3159,7 @@ async function checkpointsCmd(words) {
   console.log('\n' + ui.box(linhas, { title: 'ts checkpoints' }));
 }
 
-// ── ts conectar — BYOK: usar SUA chave de IA em vez dos créditos do TS ────────
+// ── ts conectar — BYOK: o agente roda via SUA chave de IA (ou via Ollama local) ──
 // O agente já fala OpenAI-compat, então qualquer provedor desses entra sem mexer no loop.
 // O cadastro TESTA de verdade: a chave responde? e o modelo CHAMA FERRAMENTA? A segunda
 // pergunta é a que importa — modelo que não faz tool-call vira um chat que narra sucesso.
@@ -3039,7 +3177,7 @@ async function conectarCmd(words) {
     return a
       ? C.ok('● ') + (en ? 'using YOUR key: ' : 'usando SUA chave: ') + C.bold((providers.info(a.id) || {}).nome || a.id) +
         C.dim('  ' + (a.modelo || '') + (a.toolsOk ? '' : (en ? '  (tools: unreliable)' : '  (ferramentas: não confiável)')))
-      : C.cyan('● ') + (en ? 'using TS Cloud (your credits)' : 'usando o TS Cloud (seus créditos)');
+      : C.cyan('● ') + (en ? 'no key of your own — account AI (your subscription, if connected, or TS legacy credits)' : 'sem chave própria — IA da conta (sua assinatura, se conectada, ou créditos legados do TS)');
   };
 
   // ts conectar listar
@@ -3052,11 +3190,11 @@ async function conectarCmd(words) {
     return;
   }
 
-  // ts conectar nuvem — volta a usar os créditos do TS
+  // ts conectar nuvem — desliga a chave própria (volta à IA da conta / créditos legados)
   if (sub === 'nuvem' || sub === 'cloud' || sub === 'ts') {
     keyring.usar(null);
     cfg = config.save({ forceTsCloud: true, personalModePreference:'automatico' });
-    console.log('  ' + C.ok('✔ ') + (en ? 'back to TS Cloud (your credits).' : 'de volta ao TS Cloud (seus créditos).'));
+    console.log('  ' + C.ok('✔ ') + (en ? 'own key turned off — runs use the account AI (your subscription, if selected, or TS legacy credits). To use your subscription: ts ia usar chatgpt|claude.' : 'chave própria desativada — as execuções usam a IA da conta (sua assinatura, se estiver selecionada, ou os créditos legados do TS). Para usar sua assinatura: ts ia usar chatgpt|claude.'));
     return;
   }
 
@@ -3106,7 +3244,8 @@ async function conectarCmd(words) {
         C.dim((p.gratuito ? (en ? 'free · ' : 'grátis · ') : '') + p.limite));
     }
     linhas.push('', C.dim(en ? 'Connect with:  ' : 'Conecte com:  ') + C.cyan('ts conectar <provedor>'));
-    linhas.push(C.dim(en ? 'Back to credits: ' : 'Voltar aos créditos: ') + C.cyan('ts conectar nuvem'));
+    linhas.push(C.dim(en ? 'Your subscription: ' : 'Sua assinatura: ') + C.cyan('ts ia conectar chatgpt|claude'));
+    linhas.push(C.dim(en ? 'Turn off your own key: ' : 'Desativar a chave própria: ') + C.cyan('ts conectar nuvem'));
     console.log('\n' + ui.box(linhas, { title: 'ts conectar' }));
     return;
   }
@@ -3158,7 +3297,7 @@ async function conectarCmd(words) {
   const listaNuvem = keyring.SO_NA_NUVEM.map(([o, p2]) => '  ' + C.dim('· ' + o + ' — ' + p2));
   console.log('\n' + ui.box(
     [(en ? 'Now running on YOUR key. Still needs TS Cloud:' : 'Agora roda na SUA chave. Ainda depende do TS Cloud:'), ...listaNuvem,
-      '', C.dim(en ? 'Back anytime: ' : 'Voltar quando quiser: ') + C.cyan('ts conectar nuvem')],
+      '', C.dim(en ? 'Turn your key off anytime: ' : 'Para desligar a sua chave: ') + C.cyan('ts conectar nuvem')],
     { title: en ? 'what changes' : 'o que muda' }));
 }
 
@@ -3174,6 +3313,8 @@ async function doctorCmd() {
     // Plano autoritativo. O de ~/.ts é do último login e envelhece a cada assinatura,
     // troca ou cancelamento — o diagnóstico mostrava um plano que já não existe mais.
     planoAtual: async () => { try { const r = await api('/api/credits', { token: cfg.token, timeoutMs: 8000 }); return (r && r.plan) || null; } catch (_) { return null; } },
+    // de onde vem a IA sem chave própria: a assinatura selecionada e conectada (critério do ts agente)
+    fonteIa: cfg.token ? () => aiSource(cfg.token, { timeoutMs: 5000 }) : undefined,
     // última versão publicada no npm (best-effort).
     latestVersion: async () => { try { const r = await fetch('https://registry.npmjs.org/terminal-smart-cli/latest', { signal: AbortSignal.timeout(8000) }); const j = await r.json(); return j && j.version; } catch (_) { return null; } },
   });
@@ -3338,7 +3479,8 @@ async function cloudCmd(args) {
     console.log(C.dim(en ? 'provisioning your cloud box…' : 'provisionando sua caixa na nuvem…'));
     try {
       const r = await call('up', { method: 'POST', body: { confirmed: true, ...(requestedSlug ? { slug: requestedSlug } : {}) }, timeoutMs: 120000 });
-      if (!r.ok) { console.log(ui.errLine(r.error || 'falha')); if (r.code === 'plan_required') console.log(C.dim(en ? 'Get Pro at terminalsmart.com.br/planos' : 'Assine o Pro em terminalsmart.com.br/planos')); return; }
+      // plan_required: o texto do servidor já explica (recurso só dos planos antigos); nada de venda aqui
+      if (!r.ok) { console.log(ui.errLine(r.error || 'falha')); return; }
       if (JSON_OUT) { console.log(JSON.stringify(r)); return; }
       console.log('\n' + ui.box([
         C.ok(en ? 'Cloud box is up!' : 'Caixa na nuvem no ar!'), '',
@@ -3413,7 +3555,7 @@ async function cloudCmd(args) {
       if (!slug) return;
       console.log(C.dim(en ? 'creating box…' : 'criando caixa…'));
       const up = await call('up', { method: 'POST', body: { confirmed: true, slug }, timeoutMs: 120000 });
-      if (!up.ok) { console.log(ui.errLine(up.error || 'falha')); if (up.code === 'plan_required') console.log(C.dim('terminalsmart.com.br/planos')); return; }
+      if (!up.ok) { console.log(ui.errLine(up.error || 'falha')); return; }
     }
     console.log(C.dim(en ? 'running ts meta inside the cloud box (may take a while)…' : 'rodando ts meta dentro da caixa (pode demorar)…'));
     const safe = goal.replace(/(["\\$`])/g, '\\$1');
@@ -3462,15 +3604,17 @@ async function uso() {
   const token = needToken();
   const r = await api('/api/credits', { token });
   if (JSON_OUT) { console.log(JSON.stringify(r)); return; }
+  // Mostra o plano e POR ONDE a IA roda. Crédito aparece só como saldo LEGADO (honrado
+  // até acabar), sem barra de recarga — o TS não vende IA.
   const unlimited = r.unlimited || (r.granted < 0);
+  const src = await aiSource(token);
+  const restante = Number(r.remaining) || 0;
   const lines = [
     C.dim(T.uso_plan + ': ') + C.bold(String(r.plan || '?')),
-    '',
-    unlimited
-      ? C.ok(T.uso_unlimited) + C.dim(` · ${r.used || 0} ${T.uso_credits}`)
-      // A barra mostra o que RESTA, igual ao número ao lado dela.
-      : ui.bar(Math.max(0, r.remaining ?? 0) / Math.max(1, r.granted || 1), 22, { restante: true }) + `  ${C.bold(r.remaining ?? '?')} ${C.dim(`/ ${r.granted} ${T.uso_remaining}`)}`,
+    C.dim(T.uso_ai + ': ') + (src.via ? C.cyan(src.via) : aiSourceMissing(src)),
   ];
+  if (unlimited) lines.push('', C.ok(T.uso_unlimited) + C.dim(` · ${r.used || 0} ${T.uso_credits}`));
+  else if (restante > 0) lines.push('', C.dim(T.uso_credits + ': ') + C.bold(String(restante)) + C.dim(` ${T.uso_remaining}`));
   const ledger = (r.ledger || []).slice(0, 5);
   if (ledger.length) {
     lines.push('', C.dim(T.uso_last + ':'));
@@ -3563,6 +3707,7 @@ function _resetLocalAgentState(cwd) {
 async function nova() {
   const token = needToken();
   _resetLocalAgentState(process.cwd());
+  _chatLocal().limpar(_convScope('chat')); // histórico do chat local desta pasta
   await ensureConv(token, 'chat', process.cwd(), true);
   console.log(ui.okLine(T.new_conv));
 }
@@ -3626,6 +3771,9 @@ function recallCmd(args) {
     case 'video': case 'v': return videoCmd(POS.slice(1));
     case 'arquivar': case 'archive': return arquivarCmd(POS.slice(1));
     case 'qr': return qrCmd(POS.slice(1));
+    // `ts hub ...`: usa os argumentos crus (o ID de aparelho pode começar com "-", que o POS
+    // descartaria como flag). Tudo local: não exige login.
+    case 'hub': return require('../hub/cli').main(rawArgs.slice(rawArgs.findIndex(a => a.toLowerCase() === 'hub') + 1));
     case 'desfazer': case 'undo': return desfazerCmd(POS.slice(1));
     case 'init': case 'iniciar': return initCmd();
     case 'hooks': case 'ganchos': return hooksCmd(POS.slice(1));