terminal-smart-cli 0.76.0 → 0.78.0

package/bin/ts.js

@@ -37,10 +37,12 @@ function fmtK(n) { return n >= 1000 ? (n / 1000).toFixed(1) + 'k' : String(n); }
 // 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 } = {}) {
+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] ');
@@ -61,7 +63,7 @@ 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 }) : askLabelApprove(cmd, { en });
+  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 = '    ') {
@@ -1802,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) {

package/lib/agent.js

@@ -63,6 +63,11 @@ 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.
+- NÃO DESISTA sem TENTAR: é PROIBIDO responder "não tenho acesso" / "não consigo" / "preciso que você me passe X" enquanto houver uma ferramenta que você ainda não usou pra tentar. Antes de declarar que algo é impossível, AJA: conecte (conectar_vps), procure (buscar_arquivos, ou grep/find via executar_comando/executar_remoto), leia (ler_arquivo). Ex.: pediram pra ler um código-fonte que "você não tem"? Se há uma VPS/pasta onde ele pode estar, CONECTE e procure (grep -rn "<símbolo>" <dir>) ANTES de dizer que não tem. Só afirme que não conseguiu DEPOIS de ter tentado de fato e mostre o erro/saída REAL que te barrou.
+- 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 +85,11 @@ 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.
+- DON'T GIVE UP without TRYING: it is FORBIDDEN to answer "I don't have access" / "I can't" / "I need you to give me X" while there's a tool you haven't used yet to try. Before declaring something impossible, ACT: connect (conectar_vps), search (buscar_arquivos, or grep/find via executar_comando/executar_remoto), read (ler_arquivo). E.g. asked to read source code you "don't have"? If there's a VPS/folder where it might live, CONNECT and search (grep -rn "<symbol>" <dir>) BEFORE saying you don't have it. Only claim you couldn't do it AFTER actually trying, and show the REAL error/output that blocked you.
+- 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}`
@@ -505,8 +515,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
@@ -550,7 +560,9 @@ async function run(task, opts = {}) {
           }
         } else if (!yes) {
           // Passa payload ESTRUTURADO → a UI mostra um RESUMO curto (não o heredoc inteiro).
-          const dec = await askApprove({ kind: 'destructive', cmd: String(input.comando || '') });
+          // 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));

package/lib/core.js

@@ -20,9 +20,29 @@
 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,
@@ -146,6 +166,7 @@ function classifyToolResult(raw) {
 
 module.exports = {
   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/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/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.76.0",
+  "version": "0.78.0",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"