terminal-smart-cli 0.32.0

package/bin/ts.js

@@ -0,0 +1,1267 @@
+#!/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
+'use strict';
+const pkg = require('../package.json');
+const config = require('../lib/config');
+const { t } = require('../lib/i18n');
+const ui = require('../lib/ui');
+const router = require('../lib/router');
+const { api, sse, base, ApiError } = require('../lib/api');
+
+// Windows legado (cmd.exe): força UTF-8 pro desenho das caixas não virar "?".
+if (process.platform === 'win32' && process.stdout.isTTY) {
+  try { require('child_process').execSync('chcp 65001', { stdio: 'ignore' }); } catch (_) {}
+}
+
+const rawArgs = process.argv.slice(2);
+const FLAGS = new Set(rawArgs.filter(a => a.startsWith('-')));
+const POS = rawArgs.filter(a => !a.startsWith('-'));
+const JSON_OUT = FLAGS.has('--json');
+const YES = FLAGS.has('--yes') || FLAGS.has('-y');
+
+let cfg = config.load();
+let T = t(cfg.lang || 'pt');
+const { C } = ui;
+
+function fmtK(n) { return n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n); }
+function needToken() {
+  if (cfg.token) return cfg.token;
+  console.error(ui.errLine(T.need_login));
+  process.exit(1);
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  let d = '';
+  process.stdin.setEncoding('utf8');
+  for await (const c of process.stdin) { d += c; if (d.length > 120000) break; }
+  return d;
+}
+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 (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));
+    else if (e.code === 'plan_limit') console.error(ui.errLine(e.message)); // mensagem de upgrade vinda do servidor
+    else console.error(ui.errLine(`${T.err_generic}: ${e.message}`));
+  } else console.error(ui.errLine(`${T.err_generic}: ${(e && e.message) || e}`));
+  process.exit(1);
+}
+
+// ── Ajuda ────────────────────────────────────────────────────────────────────
+function help() {
+  const out = [ui.banner(pkg.version, T.tagline)];
+  for (const g of T.help_groups) {
+    out.push('  ' + C.bold(C.indigo(g.title)));
+    const w = Math.max(...g.items.map(i => i[0].length)) + 3;
+    for (const [cmd, desc] of g.items) out.push('  ' + C.cyan(cmd.padEnd(w)) + C.dim(desc));
+    out.push('');
+  }
+  out.push('  ' + C.bold(C.indigo(T.help_examples)));
+  out.push(...[T.ex1, T.ex2, T.ex3].map(e => '  ' + C.dim('$ ') + e));
+  out.push('', '  ' + C.dim(T.help_footer), '');
+  console.log(out.join('\n'));
+}
+
+// ── Login por código (device-code) ───────────────────────────────────────────
+async function login() {
+  if (cfg.token) {
+    try {
+      const chk = await api('/api/auth/check', { token: cfg.token });
+      if (chk && (chk.success || chk.authenticated)) { console.log(ui.infoLine(T.login_already(cfg.username || '?'))); return; }
+    } catch (_) { /* sessão morta → segue pro pareamento */ }
+  }
+  const r = await api('/api/cli/pair/start', { method: 'POST' });
+  console.log(ui.banner(pkg.version, T.tagline));
+  console.log(ui.box([
+    C.bold(T.login_step1) + ' ' + C.cyan(r.url),
+    C.bold(T.login_step2),
+    '',
+    '   ' + ui.gradient([...r.code].join('  ')),
+    '',
+  ], { title: T.login_title }));
+  // conveniência: tenta abrir o navegador (best-effort; TS_NO_BROWSER=1 desliga p/ cron/ssh)
+  if (process.env.TS_NO_BROWSER !== '1') try {
+    const { exec } = require('child_process');
+    const cmd = process.platform === 'win32' ? `start "" "${r.url}"` : process.platform === 'darwin' ? `open "${r.url}"` : `xdg-open "${r.url}"`;
+    exec(cmd, () => {});
+  } catch (_) {}
+  const sp = ui.spinner(T.login_waiting).start();
+  const t0 = Date.now();
+  for (;;) {
+    await new Promise(res => setTimeout(res, 2500));
+    if (Date.now() - t0 > 10.5 * 60000) { sp.stop(ui.errLine(T.login_expired)); process.exit(1); }
+    let p;
+    try { p = await api('/api/cli/pair/poll', { method: 'POST', body: { poll: r.poll } }); } catch (_) { continue; }
+    if (p && p.status === 'ok') {
+      cfg = config.save({ token: p.token, username: p.username, plan: p.plan, convId: undefined });
+      sp.stop(ui.okLine(C.bold(T.login_ok(p.username))));
+      return;
+    }
+    if (p && (p.status === 'expired' || p.status === 'not_found')) { sp.stop(ui.errLine(T.login_expired)); process.exit(1); }
+  }
+}
+
+async function logout() {
+  if (!cfg.token) { console.log(ui.infoLine(T.logout_none)); return; }
+  try { await api('/api/logout', { method: 'POST', token: cfg.token }); } catch (_) {}
+  config.save({ token: undefined, username: undefined, plan: undefined, convId: undefined });
+  console.log(ui.okLine(T.logout_ok));
+}
+
+// ── Chat ─────────────────────────────────────────────────────────────────────
+async function ensureConv(token) {
+  if (cfg.convId) return cfg.convId;
+  const r = await api('/api/conversations', { method: 'POST', token, body: { title: 'CLI' } });
+  cfg = config.save({ convId: r.id });
+  return r.id;
+}
+// Envia uma mensagem na conversa ativa e devolve o texto (recria a conversa 1x se apagada na web).
+async function sendMessage(token, content) {
+  const doStream = async (convId) => {
+    const sp = ui.spinner(T.thinking).start();
+    let buf = '', errMsg = null;
+    try {
+      await sse('/api/ia/chat', {
+        token, body: { conversationId: convId, content },
+        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) { cfg = config.save({ convId: undefined }); convId = await ensureConv(token); return doStream(convId); }
+    throw e;
+  }
+}
+function printAnswer(text, ms) {
+  console.log('');
+  console.log('  ' + ui.gradient('⌁ TS'));
+  console.log(ui.md(text).split('\n').map(l => '  ' + l).join('\n'));
+  if (ms) console.log('  ' + C.dim('· ' + (ms / 1000).toFixed(1).replace('.', ',') + 's'));
+  console.log('');
+}
+// ── ts video <url> [pergunta]: dá "olhos" pro ts em vídeo (ideia da skill Cloud Video).
+// Minimalista de propósito: pega a TRANSCRIÇÃO (legenda auto do YouTube via yt-dlp — grátis,
+// sem baixar o vídeo inteiro) e joga no chat, que é exatamente o fluxo manual "colar transcript".
+function _cmd(bin, args, timeout = 120000) {
+  try { return require('child_process').execFileSync(bin, args, { encoding: 'utf8', timeout, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }); }
+  catch (e) { return { _err: e }; }
+}
+// Acha como invocar o yt-dlp: no PATH OU via `python -m yt_dlp` (pip instala assim, e o Scripts
+// costuma NÃO estar no PATH). Retorna {bin, pre} ou null. pre = args fixos antes dos nossos.
+function _ytDlp() {
+  for (const c of [{ bin: 'yt-dlp', pre: [] }, { bin: 'python', pre: ['-m', 'yt_dlp'] }, { bin: 'py', pre: ['-m', 'yt_dlp'] }, { bin: 'python3', pre: ['-m', 'yt_dlp'] }]) {
+    const r = _cmd(c.bin, [...c.pre, '--version'], 15000);
+    if (!(r && r._err)) return c;
+  }
+  return null;
+}
+function _vttToText(vtt) {
+  const seen = new Set(); const out = [];
+  for (let line of String(vtt).split(/\r?\n/)) {
+    line = line.replace(/<[^>]+>/g, '').trim(); // tira tags de timing inline
+    if (!line || line === 'WEBVTT' || line.includes('-->') || /^\d+$/.test(line) || /^(Kind|Language):/.test(line)) continue;
+    if (seen.has(line)) continue; seen.add(line); out.push(line);
+  }
+  return out.join(' ');
+}
+async function videoCmd(words) {
+  const token = needToken();
+  const url = (words[0] || '').trim();
+  const pergunta = words.slice(1).join(' ').trim();
+  if (!/^https?:\/\//.test(url)) { console.error(ui.infoLine(cfg.lang === 'en' ? 'Usage: ts video <url> [question]' : 'Uso: ts video <url> [pergunta]')); process.exit(2); }
+  const yt = _ytDlp();
+  if (!yt) {
+    console.error(ui.errLine(cfg.lang === 'en'
+      ? 'yt-dlp not found. Install it: `winget install yt-dlp` (Windows) or `pip install yt-dlp`, then run again.'
+      : 'yt-dlp não encontrado. Instale: `winget install yt-dlp` (Windows) ou `pip install yt-dlp`, e rode de novo.'));
+    process.exit(1);
+  }
+  const os = require('os'), fs = require('fs'), path = require('path');
+  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',
+    '-o', out + '.%(ext)s', url], 180000);
+  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'
+      ? 'No transcript/captions found for this video (yt-dlp returned nothing). It may have no captions.'
+      : 'Sem transcrição/legendas pra esse vídeo (o yt-dlp não retornou nada). Pode ser um vídeo sem legendas.'));
+    if (r && r._err) console.error(ui.infoLine(String(r._err.stderr || r._err.message || '').split('\n').slice(-3).join(' ').slice(0, 200)));
+    process.exit(1);
+  }
+  const texto = _vttToText(vtt).slice(0, 30000);
+  console.log('  ' + C.cyan('▶') + ' ' + C.dim((cfg.lang === 'en' ? 'transcript: ' : 'transcrição: ') + texto.length + ' chars'));
+  const base = pergunta || (cfg.lang === 'en' ? 'Summarize this video transcript and highlight what matters.' : 'Resuma a transcrição deste vídeo e destaque o que importa.');
+  const content = base + `\n\n${cfg.lang === 'en' ? 'VIDEO TRANSCRIPT' : 'TRANSCRIÇÃO DO VÍDEO'} (${url}):\n\`\`\`\n${texto}\n\`\`\``;
+  const t0 = Date.now();
+  const text = await sendMessage(token, content);
+  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, chars: texto.length, answer: text })); return; }
+  printAnswer(text, Date.now() - t0);
+}
+
+// ── ts arquivar <url> [saida.html]: salva uma página web como UM HTML autocontido (offline
+// fiel — CSS/imagens embutidos) usando o monolith (Rust). Utilitário; monolith NÃO roda JS,
+// então página muito dinâmica pode vir incompleta. Degrada com instrução se não instalado.
+function _monolith() { const r = _cmd('monolith', ['--version'], 12000); return !(r && r._err) ? 'monolith' : null; }
+// ts desfazer <arquivo> — restaura o backup automático mais recente (sem gastar IA).
+async function desfazerCmd(words) {
+  const _path = require('path');
+  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); }
+  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); }
+  console.log('  ' + C.ok('✔ ') + (cfg.lang === 'en' ? 'Restored ' : 'Restaurado ') + C.bold(r.caminho) + C.dim(' (' + (r.de_backup || 'backup') + ')'));
+}
+
+async function arquivarCmd(words) {
+  const fs = require('fs'), path = require('path');
+  const url = (words[0] || '').trim();
+  if (!/^https?:\/\//.test(url)) { console.error(ui.infoLine(cfg.lang === 'en' ? 'Usage: ts arquivar <url> [output.html]' : 'Uso: ts arquivar <url> [saida.html]')); process.exit(2); }
+  if (!_monolith()) {
+    console.error(ui.errLine(cfg.lang === 'en'
+      ? 'monolith not found. Install it: `winget install monolith` / `scoop install monolith` / `cargo install monolith`, then run again.'
+      : 'monolith não encontrado. Instale: `winget install monolith` / `scoop install monolith` / `cargo install monolith`, e rode de novo.'));
+    process.exit(1);
+  }
+  let out = (words[1] || '').trim();
+  if (!out) { let h = 'pagina'; try { h = new URL(url).hostname.replace(/^www\./, '').replace(/[^a-z0-9.-]/gi, '_'); } catch (_) {} out = h + '.html'; }
+  out = path.resolve(out);
+  const sp = ui.spinner(cfg.lang === 'en' ? 'Archiving page…' : 'Arquivando a página…').start();
+  // monolith escreve em STDOUT (`-o -`) e NÓS gravamos o arquivo: o `-o <arquivo>` do monolith
+  // tem bug de caminho no Windows; capturar o stdout é mais robusto (controlamos o path via fs).
+  // maxBuffer alto: a página vem com assets embutidos em base64 (pode passar de vários MB).
+  let html = null, err = null;
+  try { html = require('child_process').execFileSync('monolith', [url, '-o', '-'], { encoding: 'utf8', timeout: 180000, maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }); }
+  catch (e) { err = e; }
+  sp.stop();
+  if (err || !html) {
+    console.error(ui.errLine((cfg.lang === 'en' ? 'monolith failed: ' : 'monolith falhou: ') + String((err && (err.stderr || err.message)) || 'sem saída').split('\n').filter(Boolean).slice(-2).join(' ').slice(0, 200)));
+    process.exit(1);
+  }
+  try { fs.writeFileSync(out, html, 'utf8'); } catch (e) { console.error(ui.errLine((cfg.lang === 'en' ? 'could not write file: ' : 'não consegui gravar o arquivo: ') + e.message)); process.exit(1); }
+  let size = 0; try { size = fs.statSync(out).size; } catch (_) {}
+  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, arquivo: out, bytes: size })); return; }
+  console.log('  ' + ui.gradient('⌁') + ' ' + (cfg.lang === 'en' ? 'saved' : 'salvo') + ': ' + C.cyan(out) + C.dim('  (' + (size / 1024).toFixed(0) + ' KB)'));
+}
+
+// ── ts qr [url]: mostra um QR no terminal pra CONTINUAR no celular (ideia collab do OMYP).
+// Sem url, aponta pra conversa do ts na web (/ia). Abre no navegador do celular via câmera.
+async function qrCmd(words) {
+  const url = (words[0] || '').trim() || (base().replace(/\/+$/, '') + '/ia');
+  let qrgen; try { qrgen = require('qrcode-terminal'); } catch (_) {
+    console.log('  ' + C.cyan('▸') + ' ' + (cfg.lang === 'en' ? 'Open on your phone: ' : 'Abra no celular: ') + C.bold(url));
+    return;
+  }
+  console.log('');
+  qrgen.generate(url, { small: true }, q => console.log(q.split('\n').map(l => '  ' + l).join('\n')));
+  console.log('  ' + C.dim(cfg.lang === 'en' ? 'Scan to continue on your phone → ' : 'Aponte a câmera pra continuar no celular → ') + C.cyan(url));
+  console.log('');
+}
+
+// ── ts skills: galeria da comunidade (buscar/ver/instalar/publicar) ──────────
+async function skillsCmd(words) {
+  const token = needToken();
+  const skills = require('../lib/skills');
+  const sub = (words[0] || '').toLowerCase();
+  const arg = words.slice(1).join(' ').trim();
+
+  // 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') {
+    const _fs = require('fs'), _p = require('path'), _os = require('os');
+    const en = cfg.lang === 'en';
+    const srcDir = _p.join(_os.homedir(), '.ts', 'skills');
+    let slugs = []; try { slugs = _fs.readdirSync(srcDir).filter(s => _fs.existsSync(_p.join(srcDir, s, 'SKILL.md'))); } catch (_) {}
+    if (!slugs.length) { console.error(ui.infoLine(en ? 'No installed skills to export (~/.ts/skills is empty). Install with: ts skills add <slug>' : 'Nenhuma skill instalada pra exportar (~/.ts/skills vazio). Instale com: ts skills add <slug>')); return; }
+    const outDir = _p.resolve(arg || 'ts-skills');
+    _fs.mkdirSync(outDir, { recursive: true });
+    const rows = [];
+    for (const slug of slugs) {
+      const raw = _fs.readFileSync(_p.join(srcDir, slug, 'SKILL.md'), 'utf8');
+      _fs.mkdirSync(_p.join(outDir, slug), { recursive: true });
+      _fs.writeFileSync(_p.join(outDir, slug, 'SKILL.md'), raw);
+      const nm = (raw.match(/^name\s*:\s*(.+)$/mi) || [, slug])[1].trim();
+      const ds = (raw.match(/^description\s*:\s*(.+)$/mi) || [, ''])[1].trim();
+      rows.push(`- **${nm}** (\`${slug}\`) — ${ds}`);
+    }
+    const readme = `# ts-skills\n\n${en ? 'Skills for AI coding agents, in the open **Agent Skills** format (each skill is a `<slug>/SKILL.md`). Works with Terminal Smart (`ts`), Claude Code, Cursor, Codex and any agent that reads Agent Skills.' : 'Skills para agentes de código de IA, no formato aberto **Agent Skills** (cada skill é um `<slug>/SKILL.md`). Funciona com o Terminal Smart (`ts`), Claude Code, Cursor, Codex e qualquer agente que leia Agent Skills.'}\n\n## ${en ? 'Install' : 'Instalar'}\n\n\`\`\`bash\nnpx skills add GabbrielGG/ts-skills\n\`\`\`\n\n## Skills\n\n${rows.join('\n')}\n`;
+    _fs.writeFileSync(_p.join(outDir, 'README.md'), readme);
+    console.log('  ' + C.ok('✔ ') + (en ? 'Exported ' : 'Exportei ') + C.bold(slugs.length + (en ? ' skill(s)' : ' skill(s)')) + (en ? ' to ' : ' pra ') + C.cyan(outDir));
+    console.log('  ' + C.dim(en ? 'Next — turn it into an installable repo:' : 'Próximo — vire um repo instalável:'));
+    console.log(C.dim(`    cd ${outDir}\n    git init && git add . && git commit -m "skills"\n    git branch -M main\n    git remote add origin https://github.com/GabbrielGG/ts-skills.git\n    git push -u origin main`));
+    console.log('  ' + C.dim(en ? 'Then anyone runs: ' : 'Depois qualquer um roda: ') + C.cyan('npx skills add GabbrielGG/ts-skills') + '\n');
+    return;
+  }
+
+  // publicar <caminho>
+  if (sub === 'publicar' || sub === 'publish') {
+    const dir = arg || '.';
+    let s; try { s = skills.readLocal(require('path').resolve(dir)); }
+    catch (e) { console.error(ui.errLine((cfg.lang === 'en' ? 'could not read skill: ' : 'não consegui ler a skill: ') + e.message)); process.exit(1); }
+    console.log('  ' + C.bold(cfg.lang === 'en' ? 'Publishing:' : 'Publicando:') + ' ' + C.cyan(s.name) + C.dim(' · ' + s.category));
+    console.log('  ' + C.dim(s.description || '(sem descrição)'));
+    console.log('  ' + C.dim((cfg.lang === 'en' ? 'instructions: ' : 'instruções: ') + (s.content.instructions || '').length + ' chars' + (s.content.script ? ' · +script ' + s.content.script.nome : '') + (s.content.references.length ? ' · +' + s.content.references.length + ' refs' : '')));
+    if (process.stdin.isTTY && !YES) { const a = String(await ui.ask('  ' + (cfg.lang === 'en' ? 'Publish to the public gallery? (y/N) ' : 'Publicar na galeria pública? (s/N) '))).trim().toLowerCase(); if (!['s', 'sim', 'y', 'yes'].includes(a)) { console.log('  ' + C.dim(cfg.lang === 'en' ? 'cancelled.' : 'cancelado.')); return; } }
+    const r = await skills.publish(token, s);
+    if (r && r.slug) console.log('  ' + ui.gradient('⌁') + ' ' + (cfg.lang === 'en' ? 'published: ' : 'publicada: ') + C.cyan(r.slug) + C.dim('  (ts skills add ' + r.slug + ')'));
+    else console.error(ui.errLine((r && r.error) || 'falha ao publicar'));
+    return;
+  }
+
+  // ver <slug>  (transparência: mostra o conteúdo completo)
+  if (sub === 'ver' || sub === 'show') {
+    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('');
+    console.log('  ' + C.bold(C.cyan(s.name)) + C.dim('  · ' + s.category + ' · por ' + s.author + ' · ' + s.installs + ' instalações'));
+    if (s.description) console.log('  ' + C.dim(s.description));
+    console.log('');
+    console.log(ui.md(String(s.content.instructions || '')).split('\n').map(l => '  ' + l).join('\n'));
+    if (s.content.script) console.log('\n  ' + C.warn('⚠ inclui script: ' + s.content.script.nome) + C.dim(' (roda com os gates normais do agente, nunca sozinho)'));
+    console.log('');
+    return;
+  }
+
+  // add <slug>  (instala, com transparência + confirmação)
+  if (sub === 'add' || sub === 'instalar' || sub === 'install') {
+    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'));
+    if (s.description) console.log('  ' + C.dim(s.description));
+    console.log('  ' + C.dim((cfg.lang === 'en' ? 'content: ' : 'conteúdo: ') + (s.content.instructions || '').length + ' chars de instrução' + (s.content.script ? C.warn(' · +script ' + s.content.script.nome) : '')));
+    console.log('  ' + C.dim(cfg.lang === 'en' ? 'tip: `ts skills ver ' + s.slug + '` to read it all first.' : 'dica: `ts skills ver ' + s.slug + '` pra ler tudo antes.'));
+    if (process.stdin.isTTY && !YES) { const a = String(await ui.ask('  ' + (cfg.lang === 'en' ? 'Install to ~/.ts/skills? (y/N) ' : 'Instalar em ~/.ts/skills? (s/N) '))).trim().toLowerCase(); if (!['s', 'sim', 'y', 'yes'].includes(a)) { console.log('  ' + C.dim(cfg.lang === 'en' ? 'cancelled.' : 'cancelado.')); return; } }
+    const dir = skills.writeLocal(s); await skills.markInstalled(token, s.slug);
+    console.log('  ' + ui.gradient('⌁') + ' ' + (cfg.lang === 'en' ? 'installed at ' : 'instalada em ') + C.cyan(dir));
+    return;
+  }
+
+  // (sem sub) ou "buscar <q>" → lista
+  const q = (sub === 'buscar' || sub === 'search') ? arg : words.join(' ').trim();
+  const list = await skills.list(token, q);
+  console.log('');
+  console.log('  ' + ui.gradient('⌁ ' + (cfg.lang === 'en' ? 'Skills gallery' : 'Galeria de skills')) + (q ? C.dim('  · "' + q + '"') : ''));
+  if (!list.length) { console.log('  ' + C.dim(cfg.lang === 'en' ? 'nothing found. Publish yours: ts skills publicar <folder>' : 'nada encontrado. Publique a sua: ts skills publicar <pasta>')); console.log(''); return; }
+  const w = Math.max(...list.map(s => s.slug.length)) + 2;
+  for (const s of list) console.log('  ' + C.cyan(s.slug.padEnd(w)) + C.dim('↓' + s.installs + '  ') + s.name + (s.description ? C.dim(' — ' + s.description.slice(0, 50)) : ''));
+  console.log('\n  ' + C.dim(cfg.lang === 'en' ? 'install: ts skills add <slug>  ·  read: ts skills ver <slug>' : 'instalar: ts skills add <slug>  ·  ler: ts skills ver <slug>'));
+  console.log('');
+}
+
+// ── ts memoria: fatos persistentes que o agente sempre carrega (memória de projeto/global) ──
+async function memoriaCmd(words) {
+  const memoria = require('../lib/memoria');
+  const sub = (words[0] || '').toLowerCase();
+  if (sub === 'add' || sub === 'lembrar') {
+    const glob = process.argv.includes('-g') || process.argv.includes('--global');
+    const fato = words.slice(1).join(' ').trim(); // POS já removeu o -g/--global
+    if (!fato) { console.error(ui.infoLine(cfg.lang === 'en' ? 'Usage: ts memoria add "fact" [-g]' : 'Uso: ts memoria add "fato" [-g]')); process.exit(2); }
+    const f = memoria.append(process.cwd(), fato, glob);
+    console.log('  ' + ui.gradient('⌁') + ' ' + (cfg.lang === 'en' ? 'saved to ' : 'salvo em ') + C.cyan(f) + C.dim(glob ? ' (global)' : ' (projeto)'));
+    return;
+  }
+  // ver
+  const fs = require('fs');
+  const proj = memoria.projFile(process.cwd());
+  console.log('');
+  console.log('  ' + ui.gradient('⌁ ' + (cfg.lang === 'en' ? 'Memory' : 'Memória')));
+  const show = (label, file) => {
+    let txt = ''; try { txt = fs.existsSync(file) ? fs.readFileSync(file, 'utf8').trim() : ''; } catch (_) {}
+    console.log('  ' + C.bold(label) + C.dim('  ' + file));
+    console.log(txt ? txt.split('\n').map(l => '  ' + l).join('\n') : '  ' + C.dim(cfg.lang === 'en' ? '(empty)' : '(vazia)'));
+    console.log('');
+  };
+  show(cfg.lang === 'en' ? 'This project:' : 'Deste projeto:', proj);
+  show('Global:', memoria.GLOBAL);
+  console.log('  ' + C.dim(cfg.lang === 'en' ? 'add: ts memoria add "fact" [-g for global]' : 'adicionar: ts memoria add "fato" [-g p/ global]'));
+  console.log('');
+}
+
+async function chat(question) {
+  const token = needToken();
+  const piped = await readStdin();
+  if (!question && !piped) { console.error(ui.infoLine(T.ask_empty)); process.exit(2); }
+  let content = question || (cfg.lang === 'en' ? 'Analyze the input below and summarize what matters.' : 'Analise a entrada abaixo e resuma o que importa.');
+  if (piped) content += `\n\n${T.pipe_ctx}:\n\`\`\`\n${piped.slice(0, 30000)}\n\`\`\``;
+  const t0 = Date.now();
+  const text = await sendMessage(token, content);
+  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, answer: text })); return; }
+  printAnswer(text, Date.now() - t0);
+}
+
+// ── 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)
+  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 (_) {}
+  console.log('  ' + C.dim(T.repl_hello) + '\n');
+
+  // Onboarding: só na PRIMEIRA vez — depois a linha de dica do cabeçalho basta
+  if (!cfg.onboarded) {
+    const w = Math.max(...T.onboard_lines.map(l => l[0].length)) + 3;
+    console.log(ui.box([
+      ...T.onboard_lines.map(([k, v]) => C.cyan(k.padEnd(w)) + C.dim(v)),
+      '',
+      C.dim(T.onboard_footer),
+    ], { title: T.onboard_title }) + '\n');
+    cfg = config.save({ onboarded: true });
+  }
+
+  const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+  // 'close' (Ctrl+C/Ctrl+D/EOF de pipe) resolve a pergunta pendente com null —
+  // assim cada linha já lida é processada e o loop encerra limpo depois da última.
+  let closed = false, pending = null;
+  rl.on('close', () => { closed = true; if (pending) { const p = pending; pending = null; p(null); } });
+  const ask1 = (q) => new Promise((res) => { pending = res; rl.question(q, (a) => { pending = null; res(a); }); });
+  const prompt = ui.gradient('⌁') + ' ' + C.bold(T.chat_prompt);
+  // cwd da SESSÃO do agente: persiste entre mensagens (o problema 1). "cd"/"pwd"
+  // no REPL alteram/mostram; cada msg roteada pro agente resolve caminhos daqui.
+  const _pp = require('path'), _oo = require('os'), _ff = require('fs');
+  let agentCwd = process.cwd();
+  console.log('  ' + C.dim((cfg.lang === 'en' ? 'working folder: ' : 'pasta de trabalho: ') + agentCwd) + C.dim(cfg.lang === 'en' ? '  ·  cd <folder> to change' : '  ·  cd <pasta> pra trocar') + '\n');
+
+  for (;;) {
+    const raw = await ask1(prompt);
+    if (raw === null) break; // entrada terminou
+    const msg = String(raw || '').trim();
+    if (!msg) { if (closed) break; continue; }
+    const low = msg.toLowerCase();
+    if (['sair', 'exit', 'quit', '/sair', '/exit'].includes(low)) break;
+    try {
+      if (['/nova', '/new'].includes(low)) {
+        const r = await api('/api/conversations', { method: 'POST', token, body: { title: 'CLI' } });
+        cfg = config.save({ convId: r.id });
+        console.log(ui.okLine(T.new_conv) + '\n');
+      } else if (['/ajuda', '/help', '/?'].includes(low)) {
+        const w = Math.max(...T.repl_help.map(i => i[0].length)) + 3;
+        console.log('');
+        for (const [k, d] of T.repl_help) console.log('  ' + C.cyan(k.padEnd(w)) + C.dim(d));
+        console.log('');
+      } else if (low === '/uso') {
+        await uso();
+      } else if (low === '/runs') {
+        await runsCmd();
+      } else if (low.startsWith('/run')) {
+        const goal = msg.slice(4).trim().replace(/^["']|["']$/g, '');
+        if (goal.length < 10) { console.log(ui.infoLine(T.goal_short)); continue; }
+        await runFlow(goal, { askFn: (q) => ask1('  ' + q) });
+      } else if (low.startsWith('/agente') || low.startsWith('/agent')) {
+        const task = msg.replace(/^\/\w+\s*/, '').replace(/^["']|["']$/g, '');
+        if (task.length < 8) { console.log(ui.infoLine(T.agent_need)); continue; }
+        await agentCmd([task], { askFn: (q) => ask1('  ' + q), cwd: agentCwd, onCwd: (c) => { agentCwd = c; } });
+      } else if (low.startsWith('/chat ')) {
+        // força conversa (escape do roteador)
+        const t0 = Date.now();
+        printAnswer(await sendMessage(token, msg.slice(6)), Date.now() - t0);
+      } else if (low === 'pwd' || low === '/pwd') {
+        console.log('  ' + C.dim(agentCwd));
+      } else if (low === 'cd' || low.startsWith('cd ')) {
+        // muda a pasta de trabalho da SESSÃO (base dos caminhos relativos do agente)
+        let raw = msg.slice(2).trim().replace(/^["']|["']$/g, '') || _oo.homedir();
+        if (raw === '~' || raw.startsWith('~/') || raw.startsWith('~\\')) raw = _pp.join(_oo.homedir(), raw.slice(1));
+        const target = _pp.resolve(agentCwd, raw);
+        try {
+          if (!_ff.statSync(target).isDirectory()) throw new Error('não é pasta');
+          agentCwd = target;
+          console.log('  ' + C.dim((cfg.lang === 'en' ? 'working folder: ' : 'pasta de trabalho: ') + agentCwd));
+        } catch (_) { console.error(ui.errLine((cfg.lang === 'en' ? 'no such folder: ' : 'pasta inexistente: ') + target)); }
+      } else {
+        // ROTEADOR: linguagem natural pura — o sistema decide o caminho e AVISA
+        const r = await router.route(msg, token);
+        if (r.dest === 'agente') {
+          console.log('  ' + C.cyan('⚙') + ' ' + C.dim(T.route_agent));
+          await agentCmd([msg], { askFn: (q) => ask1('  ' + q), cwd: agentCwd, onCwd: (c) => { agentCwd = c; } });
+        } else if (r.dest === 'run') {
+          console.log('  ' + C.indigo('◆') + ' ' + C.dim(T.route_run));
+          await runFlow(msg, { askFn: (q) => ask1('  ' + q) });
+        } else {
+          const t0 = Date.now();
+          printAnswer(await sendMessage(token, msg), Date.now() - t0);
+        }
+      }
+    } catch (e) {
+      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));
+      else console.error(ui.errLine(`${T.err_generic}: ${(e && e.message) || e}`));
+    }
+    if (closed) break; // pipe: processa a última linha lida e sai
+  }
+  try { rl.close(); } catch (_) {}
+  console.log(ui.infoLine(T.chat_bye));
+}
+
+// ── Orquestração ─────────────────────────────────────────────────────────────
+const RUN_LBL = {
+  pt: { planning: 'planejando', awaiting_approval: 'aguardando aprovação', queued: 'na fila', running: 'executando', reviewing: 'revisando', paused: 'pausada', waiting_credits: 'sem créditos', done: 'concluída', failed: 'falhou', cancelled: 'cancelada' },
+  en: { planning: 'planning', awaiting_approval: 'awaiting approval', queued: 'queued', running: 'running', reviewing: 'reviewing', paused: 'paused', waiting_credits: 'out of credits', done: 'done', failed: 'failed', cancelled: 'cancelled' },
+};
+const runLbl = (st) => (RUN_LBL[cfg.lang || 'pt'] || RUN_LBL.pt)[st] || st;
+const stepTitle = (s) => String(s.title || s.task || s.descricao || s.description || s.agent || '?').slice(0, 70);
+
+function planBox(run) {
+  const steps = run.steps || [];
+  const est = run.estimated_credits ?? run.estimatedCredits ?? null;
+  const lines = [
+    C.bold(String(run.goal || '').slice(0, 84)),
+    C.dim(`${steps.length} ${T.plan_steps}` + (est != null ? ` · ${T.plan_est(est)}` : '') + (run.complexity ? ` · ${run.complexity}` : '')),
+    '',
+    ...steps.map((s, i) => C.cyan(String(i + 1).padStart(2)) + ' ' + stepTitle(s) + (s.agent ? C.dim('  ·' + s.agent) : '')),
+  ];
+  return ui.box(lines, { title: T.plan_title(run.id) });
+}
+
+async function pollRun(token, runId, sp) {
+  for (;;) {
+    await new Promise(res => setTimeout(res, 2500));
+    let r;
+    try { r = await api(`/api/ia/run/${runId}`, { token }); } catch (_) { continue; }
+    const run = r.run || r;
+    const steps = run.steps || [];
+    const done = steps.filter(s => s.status === 'done').length;
+    if (sp) sp.text(T.run_running(runLbl(run.status), done, steps.length));
+    if (['done', 'failed', 'cancelled', 'paused', 'waiting_credits'].includes(run.status)) return run;
+  }
+}
+
+// Fluxo completo de orquestração (usado pelo `ts run` e pelo /run do modo conversa).
+// askFn permite aprovar com o readline do REPL sem conflito de stdin; nunca chama process.exit.
+async function runFlow(goal, { askFn = ui.ask, json = false, yes = false } = {}) {
+  const token = needToken();
+  const sp0 = ui.spinner(runLbl('planning')).start();
+  let r;
+  try { r = await api('/api/ia/orchestrate', { method: 'POST', token, body: { goal }, timeoutMs: 120000 }); }
+  catch (e) { sp0.stop(); throw e; }
+  sp0.stop();
+  let run = r.run;
+  if (!json) console.log('\n' + planBox(run) + '\n');
+
+  if (!yes) {
+    const ans = String(await askFn(C.bold(T.plan_approve))).trim().toLowerCase();
+    if (!['s', 'sim', 'y', 'yes'].includes(ans)) {
+      try { await api(`/api/ia/run/${run.id}/cancel`, { method: 'POST', token }); } catch (_) {}
+      console.log(ui.infoLine(T.plan_cancelled));
+      return { status: 'cancelled', run };
+    }
+  }
+  await api(`/api/ia/run/${run.id}/approve-plan`, { method: 'POST', token });
+  const sp = ui.spinner(T.run_running(runLbl('running'), 0, (run.steps || []).length)).start();
+  run = await pollRun(token, run.id, sp);
+  sp.stop();
+
+  if (json) { console.log(JSON.stringify({ ok: run.status === 'done', run })); return { status: run.status, run }; }
+  if (run.status === 'done') {
+    console.log(ui.okLine(C.bold(T.run_done) + C.dim(`  · #${run.id}` + (run.actual_credits ? ` · ${run.actual_credits} ${T.uso_credits}` : ''))));
+    const result = run.final_result || run.result || '';
+    if (result) { console.log(''); console.log(ui.md(String(result)).split('\n').map(l => '  ' + l).join('\n')); console.log(''); }
+  } else if (run.status === 'failed') {
+    console.error(ui.errLine(C.bold(T.run_failed) + (run.error ? C.dim(' · ' + String(run.error).slice(0, 140)) : '')));
+  } else {
+    console.log(ui.infoLine(T.run_paused(runLbl(run.status))));
+  }
+  return { status: run.status, run };
+}
+
+async function runCmd(goalWords) {
+  const goal = goalWords.join(' ').trim();
+  if (goal.length < 10) { console.error(ui.infoLine(T.goal_short)); process.exit(2); }
+  const out = await runFlow(goal, { json: JSON_OUT, yes: YES });
+  if (out && out.status === 'failed') process.exit(1);
+  if (JSON_OUT && out && out.status !== 'done') process.exit(1);
+}
+
+// @arquivo → injeta o conteúdo do arquivo no texto. Só chars de CAMINHO (para não engolir
+// pontuação nem @menção). Só expande se EXISTE. Não injeta arquivos de SEGREDO (evita mandar
+// .env/chave pro gateway). Limita tamanho.
+const _SECRET_RE = /(^|[\\/.])(\.env|\.pem|\.key|id_rsa|id_ed25519|\.p12|\.pfx|credentials|secrets?)($|[\\/.])/i;
+const _BIN_RE = /\.(png|jpe?g|gif|webp|ico|bmp|pdf|zip|tar|gz|7z|rar|exe|dll|so|dylib|bin|mp[34]|wav|mov|avi|mkv|ttf|otf|woff2?|sqlite|db|class|o|a|lib|wasm)$/i;
+function _expandFileRefs(text, baseCwd) {
+  const _fs = require('fs'), _p = require('path');
+  // aceita @"caminho com espaço" (aspas) OU @caminho-sem-espaco
+  return String(text || '').replace(/(^|\s)@(?:"([^"]+)"|([\w.\-~/\\]+))/g, (m, pre, quoted, bare) => {
+    let clean = quoted != null ? quoted : String(bare || '').replace(/[.,;:!?)\]]+$/, ''); // tira pontuação final grudada
+    if (!clean) return m;
+    // ref BARE só expande se for path-like (tem barra ou extensão) — evita expandir @menção que
+    // por acaso bata com um arquivo (ex: @todo). Ref entre aspas é intenção explícita → sempre.
+    if (quoted == null && !/[\\/]/.test(clean) && !/\.[a-z0-9]+$/i.test(clean)) return m;
+    if (_SECRET_RE.test(clean)) return `${pre}[@${clean} — não injetado (arquivo sensível; leia sob demanda se precisar)]`;
+    try {
+      const abs = _p.resolve(baseCwd || process.cwd(), clean);
+      const st = _fs.statSync(abs);
+      if (st.isDirectory()) {
+        const list = _fs.readdirSync(abs).slice(0, 100).join('\n');
+        return `${pre}[@${clean} (pasta)]:\n\`\`\`\n${list}\n\`\`\``;
+      }
+      if (st.isFile()) {
+        if (_BIN_RE.test(clean)) return `${pre}[@${clean} — binário, não injetado (use ler_arquivo se precisar)]`;
+        if (st.size <= 200 * 1024) return `${pre}[@${clean}]:\n\`\`\`\n${_fs.readFileSync(abs, 'utf8')}\n\`\`\``;
+      }
+    } catch (_) {}
+    return m; // não existe / grande demais → mantém o @ literal
+  });
+}
+
+// ── ts hooks: mostra onde ficam os hooks + o que está configurado (descoberta) ──
+async function hooksCmd(words) {
+  const _fs = require('fs');
+  const en = cfg.lang === 'en';
+  const hm = require('../lib/hooks');
+  const exists = _fs.existsSync(hm.FILE);
+  console.log('\n  ' + C.bold(en ? 'Hooks (deterministic, run around each tool call)' : 'Hooks (determinísticos, rodam em volta de cada ferramenta)'));
+  console.log('  ' + C.dim(en ? 'File (global, trusted): ' : 'Arquivo (global, confiável): ') + hm.FILE + (exists ? '' : C.dim(en ? '  (not created yet)' : '  (ainda não existe)')));
+  if (exists) {
+    const h = hm.load();
+    for (const ev of ['PreToolUse', 'PostToolUse', 'SessionStart', 'Stop']) {
+      const n = (h[ev] || []).length; if (n) console.log('  ' + C.cyan(ev) + C.dim(': ' + n + (en ? ' hook(s)' : ' hook(s)')) + (h[ev].map(x => x.match ? ' [' + x.match + ']' : '').join('')));
+    }
+    if (!h._any) console.log('  ' + C.dim(en ? '(file present but no hooks defined)' : '(arquivo presente mas sem hooks definidos)'));
+  } else {
+    console.log('  ' + C.dim(en ? 'Example — save as the file above:' : 'Exemplo — salve no arquivo acima:'));
+    console.log(C.dim('  {\n    "PreToolUse":  [{ "match": "escrever_arquivo|editar_arquivo", "command": "meu-check.sh" }],\n    "PostToolUse": [{ "match": "editar_arquivo", "command": "prettier --write \\"$TS_FILE\\" || true" }]\n  }'));
+    console.log('  ' + C.dim(en ? 'PreToolUse: exit≠0 blocks the tool. Payload arrives as JSON on stdin; env TS_TOOL/TS_FILE set.' : 'PreToolUse: exit≠0 bloqueia a ferramenta. Payload chega como JSON no stdin; env TS_TOOL/TS_FILE definidos.'));
+  }
+  console.log('');
+}
+
+// ── ts init: gera um .ts-memoria.md inicial escaneando o projeto (determinístico, sem IA) ──
+async function initCmd() {
+  const _fs = require('fs'), _p = require('path');
+  const cwd = process.cwd();
+  const dest = _p.join(cwd, '.ts-memoria.md');
+  const has = (f) => _fs.existsSync(_p.join(cwd, f));
+  const readJson = (f) => { try { return JSON.parse(_fs.readFileSync(_p.join(cwd, f), 'utf8')); } catch (_) { return null; } };
+  const en = cfg.lang === 'en';
+  let tipo = en ? 'unknown' : 'desconhecido', build = [], run = [], test = [];
+  const pkg = has('package.json') && readJson('package.json');
+  if (pkg) {
+    tipo = 'Node.js' + (pkg.dependencies && (pkg.dependencies.react || pkg.dependencies.next) ? ' (React/Next)' : '');
+    const s = pkg.scripts || {};
+    if (s.build) build.push('npm run build'); if (s.dev || s.start) run.push('npm run ' + (s.dev ? 'dev' : 'start')); if (s.test) test.push('npm test');
+  } else if (has('pubspec.yaml')) { tipo = 'Flutter/Dart'; build = ['flutter build']; run = ['flutter run']; test = ['flutter test']; }
+  else if (has('requirements.txt') || has('pyproject.toml')) { tipo = 'Python'; run = ['python main.py']; test = ['pytest']; }
+  else if (has('go.mod')) { tipo = 'Go'; build = ['go build ./...']; run = ['go run .']; test = ['go test ./...']; }
+  else if (has('Cargo.toml')) { tipo = 'Rust'; build = ['cargo build']; run = ['cargo run']; test = ['cargo test']; }
+  else if (has('index.html')) { tipo = en ? 'Static web (HTML/JS)' : 'Web estático (HTML/JS)'; run = ['python -m http.server']; }
+  const top = _fs.readdirSync(cwd).filter(n => !n.startsWith('.') && n !== 'node_modules').slice(0, 25).join(', ');
+  const nl = (a) => a.length ? a.map(x => '`' + x + '`').join(' · ') : (en ? '(fill in)' : '(preencher)');
+  const body = (en
+    ? `# Project memory (ts)\n\n> Auto-generated by \`ts init\`. Edit freely — the ts agent reads this every session.\n\n- **Type:** ${tipo}\n- **Build:** ${nl(build)}\n- **Run:** ${nl(run)}\n- **Test:** ${nl(test)}\n- **Top-level:** ${top}\n\n## Conventions / gotchas\n- (add what the agent should always know: architecture, pitfalls, how to deploy)\n`
+    : `# Memória do projeto (ts)\n\n> Gerado por \`ts init\`. Edite à vontade — o agente ts lê isto toda sessão.\n\n- **Tipo:** ${tipo}\n- **Build:** ${nl(build)}\n- **Rodar:** ${nl(run)}\n- **Testar:** ${nl(test)}\n- **Raiz:** ${top}\n\n## Convenções / armadilhas\n- (anote o que o agente sempre deve saber: arquitetura, pegadinhas, como fazer deploy)\n`);
+  if (_fs.existsSync(dest)) {
+    const ok = await ui.ask(C.warn('▲ ') + (en ? '.ts-memoria.md already exists. Overwrite? (backup kept) [s/N] ' : '.ts-memoria.md já existe. Sobrescrever? (com backup) [s/N] '));
+    if (!['s', 'sim', 'y', 'yes'].includes(String(ok).trim().toLowerCase())) { console.log('  ' + C.dim(en ? 'cancelled.' : 'cancelado.')); return; }
+    let r; try { r = await require('../lib/tools').execute('escrever_arquivo', { caminho: dest, conteudo: body }, { baseDir: cwd }); } catch (_) {}
+    if (!r || r.erro) { try { _fs.writeFileSync(dest, body); } catch (e) { console.error(ui.errLine((en ? 'Failed to write .ts-memoria.md: ' : 'Falha ao escrever .ts-memoria.md: ') + e.message)); return; } }
+  } else { _fs.writeFileSync(dest, body); }
+  console.log('  ' + C.ok('✔ ') + (en ? 'Created ' : 'Criado ') + C.bold('.ts-memoria.md') + C.dim(' — ' + tipo) + '\n  ' + C.dim(en ? 'Edit it to teach the agent your project. It loads automatically.' : 'Edite pra ensinar o projeto ao agente. Ele carrega sozinho.'));
+}
+
+// ── git worktrees: isola uma run numa cópia descartável do repo ──
+// execFileSync (SEM shell): args como array → zero injeção/fragilidade de aspas (Win/POSIX).
+function _git(cwd, args) { return require('child_process').execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }); }
+function _isGitRepo(dir) { try { _git(dir, ['rev-parse', '--is-inside-work-tree']); return true; } catch (_) { return false; } }
+function _wtRoot() { return require('path').join(require('os').homedir(), '.ts', 'worktrees'); }
+function _worktreeCreate(baseCwd) {
+  const _p = require('path'), _fs = require('fs');
+  const stamp = Date.now().toString(36);
+  const name = (_p.basename(baseCwd).replace(/[^\w.-]/g, '_') || 'repo');
+  const branch = 'ts/' + stamp;
+  _fs.mkdirSync(_wtRoot(), { recursive: true });
+  const wtPath = _p.join(_wtRoot(), name + '-' + stamp);
+  _git(baseCwd, ['worktree', 'add', wtPath, '-b', branch]);
+  return { path: wtPath, branch, base: baseCwd };
+}
+// Depois da run: commita o que o agente mudou. Rastreia se o commit DEU CERTO (em CI/cron sem
+// git user.email o commit falha) — senão a instrução de merge enganaria e o clean apagaria o trabalho.
+function _worktreeFinish(wt) {
+  let stat = ''; try { stat = _git(wt.path, ['status', '--porcelain']).trim(); } catch (_) {}
+  const changed = stat ? stat.split('\n').filter(Boolean).length : 0;
+  let committed = false;
+  if (stat) { try { _git(wt.path, ['add', '-A']); _git(wt.path, ['commit', '-m', 'ts: run isolada em worktree']); committed = true; } catch (_) {} }
+  return { changed, committed };
+}
+async function worktreesCmd(words) {
+  const en = cfg.lang === 'en';
+  // ANCORADO em ~/.ts/worktrees, normalizando barras (git devolve "/" mesmo no Windows, path.join dá "\").
+  const _norm = (s) => String(s || '').replace(/\\/g, '/').replace(/\/+$/, '');
+  const rootN = _norm(_wtRoot()) + '/';
+  const isTs = (p) => !!p && (_norm(p) + '/').startsWith(rootN);
+  const sub = (words[0] || '').toLowerCase();
+  if (!_isGitRepo(process.cwd())) { console.error(ui.infoLine(en ? 'Not a git repo here.' : 'Aqui não é um repositório git.')); return; }
+  let list = ''; try { list = _git(process.cwd(), ['worktree', 'list', '--porcelain']); } catch (_) {}
+  const entries = [...list.matchAll(/^worktree (.+)$/gm)].map(m => m[1].trim()).filter(isTs);
+  if (sub === 'clean' || sub === 'limpar') {
+    if (!entries.length) { console.log('  ' + C.dim(en ? 'no ts worktrees to clean.' : 'nenhum worktree do ts pra limpar.')); return; }
+    for (const p of entries) {
+      let dirty = ''; try { dirty = _git(p, ['status', '--porcelain']).trim(); } catch (_) {}
+      if (dirty) { console.log('  ' + C.warn('▲ ') + (en ? 'uncommitted changes in ' : 'há mudanças NÃO-commitadas em ') + C.dim(p) + (en ? ' — skipped (commit or remove by hand).' : ' — pulado (commite ou remova à mão pra não perder).')); continue; }
+      try { _git(process.cwd(), ['worktree', 'remove', p, '--force']); console.log('  ' + C.ok('✔ ') + (en ? 'removed ' : 'removido ') + C.dim(p)); } catch (_) {}
+    }
+    try { _git(process.cwd(), ['worktree', 'prune']); } catch (_) {}
+    // apaga só as branches ts/* JÁ MERGEADAS (-d recusa não-mergeadas → nunca perde trabalho)
+    try { const br = _git(process.cwd(), ['branch', '--list', 'ts/*']).split('\n').map(s => s.replace(/^[*+]?\s*/, '').trim()).filter(Boolean); for (const b of br) { try { _git(process.cwd(), ['branch', '-d', b]); } catch (_) {} } } catch (_) {}
+    return;
+  }
+  console.log('\n  ' + C.bold(en ? 'ts worktrees (isolated runs)' : 'worktrees do ts (runs isoladas)'));
+  if (!entries.length) console.log('  ' + C.dim(en ? 'none. Create one: ts agente --worktree "..."' : 'nenhum. Crie um: ts agente --worktree "..."'));
+  else entries.forEach(p => console.log('  ' + C.dim(p)));
+  console.log('  ' + C.dim(en ? 'remove all: ts worktrees clean' : 'remover todos: ts worktrees limpar') + '\n');
+}
+
+// ── Agente LOCAL (Fase 2): executa a tarefa NESTA máquina com ferramentas reais ──
+async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null } = {}) {
+  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']) {
+    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)); }
+  }
+  let task = words.join(' ').trim();
+  const piped = await readStdin();
+  if (piped) task = (task || (cfg.lang === 'en' ? 'Analyze the input below and act on it.' : 'Analise a entrada abaixo e aja sobre ela.'))
+    + `\n\n${T.pipe_ctx}:\n\`\`\`\n${piped.slice(0, 30000)}\n\`\`\``;
+  if (task.length < 8) { console.error(ui.infoLine(T.agent_need)); process.exit(2); }
+
+  const agent = require('../lib/agent');
+  // --modelo/--model força o executor do agente (bake-off de modelos, ex: --modelo glm-5.2)
+  const _mi = process.argv.findIndex(a => a === '--modelo' || a === '--model');
+  const model = _mi >= 0 ? (process.argv[_mi + 1] || null) : null;
+  // --ler = modo Ask (só leitura, nunca escreve/roda) · --plano = propõe um plano sem agir
+  const readOnly = process.argv.includes('--ler') || process.argv.includes('--read-only');
+  const plan = process.argv.includes('--plano') || process.argv.includes('--plan');
+  // --stream-json / --output-format stream-json: modo HEADLESS pra scripts/CI — SÓ NDJSON no stdout
+  // (eventos tipados system/tool/assistant/result), sem UI bonita. Padrão Cursor/Claude Code.
+  const _ofi = process.argv.indexOf('--output-format');
+  const streamJson = process.argv.includes('--stream-json') || (_ofi >= 0 && process.argv[_ofi + 1] === 'stream-json');
+  const _emit = (o) => { try { process.stdout.write(JSON.stringify(o) + '\n'); } catch (_) {} };
+  // --worktree/-w: roda numa cópia ISOLADA do repo (git worktree). Nada toca a árvore principal.
+  const useWorktree = process.argv.includes('--worktree') || process.argv.includes('-w');
+  // SESSÃO RESUMÍVEL: `ts agente --continuar "..."` retoma o trabalho anterior DESTA pasta.
+  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;
+  // 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)')); }
+    catch (_) { if (!streamJson) console.log('  ' + C.dim(cfg.lang === 'en' ? '(no prior session here — starting fresh)' : '(sem sessão anterior aqui — começando nova)')); }
+  }
+  // WORKTREE: cria a cópia isolada e passa a trabalhar nela (todas as edições ficam confinadas ali).
+  let _wt = null;
+  if (useWorktree) {
+    if (_isGitRepo(startCwd)) {
+      try { _wt = _worktreeCreate(startCwd); startCwd = _wt.path; if (!streamJson) console.log('  ' + C.dim('⎇ ' + (cfg.lang === 'en' ? 'isolated run in worktree ' : 'run isolada na worktree ') + C.cyan(_wt.branch))); }
+      catch (e) { if (!streamJson) console.log('  ' + C.warn('▲ ') + C.dim('worktree falhou (' + String(e.message || '').slice(0, 50) + ') — rodando na pasta normal')); }
+    } else if (!streamJson) console.log('  ' + C.dim('⎇ ' + (cfg.lang === 'en' ? '--worktree needs a git repo — running normally' : '--worktree precisa de um repo git — rodando normal')));
+  }
+  // @arquivo: expande referências "@caminho" no texto pro conteúdo do arquivo (padrão Claude Code/Cursor).
+  task = _expandFileRefs(task, startCwd);
+  const ask = askFn || ui.ask;
+  const sp = streamJson ? { text() {}, start() {}, stop() {} } : ui.spinner(T.agent_thinking).start();
+  const t0 = Date.now();
+  if (streamJson) _emit({ type: 'system', subtype: 'init', model: model || 'auto', cwd: startCwd, mode: plan ? 'plan' : readOnly ? 'ask' : 'agent' });
+  let out;
+  try {
+    out = await agent.run(task, {
+      token, lang: cfg.lang || 'pt', yes: YES, model, priorMessages, cwd: startCwd, readOnly, plan,
+      onThinking: () => sp.text(T.agent_thinking),
+      onStep: ({ name, detail, blocked }) => {
+        if (streamJson) { _emit({ type: 'tool', subtype: blocked ? 'blocked' : 'started', tool: name, detail: detail || '' }); return; }
+        sp.stop();
+        const tag = blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙');
+        console.log('  ' + tag + ' ' + C.bold(name) + (detail ? C.dim(' · ' + detail) : ''));
+        sp.start();
+      },
+      askApprove: async (cmd) => {
+        // headless (stream-json): não dá pra perguntar → NEGA o destrutivo e sinaliza o evento.
+        if (streamJson) { _emit({ type: 'tool', subtype: 'approval_denied', reason: 'headless (--stream-json): destructive command not auto-approved', command: cmd }); return false; }
+        sp.stop();
+        const ans = String(await ask(C.err('▲ ') + T.agent_approve(C.bold(cmd)))).trim().toLowerCase();
+        sp.start();
+        return ['s', 'sim', 'y', 'yes'].includes(ans);
+      },
+      onRemote: ({ ttl }) => {
+        if (streamJson) { _emit({ type: 'tool', subtype: 'approval_remote', ttl: ttl || 120 }); return; }
+        sp.stop();
+        console.log('  ' + C.warn('▲') + ' ' + C.dim(T.agent_remote_wait(ttl || 120)));
+        sp.start();
+      },
+    });
+  } catch (e) { sp.stop(); throw e; }
+  sp.stop();
+  // cwd EFETIVO (o agente pode ter feito cd/mudar_diretorio) → devolve ao REPL e persiste.
+  const effCwd = out.cwd || startCwd;
+  // em worktree NÃO propaga o cwd (o REPL/sessão devem ficar na base, não na cópia descartável —
+  // 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 (_) {}
+  const secs = ((Date.now() - t0) / 1000).toFixed(1).replace('.', ',');
+  // WORKTREE: commita o que mudou e prepara o resumo (merge/descarte).
+  const _wtInfo = _wt ? _worktreeFinish(_wt) : null;
+  const _printWt = () => {
+    if (!_wt) return;
+    const en = cfg.lang === 'en';
+    if (_wtInfo && _wtInfo.changed && _wtInfo.committed) {
+      console.log('  ' + C.dim('⎇ ' + (en ? 'isolated in ' : 'isolado em ') + C.cyan(_wt.branch) + C.dim(' — ' + _wtInfo.changed + (en ? ' file(s) changed. Review then:' : ' arquivo(s) alterado(s). Revise e:'))));
+      console.log(C.dim(`    git -C ${JSON.stringify(_wt.base)} merge ${_wt.branch}   ${en ? '# apply' : '# aplicar'}\n    ts worktrees clean   ${en ? '# discard ts worktrees' : '# descartar as worktrees do ts'}`));
+    } else if (_wtInfo && _wtInfo.changed && !_wtInfo.committed) {
+      // commit falhou (ex: git user.email não configurado em CI/cron) → NÃO instrui merge nem clean
+      console.log('  ' + C.warn('▲ ') + (en ? _wtInfo.changed + ' change(s) in worktree but the auto-commit FAILED (set git user.email/user.name). Uncommitted changes are in:' : _wtInfo.changed + ' mudança(s) na worktree mas o commit automático FALHOU (configure git user.email/user.name). As mudanças NÃO-commitadas estão em:'));
+      console.log('    ' + C.cyan(_wt.path) + C.dim(en ? '   (do NOT run `ts worktrees clean` — it would discard them)' : '   (NÃO rode `ts worktrees clean` — perderia as mudanças)'));
+    } else console.log('  ' + C.dim('⎇ ' + C.cyan(_wt.branch) + C.dim(en ? ' — no changes. Clean: ts worktrees clean' : ' — sem mudanças. Limpar: ts worktrees clean')));
+  };
+  // HEADLESS stream-json: fecha com assistant (texto) + result (métricas) e sai.
+  if (streamJson) {
+    _emit({ type: 'assistant', text: out.text || '' });
+    _emit({ type: 'result', steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, needHuman: out.needHuman || null, cwd: effCwd, duration_ms: Date.now() - t0, worktree: _wt ? { path: _wt.path, branch: _wt.branch, base: _wt.base, 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 })); 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) {
+    console.log('\n  ' + C.warn('🙋 ' + (cfg.lang === 'en' ? 'I need you: ' : 'Preciso de você: ')) + C.bold(out.needHuman.motivo || ''));
+    if (out.needHuman.o_que_fazer) console.log('  ' + (cfg.lang === 'en' ? 'What to do: ' : 'O que fazer: ') + out.needHuman.o_que_fazer);
+    console.log('  ' + C.dim(cfg.lang === 'en' ? 'Then run: ts agente --continuar "done, continue"' : 'Depois rode: ts agente --continuar "feito, continua"') + '\n');
+    if (out.text) printAnswer(out.text);
+    _printWt();
+    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) + '%)'
+      : '')
+    : '';
+  console.log('  ' + C.dim(T.agent_footer(out.steps, out.credits, secs)) + C.dim(_cx) + C.dim('  ·  ts agente --continuar "..." pra seguir') + '\n');
+  _printWt();
+}
+
+// ── ts acp: servidor Agent Client Protocol (JSON-RPC/stdio) pra editores (Zed etc.) ──
+async function acpCmd() {
+  // token pode faltar — o servidor responde o handshake mesmo assim e só recusa no prompt
+  // (mensagem "rode ts login"). NÃO escreve NADA em stdout aqui (corromperia o JSON-RPC).
+  const { acpServer } = require('../lib/acp');
+  acpServer({ token: cfg.token || null, lang: cfg.lang || 'pt' });
+  // fica vivo lendo stdin até o editor fechar (rl 'close' → process.exit).
+  return new Promise(() => {});
+}
+
+// ── ts eval: roda o agente sobre uma suíte de casos e um LLM-juiz pontua cada um ──
+async function evalCmd(words) {
+  const en = cfg.lang === 'en';
+  const evalMod = require('../lib/eval');
+  // --exemplo: imprime uma suíte modelo e sai (nem precisa de login).
+  if (FLAGS.has('--exemplo') || FLAGS.has('--example')) { console.log(JSON.stringify(evalMod.EXAMPLE, null, 2)); return; }
+  const token = needToken();
+  const _val = (names) => { const i = process.argv.findIndex(a => names.includes(a)); return i >= 0 ? (process.argv[i + 1] || null) : null; };
+  const model = _val(['--modelo', '--model']);              // executor do agente (bake-off)
+  const judgeModel = _val(['--juiz', '--judge']) || undefined; // modelo do juiz (default barato)
+  const smoke = FLAGS.has('--smoke');
+  // caminho da suíte = positional que não seja valor de --modelo/--juiz. Prefere um que
+  // termine em .json ou exista em disco (robusto quando o valor de --modelo bate com o nome).
+  const skip = new Set([model, judgeModel].filter(Boolean));
+  const cand = words.filter(w => !skip.has(w));
+  const _isFile = (w) => { try { return fs.statSync(w).isFile(); } catch (_) { return false; } };
+  const suitePath = cand.find(w => /\.json$/i.test(w)) || cand.find(_isFile) || cand[0];
+  const _usage = en
+    ? 'Usage: ts eval <suite.json> [--json] [--modelo X] [--juiz Y]   ·   ts eval --smoke   ·   ts eval --exemplo'
+    : 'Uso: ts eval <suite.json> [--json] [--modelo X] [--juiz Y]   ·   ts eval --smoke   ·   ts eval --exemplo';
+  const _die = (msg, code) => { if (JSON_OUT) console.log(JSON.stringify({ error: msg })); else console.error(ui.errLine(msg)); process.exit(code); };
+
+  let suite;
+  if (smoke) suite = evalMod.smokeSuite();
+  else if (suitePath) {
+    try { suite = evalMod.loadSuite(suitePath); }
+    catch (e) { _die((en ? 'suite error: ' : 'erro na suíte: ') + e.message, 2); }
+  } else {
+    // dica: o usuário provavelmente passou o .json como VALOR de --modelo/--juiz por engano.
+    const misTaken = [model, judgeModel].find(v => v && /\.json$/i.test(v));
+    if (JSON_OUT) { console.log(JSON.stringify({ error: 'missing suite', hint: misTaken ? `"${misTaken}" foi consumido por --modelo/--juiz` : _usage })); process.exit(2); }
+    if (misTaken) console.error(ui.infoLine((en ? 'Did you pass the suite as a flag value? ' : 'Passou a suíte como valor de flag? ') + C.cyan('"' + misTaken + '"') + (en ? ' was consumed by --modelo/--juiz.' : ' foi consumido por --modelo/--juiz.')));
+    console.error(ui.infoLine(_usage));
+    process.exit(2);
+  }
+
+  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');
+  }
+  const sp = JSON_OUT ? { start() {}, stop() {}, text() {} } : ui.spinner('…').start();
+  let res;
+  try {
+    res = await evalMod.runSuite(suite, {
+      token, lang: cfg.lang || 'pt', model, judgeModel,
+      onCase: ({ i, total, id, phase, pass, score }) => {
+        if (JSON_OUT) return;
+        if (phase === 'done') {
+          sp.stop();
+          console.log('  ' + (pass ? C.ok('✔') : C.err('✗')) + ' ' + C.bold(id) + C.dim('  ' + score + '/100'));
+          sp.start();
+        } else {
+          sp.text((en ? 'case ' : 'caso ') + (i + 1) + '/' + total + ' · ' + id + ' · ' + (phase === 'judge' ? (en ? 'judging' : 'julgando') : (en ? 'running' : 'rodando')));
+        }
+      },
+    });
+  } 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); }
+    throw e;
+  }
+  sp.stop();
+
+  const s = res.summary;
+  if (JSON_OUT) { console.log(JSON.stringify(res)); if (s.failed > 0) process.exitCode = 1; return; }
+  console.log('');
+  for (const r of res.results) {
+    console.log('  ' + (r.pass ? C.ok('✔') : C.err('✗')) + ' ' + C.bold(r.id.padEnd(22)) + ' ' + C.dim(String(r.score).padStart(3) + '/100') + '  ' + r.reason);
+    if (r.error) console.log('      ' + C.warn(en ? 'run error: ' : 'erro na run: ') + C.dim(r.error));
+  }
+  const secs = (s.ms / 1000).toFixed(1).replace('.', ',');
+  const tally = s.passed + '/' + s.total;
+  const col = s.passRate === 100 ? C.ok : s.passRate >= 50 ? C.warn : C.err;
+  const judgeTok = s.judgeTokens ? '  ·  ' + (en ? 'judge ~' : 'juiz ~') + (s.judgeTokens >= 1000 ? Math.round(s.judgeTokens / 1000) + 'k' : s.judgeTokens) + ' tok' : '';
+  console.log('\n  ' + C.bold(en ? 'Result: ' : 'Resultado: ') + col(tally) + C.dim(' ' + (en ? 'passed' : 'passaram') + ' (' + s.passRate + '%)  ·  ' + (en ? 'avg ' : 'média ') + s.avgScore + '/100  ·  ' + s.credits + (en ? ' credits' : ' créditos') + judgeTok + '  ·  ' + secs + 's') + '\n');
+  // exit code pra CI: qualquer caso reprovado → status 1
+  if (s.failed > 0) process.exitCode = 1;
+}
+
+async function runsCmd() {
+  const token = needToken();
+  const r = await api('/api/ia/runs', { token });
+  const runs = (r.runs || r || []).slice(0, 10);
+  if (!runs.length) { console.log(ui.infoLine(T.runs_empty)); return; }
+  console.log('\n' + ui.box(runs.map(x =>
+    C.cyan('#' + String(x.id).padEnd(5)) + ' ' + String(runLbl(x.status)).padEnd(20) + ' ' + C.dim(String(x.goal || '').slice(0, 48))
+  ), { title: T.runs_title }) + '\n');
+}
+
+async function statusCmd(id) {
+  const token = needToken();
+  if (!id) return runsCmd();
+  let r;
+  try { r = await api(`/api/ia/run/${parseInt(id)}`, { token }); }
+  catch (e) { if (e.status === 404) { console.error(ui.errLine(T.status_notfound)); process.exit(1); } throw e; }
+  let run = r.run || r;
+  if (JSON_OUT) { console.log(JSON.stringify(run)); return; }
+  console.log('\n' + planBox(run));
+  const steps = run.steps || [];
+  console.log('  ' + C.dim(runLbl(run.status)) + C.dim(` · ${steps.filter(s => s.status === 'done').length}/${steps.length}`));
+  if (['running', 'queued', 'reviewing', 'planning'].includes(run.status)) {
+    const sp = ui.spinner(runLbl(run.status)).start();
+    run = await pollRun(token, run.id, sp);
+    sp.stop(run.status === 'done' ? ui.okLine(T.run_done) : ui.errLine(runLbl(run.status)));
+    if (run.status === 'done' && run.final_result) { console.log(''); console.log(ui.md(String(run.final_result)).split('\n').map(l => '  ' + l).join('\n')); }
+  }
+  console.log('');
+}
+
+// ── ts vps: conectar/gerenciar um servidor remoto (SSH) da máquina local ──
+async function vpsCmd(words) {
+  const ssh = require('../lib/ssh');
+  const sub = (words[0] || '').toLowerCase();
+  const rest = words.slice(1);
+  const flag = (n) => { const i = rest.indexOf(n); return i >= 0 ? rest[i + 1] : null; };
+
+  // ts vps set --host IP --user ubuntu --chave caminho.pem   (ou --login arquivo.txt / --senha ...)
+  if (sub === 'set' || sub === 'config' || sub === 'add') {
+    const prof = ssh.loadProfile() || {};
+    if (flag('--login')) { const l = ssh.parseLoginFile(flag('--login')); if (l.user) prof.user = l.user; if (l.pass) prof.pass = l.pass; if (l.host) prof.host = l.host; }
+    if (flag('--host')) prof.host = flag('--host');
+    if (flag('--porta') || flag('--port')) prof.port = parseInt(flag('--porta') || flag('--port')) || 22;
+    if (flag('--user') || flag('--usuario')) prof.user = flag('--user') || flag('--usuario');
+    if (flag('--chave') || flag('--key')) { prof.keyPath = flag('--chave') || flag('--key'); delete prof.pass; }
+    if (flag('--senha') || flag('--pass')) { prof.pass = flag('--senha') || flag('--pass'); delete prof.keyPath; }
+    ssh.saveProfile(prof);
+    console.log(ui.infoLine(`Perfil salvo: ${prof.user || 'root'}@${prof.host || '?'}:${prof.port || 22} (${prof.keyPath ? 'chave' : prof.pass ? 'senha' : 'sem credencial!'})`));
+    return;
+  }
+
+  // ts vps chave — mostra a chave pública do ts (pra você colar no authorized_keys via EC2 Instance Connect)
+  if (sub === 'chave' || sub === 'pubkey') {
+    const os = require('os'); const fsx = require('fs'); const pth = require('path');
+    const kp = pth.join(os.homedir(), '.ssh', 'id_ts_vps');
+    if (!fsx.existsSync(kp + '.pub')) { try { require('child_process').execSync(`ssh-keygen -t ed25519 -f "${kp}" -N "" -C "ts-vps"`, { stdio: 'ignore' }); } catch (_) {} }
+    let pub = ''; try { pub = fsx.readFileSync(kp + '.pub', 'utf8').trim(); } catch (_) {}
+    console.log('\n' + C.bold('Chave pública do ts (adicione ao servidor):') + '\n');
+    console.log('  ' + pub + '\n');
+    console.log(C.dim('  No servidor (ou via EC2 Instance Connect no navegador), rode:'));
+    console.log('  ' + C.cyan(`echo "${pub}" >> ~/.ssh/authorized_keys`) + '\n');
+    console.log(C.dim('  Depois: ') + C.cyan('ts vps set --chave ' + kp) + C.dim(' e ') + C.cyan('ts vps') + '\n');
+    return;
+  }
+
+  const prof = ssh.loadProfile();
+  if (!prof || !prof.host) { console.log(ui.infoLine('Nenhum servidor configurado. Use "ts vps set --host IP --user ubuntu --chave chave.pem".')); return; }
+
+  const sp = ui.spinner ? ui.spinner(`conectando em ${prof.user}@${prof.host}…`) : null; sp && sp.start && sp.start();
+  try {
+    const r = await ssh.connect();
+    sp && sp.stop && sp.stop();
+    console.log('\n  ' + C.ok('●') + ' ' + C.bold(`Logado em ${r.user}@${r.host}:${r.port}`));
+    // ts vps "comando"  → roda e sai;  ts vps  → prova de vida
+    const remoteCmd = (sub && !['ver', 'status', 'info', 'conectar', 'connect'].includes(sub)) ? words.join(' ') : null;
+    const cmd = remoteCmd || 'echo "  usuário: $(whoami) | host: $(hostname) | $(uptime -p)"; echo "  SO: $(. /etc/os-release; echo $PRETTY_NAME)"; echo "  projetos em ~:"; ls -1 ~ 2>/dev/null | head';
+    const out = await ssh.exec(cmd);
+    console.log(C.dim((out.stdout || out.stderr || '').replace(/\n$/, '')));
+    ssh.disconnect();
+    console.log('');
+  } catch (e) { sp && sp.stop && sp.stop(); console.log('\n  ' + C.err('✗') + ' ' + e.message + '\n'); }
+}
+
+// ── ts meta: MISSÃO longa (checklist + rodadas até terminar — modo noturno) ──
+function _metaChecklistBox(itens) {
+  return ui.box(itens.map(it =>
+    (it.passes ? C.ok('✔') : it.blocked ? C.err('!') : C.dim('○')) + ' ' + (it.passes ? C.dim(it.desc.slice(0, 76)) : it.desc.slice(0, 76))
+  ), { title: T.meta_title });
+}
+async function metaCmd() {
+  const token = needToken();
+  const metaMod = require('../lib/meta');
+  const dir = process.cwd();
+
+  // objetivo = args após "meta", pulando flags e seus valores (--budget 300 não entra no texto)
+  const mi = rawArgs.findIndex(a => ['meta', 'missao', 'mission'].includes(String(a).toLowerCase()));
+  const parts = [];
+  for (let i = mi + 1; i < rawArgs.length; i++) {
+    const a = rawArgs[i];
+    if (a.startsWith('-')) { if (['--budget', '--rodadas', '--rounds', '--modelo', '--model', '--pensador', '--thinker', '--maxmin', '--designer', '--design', '--olho', '--eye', '--mockup', '--arquivo', '--file', '-f'].includes(a)) i++; continue; }
+    parts.push(a);
+  }
+  // objetivo pode vir de um ARQUIVO (--arquivo/-f caminho.txt) — evita a dor de passar
+  // um texto gigante entre aspas no PowerShell/canvas. O arquivo tem prioridade.
+  const _goalFileArg = (() => { const i = rawArgs.findIndex(a => ['--arquivo', '--file', '-f'].includes(a)); return i >= 0 ? rawArgs[i + 1] : null; })();
+  let goal = parts.join(' ').trim();
+  if (_goalFileArg) { try { const t = require('fs').readFileSync(_goalFileArg, 'utf8').trim(); if (t) goal = t; } catch (e) { console.error(ui.infoLine('Não consegui ler o objetivo de ' + _goalFileArg + ': ' + e.message)); process.exit(2); } }
+  const flagNum = (name, def) => { const i = rawArgs.indexOf(name); const v = i >= 0 ? parseInt(rawArgs[i + 1]) : 0; return v > 0 ? v : def; };
+  const flagStr = (name) => { const i = rawArgs.indexOf(name); return i >= 0 ? (rawArgs[i + 1] || null) : null; };
+  const budget = flagNum('--budget', 400);
+  const maxRounds = flagNum('--rodadas', flagNum('--rounds', 20));
+  const forcedModel = flagStr('--modelo') || flagStr('--model'); // executor fixo (bake-off de modelos)
+  const thinker = flagStr('--pensador') || flagStr('--thinker') || 'grok-4.5'; // modelo caro que só PENSA quando trava
+  const maxMinutes = flagNum('--maxmin', 0); // freio de relógio (0 = sem limite)
+  const designer = flagStr('--designer') || 'grok-4.5'; // modelo forte que projeta o VISUAL antes de codar
+  const design = FLAGS.has('--sem-design') ? false : (flagStr('--design') || 'auto'); // auto = liga em app visual
+  const eye = FLAGS.has('--sem-olho') ? null : (flagStr('--olho') || flagStr('--eye') || 'grok-4.5'); // "olho" que critica o print do app
+  const visualLadder = !FLAGS.has('--sem-escada') && !FLAGS.has('--barato'); // escada visual: fix visual escala pro modelo forte (caro). --sem-escada/--barato deixa no executor barato
+  const mockup = flagStr('--mockup'); // imagem de referência (ex: mockup do Google AI Studio) — designer projeta a partir dela e o olho cobra fidelidade
+  const arch = FLAGS.has('--sem-arch') ? false : (FLAGS.has('--arch') || FLAGS.has('--arquitetura') ? true : 'auto'); // contrato de arquitetura antes de codar (auto = liga em app complexo)
+
+  const existing = metaMod.load(dir);
+  if (FLAGS.has('--status')) {
+    if (!existing) { console.log(ui.infoLine(T.meta_none)); return; }
+    const done = existing.checklist.filter(i => i.passes).length;
+    console.log('\n' + _metaChecklistBox(existing.checklist));
+    console.log('  ' + C.dim(T.meta_progress(done, existing.checklist.length, existing.creditsSpent, existing.budget)) + C.dim(' · ' + existing.status) + '\n');
+    return;
+  }
+  if (FLAGS.has('--novo')) { try { require('fs').unlinkSync(metaMod.stateFile(dir)); } catch (_) {} }
+  const st0 = FLAGS.has('--novo') ? null : existing;
+  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)
+  console.log(ui.banner(pkg.version, T.tagline));
+  if (st0 && st0.status !== 'done') {
+    const d = st0.checklist.filter(i => i.passes).length;
+    console.log('  ' + C.dim(T.meta_resuming(d, st0.checklist.length)) + '\n');
+  }
+  const sp = ui.spinner(T.meta_planning).start();
+  const t0 = Date.now();
+  if (forcedModel) console.log('  ' + C.dim('executor fixo: ') + C.cyan(forcedModel) + '\n');
+  console.log('  ' + C.dim('pensador (escala no erro): ') + C.indigo(thinker) + (maxMinutes ? C.dim(' · limite ' + maxMinutes + ' min') : '') + '\n');
+  const st = await metaMod.run(goal || null, {
+    token, lang: cfg.lang || 'pt', yes, budget, maxRounds, dir, model: forcedModel, thinker, maxMinutes, designer, design, eye, visualLadder, mockup, arch,
+    onAlert: ({ type, text }) => {
+      sp.stop();
+      const ic = type === 'human' ? C.warn('🙋') : type === 'escalate' ? C.indigo('🧠') : type === 'stagnated' ? C.err('🛑') : type === 'design' ? C.cyan('🎨') : type === 'retry' || type === 'conn' ? C.warn('📡') : C.warn('⏱');
+      console.log('\n  ' + ic + ' ' + C.bold(String(text).split('\n')[0]));
+      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
+      sp.start();
+    },
+    onChecklist: (itens) => { sp.stop(); console.log(_metaChecklistBox(itens) + '\n'); sp.start(); },
+    onRound: ({ n, item, attempt }) => { sp.stop(); console.log('  ' + C.indigo('◆') + ' ' + C.bold(T.meta_round(n, item.slice(0, 70), attempt))); sp.start(); },
+    onThinking: () => sp.text(T.agent_thinking),
+    onStep: ({ name, detail, blocked }) => {
+      sp.stop();
+      console.log('    ' + (blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙')) + ' ' + name + (detail ? C.dim(' · ' + detail) : ''));
+      sp.start();
+    },
+    askApprove: async (cmd) => { sp.stop(); const a = String(await ui.ask(C.err('▲ ') + T.agent_approve(C.bold(cmd)))).trim().toLowerCase(); sp.start(); return ['s', 'sim', 'y', 'yes'].includes(a); },
+    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;
+      console.log('    ' + C.dim(T.meta_progress(d, checklist.length, spent, budget)) + '\n');
+      sp.text(T.meta_marking).start();
+    },
+  });
+  sp.stop();
+  if (!st) { console.error(ui.infoLine(T.meta_none)); process.exit(2); }
+
+  const done = st.checklist.filter(i => i.passes).length;
+  const blocked = st.checklist.filter(i => i.blocked && !i.passes);
+  const secs = ((Date.now() - t0) / 1000 / 60).toFixed(1).replace('.', ',');
+  console.log('\n' + _metaChecklistBox(st.checklist));
+  if (JSON_OUT) { console.log(JSON.stringify(st)); }
+  if (st.status === 'done') {
+    console.log(ui.okLine(C.bold(T.meta_done) + C.dim(` · ${st.rounds.length} rodada(s) · ${st.creditsSpent} créditos · ${secs} min` + (st.escalations ? ` · ${st.escalations} escalonamento(s)` : ''))));
+    metaMod.notify(token, T.meta_notify_done(st.goal, done, st.creditsSpent));
+  } else if (st.pause_reason === 'awaiting_human' && st.humanRequest) {
+    console.log(ui.infoLine(C.bold('🙋 Preciso de você: ') + st.humanRequest.motivo));
+    console.log('  ' + C.dim(st.humanRequest.o_que_fazer));
+    console.log('  ' + C.dim('Quando terminar, rode "ts meta" pra continuar de onde parou.'));
+  } else if (st.pause_reason === 'stagnated') {
+    console.log(ui.errLine(C.bold('Missão travada sem progresso — parei pra não desperdiçar créditos.') + C.dim(` (${st.escalations || 0} escalonamento(s) tentado(s))`)));
+    console.log('  ' + C.dim('Resolva o bloqueio manualmente e rode "ts meta", ou ajuste o objetivo com --novo.'));
+  } else if (st.pause_reason === 'timeout') {
+    console.log(ui.infoLine('Tempo limite atingido. Retome com "ts meta".'));
+  } else {
+    console.log(ui.infoLine(st.pause_reason === 'budget' ? T.meta_paused_budget : T.meta_paused_rounds));
+    metaMod.notify(token, T.meta_notify_paused(st.goal, done, st.checklist.length, st.pause_reason));
+  }
+  if (blocked.length) {
+    console.log('  ' + C.err(T.meta_blocked));
+    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);
+}
+
+// ── Uso / conta / idioma ─────────────────────────────────────────────────────
+async function uso() {
+  const token = needToken();
+  const r = await api('/api/credits', { token });
+  if (JSON_OUT) { console.log(JSON.stringify(r)); return; }
+  const unlimited = r.unlimited || (r.granted < 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}`)
+      : ui.bar((r.used || 0) / Math.max(1, r.granted || 1)) + `  ${C.bold(r.remaining ?? '?')} ${C.dim(`/ ${r.granted} ${T.uso_remaining}`)}`,
+  ];
+  const ledger = (r.ledger || []).slice(0, 5);
+  if (ledger.length) {
+    lines.push('', C.dim(T.uso_last + ':'));
+    for (const l of ledger) lines.push(C.dim(`  -${l.credits || 0}`.padEnd(8) + String(l.reason || '').padEnd(20) + ' ' + String(l.model || '').slice(0, 26)));
+  }
+  console.log('\n' + ui.box(lines, { title: T.uso_title }) + '\n');
+}
+
+async function quem() {
+  const token = needToken();
+  let ok = false;
+  try { const chk = await api('/api/auth/check', { token }); ok = !!(chk && (chk.success || chk.authenticated)); } catch (_) {}
+  console.log('\n' + ui.box([
+    C.dim(T.quem_user + ': ') + C.bold(cfg.username || '?') + (ok ? '  ' + C.ok('•') : '  ' + C.err('• offline')),
+    C.dim(T.quem_plan + ': ') + (cfg.plan || '?'),
+    C.dim(T.quem_server + ': ') + base(),
+    C.dim(T.quem_conv + ': ') + (cfg.convId ? '#' + cfg.convId : '—'),
+  ], { title: T.quem_title }) + '\n');
+}
+
+function idioma(l) {
+  const lang = String(l || '').toLowerCase();
+  if (!['pt', 'en'].includes(lang)) { console.error(ui.infoLine(T.lang_invalid)); process.exit(2); }
+  cfg = config.save({ lang });
+  T = t(lang);
+  console.log(ui.okLine(T.lang_set(lang)));
+}
+
+async function nova() {
+  const token = needToken();
+  const r = await api('/api/conversations', { method: 'POST', token, body: { title: 'CLI' } });
+  cfg = config.save({ convId: r.id });
+  console.log(ui.okLine(T.new_conv));
+}
+
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+(async () => {
+  const cmd = (POS[0] || '').toLowerCase();
+  if (FLAGS.has('--version') || FLAGS.has('-v') || cmd === 'versao' || cmd === 'version') {
+    console.log(`ts ${pkg.version}`); return;
+  }
+  if (FLAGS.has('--help') || FLAGS.has('-h') || cmd === 'ajuda' || cmd === 'help') return help();
+  switch (cmd) {
+    case 'login':  return login();
+    case 'logout': return logout();
+    case 'chat': case 'conversa': return chatRepl();
+    case 'quem': case 'whoami': return quem();
+    case 'nova': case 'new':    return nova();
+    case 'run':    return runCmd(POS.slice(1));
+    case 'agente': case 'agent': return agentCmd(POS.slice(1));
+    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));
+    case 'desfazer': case 'undo': return desfazerCmd(POS.slice(1));
+    case 'init': case 'iniciar': return initCmd();
+    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 'acp': return acpCmd();
+    case 'skills': case 'skill': return skillsCmd(POS.slice(1));
+    case 'memoria': case 'memória': case 'memory': return memoriaCmd(POS.slice(1));
+    case 'vps': case 'servidor': return vpsCmd(POS.slice(1));
+    case 'meta': case 'missao': case 'mission': return metaCmd();
+    case 'runs':   return runsCmd();
+    case 'status': return statusCmd(POS[1]);
+    case 'uso': case 'usage':   return uso();
+    case 'idioma': case 'lang': return idioma(POS[1]);
+    case '': {
+      // ts puro: pipe → analisa; terminal → MODO CONVERSA (linguagem natural é o padrão)
+      if (!process.stdin.isTTY) return chat('');
+      if (!cfg.token) return help(); // sem login ainda: apresenta o CLI primeiro
+      return chatRepl();
+    }
+    default: {
+      // one-shot em TTY também passa pelo roteador ("ts crie um arquivo..." age);
+      // pipe/--json ficam determinísticos no chat (scripts não levam surpresa)
+      const text = POS.join(' ');
+      if (process.stdin.isTTY && !JSON_OUT && cfg.token) {
+        const r = await router.route(text, cfg.token);
+        if (r.dest === 'agente') { console.log('  ' + C.cyan('⚙') + ' ' + C.dim(T.route_agent)); return agentCmd([text]); }
+        if (r.dest === 'run') { console.log('  ' + C.indigo('◆') + ' ' + C.dim(T.route_run)); return runCmd([text]); }
+      }
+      return chat(text);
+    }
+  }
+})().then(
+  // Encerramento limpo: se o agente/meta abriu uma conexão SSH (conectar_vps),
+  // ela mantém o event loop VIVO e o processo NÃO sai (o `ts` fica pendurado
+  // depois de imprimir o resultado). Fechar o socket deixa o Node drenar e sair
+  // sozinho — sem process.exit forçado, então o stdout termina de descarregar.
+  () => { try { require('../lib/ssh').disconnect(); } catch (_) {} },
+  (e) => { try { require('../lib/ssh').disconnect(); } catch (_) {} fail(e); }
+);