terminal-smart-cli 0.94.2 → 0.97.1

package/lib/device-tools.js

@@ -0,0 +1,226 @@
+'use strict';
+
+// Android/Android TV via ADB. Todas as chamadas usam execFile (sem shell) e
+// validação estrita, portanto IP, pacote, serial e caminhos não viram comandos.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const cp = require('child_process');
+const crypto = require('crypto');
+
+const HOST_RE = /^(?:[a-z0-9.-]+|\[[0-9a-f:]+\])$/i;
+const SERIAL_RE = /^[a-z0-9._:[\]-]+$/i;
+const PACKAGE_RE = /^[a-z][a-z0-9_]*(?:\.[a-z0-9_]+)+$/i;
+
+function _candidateAdbPaths() {
+  const sdk = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT ||
+    (process.platform === 'win32'
+      ? path.join(os.homedir(), 'AppData', 'Local', 'Android', 'Sdk')
+      : path.join(os.homedir(), 'Android', 'Sdk'));
+  const exe = process.platform === 'win32' ? 'adb.exe' : 'adb';
+  return [
+    path.join(sdk, 'platform-tools', exe),
+    process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || '', 'Android', 'Sdk', 'platform-tools', exe) : '',
+    'adb',
+  ].filter(Boolean);
+}
+
+function findAdb() {
+  for (const candidate of _candidateAdbPaths()) {
+    if (candidate === 'adb' || fs.existsSync(candidate)) return candidate;
+  }
+  return 'adb';
+}
+
+function _run(args, options = {}) {
+  const timeout = Math.min(180000, Math.max(3000, Number(options.timeoutMs) || 30000));
+  return new Promise((resolve) => {
+    cp.execFile(findAdb(), args, {
+      encoding: options.buffer ? null : 'utf8',
+      timeout,
+      windowsHide: true,
+      maxBuffer: options.maxBuffer || 8 * 1024 * 1024,
+    }, (error, stdout, stderr) => {
+      const code = typeof error?.code === 'number' ? error.code : (error ? 1 : 0);
+      resolve({
+        ok: !error,
+        codigo: code,
+        stdout: options.buffer ? stdout : String(stdout || '').trim(),
+        stderr: options.buffer ? stderr : String(stderr || error?.message || '').trim(),
+      });
+    });
+  });
+}
+
+function _runWithInput(args, input, options = {}) {
+  const timeout = Math.min(180000, Math.max(3000, Number(options.timeoutMs) || 30000));
+  return new Promise((resolve) => {
+    const child = cp.spawn(findAdb(), args, { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+    const out = [], err = [];
+    let settled = false;
+    const timer = setTimeout(() => { try { child.kill(); } catch (_) {} }, timeout);
+    child.stdout.on('data', b => out.push(b));
+    child.stderr.on('data', b => err.push(b));
+    child.on('error', (error) => {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      resolve({ ok: false, codigo: 1, stdout: Buffer.concat(out).toString('utf8').trim(), stderr: error.message });
+    });
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      resolve({
+        ok: code === 0,
+        codigo: typeof code === 'number' ? code : 1,
+        stdout: Buffer.concat(out).toString('utf8').trim(),
+        stderr: Buffer.concat(err).toString('utf8').trim(),
+      });
+    });
+    // O código não aparece na linha de comando nem em listagens de processos.
+    child.stdin.end(String(input || '') + '\n');
+  });
+}
+
+function _endpoint(host, port) {
+  const h = String(host || '').trim();
+  const p = Number(port);
+  if (!HOST_RE.test(h)) throw new Error('Host/IP inválido.');
+  if (!Number.isInteger(p) || p < 1 || p > 65535) throw new Error('Porta inválida.');
+  return `${h}:${p}`;
+}
+
+function _serialArgs(serial) {
+  const value = String(serial || '').trim();
+  if (!value) return [];
+  if (!SERIAL_RE.test(value)) throw new Error('Serial do dispositivo inválido.');
+  return ['-s', value];
+}
+
+function _package(value) {
+  const pkg = String(value || '').trim();
+  if (!PACKAGE_RE.test(pkg)) throw new Error('Nome de pacote Android inválido.');
+  return pkg;
+}
+
+async function adbInfo() {
+  const version = await _run(['version'], { timeoutMs: 10000 });
+  if (!version.ok) {
+    return {
+      ok: false,
+      erro: 'ADB não encontrado ou indisponível.',
+      adb: findAdb(),
+      detalhe: version.stderr,
+      correcao: 'Instale Android SDK Platform-Tools ou configure ANDROID_HOME/ANDROID_SDK_ROOT.',
+    };
+  }
+  return { ok: true, adb: findAdb(), versao: version.stdout.split(/\r?\n/)[0] || version.stdout };
+}
+
+async function listarDispositivos() {
+  const info = await adbInfo();
+  if (!info.ok) return info;
+  const result = await _run(['devices', '-l'], { timeoutMs: 15000 });
+  if (!result.ok) return { ok: false, erro: 'Falha ao listar dispositivos.', detalhe: result.stderr };
+  const dispositivos = result.stdout.split(/\r?\n/).slice(1).map(s => s.trim()).filter(Boolean).map((line) => {
+    const [serial, estado, ...rest] = line.split(/\s+/);
+    const meta = {};
+    for (const item of rest) {
+      const i = item.indexOf(':');
+      if (i > 0) meta[item.slice(0, i)] = item.slice(i + 1);
+    }
+    return { serial, estado, modelo: meta.model || null, produto: meta.product || null, transporte: meta.transport_id || null };
+  });
+  return { ok: true, adb: info.adb, total: dispositivos.length, dispositivos };
+}
+
+async function parear({ host, porta, codigo }) {
+  const endpoint = _endpoint(host, porta);
+  const code = String(codigo || '').trim();
+  if (!/^\d{6}$/.test(code)) return { ok: false, erro: 'Código de pareamento inválido; informe os 6 dígitos exibidos no aparelho.' };
+  const result = await _runWithInput(['pair', endpoint], code, { timeoutMs: 30000 });
+  return result.ok
+    ? { ok: true, endpoint, mensagem: result.stdout || 'Dispositivo pareado.' }
+    : { ok: false, erro: 'Pareamento ADB falhou.', endpoint, detalhe: result.stderr || result.stdout };
+}
+
+async function conectar({ host, porta }) {
+  const endpoint = _endpoint(host, porta);
+  const result = await _run(['connect', endpoint], { timeoutMs: 30000 });
+  const accepted = result.ok && /connected|already connected|conectado/i.test(result.stdout);
+  return accepted
+    ? { ok: true, serial: endpoint, mensagem: result.stdout }
+    : { ok: false, erro: 'Conexão ADB falhou.', endpoint, detalhe: result.stderr || result.stdout };
+}
+
+async function instalar({ apk, serial, substituir = true, conceder_permissoes = false }) {
+  const file = path.resolve(String(apk || ''));
+  if (!/\.apk$/i.test(file)) return { ok: false, erro: 'O arquivo precisa terminar em .apk.' };
+  if (!fs.existsSync(file) || !fs.statSync(file).isFile()) return { ok: false, erro: 'APK não encontrado: ' + file };
+  const args = [..._serialArgs(serial), 'install'];
+  if (substituir !== false) args.push('-r');
+  if (conceder_permissoes) args.push('-g');
+  args.push(file);
+  const result = await _run(args, { timeoutMs: 180000, maxBuffer: 16 * 1024 * 1024 });
+  const accepted = result.ok && /success/i.test(result.stdout);
+  return accepted
+    ? { ok: true, apk: file, serial: serial || 'padrão', tamanho_bytes: fs.statSync(file).size, mensagem: result.stdout }
+    : { ok: false, erro: 'Instalação do APK falhou.', apk: file, detalhe: result.stderr || result.stdout, codigo: result.codigo };
+}
+
+async function iniciar({ pacote, serial }) {
+  const pkg = _package(pacote);
+  const result = await _run([..._serialArgs(serial), 'shell', 'monkey', '-p', pkg, '-c', 'android.intent.category.LAUNCHER', '1'], { timeoutMs: 30000 });
+  return result.ok
+    ? { ok: true, pacote: pkg, serial: serial || 'padrão', mensagem: result.stdout.slice(-1200) }
+    : { ok: false, erro: 'Não foi possível iniciar o aplicativo.', detalhe: result.stderr || result.stdout };
+}
+
+async function logs({ serial, pacote, linhas = 300, nivel = '' }) {
+  const max = Math.min(2000, Math.max(20, Number(linhas) || 300));
+  const base = _serialArgs(serial);
+  let pid = '';
+  if (pacote) {
+    const pkg = _package(pacote);
+    const found = await _run([...base, 'shell', 'pidof', pkg], { timeoutMs: 10000 });
+    pid = found.ok ? String(found.stdout).trim().split(/\s+/)[0] : '';
+    if (!pid) return { ok: false, erro: `O processo ${pkg} não está em execução. Inicie o app e tente novamente.` };
+  }
+  const args = [...base, 'logcat', '-d', '-t', String(max), '-v', 'threadtime'];
+  if (pid && /^\d+$/.test(pid)) args.push('--pid', pid);
+  if (nivel && /^[VDIWEF]$/i.test(String(nivel))) args.push(`*:${String(nivel).toUpperCase()}`);
+  const result = await _run(args, { timeoutMs: 30000, maxBuffer: 16 * 1024 * 1024 });
+  if (!result.ok) return { ok: false, erro: 'Falha ao ler logcat.', detalhe: result.stderr };
+  const text = result.stdout;
+  const crashes = text.split(/\r?\n/).filter(l => /FATAL EXCEPTION|AndroidRuntime|ANR in |Process: .* has died/i.test(l)).slice(-30);
+  return { ok: true, serial: serial || 'padrão', pacote: pacote || null, linhas_retornadas: text ? text.split(/\r?\n/).length : 0, crashes, log: text.slice(-120000) };
+}
+
+async function capturarTela({ caminho, serial }) {
+  const target = path.resolve(String(caminho || ''));
+  if (!/\.png$/i.test(target)) return { ok: false, erro: 'O caminho da captura precisa terminar em .png.' };
+  const result = await _run([..._serialArgs(serial), 'exec-out', 'screencap', '-p'], { timeoutMs: 30000, buffer: true, maxBuffer: 32 * 1024 * 1024 });
+  if (!result.ok || !Buffer.isBuffer(result.stdout) || result.stdout.length < 100) {
+    return { ok: false, erro: 'Falha ao capturar a tela.', detalhe: Buffer.isBuffer(result.stderr) ? result.stderr.toString('utf8') : result.stderr };
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, result.stdout);
+  return {
+    ok: true,
+    caminho: target,
+    tamanho_bytes: result.stdout.length,
+    sha256: crypto.createHash('sha256').update(result.stdout).digest('hex'),
+    serial: serial || 'padrão',
+  };
+}
+
+module.exports = {
+  findAdb,
+  adbInfo,
+  listarDispositivos,
+  parear,
+  conectar,
+  instalar,
+  iniciar,
+  logs,
+  capturarTela,
+};

