terminal-smart-cli 0.94.2 → 0.97.0

package/README.md

@@ -56,5 +56,14 @@ docker logs api --tail 200 | ts "tem erro grave aqui?"
 git diff HEAD~1 | ts "revise este diff procurando problemas de segurança"
 ```
 
+## Capability Pack: Office e Android
+
+O CLI lê DOCX/PPTX de forma paginada e opera Android/Android TV por ferramentas
+ADB tipadas (`android_dispositivos`, pareamento, conexão, instalação, abertura,
+logcat e captura de tela). Ações no aparelho passam por aprovação; caminhos
+continuam confinados à raiz da missão. Os motores pesados de criação
+DOCX/XLSX/PDF/PPTX permanecem no App para manter o CLI leve e sem
+vulnerabilidades de produção.
+
 ---
 Feito por [Terminal Smart](https://terminalsmart.com.br) · a conversa do CLI aparece também na web (/ia).

package/bin/ts.js

@@ -249,12 +249,26 @@ async function videoCmd(words) {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tsvid-'));
   const sp = ui.spinner(cfg.lang === 'en' ? 'Fetching transcript…' : 'Buscando a transcrição…').start();
   const out = path.join(tmp, 'v');
-  const r = _cmd(yt.bin, [...yt.pre, '--skip-download', '--write-auto-subs', '--write-subs',
-    '--sub-langs', 'pt.*,pt-BR,en.*,en', '--sub-format', 'vtt', '--convert-subs', 'vtt',
+  // LEGENDAS EM 2 TEMPOS (o pedido único de 4 faixas — pt.*,pt-BR,en.*,en — fazia o
+  // yt-dlp baixar uma atrás da outra e o YouTube devolvia HTTP 429). Primeiro tenta só a
+  // faixa ORIGINAL do vídeo (1 download); só se não vier nada é que amplia. `--sleep-requests`
+  // espaça as chamadas, que é o que o próprio yt-dlp recomenda contra rate limit.
+  const _baixarLegenda = (langs) => _cmd(yt.bin, [...yt.pre, '--skip-download', '--write-auto-subs', '--write-subs',
+    '--sub-langs', langs, '--sub-format', 'vtt', '--convert-subs', 'vtt',
+    '--sleep-requests', '1.5', '--retries', '3',
     '-o', out + '.%(ext)s', url], 180000);
+  const _achaVtt = () => {
+    try { const f = fs.readdirSync(tmp).find(n => n.endsWith('.vtt')); if (f) return fs.readFileSync(path.join(tmp, f), 'utf8'); } catch (_) {}
+    return null;
+  };
+  let r = _baixarLegenda('pt-orig,en-orig');
+  let vtt = _achaVtt();
+  if (!vtt) {                    // sem faixa "original" nomeada → tenta as normais
+    sp.text(cfg.lang === 'en' ? 'no original track, widening…' : 'sem faixa original, ampliando…');
+    r = _baixarLegenda('pt-BR,pt,en');
+    vtt = _achaVtt();
+  }
   sp.stop();
-  let vtt = null;
-  try { const f = fs.readdirSync(tmp).find(n => n.endsWith('.vtt')); if (f) vtt = fs.readFileSync(path.join(tmp, f), 'utf8'); } catch (_) {}
   try { fs.rmSync(tmp, { recursive: true, force: true }); } catch (_) {}
   if (!vtt) {
     console.error(ui.errLine(cfg.lang === 'en'
@@ -280,8 +294,50 @@ function _monolith() { const r = _cmd('monolith', ['--version'], 12000); return
 // ts desfazer <arquivo> — restaura o backup automático mais recente (sem gastar IA).
 async function desfazerCmd(words) {
   const _path = require('path');
+  const en = (cfg.lang === 'en');
+
+  // ts desfazer --sessao [id] — desfaz TUDO o que o agente mudou naquela sessão.
+  // Sem id = a mais recente. O plano checa hash: arquivo que VOCÊ editou depois entra como
+  // conflito e é PULADO (restaurar apagaria seu trabalho) — só passa com --forcar.
+  if (rawArgs.includes('--sessao') || rawArgs.includes('--session')) {
+    const cp = require('../lib/checkpoint');
+    const _i = rawArgs.findIndex(a => a === '--sessao' || a === '--session');
+    let id = rawArgs[_i + 1];
+    if (!id || id.startsWith('--')) { const l = cp.listar({ limite: 1 }); id = l.length ? l[0].id : null; }
+    if (!id) { console.error(ui.errLine(en ? 'no session recorded' : 'nenhuma sessão registrada')); process.exit(1); }
+    const forcar = rawArgs.includes('--forcar') || rawArgs.includes('--force');
+    const sess = cp.carregar(id);
+    if (!sess) { console.error(ui.errLine((en ? 'session not found: ' : 'sessão não encontrada: ') + id)); process.exit(1); }
+
+    const plano = cp.planejar(sess);
+    if (!plano.acoes.length && !(forcar && plano.conflitos.length)) {
+      console.log('  ' + C.dim(en ? 'nothing to undo' : 'nada a desfazer') +
+        (plano.conflitos.length ? C.warn(en ? ' (' + plano.conflitos.length + ' conflict(s) — use --forcar)' : ' (' + plano.conflitos.length + ' conflito(s) — use --forcar)') : ''));
+      for (const c2 of plano.conflitos) console.log('    ' + C.warn('▲ ') + C.dim(c2.caminho) + ' — ' + c2.motivo);
+      return;
+    }
+    // Mostra o plano e pede OK: desfazer é destrutivo do outro lado (reverte trabalho feito).
+    console.log('\n' + ui.box([
+      C.dim(en ? 'session: ' : 'sessão: ') + id,
+      C.dim(en ? 'task: ' : 'tarefa: ') + String(sess.tarefa || '—').slice(0, 60), '',
+      ...plano.acoes.map(a => (a.tipo === 'apagar' ? C.err('apagar  ') : C.ok('restaurar ')) + C.dim(a.caminho)),
+      ...(plano.conflitos.length ? ['', C.warn(en ? 'skipped (changed after the session):' : 'pulados (mudaram depois da sessão):'),
+        ...plano.conflitos.map(c2 => C.dim('  ' + c2.caminho + ' — ' + c2.motivo))] : []),
+      ...(plano.jaDesfeita ? ['', C.warn(en ? 'this session was already undone once' : 'esta sessão já foi desfeita uma vez')] : []),
+    ], { title: 'ts desfazer --sessao' }));
+    const resposta = await ui.ask((en ? 'undo these ' : 'desfazer estas ') + (forcar ? plano.acoes.length + plano.conflitos.length : plano.acoes.length) + (en ? ' change(s)? [y/N] ' : ' mudança(s)? [s/N] '));
+    if (!/^(s|sim|y|yes)$/i.test(resposta)) { console.log('  ' + C.dim(en ? 'cancelled.' : 'cancelado.')); return; }
+
+    const r = cp.desfazer(id, { forcar });
+    console.log('  ' + C.ok('✔ ') + r.feitos.length + (en ? ' undone' : ' desfeita(s)') +
+      (r.falhas.length ? C.err('  ' + r.falhas.length + (en ? ' failed' : ' falharam')) : '') +
+      (r.pulados.length ? C.dim('  ' + r.pulados.length + (en ? ' skipped' : ' puladas')) : ''));
+    for (const f of r.falhas) console.log('    ' + C.err('✖ ') + f.caminho + ' — ' + f.erro);
+    return;
+  }
+
   const alvo = (words.join(' ') || '').trim();
-  if (!alvo) { console.error(ui.infoLine(cfg.lang === 'en' ? 'Usage: ts desfazer <file> — restores the last auto-backup' : 'Uso: ts desfazer <arquivo> — restaura o último backup automático')); process.exit(2); }
+  if (!alvo) { console.error(ui.infoLine(cfg.lang === 'en' ? 'Usage: ts desfazer <file> — restores the last auto-backup  ·  ts desfazer --sessao [id] — undoes the whole session' : 'Uso: ts desfazer <arquivo> — restaura o último backup  ·  ts desfazer --sessao [id] — desfaz a sessão inteira')); process.exit(2); }
   const abs = _path.resolve(process.cwd(), alvo);
   const r = await require('../lib/tools').execute('restaurar_arquivo', { caminho: abs }, { baseDir: process.cwd() });
   if (r && r.erro) { console.error(ui.errLine(r.erro)); process.exit(1); }
@@ -339,9 +395,83 @@ async function skillsCmd(words) {
   const sub = (words[0] || '').toLowerCase();
   const arg = words.slice(1).join(' ').trim();
   // subcomandos 100% LOCAIS primeiro (revisão de pendências não exige pareamento)
-  const _localSubs = ['pendentes', 'pending', 'ver-pendente', 'show-pending', 'aprovar', 'approve', 'recusar', 'reject', 'export', 'exportar', 'publish-git'];
+  const _localSubs = ['pendentes', 'pending', 'ver-pendente', 'show-pending', 'aprovar', 'approve', 'recusar', 'reject', 'export', 'exportar', 'publish-git', 'buscar', 'search', 'fontes', 'sources', 'indexar', 'index'];
   const token = _localSubs.includes(sub) ? null : needToken();
 
+  // ── DESCOBERTA: buscar/fontes/indexar (o "existe skill pra isso?") ─────────
+  const si = require('../lib/skill-index');
+  const _en = cfg.lang === 'en';
+
+  // ts skills buscar "o que preciso fazer"
+  if (sub === 'buscar' || sub === 'search') {
+    if (!arg) { console.error(ui.infoLine(_en ? 'usage: ts skills buscar "review a pull request"' : 'uso: ts skills buscar "revisar um pull request"')); process.exit(2); }
+    const achadas = si.buscar(si.todas(), arg, { k: 6 });
+    if (!achadas.length) {
+      console.log('  ' + C.dim(_en ? 'no skill covers that (searched installed + catalog).' : 'nenhuma skill cobre isso (procurei instaladas + catálogo).'));
+      const cache = si.lerCache();
+      if (!cache) console.log('  ' + C.dim(_en ? 'the catalog was never indexed: ' : 'o catálogo nunca foi indexado: ') + C.cyan('ts skills indexar'));
+      return;
+    }
+    const linhas = achadas.map(a => (a.instalada ? C.ok('●') : C.dim('○')) + ' ' + C.cyan(a.slug.padEnd(28)) +
+      C.dim(String(a.descricao || '').slice(0, 60)) + C.dim('  [' + a.origem + ']'));
+    linhas.push('', C.dim(_en ? '● installed · ○ available — install with ' : '● instalada · ○ disponível — instale com ') + C.cyan('ts skills add <slug>'));
+    console.log('\n' + ui.box(linhas, { title: 'ts skills buscar' }));
+    return;
+  }
+
+  // ts skills fontes [add <org>/<repo> | rm <org>/<repo>]
+  if (sub === 'fontes' || sub === 'sources') {
+    const acao = (words[1] || '').toLowerCase();
+    if (acao === 'add' && words[2]) {
+      try { si.addFonte(words[2]); console.log('  ' + C.ok('✔ ') + (_en ? 'source added: ' : 'fonte adicionada: ') + words[2] + C.dim(_en ? '  — now run: ts skills indexar' : '  — agora rode: ts skills indexar')); }
+      catch (e) { console.error(ui.errLine(e.message)); process.exit(2); }
+      return;
+    }
+    if ((acao === 'rm' || acao === 'remover') && words[2]) {
+      si.rmFonte(words[2]); console.log('  ' + C.ok('✔ ') + (_en ? 'removed: ' : 'removida: ') + words[2]); return;
+    }
+    const fs2 = si.fontes();
+    const linhas = fs2.length ? fs2.map(f => C.cyan('· ' + f.repo) + C.dim('  (' + (f.pasta || 'skills') + '/)'))
+                             : [C.dim(_en ? 'no external source' : 'nenhuma fonte externa')];
+    linhas.push('', C.dim(_en ? 'add: ' : 'adicionar: ') + C.cyan('ts skills fontes add NVIDIA/skills'));
+    console.log('\n' + ui.box(linhas, { title: 'ts skills fontes' }));
+    return;
+  }
+
+  // ts skills indexar — monta o índice de busca (galeria + fontes externas)
+  if (sub === 'indexar' || sub === 'index') {
+    const _tok = (() => { try { return cfg.token; } catch (_) { return null; } })();
+    const sp = ui.spinner(_en ? 'indexing…' : 'indexando…').start();
+    const fetchGaleria = _tok ? (async () => {
+      const r = await require('../lib/skills').list(_tok);
+      return Array.isArray(r) ? r : (r && r.skills) || [];
+    }) : null;
+    const fetchExternas = async () => {
+      const out = [];
+      for (const f of si.fontes()) {
+        sp.text((_en ? 'indexing ' : 'indexando ') + f.repo + '…');
+        try {
+          // pasta:null = detecta sozinho (nem todo repo usa `skills/`)
+          const r = await si.indexarRepo(f.repo, { pasta: f.pasta || null, onProgresso: (i, n) => sp.text(f.repo + ' ' + i + '/' + n) });
+          out.push(...r.skills);
+          // Avisa SÓ quando o teto cortou de verdade. A diferença total×lidas normalmente é
+          // skill sem descrição ou cópia em pasta de outro agente — dizer "teto" ali seria
+          // alarme falso.
+          if (r.truncado) console.error('  ' + C.warn('▲ ') + f.repo + ': ' + (_en ? 'cap reached — some skills are not searchable' : 'teto atingido — algumas skills ficaram de fora'));
+          else if (r.lidas === 0) console.error('  ' + C.warn('▲ ') + f.repo + (_en ? ': no skill with description found' : ': nenhuma skill com descrição encontrada'));
+        } catch (e) { console.error('  ' + C.warn('▲ ') + f.repo + ': ' + e.message); }
+      }
+      return out;
+    };
+    const todas2 = await si.atualizar({ fetchGaleria, fetchExternas });
+    sp.stop();
+    console.log('  ' + C.ok('✔ ') + todas2.length + (_en ? ' skills in the index' : ' skills no índice') +
+      C.dim('  (' + (_en ? 'installed: ' : 'instaladas: ') + si.locais().length + ')'));
+    console.log('  ' + C.dim(_en ? 'try: ' : 'teste: ') + C.cyan('ts skills buscar "' + (_en ? 'what you need' : 'o que você precisa') + '"'));
+    return;
+  }
+
+
   // export [pasta] — exporta as skills INSTALADAS (~/.ts/skills) pro formato aberto Agent Skills
   // (cada skill vira <slug>/SKILL.md) + README, pronto pra virar um repo `npx skills add owner/repo`.
   if (sub === 'export' || sub === 'exportar' || sub === 'publish-git') {
@@ -431,6 +561,28 @@ async function skillsCmd(words) {
 
   // add <slug>  (instala, com transparência + confirmação)
   if (sub === 'add' || sub === 'instalar' || sub === 'install') {
+    // Skill de CATÁLOGO EXTERNO: a galeria não conhece, então baixa o SKILL.md do repo de
+    // origem. Sem isto, o `ts skills add <slug>` que o próprio agente sugere falharia com
+    // "skill não encontrada" para tudo que não fosse da galeria.
+    const _ext = (si.lerCache() || { skills: [] }).skills.find(x => x.slug === arg && x.caminhoRepo);
+    if (_ext) {
+      const _fs2 = require('fs'), _p2 = require('path'), _os2 = require('os');
+      console.log('  ' + C.bold(C.cyan(_ext.slug)) + C.dim('  ' + _ext.origem));
+      if (_ext.descricao) console.log('  ' + C.dim(String(_ext.descricao).slice(0, 160)));
+      console.log('  ' + C.dim(_en ? 'source: ' : 'origem: ') + (_ext.url || _ext.origem));
+      // Conteúdo de terceiro: mostra de onde vem e PEDE confirmação antes de gravar.
+      if (process.stdin.isTTY && !YES) {
+        const a = String(await ui.ask('  ' + (_en ? 'Install from this third-party repo? (y/N) ' : 'Instalar desse repositório de terceiro? (s/N) '))).trim().toLowerCase();
+        if (!['s', 'sim', 'y', 'yes'].includes(a)) { console.log('  ' + C.dim(_en ? 'cancelled.' : 'cancelado.')); return; }
+      }
+      let md; try { md = await si.baixarSkill(_ext); } catch (e) { console.error(ui.errLine(e.message)); process.exit(1); }
+      const destino = _p2.join(_os2.homedir(), '.ts', 'skills', _ext.slug);
+      _fs2.mkdirSync(destino, { recursive: true });
+      _fs2.writeFileSync(_p2.join(destino, 'SKILL.md'), md, 'utf8');
+      console.log('  ' + ui.gradient('⌁') + ' ' + (_en ? 'installed at ' : 'instalada em ') + C.cyan(destino));
+      console.log('  ' + C.dim(_en ? 'read it before trusting: ' : 'leia antes de confiar: ') + C.cyan('ts skills ver ' + _ext.slug));
+      return;
+    }
     const s = await skills.get(token, arg);
     if (!s) { console.error(ui.infoLine(cfg.lang === 'en' ? 'skill not found.' : 'skill não encontrada.')); process.exit(1); }
     console.log('  ' + C.bold(C.cyan(s.name)) + C.dim(' · por ' + s.author + ' · ' + s.installs + ' instalações'));
@@ -564,6 +716,44 @@ async function chatRepl() {
         console.log('');
       } else if (low === '/uso') {
         await uso();
+      } else if (low === '/modelo' || low.startsWith('/modelo ') || low === '/model' || low.startsWith('/model ')) {
+        // /modelo — mostra o que está executando (e de onde vem); /modelo X troca na hora.
+        // Trocar no meio da conversa é o pedido mais repetido em CLI de agente.
+        const novo = msg.replace(/^\/\w+\s*/, '').trim();
+        const _kr = require('../lib/keyring');
+        const at = _kr.ativo();
+        if (novo) {
+          if (!at) {
+            console.log('  ' + C.warn('▲ ') + (cfg.lang === 'en'
+              ? 'model choice applies to your own key — set one with `ts conectar`.'
+              : 'a escolha de modelo vale pra SUA chave — configure com `ts conectar`.'));
+          } else {
+            _kr.salvar(at.id, { modelo: novo });
+            console.log('  ' + C.ok('✔ ') + (cfg.lang === 'en' ? 'model: ' : 'modelo: ') + C.cyan(novo) + C.dim('  (' + at.id + ')'));
+          }
+        } else {
+          console.log('  ' + (at
+            ? C.cyan('● ') + (cfg.lang === 'en' ? 'your key: ' : 'sua chave: ') + at.id + C.dim('  ' + (at.modelo || '—'))
+            : C.cyan('● ') + (cfg.lang === 'en' ? 'TS Cloud — the router picks per task' : 'TS Cloud — o roteador escolhe por tarefa')));
+          console.log('  ' + C.dim(cfg.lang === 'en' ? 'change: /modelo <name>' : 'trocar: /modelo <nome>'));
+        }
+      } else if (low === '/custo' || low === '/cost') {
+        // Com chave própria não há crédito do TS pra mostrar — dizer "0" seria mentira.
+        const at = require('../lib/keyring').ativo();
+        if (at) {
+          console.log('  ' + C.cyan('● ') + (cfg.lang === 'en'
+            ? 'running on YOUR key (' + at.id + ') — billed by the provider, not by TS.'
+            : 'rodando na SUA chave (' + at.id + ') — quem cobra é o provedor, não o TS.'));
+        } else { await uso(); }
+      } else if (low === '/tema' || low.startsWith('/tema ') || low === '/theme' || low.startsWith('/theme ')) {
+        temaCmd(msg.replace(/^\/\w+\s*/, '').trim().split(/\s+/).filter(Boolean));
+        if (msg.replace(/^\/\w+\s*/, '').trim()) console.log('  ' + C.dim(cfg.lang === 'en' ? '(applies fully on the next run)' : '(vale por completo na próxima execução)'));
+      } else if (low === '/limpar' || low === '/clear' || low === '/cls') {
+        // limpa a TELA, não o contexto (/nova é que zera a conversa) — a confusão entre os
+        // dois é clássica, por isso o lembrete.
+        process.stdout.write('\x1b[2J\x1b[H');
+        console.log('  ' + C.dim(cfg.lang === 'en' ? 'screen cleared — context intact (/nova resets the conversation)'
+                                                  : 'tela limpa — o contexto continua (/nova zera a conversa)') + '\n');
       } else if (low === '/runs') {
         await runsCmd();
       } else if (low.startsWith('/run')) {
@@ -1031,7 +1221,11 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   // rodapé enriquecido: passos · créditos · 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' : '');
-  console.log('  ' + C.dim(T.agent_footer(out.steps, out.credits, secs)) + C.dim(_extra) + C.dim(_cx) + C.dim('  ·  ts agente --continuar "..." pra seguir') + '\n');
+  // 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.
+  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');
   _printWt();
 }
 
@@ -1582,6 +1776,32 @@ async function diagnosticarCmd(args) {
       C.dim(en ? 'Ruled out: ' : 'Descartado: ') + r.evidence.map(e => e.hypothesis).filter((v, i, a) => v && a.indexOf(v) === i).slice(0, 5).join('; ').slice(0, 120),
     ], { title: 'ts diagnóstico' }));
   }
+
+  // --registrar: a investigação vira NOTA DE CONHECIMENTO em vez de sumir com o terminal.
+  // Guarda a trilha inteira, inclusive o que foi REFUTADO — na próxima vez que o sintoma
+  // voltar, o caminho já descartado não precisa ser refeito. Vale também quando o
+  // diagnóstico NÃO conclui (aí a nota é justamente a lista do que já se sabe que não é).
+  if (rawArgs.includes('--registrar') || rawArgs.includes('--record')) {
+    try {
+      const conhecimento = require('../lib/conhecimento');
+      const core = require('../lib/core');
+      const { meta, corpo } = conhecimento.montarIncidente(r, {
+        sintoma: sym,
+        alvo: target,
+        projeto: require('path').basename(process.cwd()),
+        redigir: core.redactSecrets,          // saída de sonda vem com token/senha
+      });
+      const arq = conhecimento.salvar({ tipo: 'incidente', meta, corpo });
+      console.log('\n  ' + C.ok('✔ ') + (en ? 'incident note saved: ' : 'nota de incidente salva: ') +
+        C.bold(require('path').relative(process.cwd(), arq)));
+      console.log('  ' + C.dim(en
+        ? 'confidence: ' + meta.confianca + ' · edit it and set origem: humano to make it yours'
+        : 'confiança: ' + meta.confianca + ' · edite e troque para origem: humano para a IA não reescrever'));
+    } catch (e) {
+      // Registrar é BÔNUS: falhar aqui não pode invalidar o diagnóstico que já foi feito.
+      console.error('  ' + C.warn('▲ ') + (en ? 'could not save the note: ' : 'não deu pra salvar a nota: ') + e.message);
+    }
+  }
 }
 
 // ── ts sentinela — vigia DETERMINÍSTICO (cron --no-agent, zero token) ────────
@@ -1810,7 +2030,7 @@ async function sonharCmd(args) {
   if (cfg.token) {
     const agent = require('../lib/agent');
     summarizeFn = async (bruto) => {
-      const k = await api('/api/ai/key?feature=cli_agent', { token: cfg.token, timeoutMs: 20000 });
+      const k = await require('../lib/keyring').resolve(cfg.token, { feature: 'cli_agent' });
       if (!k || !k.key) return '';
       const prompt = (en
         ? 'Consolidate this project run-history into a SHORT, durable memory (5-8 bullet lines): what the project is, what was done, key decisions, what remains. Keep the history\'s language. No preamble.\n\n'
@@ -2005,6 +2225,275 @@ function trilhaCmd() {
   console.log('\n' + ui.box(lines, { title: 'ts trilha' }));
 }
 
+// ── ts tema — paleta do CLI (cor é SEMÂNTICA: ok/aprovação/bloqueado) ────────
+function temaCmd(words) {
+  const en = (cfg.lang === 'en');
+  const temas = require('../lib/temas');
+  const alvo = (words[0] || '').toLowerCase();
+
+  if (alvo && !temas.existe(alvo)) {
+    console.error(ui.errLine((en ? 'unknown theme: ' : 'tema desconhecido: ') + alvo + '  (' + temas.nomes().join(', ') + ')'));
+    process.exit(2);
+  }
+  if (alvo) {
+    config.save({ tema: alvo });
+    // repinta com o tema NOVO: o ui.js já foi carregado com o antigo, então monta na hora
+    const C2 = temas.montar(alvo, ui.TTY);
+    console.log('  ' + C2.ok('✔ ') + (en ? 'theme: ' : 'tema: ') + C2.cyan(temas.info(alvo).nome));
+    console.log('  ' + temas.gradienteDe(alvo, 'T E R M I N A L   S M A R T', ui.TTY) + '   ' +
+      C2.ok('✔') + ' ' + C2.warn('▲') + ' ' + C2.err('✖') + ' ' + C2.dim('·'));
+    return;
+  }
+
+  // sem argumento: mostra a amostra de TODOS (é assim que se escolhe tema)
+  const linhas = [];
+  for (const id of temas.nomes()) {
+    const C2 = temas.montar(id, ui.TTY);
+    const marca = (id === ui.TEMA) ? C2.ok('●') : C2.dim('○');
+    linhas.push(marca + ' ' + C2.cyan(id.padEnd(10)) +
+      temas.gradienteDe(id, 'Terminal Smart', ui.TTY) + '  ' +
+      C2.ok('✔') + ' ' + C2.warn('▲') + ' ' + C2.err('✖') + ' ' + C2.dim('leitura') +
+      C2.dim('   ' + temas.info(id).nome));
+  }
+  linhas.push('', C.dim(en ? 'pick one: ' : 'escolha: ') + C.cyan('ts tema <nome>'));
+  linhas.push(C.dim(en ? 'colors mean state: ✔ proven · ▲ needs approval · ✖ blocked · dim read-only'
+                       : 'a cor É o estado: ✔ comprovado · ▲ pede aprovação · ✖ bloqueado · apagado só-leitura'));
+  console.log('\n' + ui.box(linhas, { title: 'ts tema' }));
+}
+
+// ── ts politica — permissões declarativas por projeto ────────────────────────
+async function politicaCmd(words) {
+  const en = (cfg.lang === 'en');
+  const policy = require('../lib/policy');
+  const _fs = require('fs'), _path = require('path');
+  const sub = (words[0] || '').toLowerCase();
+  const arqProjeto = _path.join(process.cwd(), policy.ARQ_PROJETO);
+
+  // ts politica exemplo — imprime um modelo comentado
+  if (sub === 'exemplo' || sub === 'example') {
+    console.log(JSON.stringify(policy.EXEMPLO, null, 2));
+    console.log('\n' + C.dim(en ? 'save as ' : 'salve como ') + C.cyan(policy.ARQ_PROJETO) +
+      C.dim(en ? ' (project) or ' : ' (projeto) ou ') + C.cyan('~/.ts/policy.json') + C.dim(en ? ' (global)' : ' (global)'));
+    return;
+  }
+
+  // ts politica testar "<comando>" [--tool nome]
+  if (sub === 'testar' || sub === 'test') {
+    const _ti = rawArgs.indexOf('--tool');
+    const tool = _ti >= 0 ? rawArgs[_ti + 1] : 'executar_comando';
+    const valor = words.slice(1).filter(a => a !== '--tool' && a !== tool).join(' ').trim();
+    if (!valor) { console.error(ui.infoLine(en ? 'usage: ts politica testar "rm -rf build" [--tool executar_comando]' : 'uso: ts politica testar "rm -rf build" [--tool executar_comando]')); process.exit(2); }
+    const pol = policy.carregar({ dir: process.cwd() });
+    if (!pol.temPolitica) { console.log('  ' + C.dim(en ? 'no policy file — the normal gate decides' : 'sem arquivo de política — quem decide é o gate normal')); return; }
+    const d = policy.decidir(pol, tool, {}, { valor });
+    const cor = { allow: C.ok, ask: C.warn, deny: C.err };
+    if (!d) { console.log('  ' + C.dim(en ? 'the policy does not rule on this — normal gate decides' : 'a política não opina sobre isso — decide o gate normal')); return; }
+    console.log('\n' + ui.box([
+      (cor[d.veredito] || C.dim)(d.veredito.toUpperCase()) + C.dim('  ' + (en ? 'category: ' : 'categoria: ') + policy.categoriaDe(tool)),
+      C.dim(en ? 'rule: ' : 'regra: ') + d.regra + C.dim(' (' + d.origem + ')'),
+      ...(d.nota ? ['', C.warn('▲ ' + d.nota)] : []),
+    ], { title: 'ts politica' }));
+    return;
+  }
+
+  // ts politica  → mostra o que está valendo
+  const pol = policy.carregar({ dir: process.cwd() });
+  const linhas = [];
+  const _desc = (arq, obj) => {
+    if (!obj) { linhas.push(C.dim('○ ' + arq + (en ? ' — none' : ' — nenhuma'))); return; }
+    const erros = policy.validar(obj);
+    linhas.push((erros.length ? C.err('✖ ') : C.ok('● ')) + C.bold(arq));
+    for (const [cat, val] of Object.entries(obj)) {
+      const txt = (typeof val === 'string') ? val
+        : Object.entries(val).map(([g, v]) => g + '=' + v).join('  ');
+      linhas.push('    ' + C.cyan(cat.padEnd(12)) + C.dim(txt));
+    }
+    for (const e of erros) linhas.push('    ' + C.err('✖ ' + e));
+  };
+  _desc('~/.ts/policy.json' + (en ? ' (global)' : ' (global)'), pol.global);
+  linhas.push('');
+  _desc(policy.ARQ_PROJETO + (en ? ' (project)' : ' (projeto)'), pol.projeto);
+  linhas.push('', C.dim(en
+    ? 'the project policy can only RESTRICT the global one (repo content is untrusted)'
+    : 'a política do projeto só pode RESTRINGIR a global (conteúdo de repo não é confiável)'));
+  linhas.push(C.dim(en ? 'try: ' : 'teste: ') + C.cyan('ts politica testar "rm -rf build"') + C.dim(' · ') + C.cyan('ts politica exemplo'));
+  console.log('\n' + ui.box(linhas, { title: 'ts politica' }));
+  if (!pol.temPolitica) console.log('  ' + C.dim(en ? 'no policy yet — the normal gate is in charge.' : 'sem política ainda — quem manda é o gate normal.'));
+}
+
+// ── ts checkpoints — o que o agente mudou em cada sessão (e como desfazer tudo) ──
+async function checkpointsCmd(words) {
+  const en = (cfg.lang === 'en');
+  const cp = require('../lib/checkpoint');
+  const sub = (words[0] || '').toLowerCase();
+
+  if (sub === 'limpar' || sub === 'clean') {
+    console.log('  ' + C.ok('✔ ') + cp.podar() + (en ? ' old session(s) removed' : ' sessão(ões) antiga(s) removida(s)'));
+    return;
+  }
+
+  // ts checkpoints ver <id>
+  if (sub === 'ver' || sub === 'show') {
+    const sess = cp.carregar(words[1]);
+    if (!sess) { console.error(ui.errLine(en ? 'session not found' : 'sessão não encontrada')); process.exit(1); }
+    const plano = cp.planejar(sess);
+    const linhas = [C.dim(en ? 'task: ' : 'tarefa: ') + String(sess.tarefa || '—').slice(0, 70), ''];
+    for (const a of plano.acoes) linhas.push(C.ok('↶ ') + (a.tipo === 'apagar' ? (en ? 'delete  ' : 'apagar  ') : (en ? 'restore ' : 'restaura')) + ' ' + C.dim(a.caminho));
+    for (const c2 of plano.conflitos) linhas.push(C.warn('▲ ') + C.dim(c2.caminho) + '  ' + C.warn(c2.motivo));
+    if (plano.jaDesfeita) linhas.push('', C.dim(en ? 'already undone once' : 'já foi desfeita uma vez'));
+    console.log('\n' + ui.box(linhas, { title: 'checkpoint ' + sess.id }));
+    return;
+  }
+
+  const l = cp.listar();
+  if (!l.length) { console.log('  ' + C.dim(en ? 'no session recorded yet' : 'nenhuma sessão registrada ainda')); return; }
+  const linhas = l.map(s => (s.desfeitaEm ? C.dim('↶') : C.ok('●')) + ' ' + C.bold(s.id) +
+    C.dim('  ' + s.arquivos + (en ? ' file(s)' : ' arquivo(s)') + ' · ' + s.mutacoes + (en ? ' change(s)' : ' mudança(s)')) +
+    C.dim('  ' + String(s.tarefa || '').slice(0, 40)));
+  linhas.push('', C.dim(en ? 'undo everything: ' : 'desfazer tudo: ') + C.cyan('ts desfazer --sessao ' + l[0].id));
+  console.log('\n' + ui.box(linhas, { title: 'ts checkpoints' }));
+}
+
+// ── ts conectar — BYOK: usar SUA chave de IA em vez dos créditos do TS ────────
+// 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.
+async function conectarCmd(words) {
+  const en = (cfg.lang === 'en');
+  const providers = require('../lib/providers');
+  const keyring = require('../lib/keyring');
+  const sub = (words[0] || '').toLowerCase();
+
+  const _rl = () => require('readline').createInterface({ input: process.stdin, output: process.stdout });
+  const perguntar = (q) => new Promise((res) => { const rl = _rl(); rl.question(q, (a) => { rl.close(); res(String(a || '').trim()); }); });
+
+  const _statusAtual = () => {
+    const a = keyring.ativo();
+    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)');
+  };
+
+  // ts conectar listar
+  if (sub === 'listar' || sub === 'list' || sub === 'ls') {
+    const l = keyring.listar();
+    if (!l.length) { console.log('  ' + C.dim(en ? 'no provider configured. Run: ts conectar' : 'nenhum provedor configurado. Rode: ts conectar')); return; }
+    const linhas = l.map(p => (p.ativo ? C.ok('●') : C.dim('○')) + ' ' + C.bold(((providers.info(p.id) || {}).nome) || p.id).padEnd(28) +
+      C.dim(p.chaveMascarada.padEnd(16) + ' ' + (p.modelo || '') + (p.toolsOk ? '' : (en ? '  [no tools]' : '  [sem ferramentas]'))));
+    console.log('\n' + ui.box(linhas, { title: 'ts conectar' }));
+    return;
+  }
+
+  // ts conectar nuvem — volta a usar os créditos do TS
+  if (sub === 'nuvem' || sub === 'cloud' || sub === 'ts') {
+    keyring.usar(null);
+    console.log('  ' + C.ok('✔ ') + (en ? 'back to TS Cloud (your credits).' : 'de volta ao TS Cloud (seus créditos).'));
+    return;
+  }
+
+  // ts conectar usar <id>
+  if (sub === 'usar' || sub === 'use') {
+    try { keyring.usar((words[1] || '').toLowerCase()); }
+    catch (e) { console.error(ui.errLine(e.message)); process.exit(1); }
+    console.log('  ' + C.ok('✔ ') + _statusAtual());
+    return;
+  }
+
+  // ts conectar remover <id>
+  if (sub === 'remover' || sub === 'rm' || sub === 'remove') {
+    const id = (words[1] || '').toLowerCase();
+    console.log('  ' + (keyring.remover(id)
+      ? C.ok('✔ ') + (en ? 'removed: ' : 'removido: ') + id
+      : C.warn('· ') + (en ? 'not configured: ' : 'não estava configurado: ') + id));
+    return;
+  }
+
+  // ts conectar testar [id]
+  if (sub === 'testar' || sub === 'test') {
+    const a = (words[1] ? { id: words[1].toLowerCase() } : keyring.ativo());
+    if (!a) { console.error(ui.errLine(en ? 'no active provider. Run: ts conectar' : 'nenhum provedor ativo. Rode: ts conectar')); process.exit(1); }
+    const salvo = keyring.listar().find(p => p.id === a.id) || {};
+    const st = keyring._load().provedores || {};
+    const sp = ui.spinner(en ? 'testing…' : 'testando…').start();
+    const r = await keyring.testar(a.id, { key: (st[a.id] || {}).key, baseUrl: salvo.baseUrl, modelo: salvo.modelo });
+    sp.stop();
+    if (!r.ok) { console.error(ui.errLine(r.erro)); process.exit(1); }
+    keyring.salvar(a.id, { toolsOk: r.toolsOk, testadoEm: new Date().toISOString() });
+    console.log('  ' + C.ok('✔ ') + (en ? 'key works' : 'a chave funciona') + C.dim(' · ' + r.modelo));
+    console.log('  ' + (r.toolsOk ? C.ok('✔ ') + (en ? 'calls tools' : 'chama ferramentas') : C.warn('▲ ') + (en ? 'does NOT call tools — ' : 'NÃO chama ferramentas — ') + r.obsTools));
+    return;
+  }
+
+  // ts conectar            → mostra o estado e o menu
+  // ts conectar <provedor> → cadastra
+  const alvo = sub;
+  if (!alvo) {
+    const linhas = [_statusAtual(), ''];
+    linhas.push(C.dim(en ? 'Available providers:' : 'Provedores disponíveis:'));
+    for (const id of providers.ids()) {
+      if (id === 'custom') continue;
+      const p = providers.info(id);
+      linhas.push('  ' + C.cyan(id.padEnd(12)) + C.bold(p.nome.padEnd(22)) +
+        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'));
+    console.log('\n' + ui.box(linhas, { title: 'ts conectar' }));
+    return;
+  }
+
+  const p = providers.info(alvo);
+  if (!p) {
+    console.error(ui.errLine((en ? 'unknown provider: ' : 'provedor desconhecido: ') + alvo +
+      '  (' + providers.ids().filter(i => i !== 'custom').join(', ') + ')'));
+    process.exit(2);
+  }
+
+  console.log('\n  ' + ui.gradient('⌁') + ' ' + C.bold(p.nome) + C.dim('  ' + p.cadastro));
+  let baseUrl = p.baseUrl;
+  if (alvo === 'custom' || !baseUrl) {
+    baseUrl = await perguntar('  ' + (en ? 'baseUrl (ends in /v1): ' : 'baseUrl (termina em /v1): '));
+    if (!baseUrl) { console.error(ui.errLine(en ? 'baseUrl required.' : 'baseUrl é obrigatória.')); process.exit(2); }
+  }
+  let key = '';
+  if (!p.semChave) {
+    key = await perguntar('  ' + (en ? 'paste your API key: ' : 'cole sua chave de API: '));
+    const errChave = providers.validarChave(alvo, key);
+    if (errChave) { console.error(ui.errLine(errChave)); process.exit(2); }
+  }
+  // A escolha do modelo é o que decide a experiência (latência e tool-calling), então
+  // mostro o que já foi MEDIDO em vez de deixar o usuário adivinhar entre 100+ opções.
+  if (Array.isArray(p.sugestoes) && p.sugestoes.length) {
+    console.log('  ' + C.dim(en ? 'measured options:' : 'opções já medidas:'));
+    for (const [m, nota] of p.sugestoes) console.log('    ' + C.cyan(m) + C.dim('  ' + nota));
+  }
+  const modelo = (await perguntar('  ' + (en ? 'model' : 'modelo') + C.dim(' [' + (p.modeloPadrao || '?') + ']') + ': ')) || p.modeloPadrao;
+
+  const sp = ui.spinner(en ? 'testing the key…' : 'testando a chave…').start();
+  const r = await keyring.testar(alvo, { key, baseUrl, modelo });
+  sp.stop();
+  if (!r.ok) { console.error(ui.errLine(r.erro)); process.exit(1); }
+
+  keyring.salvar(alvo, { key, baseUrl: r.baseUrl, modelo: r.modelo, toolsOk: r.toolsOk, testadoEm: new Date().toISOString() });
+  keyring.usar(alvo);
+
+  console.log('  ' + C.ok('✔ ') + (en ? 'key works' : 'a chave funciona') + C.dim(' · ' + r.modelo));
+  if (r.toolsOk) {
+    console.log('  ' + C.ok('✔ ') + (en ? 'calls tools — good for the agent' : 'chama ferramentas — serve pro agente'));
+  } else {
+    // Aviso honesto: sem tool-call o agente não EXECUTA, só conversa.
+    console.log('  ' + C.warn('▲ ') + (en ? 'does NOT call tools (' : 'NÃO chama ferramentas (') + r.obsTools + ')');
+    console.log('    ' + C.dim(en ? 'use it for chat/plan; for `ts agente` prefer another model.'
+                                  : 'use pra chat/plano; pro `ts agente` prefira outro modelo.'));
+  }
+  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')],
+    { title: en ? 'what changes' : 'o que muda' }));
+}
+
 // ── ts doctor — auto-diagnóstico do ambiente (Node/login/gateway/versão/deps) ──
 async function doctorCmd() {
   const en = (cfg.lang === 'en');
@@ -2280,6 +2769,10 @@ function recallCmd(args) {
     case 'hooks': case 'ganchos': return hooksCmd(POS.slice(1));
     case 'worktrees': case 'worktree': case 'wt': return worktreesCmd(POS.slice(1));
     case 'eval': case 'avaliar': case 'evals': return evalCmd(POS.slice(1));
+    case 'tema': case 'theme': return temaCmd(POS.slice(1));
+    case 'politica': case 'política': case 'policy': return politicaCmd(POS.slice(1));
+    case 'checkpoints': case 'checkpoint': return checkpointsCmd(POS.slice(1));
+    case 'conectar': case 'connect': case 'provedor': case 'provider': return conectarCmd(POS.slice(1));
     case 'mcp': return mcpCmd(POS.slice(1));
     case 'acp': return acpCmd();
     case 'skills': case 'skill': return skillsCmd(POS.slice(1));