terminal-smart-cli 0.75.0 → 0.77.0

package/bin/ts.js

@@ -19,12 +19,56 @@ 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');
+// --yolo / --full-auto: modo FULL-AUTO (autoridade total) — aprova TUDO nesta sessão, inclusive
+// destrutivos, sem perguntar. NÃO reusa --auto (já é "noturno" no meta e "detectar stack" no init).
+// O gate anti-catástrofe de AUTO-destrutivos (rm -rf ~, mexer em ~/.ts…) segue RECUSANDO na hora
+// mesmo aqui: full-auto não abre mão da proteção que mataria a própria máquina/missão.
+const YOLO = FLAGS.has('--yolo') || FLAGS.has('--full-auto');
 
 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); }
+
+// ── APROVAÇÃO DE PASSO (UX) ──────────────────────────────────────────────────
+// askDestructive: prompt de comando DESTRUTIVO. Mostra um RESUMO curto em AMARELO (destaque,
+// não vermelho = não é erro) — a 1ª linha do comando + quantas linhas ficam escondidas (num
+// heredoc SQL a 1ª linha é o comando externo, ex "mysql -u root pw <<'SQL'"). Aceita:
+//   s/N = sim/não neste passo · a = aprovar TUDO na sessão (full-auto) · v = ver o comando inteiro
+// Retorna true | false | 'all'.
+async function askDestructive(cmd, { en = false, warning = null } = {}) {
+  const raw = String(cmd || '');
+  const { shown, hidden } = ui.cmdSummary(raw);
+  const more = hidden > 0 ? C.dim(`  … +${hidden} ${en ? 'lines' : 'linhas'}`) : '';
+  // efeito colateral GLOBAL (ex: ALTER USER root quebra o sudo mysql): avisa UMA vez, antes do prompt.
+  if (warning) console.log(C.warn('  ⚠ ' + (en ? 'side effect: ' : 'efeito colateral: ')) + C.dim(warning));
+  for (;;) {
+    const q = C.warn('  ▲ ' + (en ? 'destructive: ' : 'destrutivo: ')) + C.bold(shown) + more
+      + C.dim(en ? '  [y/N · a=all · v=view] ' : '  [s/N · a=tudo · v=ver] ');
+    const a = String(await ui.ask(q)).trim().toLowerCase();
+    if (['v', 'ver', 'view'].includes(a)) { console.log('\n' + raw.split('\n').map(l => '    ' + C.dim(l)).join('\n') + '\n'); continue; }
+    if (['a', 'all', 'tudo'].includes(a)) return 'all';
+    return ['s', 'sim', 'y', 'yes'].includes(a);
+  }
+}
+// askLabelApprove: aprovação de um LABEL já formatado (skill/MCP, não é comando cru). s/N + a=tudo.
+async function askLabelApprove(label, { en = false } = {}) {
+  const a = String(await ui.ask(C.warn('▲ ') + T.agent_approve(C.bold(label)) + C.dim(en ? '(a=all) ' : '(a=tudo) '))).trim().toLowerCase();
+  if (['a', 'all', 'tudo'].includes(a)) return 'all';
+  return ['s', 'sim', 'y', 'yes'].includes(a);
+}
+// Roteia o payload do askApprove do agente (obj destrutivo → resumo; string label → skill/MCP).
+async function askApproveRoute(payload) {
+  const en = cfg.lang === 'en';
+  const isObj = payload && typeof payload === 'object';
+  const cmd = isObj ? payload.cmd : String(payload);
+  return (isObj && payload.kind === 'destructive') ? askDestructive(cmd, { en, warning: payload.warning }) : askLabelApprove(cmd, { en });
+}
+// Linha de STATUS por etapa (✓ verde / ✗ vermelho) sob a linha ⚙, com recuo `pad`.
+function stepDoneLine({ ok, evidence }, pad = '    ') {
+  return pad + (ok ? C.ok('✓') : C.err('✗')) + (evidence ? ' ' + C.dim(String(evidence).slice(0, 80)) : C.dim(ok ? ' ok' : ' erro'));
+}
 function needToken() {
   if (cfg.token) return cfg.token;
   console.error(ui.errLine(T.need_login));
@@ -824,22 +868,28 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null } = {})
   let out;
   try {
     out = await agent.run(task, {
-      token, lang: cfg.lang || 'pt', yes: YES, model, priorMessages, cwd: startCwd, readOnly, plan, browser: useBrowser,
+      token, lang: cfg.lang || 'pt', yes: YES, autoAll: YOLO, model, priorMessages, cwd: startCwd, readOnly, plan, browser: useBrowser,
       onThinking: () => sp.text(T.agent_thinking),
-      onStep: ({ name, detail, blocked, loop, retry }) => {
-        if (streamJson) { _emit(core.AgentEvents.tool({ subtype: retry ? 'retry' : loop ? 'loop' : blocked ? 'blocked' : 'started', tool: name, detail: detail || '' })); return; }
+      onStep: ({ name, detail, blocked, loop, retry, auto }) => {
+        if (streamJson) { _emit(core.AgentEvents.tool({ subtype: retry ? 'retry' : loop ? 'loop' : blocked ? 'blocked' : auto ? 'auto_approved' : 'started', tool: name, detail: detail || '' })); return; }
         sp.stop();
-        const tag = retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙');
+        const tag = auto ? C.warn('▲ auto') : retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙');
         console.log('  ' + tag + ' ' + C.bold(name) + (detail ? C.dim(' · ' + detail) : ''));
         sp.start();
       },
-      askApprove: async (cmd) => {
+      onStepDone: (e) => {
+        if (streamJson) return; // o evento 'result' já cobre; aqui é só a UI bonita
+        sp.stop();
+        console.log(stepDoneLine(e, '    '));
+        sp.start();
+      },
+      askApprove: async (payload) => {
         // headless (stream-json): não dá pra perguntar → NEGA o destrutivo e sinaliza o evento.
-        if (streamJson) { _emit(core.AgentEvents.tool({ subtype: 'approval_denied', reason: 'headless (--stream-json): destructive command not auto-approved', command: cmd })); return false; }
+        if (streamJson) { const cmd = payload && typeof payload === 'object' ? payload.cmd : payload; _emit(core.AgentEvents.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();
+        const r = await askApproveRoute(payload);
         sp.start();
-        return ['s', 'sim', 'y', 'yes'].includes(ans);
+        return r;
       },
       onRemote: ({ ttl }) => {
         if (streamJson) { _emit(core.AgentEvents.tool({ subtype: 'approval_remote', ttl: ttl || 120 })); return; }
@@ -1276,7 +1326,7 @@ async function metaCmd() {
     const goalArg = janela === 1 ? (goal || null) : null; // janelas seguintes só retomam
     try {
       st = await metaMod.run(goalArg, {
-        token, lang: cfg.lang || 'pt', yes, budget, maxRounds, dir, model: forcedModel, thinker, maxMinutes, designer, design, eye, visualLadder, mockup, arch, criteria, prove,
+        token, lang: cfg.lang || 'pt', yes, autoAll: YOLO, budget, maxRounds, dir, model: forcedModel, thinker, maxMinutes, designer, design, eye, visualLadder, mockup, arch, criteria, prove,
         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('⏱');
@@ -1290,12 +1340,13 @@ async function metaCmd() {
         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, loop, retry }) => {
+        onStep: ({ name, detail, blocked, loop, retry, auto }) => {
           sp.stop();
-          console.log('    ' + (retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙')) + ' ' + name + (detail ? C.dim(' · ' + detail) : ''));
+          console.log('    ' + (auto ? C.warn('▲ auto') : retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('⚙')) + ' ' + name + (detail ? C.dim(' · ' + detail) : ''));
           sp.start();
         },
-        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); },
+        onStepDone: (e) => { sp.stop(); console.log(stepDoneLine(e, '      ')); sp.start(); },
+        askApprove: async (payload) => { sp.stop(); const r = await askApproveRoute(payload); sp.start(); return r; },
         onRemote: ({ ttl }) => { sp.stop(); console.log('    ' + C.warn('▲') + ' ' + C.dim(T.agent_remote_wait(ttl || 120))); sp.start(); },
         onRoundDone: ({ checklist, spent }) => {
           sp.stop();
@@ -1753,7 +1804,9 @@ async function verificarCmd(args) {
   }
 
   if (!JSON_OUT) console.log('\n' + C.dim(en ? 'proving completion — ' : 'provando conclusão — ') + criteria.length + (en ? ' criterion(s)…' : ' critério(s)…'));
-  const rep = await verify.runAll(criteria, { cwd });
+  // remoteExec: liga o verificador ldd remoto à conexão SSH ativa (binário PW mora na VPS).
+  const _ssh = require('../lib/ssh');
+  const rep = await verify.runAll(criteria, { cwd, remoteExec: _ssh.isConnected() ? (cmd => _ssh.exec(cmd, { timeoutMs: 30000 })) : undefined });
   if (JSON_OUT) { console.log(JSON.stringify(rep)); process.exit(rep.allOk ? 0 : 1); }
 
   for (const r of rep.results) {
@@ -1812,8 +1865,8 @@ async function runbookCmd(args) {
       cwd: process.cwd(),
       askApprove: async (cmd) => {
         if (YES || !process.stdin.isTTY) return false; // não-interativo não aprova destrutivo
-        const a = await ui.ask(C.warn('  ▲ ' + (en ? 'destructive step: ' : 'passo destrutivo: ')) + cmd + C.dim(' [s/N] '));
-        return ['s', 'sim', 'y', 'yes'].includes(String(a).trim().toLowerCase());
+        const d = await askDestructive(String(cmd), { en }); // resumo curto + ver completo (v)
+        return d === true || d === 'all'; // runbook aprova passo-a-passo (sem sessão full-auto)
       },
       onStep: (e) => {
         if (e.phase === 'start') console.log('  ' + C.indigo('◆') + ' ' + (e.desc ? C.bold(e.desc) + C.dim(' · ') : '') + C.dim(e.cmd.slice(0, 60)));

package/lib/agent.js

@@ -63,6 +63,10 @@ REGRAS:
 - Windows: python -c multi-linha falha em silêncio — escreva um .py com escrever_arquivo e execute "python arquivo.py".
 - Se faltar dependência, instale (winget/apt/pip/npm) e prossiga.
 - LINUX/apt: NUNCA rode "apt-get install" cru. (a) Em máquina nova o unattended-upgrades segura o lock e a instalação PENDURA. (b) Install que baixa VÁRIOS pacotes (gcc, mariadb, tomcat…) leva mais de 60s e MORRE no timeout padrão → nada instala. Instale SEMPRE assim, com timeout LONGO: chame executar_comando com timeout_s: 300 e comando "sudo DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=600 install -y <pacotes>" (Lock::Timeout ESPERA o lock; noninteractive+-y evita prompts sem TTY; timeout_s:300 dá 5min pro download). PPA com "add-apt-repository -y" + "apt-get update". Se um comando de install voltar vazio/sem efeito, quase sempre foi timeout curto — refaça com timeout_s: 300.
+- FONTE AUTÊNTICA antes de improvisar: antes de GERAR do zero um arquivo estruturado (config, schema SQL, .conf, dados, manifesto), PROCURE se já existe a versão real — no projeto atual, no pack/instalação de referência que o usuário citou, ou numa instalação funcionante. Se existir, USE-A (copie/adapte o mínimo). A versão inventada de memória quase sempre sai sutilmente errada/incompleta (falta uma linha, uma procedure, um valor). Só improvise se comprovadamente não existir — e nesse caso AVISE que é uma reconstrução (pode ter erro) e peça pra validar.
+- PRIVILÉGIO MÍNIMO em infra: pra dar acesso de uma aplicação a um serviço (banco, broker), crie uma CREDENCIAL DEDICADA com o mínimo de permissão (ex: CREATE USER 'app' + GRANT só no schema necessário) e aponte a app pra ela. NUNCA altere a autenticação/config GLOBAL existente (root/admin) só pra uma app conectar — isso afeta TUDO que já usa aquele acesso (backups, outros serviços, seu próprio acesso). Se precisar MESMO mudar algo global, AVISE explicitamente o que mais será afetado e por quê.
+- NUNCA peça segredo ao usuário: jamais peça senha/chave/token/credencial no chat. Se uma operação remota (ssh/scp) falhar por autenticação, REUSE a conexão/chave que JÁ funcionou nesta sessão (mesmo host/user/chave — não reconstrua o comando do zero esquecendo o -i da chave). Se ainda assim não conectar, peça pro usuário EXECUTAR a ação — nunca entregar o segredo.
+- BINÁRIO NATIVO: ao subir/instalar um executável numa máquina, valide com file (arquitetura: 32 vs 64-bit) E ldd (as bibliotecas resolvem?) ANTES de declarar "pronto/instalado" — "está no lugar" NÃO é "roda". Se ldd mostrar "not found", instale a lib faltante e revalide.
 - Termine SEMPRE com um resumo curto: o que foi feito, resultado e caminhos de arquivos criados/alterados.
 - Responda no idioma do usuário (padrão: português do Brasil).`
     : 'You are the Terminal Smart agent running ON THIS machine via CLI, with REAL tools. Act for real — never say "I will do it" without calling the tool in the same turn, and never invent results that did not come from a tool.'
@@ -80,6 +84,10 @@ RULES:
 - Windows: multi-line python -c fails silently — write a .py with escrever_arquivo and run "python file.py".
 - If a dependency is missing, install it (winget/apt/pip/npm) and continue.
 - LINUX/apt: NEVER run a bare "apt-get install" — on a freshly-created machine unattended-upgrades holds the apt lock and the install HANGS silently (no output). ALWAYS install like this: "sudo DEBIAN_FRONTEND=noninteractive apt-get -o DPkg::Lock::Timeout=600 install -y <packages>" (the -o Lock::Timeout WAITS for the lock up to 10min instead of hanging; noninteractive+-y avoids prompts that block without a TTY). Use "add-apt-repository -y" + "apt-get update" for PPAs. A command that doesn't return in ~1min is likely stuck on the lock/prompt — don't wait forever.
+- AUTHENTIC SOURCE before improvising: before GENERATING a structured file from scratch (config, SQL schema, .conf, data, manifest), SEARCH for whether a real version already exists — in the current project, in the reference pack/install the user mentioned, or in a working install. If it exists, USE IT (copy/adapt minimally). A version invented from memory almost always comes out subtly wrong/incomplete (a missing line, a missing procedure, a wrong value). Only improvise if it truly doesn't exist — and then WARN that it's a reconstruction (may have errors) and ask to validate.
+- LEAST PRIVILEGE in infra: to give an app access to a service (DB, broker), create a DEDICATED credential with minimal permission (e.g. CREATE USER 'app' + GRANT on the needed schema only) and point the app at it. NEVER alter the existing GLOBAL auth/config (root/admin) just to make an app connect — that affects EVERYTHING already using that access (backups, other services, your own access). If you truly must change something global, explicitly WARN what else will be affected and why.
+- NEVER ask the user for a secret: never ask for a password/key/token/credential in chat. If a remote op (ssh/scp) fails on auth, REUSE the connection/key that ALREADY worked this session (same host/user/key — don't rebuild the command dropping the -i key flag). If it still won't connect, ask the user to PERFORM the action — never to hand over the secret.
+- NATIVE BINARY: when uploading/installing an executable on a machine, validate with file (architecture: 32 vs 64-bit) AND ldd (do the libraries resolve?) BEFORE declaring "done/installed" — "it's in place" is NOT "it runs". If ldd shows "not found", install the missing lib and re-validate.
 - ALWAYS end with a short summary: what was done, the result, and paths of created/changed files.
 - Answer in the user's language.`);
   const volatile = `\n\nMáquina: ${process.platform} ${os.release()} · host ${os.hostname()} · user ${os.userInfo().username}`
@@ -153,6 +161,15 @@ function loopDecision({ nSig, cycling, warnedThis, loopWarned, WARN, BREAK }) {
   return 'ok';
 }
 
+// Decisão de aprovação de passo destrutivo (PURO/testável, fonte única do mapeamento).
+// decision vem do askApprove interativo: true = aprovou este · 'all' = aprovar TUDO na sessão
+// (full-auto) · false = recusou. autoAll = a sessão já está em full-auto (aprova sem perguntar).
+function decideApproval({ autoAll, decision }) {
+  if (autoAll) return { approved: true, enableAll: true };
+  if (decision === 'all') return { approved: true, enableAll: true };
+  return { approved: decision === true, enableAll: false };
+}
+
 // SUB-AGENTE de exploração (padrão Claude Code): contexto PRÓPRIO, só-leitura, poucos passos.
 // A leitura pesada acontece AQUI e só o RESUMO volta pro agente principal → economia de contexto.
 async function _subAgent({ task, k, model, cwd, lang, onStep }) {
@@ -215,10 +232,17 @@ async function _remoteApprove(comando, token, onRemote) {
 /**
  * Roda o agente. opts:
  *  token (sessão ts) · lang · yes (auto-aprova NÃO-destrutivos; destrutivo recusa)
- *  onStep({name, detail}) — passo executado (pra UI) · askApprove(cmd) → Promise<boolean>
+ *  autoAll (FULL-AUTO: aprova TUDO na sessão, inclusive destrutivos — o gate anti-catástrofe
+ *    de AUTO-destrutivos segue recusando na hora, full-auto não abre mão dele)
+ *  onStep({name, detail, auto}) — passo iniciado (pra UI; auto=destrutivo aprovado em full-auto)
+ *  onStepDone({name, ok, status, evidence}) — passo concluído (✓/✗ por etapa)
+ *  askApprove(cmd|{kind,cmd}) → Promise<boolean|'all'>  ('all' liga o full-auto na sessão)
  */
 async function run(task, opts = {}) {
-  const { token, lang = 'pt', yes = false, model = null, confineDir = null, onStep = () => {}, askApprove = async () => false, onThinking = () => {}, onRemote = () => {} } = opts;
+  const { token, lang = 'pt', yes = false, autoAll = false, model = null, confineDir = null, onStep = () => {}, onStepDone = () => {}, askApprove = async () => false, onThinking = () => {}, onRemote = () => {} } = opts;
+  // FULL-AUTO (autoridade total): aprova destrutivos sem perguntar. Começa por --yolo/--full-auto
+  // (opts.autoAll) e pode ser LIGADO no meio da sessão quando o humano responde "a" (aprovar tudo).
+  let autoApproveDestructive = !!autoAll;
   // CWD da SESSÃO: base de todo caminho relativo e do shell. Persiste entre
   // mensagens (o chamador passa opts.cwd e lê o out.cwd de volta). Missão usa a
   // pasta confinada. É MUTÁVEL: a ferramenta mudar_diretorio e o "cd" no início
@@ -465,6 +489,7 @@ async function run(task, opts = {}) {
       const name = (tc.function && tc.function.name) || '';
       let input = {}; try { input = JSON.parse((tc.function && tc.function.arguments) || '{}'); } catch (_) {}
       let result;
+      let _ran = false; // true só quando uma ferramenta REALMENTE executou (não gate/bloqueio) → status ✓/✗
 
       // ── WATCHDOG anti-loop: mede repetição ANTES de qualquer gate/execução ──
       const _sig = loopSig(name, input);
@@ -488,8 +513,8 @@ async function run(task, opts = {}) {
         _warnedSigs.add(_sig); _loopWarned = true;
         onStep({ name, detail: argsShort(name, input), loop: true });
         result = { erro: lang !== 'en'
-          ? `LOOP DETECTADO: você já fez "${name}(${argsShort(name, input)})" ${_nSig}× e o resultado NÃO muda. PARE de repetir — mude de abordagem (outra ferramenta/estratégia) OU conclua honestamente. Repetir de novo encerra a missão.`
-          : `LOOP DETECTED: you already did "${name}(${argsShort(name, input)})" ${_nSig}× and the result is NOT changing. STOP repeating — change approach (different tool/strategy) OR conclude honestly. Repeating again ends the mission.` };
+          ? `LOOP DETECTADO: você já fez "${name}(${argsShort(name, input)})" ${_nSig}× e o resultado NÃO muda. PARE de repetir. Chutar não resolve — vá à CAUSA RAIZ: LEIA a fonte autêntica (o código-fonte que gera o erro, o .conf/manual real, o log completo) com ler_arquivo/buscar_codigo/explorar, entenda o formato exato e AÍ conserte. Se for grande demais pra este modo, diga que precisa escalar (o "ts meta" chama o modelo forte). Repetir a mesma ação de novo encerra a missão.`
+          : `LOOP DETECTED: you already did "${name}(${argsShort(name, input)})" ${_nSig}× and the result is NOT changing. STOP repeating. Guessing won't fix it — go to the ROOT CAUSE: READ the authentic source (the source code that emits the error, the real .conf/manual, the full log) with ler_arquivo/buscar_codigo/explorar, learn the exact format, THEN fix. If it's too big for this mode, say you need to escalate ("ts meta" calls the strong model). Repeating the same action again ends the mission.` };
       }
 
       // ENFORCEMENT do modo só-leitura PRIMEIRO: bloqueia ferramentas que alteram/rodam ANTES de
@@ -517,9 +542,30 @@ async function run(task, opts = {}) {
       // Interativo pergunta no terminal; em --yes (cron) tenta APROVAÇÃO REMOTA no Telegram do dono.
       if (result === undefined && (name === 'executar_comando' || name === 'executar_remoto') && tools.isDestructive(input.comando)) {
         let approved = false, remoteTried = false;
-        if (!yes) approved = await askApprove(String(input.comando || ''));
-        else ({ approved, remoteTried } = await _remoteApprove(String(input.comando || ''), token, onRemote));
-        if (!approved) {
+        if (autoApproveDestructive) {
+          // FULL-AUTO não abre mão do anti-catástrofe: os auto-destrutivos de máquina/processo/
+          // pasta já caíram no gate acima (selfDestructiveReason). O que sobra é ~/.ts por shell
+          // (bypass dos gates dedicados skill_gerenciar/hooks) — esse NUNCA é auto-aprovado nem em
+          // --yolo: exige o humano. Todo o resto: aprova sem perguntar, mas VISÍVEL (auto:true).
+          if (core.touchesTsConfig(String(input.comando || ''))) {
+            onStep({ name, detail: argsShort(name, input), blocked: true });
+            result = { erro: lang !== 'en'
+              ? 'FULL-AUTO (--yolo) NÃO auto-aprova comando que mexe em ~/.ts (skills/hooks/mcp/config do ts via shell) — isso burlaria os gates dedicados. Use a ferramenta própria (skill_gerenciar) ou rode SEM --yolo pra aprovar manualmente.'
+              : 'FULL-AUTO (--yolo) will NOT auto-approve a command that touches ~/.ts (ts skills/hooks/mcp/config via shell) — it would bypass the dedicated gates. Use the proper tool (skill_gerenciar) or run WITHOUT --yolo to approve manually.' };
+          } else {
+            approved = true;
+            onStep({ name, detail: argsShort(name, input), auto: true });
+          }
+        } else if (!yes) {
+          // Passa payload ESTRUTURADO → a UI mostra um RESUMO curto (não o heredoc inteiro).
+          // warning: aviso ESPECÍFICO de efeito colateral se o comando muda estado global (ex: ALTER USER root).
+          const _cmd = String(input.comando || '');
+          const dec = await askApprove({ kind: 'destructive', cmd: _cmd, warning: core.globalStateWarning(_cmd) });
+          const d = decideApproval({ autoAll: false, decision: dec });
+          approved = d.approved; if (d.enableAll) autoApproveDestructive = true;
+        } else ({ approved, remoteTried } = await _remoteApprove(String(input.comando || ''), token, onRemote));
+        // result === undefined evita sobrescrever a mensagem específica do bloqueio ~/.ts do full-auto
+        if (!approved && result === undefined) {
           result = { erro: yes
             ? (remoteTried
               ? 'RECUSADO: o dono NEGOU (ou não respondeu em 2 min) a aprovação remota deste comando destrutivo. Não repita; siga sem ele e relate no resumo.'
@@ -549,7 +595,8 @@ async function run(task, opts = {}) {
           const prev = input.acao === 'criar'
             ? `criar skill "${_cl(input.slug)}" — ${_cl(input.descricao || input.nome).slice(0, 120)}\n  motivo: ${_cl(input.motivo).slice(0, 200)}\n  instruções:\n  ${_full.slice(0, CAP)}${_nota}`
             : `melhorar skill "${_cl(input.slug)}"\n  motivo: ${_cl(input.motivo).slice(0, 200)}\n  trocar: ${_cl(input.buscar || (lang !== 'en' ? '(adicionar seção no fim)' : '(append section at the end)')).slice(0, 400)}\n  por: ${_full.slice(0, Math.min(CAP, 400))}${_nota}`;
-          const okS = await askApprove((lang !== 'en' ? 'O agente quer ATUALIZAR as próprias skills:\n  ' : 'The agent wants to UPDATE its own skills:\n  ') + prev);
+          const okS = autoApproveDestructive ? true : await askApprove((lang !== 'en' ? 'O agente quer ATUALIZAR as próprias skills:\n  ' : 'The agent wants to UPDATE its own skills:\n  ') + prev);
+          if (okS === 'all') autoApproveDestructive = true;
           if (!okS) {
             result = { erro: lang !== 'en'
               ? 'O usuário RECUSOU a mudança de skill. Não repita nesta sessão; siga com a tarefa normalmente.'
@@ -566,8 +613,12 @@ async function run(task, opts = {}) {
         const _js = JSON.stringify(input);
         const _lbl = 'MCP ' + _mcp.route[name].server + ' → ' + _mcp.route[name].realName + ' ' + (_js.length > 1500 ? _js.slice(0, 1500) + ' …(+' + (_js.length - 1500) + ' chars)' : _js);
         let approved = false, remoteTried = false;
-        if (!yes) approved = await askApprove(_lbl);
-        else ({ approved, remoteTried } = await _remoteApprove(_lbl, token, onRemote));
+        if (autoApproveDestructive) { approved = true; onStep({ name, detail: argsShort(name, input), auto: true }); }
+        else if (!yes) {
+          const dec = await askApprove(_lbl);
+          const d = decideApproval({ autoAll: false, decision: dec });
+          approved = d.approved; if (d.enableAll) autoApproveDestructive = true;
+        } else ({ approved, remoteTried } = await _remoteApprove(_lbl, token, onRemote));
         if (!approved) {
           result = { erro: yes
             ? (remoteTried ? 'RECUSADO: o dono NEGOU (ou não respondeu) a aprovação remota desta ferramenta MCP mutante. Não repita; siga sem ela.' : 'RECUSADO automaticamente: ferramenta MCP mutante não roda em --yes sem aprovação remota (Telegram). Siga sem ela.')
@@ -589,8 +640,9 @@ async function run(task, opts = {}) {
         // 1ª chamada a ESTE servidor na sessão pede um OK (mesmo tool de leitura): os ARGUMENTOS
         // saem da máquina pro servidor externo, e podem ter sido influenciados por prompt-injection
         // de algo que o agente leu. Em --yes (cron) o dono já pré-autorizou os servers → não pergunta.
-        if (!rt.needsApproval && !yes && !_mcpSeen.has(rt.server)) {
+        if (!rt.needsApproval && !yes && !autoApproveDestructive && !_mcpSeen.has(rt.server)) {
           const okFirst = await askApprove('1ª chamada ao servidor MCP "' + rt.server + '" (tool ' + rt.realName + '). Dados sairão pra ele. Permitir este servidor nesta sessão?');
+          if (okFirst === 'all') autoApproveDestructive = true;
           if (!okFirst) { result = { erro: 'O usuário NÃO autorizou o servidor MCP "' + rt.server + '" nesta sessão. Não use tools desse servidor; siga sem elas.' }; onStep({ name, detail: argsShort(name, input), blocked: true }); }
         }
         if (result === undefined) {
@@ -598,7 +650,7 @@ async function run(task, opts = {}) {
           onStep({ name: 'mcp:' + rt.realName, detail: rt.server });
           try { result = { resultado: await require('./mcp').callTool(rt.endpoint, rt.auth, rt.realName, input) }; }
           catch (e) { result = { erro: 'MCP falhou: ' + String((e && e.message) || e).slice(0, 200) }; }
-          steps++;
+          steps++; _ran = true;
         }
       }
       // LIMITE DE PESQUISA (convergência): conta buscar_web + navegador abrir/ler. Ao passar o
@@ -636,7 +688,7 @@ async function run(task, opts = {}) {
           }
           else result = { erro: 'acao inválida — use abrir|clicar|digitar|ler|print.' };
         } catch (e) { result = { erro: String((e && e.message) || e).slice(0, 300) }; }
-        steps++;
+        steps++; _ran = true;
       }
       // SUB-AGENTE: 'explorar' roda em contexto próprio (só-leitura) e devolve só o resumo.
       if (result === undefined && name === 'explorar') {
@@ -644,12 +696,12 @@ async function run(task, opts = {}) {
         const sub = await _subAgent({ task: input.tarefa || input.pergunta || '', k, model, cwd, lang, onStep });
         acc.inTok += sub._tin; acc.outTok += sub._tout; acc.cachedTok += sub._tcach || 0;
         result = { resumo: sub.resumo };
-        steps++;
+        steps++; _ran = true;
       }
       if (result === undefined) {
         onStep({ name, detail: argsShort(name, input) });
         result = await tools.execute(name, input, { confineDir, baseDir: cwd, token });
-        steps++;
+        steps++; _ran = true;
         // TOOLRESULT TIPADO (core.classifyToolResult): classe de erro DETERMINÍSTICA. A verdade
         // sobre "deu certo?" vem daqui, não da narrativa do modelo. 'blocked' = política (gate),
         // não falha de execução — não conta pro ledger nem pro sinal de erro da run.
@@ -681,6 +733,10 @@ async function run(task, opts = {}) {
           && _researchCalls >= Math.ceil(RESEARCH_MAX * 2 / 3) && _researchCalls <= RESEARCH_MAX) {
         result = Object.assign({}, result, { _aviso: 'Você já pesquisou ' + _researchCalls + 'x (limite ' + RESEARCH_MAX + '). Se já tem o suficiente, PARE de pesquisar e ENTREGUE o resultado agora.' });
       }
+      // STATUS POR ETAPA (UX): ✓ verde / ✗ vermelho por passo, a partir do ToolResult TIPADO
+      // (core.classifyToolResult) — o usuário vê na hora o que deu certo/errado (antes as ⚙
+      // não indicavam resultado nenhum). Só para passos que REALMENTE rodaram (não gate/bloqueio).
+      if (_ran) { const _c = core.classifyToolResult(result); onStepDone({ name, ok: _c.ok, status: _c.status, evidence: _c.evidence }); }
       // BLOQUEIO HUMANO: o agente pediu uma ação externa que só o usuário faz →
       // encerra o turno devolvendo o pedido; a missão pausa e chama o usuário.
       if (result && result._needHuman) {
@@ -731,4 +787,4 @@ async function run(task, opts = {}) {
   return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, toolErrors: _toolErrs, lastToolError: _lastErr };
 }
 
-module.exports = { run, llm, _test: { winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision } };
+module.exports = { run, llm, _test: { winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval } };

package/lib/core.js

@@ -12,9 +12,37 @@
 // — só funções puras e constantes, pra ser importável por qualquer superfície e testável.
 
 // ── 1) GATE DE DESTRUTIVO ─────────────────────────────────────────────────────
+// ~/.ts = config do agente (skills viram INSTRUÇÕES futuras; hooks executam comandos;
+// mcp.json guarda auth). Tocar nisso por shell burlaria os gates dedicados
+// (skill_gerenciar/lembrar) → prompt-injection persistente. Exige a barra antes de ".ts/"
+// — não casa arquivos TypeScript (utils.ts). É o subconjunto "endurecido" do gate destrutivo:
+// o ÚNICO destrutivo que o FULL-AUTO (--yolo) NÃO libera sozinho — sempre exige o humano.
+const TS_CONFIG_RE = /[\\\/]\.ts[\\\/](skills|skills-pending|hooks|mcp|config)/i;
+function touchesTsConfig(cmd) { return TS_CONFIG_RE.test(String(cmd || '')); }
+
+// Comandos que mudam ESTADO GLOBAL de um serviço/host: o efeito colateral vai ALÉM do que o
+// usuário pediu. Cada um traz um AVISO ESPECÍFICO (não "destrutivo" genérico) pra a aprovação.
+// Nasceu de um ALTER USER root que fez uma app conectar MAS quebrou o `sudo mysql` sem senha.
+const GLOBAL_STATE = [
+  [/\bALTER\s+USER\b[^;]*IDENTIFIED\s+BY\b/i, 'muda a senha/auth de um usuário do banco — quebra TUDO que já conecta com ele (backups, sudo mysql, outros serviços). O certo é criar um usuário DEDICADO (CREATE USER + GRANT no schema) em vez de mexer no root.'],
+  [/\b(SET\s+PASSWORD|GRANT\s+ALL\s+PRIVILEGES)\b/i, 'muda credencial/privilégio GLOBAL do banco — afeta tudo que usa esse acesso.'],
+  [/\bDROP\s+USER\b/i, 'remove um usuário do banco — quebra tudo que autentica com ele.'],
+  [/\/etc\/ssh\/sshd_config/i, 'edita a config do SSH do host — pode te TRANCAR pra fora (porta/auth). Faça backup e não reinicie o sshd sem confirmar que ainda entra.'],
+  [/\b(ufw|iptables)\b[^\n]*(-F|flush|reset|\bdeny\b|\bDROP\b)/i, 'mexe no firewall do host — pode cortar seu PRÓPRIO acesso SSH.'],
+  [/\busermod\b|\/etc\/sudoers|\bvisudo\b/i, 'muda usuários/sudoers do sistema — efeito global de permissão.'],
+  [/\bchmod\b[^\n]*\/etc\b|\bchown\b[^\n]*\/etc\b/i, 'muda permissão/dono em /etc — config global do sistema.'],
+];
+// aviso específico do efeito colateral, ou null se o comando não mexe em estado global.
+function globalStateWarning(cmd) {
+  const s = String(cmd || '');
+  for (const [re, msg] of GLOBAL_STATE) if (re.test(s)) return msg;
+  return null;
+}
+
 // Padrões de comando destrutivo/irreversível — SEMPRE pedem aprovação humana.
 // (fonte única: antes vivia em tools.js; App e Web tinham cópias divergentes.)
 const DESTRUCTIVE = [
+  ...GLOBAL_STATE.map(g => g[0]), // mudanças de estado global também passam pela aprovação
   /\brm\s+(-[a-z]*[rf][a-z]*\s+)/i, /\brm\s+.*\*/, /\brmdir\b/i, /\bdel\s+\/[sq]/i, /\brd\s+\/s/i,
   /\bmkfs\b/i, /\bdd\s+if=/i, /(?:^|[\s&;|])format\s+[a-z]:/i, /\bdiskpart\b/i, /> ?\/dev\/sd/i,
   /\bshutdown\b/i, /\breboot\b/i, /\bhalt\b/i, /\bpoweroff\b/i,
@@ -25,11 +53,7 @@ const DESTRUCTIVE = [
   /\btaskkill\b.*\/im\b/i, /\btaskkill\b.*\/f\b.*\/im/i, // taskkill /IM mata TODOS os processos daquele nome (ex: node.exe = a própria missão)
   /\bStop-Process\b[^|;&]*-Name\b/i, /\bGet-Process\b[^|]*\|[^|]*\bStop-Process\b/i, // PowerShell: matar por NOME mata todos (=taskkill /IM); Stop-Process -Id <pid> segue liberado
   /\bsystemctl\s+(stop|disable|mask)\b/i, /\bdocker\s+(rm|rmi|system\s+prune|volume\s+rm)\b/i,
-  // ~/.ts = config do agente (skills viram INSTRUÇÕES futuras; hooks executam comandos;
-  // mcp.json guarda auth). Tocar nisso por shell burlaria os gates dedicados
-  // (skill_gerenciar/lembrar) → prompt-injection persistente. Sempre pede aprovação.
-  // Exige a barra antes de ".ts/" — não casa arquivos TypeScript (utils.ts).
-  /[\\\/]\.ts[\\\/](skills|skills-pending|hooks|mcp|config)/i,
+  TS_CONFIG_RE, // ~/.ts por shell = bypass dos gates dedicados (ver comentário acima)
 ];
 function isDestructive(cmd) { return DESTRUCTIVE.some(re => re.test(String(cmd || ''))); }
 
@@ -141,7 +165,8 @@ function classifyToolResult(raw) {
 }
 
 module.exports = {
-  DESTRUCTIVE, isDestructive,
+  DESTRUCTIVE, isDestructive, touchesTsConfig,
+  GLOBAL_STATE, globalStateWarning,
   MODEL_WINDOWS, CTX_WINDOW_DEFAULT, DEFAULT_EXECUTOR, COMPACT_AT, KEEP_TAIL, winFor, estMsgsTok,
   AgentEvents, EVENT_TYPES,
   ERROR_CLASSES, RETRYABLE_CLASSES, classifyError, classifyToolResult,

package/lib/i18n.js

@@ -41,6 +41,7 @@ const STR = {
         ['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'],
+        ['ts agente "..." --yolo', 'FULL-AUTO: aprova TUDO na sessão, inclusive destrutivos (o gate anti-catástrofe ~/.ts/máquina segue ativo)'],
         ['ts agente "..." --navegador', 'EXPERIMENTAL: dá um Chrome real ao agente (abrir/ler/clicar/print+visão)'],
         ['ts meta "objetivo grande"', 'MISSÃO: checklist + rodadas até terminar (noturno)'],
         ['ts meta "..." --criterios prova.json', 'só declara "verificada" se os critérios executáveis (verify) passarem de verdade'],
@@ -197,6 +198,7 @@ const STR = {
         ['ts agente "task"', 'actually does it here: commands, files, diagnosis'],
         ['ts agente "..." --yes', 'autonomous (destructive asks on Telegram)'],
         ['ts agente --continuar "..."', 'resume this folder\'s previous work'],
+        ['ts agente "..." --yolo', 'FULL-AUTO: approves EVERYTHING this session, destructive included (~/.ts & machine anti-catastrophe still on)'],
         ['ts agente "..." --navegador', 'EXPERIMENTAL: gives the agent a real Chrome (open/read/click/print+vision)'],
         ['ts sentinela add "name" --cmd "..."', 'DETERMINISTIC watch (if-rule, ZERO tokens); escalates to AI only on failure'],
         ['ts sentinela instalar', 'schedule checks on the OS (cron/Task Scheduler), alert on Telegram'],

package/lib/meta.js

@@ -1028,7 +1028,7 @@ async function _checkCriteria(st, dir) {
 }
 
 async function run(goal, opts = {}) {
-  const { token, lang = 'pt', yes = false, budget = 400, maxRounds = 20, dir = process.cwd(), model = null, thinker = null, maxMinutes = 0, designer = null, design = 'auto', runGate = true, eye = null, visualLadder = true, prove = false } = opts;
+  const { token, lang = 'pt', yes = false, autoAll = false, budget = 400, maxRounds = 20, dir = process.cwd(), model = null, thinker = null, maxMinutes = 0, designer = null, design = 'auto', runGate = true, eye = null, visualLadder = true, prove = false } = opts;
   const onChecklist = opts.onChecklist || (() => {});
   const onRound = opts.onRound || (() => {});
   const onRoundDone = opts.onRoundDone || (() => {});
@@ -1320,7 +1320,7 @@ async function run(goal, opts = {}) {
     }
     let out = null, connErr = null;
     for (let att = 0; att < 3 && !out; att++) {
-      try { out = await agent.run(task, { token, lang, yes, model: roundModel, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking }); }
+      try { out = await agent.run(task, { token, lang, yes, autoAll, model: roundModel, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, onStepDone: opts.onStepDone, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking }); }
       catch (e) {
         connErr = e;
         // teto de IA estourado → PAUSA limpa e resumível com CTA de upgrade (nunca segue em silêncio)

package/lib/ssh.js

@@ -6,7 +6,8 @@ const path = require('path');
 const os = require('os');
 
 let _conn = null;       // cliente ssh2 conectado
-let _info = null;       // { host, port, user }
+let _info = null;       // { host, port, user, keyPath } — some no 'close'
+let _lastGood = null;   // ÚLTIMO login que DEU CERTO nesta sessão { host, port, user, keyPath } — SOBREVIVE à queda
 let Client = null;
 try { Client = require('ssh2').Client; } catch (_) { /* ssh2 ausente → erro amigável no connect */ }
 
@@ -47,17 +48,22 @@ function parseLoginFile(p) {
 
 function isConnected() { return !!_conn; }
 function info() { return _info; }
+// Último login que funcionou nesta sessão — pra reconectar sem o usuário reinformar host/chave,
+// e pra o agente NUNCA "esquecer" que já entrou (foi o que causou IP errado e scp sem -i).
+function lastGood() { return _lastGood; }
 
 function connect(opts = {}) {
   return new Promise((resolve, reject) => {
     if (!Client) return reject(new Error('Biblioteca ssh2 não instalada no CLI.'));
     const prof = loadProfile() || {};
-    const host = opts.host || prof.host;
-    const port = opts.port || prof.port || 22;
-    const user = opts.user || prof.user || 'root';
+    // ordem de resolução: o que foi passado agora → perfil salvo → ÚLTIMO login que deu certo nesta sessão.
+    // assim, se a conexão caiu, um conectar_vps SEM args reusa host+chave que já funcionaram (não pede nada).
+    const host = opts.host || prof.host || (_lastGood && _lastGood.host);
+    const port = opts.port || prof.port || (_lastGood && _lastGood.port) || 22;
+    const user = opts.user || prof.user || (_lastGood && _lastGood.user) || 'root';
     let password = opts.pass || prof.pass;
     let privateKey;
-    const keyPath = opts.keyPath || prof.keyPath;
+    const keyPath = opts.keyPath || prof.keyPath || (_lastGood && _lastGood.keyPath);
     if (keyPath) { try { privateKey = fs.readFileSync(keyPath); } catch (_) {} }
     if (!host) return reject(new Error('Sem host — configure com "ts vps set" ou passe --host.'));
     if (!password && !privateKey) return reject(new Error('Sem senha nem chave — configure a credencial.'));
@@ -66,7 +72,12 @@ function connect(opts = {}) {
     const c = new Client();
     const cfg = { host, port, username: user, readyTimeout: 20000, keepaliveInterval: 15000 };
     if (privateKey) cfg.privateKey = privateKey; else cfg.password = password;
-    c.on('ready', () => { _conn = c; _info = { host, port, user }; resolve({ host, port, user }); });
+    c.on('ready', () => {
+      _conn = c;
+      _info = { host, port, user, keyPath: keyPath || null };
+      _lastGood = { host, port, user, keyPath: keyPath || null }; // grava a conexão boa (sobrevive ao close)
+      resolve({ host, port, user });
+    });
     c.on('error', (e) => { _conn = null; reject(new Error('Falha ao conectar: ' + (e && e.message || e))); });
     c.on('close', () => { if (_conn === c) { _conn = null; _info = null; } });
     try { c.connect(cfg); } catch (e) { reject(e); }
@@ -90,4 +101,4 @@ function exec(cmd, { timeoutMs = 120000 } = {}) {
 
 function disconnect() { if (_conn) { try { _conn.end(); } catch (_) {} _conn = null; _info = null; return true; } return false; }
 
-module.exports = { connect, exec, disconnect, isConnected, info, loadProfile, saveProfile, parseLoginFile };
+module.exports = { connect, exec, disconnect, isConnected, info, lastGood, loadProfile, saveProfile, parseLoginFile };

package/lib/tools.js

@@ -368,8 +368,16 @@ async function execute(name, input, opts = {}) {
         try {
           const r = await ssh.connect({ host: input.host, user: input.usuario, keyPath: input.chave });
           const who = await ssh.exec('echo "$(whoami)@$(hostname) | $(. /etc/os-release 2>/dev/null; echo $PRETTY_NAME) | pwd=$(pwd)"');
-          return { conectado: true, servidor: `${r.user}@${r.host}:${r.port}`, info: (who.stdout || '').trim() };
-        } catch (e) { return { conectado: false, erro: String(e.message).slice(0, 300) + ' — configure com "ts vps set" ou passe host/usuario/chave.' }; }
+          // memoriza a conexão boa: nas próximas vezes basta executar_remoto (não reconstrua ssh/scp cru).
+          return { conectado: true, servidor: `${r.user}@${r.host}:${r.port}`, info: (who.stdout || '').trim(), memorizado: 'Conexão ativa e memorizada — use executar_remoto/enviar_arquivo (NÃO monte ssh/scp cru) e não repasse host/chave.' };
+        } catch (e) {
+          // se JÁ conectamos com sucesso nesta sessão, o certo é REUSAR (não pedir credencial ao usuário).
+          const lg = ssh.lastGood && ssh.lastGood();
+          const dica = lg
+            ? ` — mas você JÁ conectou nesta sessão em ${lg.user}@${lg.host}${lg.keyPath ? ' (chave ' + require('path').basename(lg.keyPath) + ')' : ''}. Chame conectar_vps SEM argumentos pra reusar essa conexão; NÃO peça senha ao usuário.`
+            : ' — configure com "ts vps set" ou passe host/usuario/chave.';
+          return { conectado: false, erro: String(e.message).slice(0, 300) + dica };
+        }
       }
       case 'executar_remoto': {
         const ssh = require('./ssh');

package/lib/ui.js

@@ -99,8 +99,20 @@ function ask(question) {
   });
 }
 
+// Resumo de 1 linha de um comando pro prompt de aprovação: a 1ª linha SIGNIFICATIVA (que
+// num heredoc é o comando externo, ex "mysql -u root pw <<'SQL'") + quantas linhas ficam
+// escondidas. PURO/testável — a cor e as teclas do prompt ficam no bin. Evita despejar 50+
+// linhas de um heredoc SQL antes do usuário decidir.
+function cmdSummary(cmd, max = 72) {
+  const raw = String(cmd == null ? '' : cmd);
+  const lines = raw.split('\n');
+  const first = (lines.find(l => l.trim()) || raw).trim();
+  const shown = first.length > max ? first.slice(0, max - 1) + '…' : first;
+  return { shown, hidden: Math.max(0, lines.length - 1), lines: lines.length };
+}
+
 const okLine  = (s) => '  ' + C.ok('✔') + ' ' + s;
 const errLine = (s) => '  ' + C.err('✖') + ' ' + s;
 const infoLine = (s) => '  ' + C.cyan('⌁') + ' ' + s;
 
-module.exports = { C, TTY, gradient, banner, box, spinner, md, bar, ask, okLine, errLine, infoLine };
+module.exports = { C, TTY, gradient, banner, box, spinner, md, bar, ask, cmdSummary, okLine, errLine, infoLine };

package/lib/verify.js

@@ -61,6 +61,35 @@ function vPort(c) {
   });
 }
 
+// Analisa a saída de `ldd`: quais libs NÃO resolvem. Separado pra ser testável sem ldd real.
+// "arquivo está no lugar" ≠ "roda": foi o buraco do deploy que só checou `file` (arquitetura).
+function _analyzeLdd(out) {
+  const s = String(out || '');
+  if (/not a dynamic executable|não é um executável dinâmico|statically linked/i.test(s)) return { ok: true, missing: [], detail: 'binário estático (sem deps dinâmicas)' };
+  const missing = (s.match(/^\s*(\S+)\s*=>\s*not found/gim) || []).map(l => l.trim().split(/\s+/)[0]);
+  if (missing.length) return { ok: false, missing, detail: 'libs faltando: ' + missing.join(', ') };
+  if (/=>/.test(s)) return { ok: true, missing: [], detail: 'todas as libs resolvem' };
+  return { ok: false, missing: [], detail: 'ldd sem saída válida (arquivo existe? é ELF?)' };
+}
+// opts.remoteExec(cmd) → Promise<{stdout,stderr}> é INJETADO por quem chama (bin/ts.js liga ao ssh),
+// pra o verify.js seguir portável (só núcleo+builtins). Sem ele, ldd remoto avisa em vez de importar ssh.
+async function vLdd(c, cwd, opts = {}) {
+  const target = c.remote ? String(c.path) : _abs(cwd, c.path);
+  const cmd = 'ldd ' + JSON.stringify(target);
+  let out = '';
+  try {
+    if (c.remote) {
+      if (typeof opts.remoteExec !== 'function') return { ok: false, detail: 'binário remoto mas sem executor SSH ligado — conecte a VPS antes', errorClass: 'network' };
+      const r = await opts.remoteExec(cmd);
+      out = (r.stdout || '') + (r.stderr || '');
+    } else {
+      out = execSync(cmd, { cwd, encoding: 'utf8', timeout: 30000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    }
+  } catch (e) { out = String(e.stdout || '') + String(e.stderr || e.message || ''); }
+  const a = _analyzeLdd(out);
+  return { ok: a.ok, detail: a.detail, errorClass: a.ok ? null : 'missing_dep', evidence: String(out).slice(0, 200).replace(/\s+/g, ' ') };
+}
+
 const VERIFIERS = {
   command: (c, cwd) => vCommand(c, cwd),
   file_exists: (c, cwd) => vFileExists(c, cwd),
@@ -68,6 +97,7 @@ const VERIFIERS = {
   file_contains: (c, cwd) => vFileContains(c, cwd),
   http: (c) => vHttp(c),
   port: (c) => vPort(c),
+  ldd: (c, cwd, opts) => vLdd(c, cwd, opts),
 };
 const VERIFIER_TYPES = Object.keys(VERIFIERS);
 
@@ -77,7 +107,7 @@ async function runCriterion(c, opts = {}) {
   const type = c && c.type;
   const fn = VERIFIERS[type];
   if (!fn) return { ok: false, type: type || '?', detail: 'tipo de critério desconhecido: ' + type, unknown: true };
-  try { const r = await fn(c, cwd); return Object.assign({ type, label: c.label || _labelFor(c) }, r); }
+  try { const r = await fn(c, cwd, opts); return Object.assign({ type, label: c.label || _labelFor(c) }, r); }
   catch (e) { return { ok: false, type, label: c.label || _labelFor(c), detail: 'erro no verificador: ' + (e.message || e) }; }
 }
 function _labelFor(c) {
@@ -88,6 +118,7 @@ function _labelFor(c) {
     case 'file_contains': return c.path + (c.absent ? ' SEM ' : ' contém ') + '"' + String(c.text).slice(0, 30) + '"';
     case 'http': return (c.method || 'GET') + ' ' + c.url + ' → ' + (c.status || 200);
     case 'port': return 'porta ' + c.port + ' escutando';
+    case 'ldd': return 'libs de ' + c.path + ' resolvem' + (c.remote ? ' (VPS)' : '');
     default: return c.type || '?';
   }
 }
@@ -104,7 +135,7 @@ async function runAll(criteria, opts = {}) {
 // ── COMPILADOR de critérios (TaskSpec): o LLM/usuário PROPÕE, o harness VALIDA ────
 // Aceita só tipos conhecidos com os campos obrigatórios preenchidos; descarta o resto
 // (o modelo não impõe critério malformado). Determinístico. Retorna { criteria, dropped }.
-const _REQUIRED = { command: ['cmd'], file_exists: ['path'], file_absent: ['path'], file_contains: ['path', 'text'], http: ['url'], port: ['port'] };
+const _REQUIRED = { command: ['cmd'], file_exists: ['path'], file_absent: ['path'], file_contains: ['path', 'text'], http: ['url'], port: ['port'], ldd: ['path'] };
 function compileCriteria(raw) {
   const list = Array.isArray(raw) ? raw : (raw && Array.isArray(raw.criteria) ? raw.criteria : []);
   const criteria = [], dropped = [];
@@ -113,7 +144,7 @@ function compileCriteria(raw) {
     const missing = _REQUIRED[c.type].some(k => c[k] === undefined || c[k] === null || c[k] === '');
     if (missing) { dropped.push(c); continue; }
     const clean = { type: c.type };
-    for (const k of ['cmd', 'exit', 'path', 'text', 'regex', 'flags', 'absent', 'url', 'method', 'status', 'contains', 'port', 'host', 'timeout_s', 'label']) if (c[k] !== undefined) clean[k] = c[k];
+    for (const k of ['cmd', 'exit', 'path', 'text', 'regex', 'flags', 'absent', 'url', 'method', 'status', 'contains', 'port', 'host', 'remote', 'timeout_s', 'label']) if (c[k] !== undefined) clean[k] = c[k];
     criteria.push(clean);
   }
   return { criteria, dropped };
@@ -128,4 +159,4 @@ function deriveFromStack(cwd) {
   return out;
 }
 
-module.exports = { runCriterion, runAll, compileCriteria, deriveFromStack, VERIFIERS, VERIFIER_TYPES, _labelFor };
+module.exports = { runCriterion, runAll, compileCriteria, deriveFromStack, VERIFIERS, VERIFIER_TYPES, _labelFor, _analyzeLdd };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.75.0",
+  "version": "0.77.0",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"