package/lib/diagnose.js

@@ -1,3 +1,4 @@
+
 // lib/diagnose.js — MODO DIAGNÓSTICO do TS: um loop de INVESTIGAÇÃO (não de build).
 // Dado um SINTOMA (erro/comando que falha), o agente forma HIPÓTESES rankeadas, testa
 // cada uma com uma SONDA somente-leitura, lê o resultado, dá um VEREDITO (confirma/refuta)
@@ -5,6 +6,7 @@
 // É o que faltava pro TS encarar legado obscuro (ex: instalar um servidor de MMO) em vez de
 // só construir do zero: hipótese → teste → descarte → nova hipótese.
 const { api, ApiError } = require('./api');
+const keyring = require('./keyring');
 const agent = require('./agent');
 const tools = require('./tools');
 
@@ -46,8 +48,10 @@ function extractJson(s) {
 
 async function diagnose(symptom, opts = {}) {
   const { token, lang = 'pt', model = null, cwd = process.cwd(), target = '', maxRounds = 12, onEvent = () => {} } = opts;
-  const k = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  const k = await keyring.resolve(token, { feature: 'cli_agent' });
   if (!k || !k.key) throw new ApiError('ai_key', {});
+  // BYOK: sem modelo explícito, o id do gateway não existe no provedor do usuário (404).
+  const mdl = keyring.modeloPara(k, model);
   const wrap = (probe) => target ? `${target} ${JSON.stringify(probe)}` : probe; // remoto = prefixo ssh + sonda quotada
 
   const evidence = [];   // { round, hypothesis, probe, output }
@@ -60,7 +64,7 @@ async function diagnose(symptom, opts = {}) {
     const userMsg = (lang === 'en' ? 'SYMPTOM:\n' : 'SINTOMA:\n') + symptom + '\n\n' + (lang === 'en' ? 'EVIDENCE SO FAR:\n' : 'EVIDÊNCIAS ATÉ AGORA:\n') + evLog + '\n\n' + (lang === 'en' ? `Round ${round}/${maxRounds}. Next step as JSON.` : `Rodada ${round}/${maxRounds}. Próximo passo em JSON.`);
     let r;
     try {
-      r = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model, noTools: true, signalMs: 90000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: userMsg }] });
+      r = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model: mdl, noTools: true, signalMs: 90000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: userMsg }] });
     } catch (e) { if (e.code === 'no_credits') { result.status = 'no_credits'; break; } throw e; }
     inTok += (r.usage.prompt_tokens || 0); outTok += (r.usage.completion_tokens || 0);
     const j = extractJson(r.msg.content) || { status: 'stuck', thought: 'resposta não-JSON', probe: '' };
@@ -77,7 +81,7 @@ async function diagnose(symptom, opts = {}) {
       const vAsk = lang === 'en'
         ? 'Before finalizing, ADVERSARIALLY refute this. Give ONE read-only probe whose output would DISPROVE the root cause if it is wrong. Classic trap: a symbol/lib/file that looks "missing/broken" but is provided elsewhere (e.g. an undefined symbol in a .so is resolved by the MAIN executable at runtime → check the main binary with nm -C). JSON {"refute_probe":"...","disproves_if":"..."}'
         : 'Antes de finalizar, REFUTE adversarialmente. Dê UMA sonda só-leitura cuja saída DESMENTIRIA a causa raiz se ela estiver errada. Armadilha clássica: um símbolo/lib/arquivo que parece "faltando/quebrado" mas é provido em OUTRO lugar (ex.: símbolo indefinido numa .so é resolvido pelo EXECUTÁVEL principal em runtime → cheque o binário principal com nm -C). JSON {"refute_probe":"...","disproves_if":"..."}';
-      let vr = null; try { vr = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model, noTools: true, signalMs: 90000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: (lang === 'en' ? 'SYMPTOM:\n' : 'SINTOMA:\n') + symptom + '\n\n' + (lang === 'en' ? 'EVIDENCE:\n' : 'EVIDÊNCIAS:\n') + evLog + '\n\n' + (lang === 'en' ? 'PROPOSED ROOT CAUSE: ' : 'CAUSA RAIZ PROPOSTA: ') + claim + '\n\n' + vAsk }] }); } catch (_) {}
+      let vr = null; try { vr = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model: mdl, noTools: true, signalMs: 90000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: (lang === 'en' ? 'SYMPTOM:\n' : 'SINTOMA:\n') + symptom + '\n\n' + (lang === 'en' ? 'EVIDENCE:\n' : 'EVIDÊNCIAS:\n') + evLog + '\n\n' + (lang === 'en' ? 'PROPOSED ROOT CAUSE: ' : 'CAUSA RAIZ PROPOSTA: ') + claim + '\n\n' + vAsk }] }); } catch (_) {}
       if (vr) { inTok += (vr.usage.prompt_tokens || 0); outTok += (vr.usage.completion_tokens || 0); }
       const vj = vr ? extractJson(vr.msg.content) : null;
       const rprobe = vj && String(vj.refute_probe || '').trim();
@@ -86,7 +90,7 @@ async function diagnose(symptom, opts = {}) {
         onEvent({ type: 'probe', round, hypothesis: '↯ verificação: ' + (j.hypothesis || ''), probe: rprobe, expect: vj.disproves_if || '' });
         let rout; try { const ex = await tools.execute('executar_comando', { comando: wrap(rprobe) }, { baseDir: cwd, token }); rout = ex.erro ? ('ERRO: ' + ex.erro) : ([ex.stdout, ex.stderr].filter(Boolean).join('\n') || ('(sem saída, exit ' + (ex.codigo ?? '?') + ')')); } catch (e) { rout = 'FALHA: ' + (e.message || e); }
         evidence.push({ round, hypothesis: '↯ verificação: ' + (j.hypothesis || ''), probe: rprobe, output: rout });
-        let fr = null; try { fr = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model, noTools: true, signalMs: 60000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: (lang === 'en' ? 'Root cause claim: ' : 'Causa raiz alegada: ') + claim + '\n' + (lang === 'en' ? 'Refutation probe output:\n' : 'Saída da sonda de refutação:\n') + String(rout).slice(0, 1600) + '\n\n' + (lang === 'en' ? 'CONFIRMED or REFUTED? JSON {"verdict":"confirmed|refuted","reason":"..."}' : 'CONFIRMADA ou REFUTADA? JSON {"verdict":"confirmed|refuted","reason":"..."}') }] }); } catch (_) {}
+        let fr = null; try { fr = await agent.llm({ baseUrl: k.baseUrl, key: k.key, model: mdl, noTools: true, signalMs: 60000, messages: [{ role: 'system', content: sysPrompt(lang, target) }, { role: 'user', content: (lang === 'en' ? 'Root cause claim: ' : 'Causa raiz alegada: ') + claim + '\n' + (lang === 'en' ? 'Refutation probe output:\n' : 'Saída da sonda de refutação:\n') + String(rout).slice(0, 1600) + '\n\n' + (lang === 'en' ? 'CONFIRMED or REFUTED? JSON {"verdict":"confirmed|refuted","reason":"..."}' : 'CONFIRMADA ou REFUTADA? JSON {"verdict":"confirmed|refuted","reason":"..."}') }] }); } catch (_) {}
         if (fr) { inTok += (fr.usage.prompt_tokens || 0); outTok += (fr.usage.completion_tokens || 0); }
         const fj = fr ? extractJson(fr.msg.content) : null;
         if (fj && /refut/i.test(String(fj.verdict))) {

package/lib/doctor.js

@@ -59,6 +59,23 @@ async function run(opts = {}) {
   const dir = path.join(os.homedir(), '.ts');
   results.push({ nome: 'Config (~/.ts)', level: fs.existsSync(dir) ? 'ok' : 'warn', detail: fs.existsSync(dir) ? dir : 'ainda não criado (normal se nunca rodou nada)' });
 
+  // 2b) de onde vem a IA: chave própria (BYOK) ou créditos do TS.
+  // Provedor ativo cujo modelo NÃO chama ferramenta é um aviso de verdade: o agente
+  // vira um chat que narra o que faria, sem executar nada.
+  try {
+    const keyring = require('./keyring');
+    const a = keyring.ativo();
+    if (a) {
+      const prov = (require('./providers').info(a.id) || {}).nome || a.id;
+      results.push(a.toolsOk
+        ? { nome: 'IA (sua chave)', level: 'ok', detail: prov + (a.modelo ? ' · ' + a.modelo : '') }
+        : { nome: 'IA (sua chave)', level: 'warn', detail: prov + ' — o modelo não chama ferramentas',
+            dica: 'troque o modelo (ts conectar ' + a.id + ') ou volte: ts conectar nuvem' });
+    } else {
+      results.push({ nome: 'IA', level: 'ok', detail: 'TS Cloud (seus créditos)' });
+    }
+  } catch (_) { /* keyring é opcional pro doctor: nunca derruba o diagnóstico */ }
+
   // 3) gateway/backend (rede, best-effort)
   if (typeof opts.pingBackend === 'function') {
     try { const ok = await opts.pingBackend(); results.push({ nome: 'Backend', level: ok ? 'ok' : 'warn', detail: ok ? (opts.base || 'acessível') : 'sem resposta', dica: ok ? undefined : 'cheque a conexão / status em terminalsmart.com.br' }); }

package/lib/eval.js

@@ -19,6 +19,7 @@ const os = require('os');
 const fs = require('fs');
 const path = require('path');
 const { api } = require('./api');
+const keyring = require('./keyring');
 const agent = require('./agent');
 const intelligence = require('./intelligence-core');
 
@@ -154,7 +155,7 @@ async function runSuite(suite, opts = {}) {
   const { token, lang = 'pt', model = null, judgeModel = DEFAULT_JUDGE } = opts;
   const onCase = opts.onCase || (() => {});
   // chave sk-hub (mesma do agente) — reusada pra chamar o juiz direto no gateway.
-  const k = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  const k = await keyring.resolve(token, { feature: 'cli_agent' });
   if (!k || !k.key) { const e = new Error('sem chave de IA'); e.code = 'ai_key'; throw e; }
 
   const results = [];
@@ -215,7 +216,8 @@ async function runSuite(suite, opts = {}) {
       if (!substituted) {
         onCase({ i, total, id: c.id, phase: 'judge' });
         try {
-          verdict = await judge({ key: k.key, baseUrl: k.baseUrl, model: judgeModel, caseObj: c, evidence });
+          // BYOK: o juiz padrão é um id do gateway e não existe no provedor do usuário (404).
+          verdict = await judge({ key: k.key, baseUrl: k.baseUrl, model: keyring.modeloPara(k, judgeModel), caseObj: c, evidence });
           judgeTin = verdict._tin || 0; judgeTout = verdict._tout || 0;
         } catch (e) {
           if (e && (e.code === 'no_credits' || e.status === 402)) throw e;

package/lib/i18n.js

@@ -15,10 +15,12 @@ const STR = {
       ] },
       { title: 'Galeria de Skills (comunidade)', items: [
         ['ts skills', 'lista as skills da comunidade (mais instaladas)'],
-        ['ts skills buscar "x"', 'busca skills por termo'],
         ['ts skills ver <slug>', 'lê a skill INTEIRA antes de instalar'],
         ['ts skills add <slug>', 'instala em ~/.ts/skills'],
         ['ts skills publicar <pasta>', 'publica sua skill na galeria'],
+        ['ts skills buscar "o que preciso"', 'ACHA a skill certa entre instaladas + catálogo (o agente também busca sozinho)'],
+        ['ts skills indexar', 'monta o índice de busca (galeria + fontes externas)'],
+        ['ts skills fontes add NVIDIA/skills', 'soma um catálogo externo no formato Agent Skills'],
         ['ts skills pendentes', 'skills que o agente propôs em modo --yes (revisar)'],
         ['ts skills aprovar <slug>', 'aprova uma pendência (vira skill ativa)'],
       ] },
@@ -38,6 +40,7 @@ const STR = {
         ['ts agente "..." --yes', 'autônomo (destrutivo pede aprovação no Telegram)'],
         ['ts diagnosticar "erro"', 'INVESTIGA a causa raiz: hipótese→sonda→veredito (só-leitura)'],
         ['ts diagnosticar "..." --remoto "ssh user@host"', 'investiga uma máquina remota'],
+        ['ts diagnosticar "..." --registrar', 'salva a investigação como nota em .ts-conhecimento (inclusive o que foi REFUTADO)'],
         ['ts sentinela add "nome" --cmd "..."', 'VIGIA determinístico (regra do if, ZERO token); --escalar diagnostica se falhar; --autofix conserta (com aprovação no Telegram)'],
         ['ts sentinela instalar', 'agenda os checks no SO (cron/Task Scheduler) e avisa no Telegram'],
         ['ts agente --continuar "..."', 'retoma o trabalho anterior desta pasta'],
@@ -54,6 +57,12 @@ const STR = {
         ['ts runbook rodar <nome>', 'procedimento DevOps reexecutável: roda os passos (destrutivo pede OK) e PROVA o resultado'],
         ['ts acp', 'servidor Agent Client Protocol (conecta o ts a editores tipo Zed)'],
         ['ts mcp', 'servidores MCP: as ferramentas deles entram no agente'],
+        ['ts politica', 'permissões por projeto (.ts-politica.json): allow/ask/deny por categoria'],
+        ['ts politica testar "rm -rf build"', 'mostra o veredito e DE QUAL regra veio'],
+        ['ts checkpoints', 'o que o agente mudou em cada sessão'],
+        ['ts desfazer --sessao [id]', 'DESFAZ TUDO o que o agente fez na sessão (pula o que você editou depois)'],
+        ['ts conectar', 'usa SUA chave de IA (NVIDIA/Google/Cerebras/Groq/Ollama) em vez dos créditos'],
+        ['ts conectar nuvem', 'volta a usar os créditos do TS'],
       ] },
       { title: 'Agentes na nuvem (orquestração)', items: [
         ['ts run "objetivo"', 'planeja → você aprova → executa'],
@@ -66,6 +75,7 @@ const STR = {
         ['ts uso', 'créditos e consumo do mês'],
         ['ts quem', 'conta conectada'],
         ['ts doctor', 'diagnóstico do ambiente (Node, login, gateway, versão, deps opcionais)'],
+        ['ts tema', 'paleta do terminal (7 temas; a cor indica o ESTADO)'],
         ['ts idioma pt|en', 'idioma (padrão pt-BR)'],
       ] },
     ],
@@ -88,6 +98,10 @@ const STR = {
       ['/run "objetivo"', 'orquestra agentes na nuvem (plano + aprovação)'],
       ['cd <pasta> · pwd', 'muda/mostra a pasta de trabalho do agente'],
       ['/runs', 'últimas orquestrações'],
+      ['/modelo [nome]', 'mostra ou troca o modelo em execução'],
+      ['/custo', 'quanto está gastando (ou de quem é a conta)'],
+      ['/tema [nome]', 'troca a paleta do terminal'],
+      ['/limpar', 'limpa a tela (o contexto continua)'],
       ['/uso', 'créditos do mês'],
       ['/nova', 'zera o contexto'],
       ['sair', 'encerra'],
@@ -146,6 +160,7 @@ const STR = {
     agent_blocked: 'bloqueado (destrutivo)',
     agent_approve: (cmd) => `O agente quer rodar um comando DESTRUTIVO:\n\n    ${cmd}\n\n  Permitir? (s/N) `,
     agent_footer: (st, cr, s) => `${st} passo(s) · ${cr} créditos · ${s}`,
+    agent_footer_byok: (st, prov, s) => `${st} passo(s) · sua chave (${prov}) · ${s}`,
     agent_remote_wait: (ttl) => `comando destrutivo — pedido de aprovação enviado no seu Telegram (responda em até ${Math.round(ttl / 60)} min; sem resposta = negado)`,
     meta_need: 'Descreva o objetivo. Ex.:  ts meta "monte um site de portfólio completo nesta pasta" --budget 300',
     meta_title: 'MISSÃO',
@@ -181,7 +196,6 @@ const STR = {
       ] },
       { title: 'Skills gallery (community)', items: [
         ['ts skills', 'list community skills (most installed)'],
-        ['ts skills buscar "x"', 'search skills by term'],
         ['ts skills ver <slug>', 'read the WHOLE skill before installing'],
         ['ts skills add <slug>', 'install to ~/.ts/skills'],
         ['ts skills publicar <folder>', 'publish your skill to the gallery'],
@@ -207,6 +221,12 @@ const STR = {
         ['ts eval suite.json', 'grade the agent on a case suite (AI judge + score)'],
         ['ts acp', 'Agent Client Protocol server (plug ts into editors like Zed)'],
         ['ts mcp', 'MCP servers: their tools plug into the agent'],
+        ['ts politica', 'per-project permissions (.ts-politica.json): allow/ask/deny by category'],
+        ['ts politica testar "rm -rf build"', 'shows the verdict and WHICH rule produced it'],
+        ['ts checkpoints', 'what the agent changed in each session'],
+        ['ts desfazer --sessao [id]', 'UNDO everything the agent did in that session (skips what you edited after)'],
+        ['ts conectar', 'use YOUR own AI key (NVIDIA/Google/Cerebras/Groq/Ollama) instead of credits'],
+        ['ts conectar nuvem', 'switch back to TS credits'],
       ] },
       { title: 'Cloud agents (orchestration)', items: [
         ['ts run "goal"', 'plan → you approve → execute'],
@@ -218,6 +238,7 @@ const STR = {
         ['ts login · ts logout', 'connect / disconnect this terminal'],
         ['ts uso', 'monthly credits and usage'],
         ['ts quem', 'connected account'],
+        ['ts tema', 'terminal palette (7 themes; color means STATE)'],
         ['ts idioma pt|en', 'language (default pt-BR)'],
       ] },
     ],
@@ -240,6 +261,10 @@ const STR = {
       ['/run "goal"', 'orchestrate cloud agents (plan + approval)'],
       ['cd <folder> · pwd', 'change/show the agent working folder'],
       ['/runs', 'recent orchestrations'],
+      ['/modelo [name]', 'show or switch the running model'],
+      ['/custo', 'what it is costing (and whose bill it is)'],
+      ['/tema [name]', 'switch the terminal palette'],
+      ['/limpar', 'clear the screen (context stays)'],
       ['/uso', 'monthly credits'],
       ['/nova', 'reset context'],
       ['exit', 'quit'],
@@ -298,6 +323,7 @@ const STR = {
     agent_blocked: 'blocked (destructive)',
     agent_approve: (cmd) => `The agent wants to run a DESTRUCTIVE command:\n\n    ${cmd}\n\n  Allow? (y/N) `,
     agent_footer: (st, cr, s) => `${st} step(s) · ${cr} credits · ${s}`,
+    agent_footer_byok: (st, prov, s) => `${st} step(s) · your key (${prov}) · ${s}`,
     agent_remote_wait: (ttl) => `destructive command — approval request sent to your Telegram (answer within ${Math.round(ttl / 60)} min; no answer = denied)`,
     meta_need: 'Describe the goal. E.g.:  ts meta "build a complete portfolio site in this folder" --budget 300',
     meta_title: 'MISSION',