terminal-smart-cli 0.39.0 → 0.40.0

package/bin/ts.js

@@ -1149,7 +1149,7 @@ async function metaCmd() {
   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; }
+    if (a.startsWith('-')) { if (['--budget', '--rodadas', '--rounds', '--modelo', '--model', '--pensador', '--thinker', '--maxmin', '--designer', '--design', '--olho', '--eye', '--mockup', '--arquivo', '--file', '-f', '--budget-total', '--max-janelas', '--max-windows', '--max-horas', '--intervalo'].includes(a)) i++; continue; }
     parts.push(a);
   }
   // objetivo pode vir de um ARQUIVO (--arquivo/-f caminho.txt) — evita a dor de passar
@@ -1170,6 +1170,15 @@ async function metaCmd() {
   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)
+  // ── MODO NOTURNO (auto-continuação por orçamento): retoma sozinho quando o teto
+  // de crédito da janela estoura, até a missão terminar OU bater um teto TOTAL. ──
+  const noturno = FLAGS.has('--noturno') || FLAGS.has('--auto');
+  const budgetTotal = flagNum('--budget-total', 0); // teto TOTAL de créditos (0 = sem teto)
+  const maxJanelas = flagNum('--max-janelas', flagNum('--max-windows', 0)); // nº máx. de janelas (0 = sem teto)
+  const maxHoras = flagNum('--max-horas', 0); // teto de horas de parede (0 = sem teto)
+  const intervaloMin = flagNum('--intervalo', 5); // min de espera entre janelas ao aguardar crédito
+  // Anti-loop-infinito: se ninguém definiu teto, cai num limite de janelas seguro.
+  const maxJanelasEff = maxJanelas || ((budgetTotal || maxHoras) ? 0 : 20);
 
   const existing = metaMod.load(dir);
   if (FLAGS.has('--status')) {
@@ -1190,40 +1199,95 @@ async function metaCmd() {
     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 }) => {
+  if (noturno) {
+    const lim = [];
+    if (budgetTotal) lim.push(`${budgetTotal} créditos totais`);
+    if (maxJanelasEff) lim.push(`${maxJanelasEff} janela(s)`);
+    if (maxHoras) lim.push(`${maxHoras}h`);
+    console.log('  ' + C.warn('🌙') + ' ' + C.dim('modo noturno LIGADO — retomo sozinho ao esgotar crédito' + (lim.length ? ' · teto: ' + lim.join(', ') : '') + ` · intervalo ${intervaloMin} min`) + '\n');
+  }
+
+  // ── LOOP DE JANELAS (modo noturno) ─────────────────────────────────────────
+  // Sem --noturno, o for roda UMA vez e sai (comportamento idêntico ao de hoje).
+  // Com --noturno, quando a run PAUSA por falta de crédito, esperamos o intervalo
+  // e RE-INVOCAMOS run() — que retoma sozinho do .ts-meta.json — até concluir ou
+  // bater um teto (créditos totais / janelas / horas / travamento sem progresso).
+  const RETOMAVEL = new Set(['no_credits', 'budget', 'connection']); // pausas que valem re-tentar
+  const _sleep = (ms) => new Promise(r => setTimeout(r, ms));
+  let st = null, janela = 0, prevPend = null, semProgresso = 0;
+  const loopStart = Date.now();
+  for (;;) {
+    janela++;
+    const sp = ui.spinner(T.meta_planning).start();
+    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,
+        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();
+        },
+      });
+    } catch (e) {
       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();
+      // run() pode ESTOURAR o teto durante as fases pré-rodada (viabilidade/design/arquitetura),
+      // ANTES de salvar o estado como "paused". Tratamos igual a uma pausa por crédito.
+      if (e && e.code === 'no_credits') {
+        const cur = metaMod.load(dir);
+        st = cur ? Object.assign(cur, { status: 'paused', pause_reason: 'no_credits' })
+                 : { status: 'paused', pause_reason: 'no_credits', checklist: [], creditsSpent: 0, budget };
+      } else { throw e; }
+    }
+    sp.stop();
+    if (!st) break;
+    if (st.status === 'done') break;         // missão concluída
+    if (!noturno) break;                      // caminho default: uma janela só
+    if (!RETOMAVEL.has(st.pause_reason)) break; // awaiting_human / stagnated / timeout / max_rounds → para e avisa
+
+    // Guarda anti-giro-em-falso: 2 janelas seguidas sem reduzir os pendentes = para.
+    const pend = (st.checklist || []).filter(i => !i.passes && !i.blocked).length;
+    if (prevPend !== null && pend >= prevPend) semProgresso++; else semProgresso = 0;
+    prevPend = pend;
+    if (semProgresso >= 2) { st._noturnoStop = 'stall'; break; }
+
+    // Tetos absolutos (nunca roda pra sempre).
+    const horas = (Date.now() - loopStart) / 3600000;
+    if (budgetTotal > 0 && (st.creditsSpent || 0) >= budgetTotal) { st._noturnoStop = 'budget-total'; break; }
+    if (maxJanelasEff > 0 && janela >= maxJanelasEff) { st._noturnoStop = 'janelas'; break; }
+    if (maxHoras > 0 && horas >= maxHoras) { st._noturnoStop = 'horas'; break; }
+
+    // Progresso entre janelas + espera o crédito voltar.
+    const feitos = (st.checklist || []).filter(i => i.passes).length;
+    const tot = (st.checklist || []).length;
+    const gasto = budgetTotal > 0 ? `${st.creditsSpent} de ${budgetTotal}` : `${st.creditsSpent}`;
+    console.log('\n  ' + C.warn('🌙') + ' ' + C.bold(`Janela ${janela} concluída`) + C.dim(` · ${feitos}/${tot} itens (${pend} restantes) · ${gasto} créditos gastos · aguardando ${intervaloMin} min pra próxima janela…`) + '\n');
+    await _sleep(intervaloMin * 60000);
+  }
   if (!st) { console.error(ui.infoLine(T.meta_none)); process.exit(2); }
 
   const done = st.checklist.filter(i => i.passes).length;
@@ -1247,6 +1311,15 @@ async function metaCmd() {
     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 (noturno && st._noturnoStop) {
+    const why = st._noturnoStop === 'stall' ? 'sem progresso em 2 janelas seguidas — parei pra não queimar crédito girando em falso'
+      : st._noturnoStop === 'budget-total' ? `orçamento total de ${budgetTotal} créditos esgotado`
+      : st._noturnoStop === 'janelas' ? `limite de ${maxJanelasEff} janela(s) atingido`
+      : `limite de ${maxHoras}h atingido`;
+    console.log('  ' + C.warn('🌙') + ' ' + C.dim(`modo noturno encerrado: ${why} · ${janela} janela(s) rodada(s). Retome com "ts meta --noturno".`));
+  } else if (noturno && st.status === 'done') {
+    console.log('  ' + C.warn('🌙') + ' ' + C.dim(`modo noturno: missão concluída em ${janela} janela(s) sem você precisar rerodar na mão.`));
+  }
   if (blocked.length) {
     console.log('  ' + C.err(T.meta_blocked));
     for (const b of blocked) console.log('    ' + C.err('!') + ' ' + b.desc.slice(0, 80));

package/lib/agent.js

@@ -414,6 +414,16 @@ async function run(task, opts = {}) {
           ? `Sessão SÓ-LEITURA (--ler/--plano): a ferramenta "${name}" está BLOQUEADA (ela altera/roda algo). Responda apenas com base no que leu; se precisar mesmo agir, o usuário deve rodar sem --ler.`
           : `READ-ONLY session (--ler/--plan): tool "${name}" is BLOCKED (it changes/runs things). Answer from what you read; to actually act, the user must run without --ler.` };
       }
+      // RECUSA INSTANTÂNEA de AUTO-DESTRUTIVOS (vem ANTES do gate de aprovação): comandos que
+      // matam a própria missão (o processo do agente / o dev server que ela usa) ou a máquina
+      // são recusados NA HORA — sem askApprove, sem poll remoto no Telegram (~150s POR tentativa
+      // desperdiçados no incidente do jogo, em que o modelo insistia em "taskkill /f /im node").
+      // Só o comando LOCAL (executar_comando roda NESTE processo/cwd); o remoto tem outro pid/cwd
+      // e segue pelo gate de aprovação comum.
+      if (result === undefined && name === 'executar_comando') {
+        const sd = tools.selfDestructiveReason(String(input.comando || ''), { cwd });
+        if (sd) { onStep({ name, detail: argsShort(name, input), blocked: true }); result = { erro: sd }; }
+      }
       // Gate de segurança: destrutivo → humano decide (só se ainda não foi bloqueado acima).
       // 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)) {

package/lib/meta.js

@@ -28,6 +28,9 @@ const MAX_VISUAL_FIXES = 5;  // rodadas de polimento VISUAL (o olho crítico)
 const MAX_VISUAL_FIXES_FLUTTER = 3; // Flutter: rebuild é MUITO mais pesado/lento → teto menor de polimento (economia)
 const VISUAL_ESCALATE_AT = 2; // após N reprovações visuais, a MÃO do fix vira o modelo forte (grok) — o deepseek erra layout complexo
 const MAX_BUILD_FIXES = 12; // rodadas extras de correção de build antes de desistir
+const WEB_CANVAS_MOVE_MIN = 0.02; // check de MOVIMENTO do canvas web (jogo/cena 3D): diferença MÍNIMA
+// entre 2 quadros pra a cena contar como VIVA. Abaixo disso = parada/congelada (T-pose, mixer parado,
+// loop sem avançar o tempo). SÓ se aplica a canvas de JOGO/3D — dashboard/gráfico pode ficar estático.
 
 // Detecta se o projeto é COMPILÁVEL e devolve como compilar + como saber que passou.
 // Procura recursivamente (modelos costumam aninhar em uma subpasta tipo MultiApps/).
@@ -197,12 +200,31 @@ function _seedCreds(cwd) {
   return (email && senha) ? { email, senha } : null;
 }
 
+// Compara N quadros PNG do MESMO recorte e devolve a MAIOR diferença relativa entre pares
+// consecutivos (0 = quadros idênticos → cena PARADA; perto de 1 = mudou muito → cena ANIMANDO).
+// Barato e sem libs: PNG é DEFLATE (qualquer mudança de pixel embaralha os bytes seguintes), então
+// amostrar ~4000 bytes já separa bem "congelado" (≈0) de "animando" (alto). Não decodifica o PNG.
+function _pngFramesDiff(frames) {
+  let maxDiff = 0;
+  for (let i = 1; i < frames.length; i++) {
+    const a = frames[i - 1], b = frames[i];
+    if (!a || !b || !a.length || !b.length) continue;
+    const n = Math.min(a.length, b.length), m = Math.max(a.length, b.length);
+    const step = Math.max(1, Math.floor(n / 4000));
+    let sampled = 0, changed = 0;
+    for (let k = 0; k < n; k += step) { sampled++; if (a[k] !== b[k]) changed++; }
+    const ratio = (sampled ? changed / sampled : 0) + (m ? (m - n) / m : 0);
+    if (ratio > maxDiff) maxDiff = ratio;
+  }
+  return maxDiff;
+}
+
 // ── GATE WEB (novo, pra portais/APIs Node): sobe o servidor DE VERDADE, checa se a porta
 // responde (senão = erro de inicialização) e — com Chrome headless (puppeteer-core) — carrega
 // a página, captura ERROS DE CONSOLE (ex: "Invalid Date") e tira PRINT pro olho criticar o
 // visual. Se a home for uma TELA DE LOGIN, LOGA com o seed e verifica as telas AUTENTICADAS
 // (senão dashboard/kanban quebrados passariam batido). Dá pra web a MESMA verificação real que apps têm.
-async function webRunGate(b) {
+async function webRunGate(b, opts = {}) {
   const cwd = b.cwd, port = b.port || 3000, url = 'http://localhost:' + port + '/';
   // instala deps se faltarem
   try { if (!fs.existsSync(path.join(cwd, 'node_modules'))) { try { cp.execSync('npm install', { cwd, stdio: 'ignore', timeout: 240000 }); } catch (_) {} } } catch (_) {}
@@ -287,7 +309,7 @@ async function webRunGate(b) {
       // (2) mede a COMPRESSÃO do PNG do canvas: tela preta/uniforme comprime absurdamente
       // (bytes/pixel minúsculo); cena viva é rica. Usa o screenshot do Chrome (compositor
       // real — captura WebGL certo, ao contrário de readPixels/drawImage que dão preto).
-      let canvasDead = null;
+      let canvasDead = null, canvasFrozen = null, eyeProblem = '', eyeCredits = 0, frameCount = 0;
       try {
         const cInfo = await page.evaluate(() => {
           const cs = [...document.querySelectorAll('canvas')].map(c => { const r = c.getBoundingClientRect(); return { r, area: r.width * r.height }; }).sort((a, b) => b.area - a.area);
@@ -304,15 +326,64 @@ async function webRunGate(b) {
             if (b) { b.click(); return true; } return false;
           });
           if (started) await new Promise(r => setTimeout(r, 2500)); // deixa o gameplay renderizar
-          // recalcula a bbox (o canvas pode ter mudado de tamanho ao iniciar)
-          const box = await page.evaluate(() => { const c = [...document.querySelectorAll('canvas')].map(c => { const r = c.getBoundingClientRect(); return { r, a: r.width * r.height }; }).sort((a, b) => b.a - a.a)[0]; if (!c) return null; const r = c.r; return { x: Math.max(0, Math.round(r.x)), y: Math.max(0, Math.round(r.y)), width: Math.round(r.width), height: Math.round(r.height) }; });
+          // recalcula a bbox + detecta se é JOGO/CENA 3D (só aí exigimos MOVIMENTO — canvas de
+          // dashboard/gráfico é legitimamente estático). Sinais de jogo: contexto WebGL, lib de
+          // engine (Three/Babylon/PIXI/Phaser/PlayCanvas), botão de start clicado, ou o canvas
+          // ocupa a MAIOR parte da viewport (experiência imersiva).
+          const meta = await page.evaluate(() => {
+            const c = [...document.querySelectorAll('canvas')].map(el => { const r = el.getBoundingClientRect(); return { el, r, a: r.width * r.height }; }).sort((a, b) => b.a - a.a)[0];
+            if (!c) return null;
+            const r = c.r;
+            let webgl = false; try { webgl = !!(c.el.getContext('webgl2') || c.el.getContext('webgl') || c.el.getContext('experimental-webgl')); } catch (_) {}
+            const lib = !!(window.THREE || window.BABYLON || window.PIXI || window.Phaser || window.pc || window.PlayCanvas);
+            const vp = (window.innerWidth || 0) * (window.innerHeight || 0);
+            const coversMost = vp ? (r.width * r.height) / vp > 0.6 : false;
+            return { box: { x: Math.max(0, Math.round(r.x)), y: Math.max(0, Math.round(r.y)), width: Math.round(r.width), height: Math.round(r.height) }, webgl, lib, coversMost };
+          });
+          const box = meta && meta.box;
           if (box && box.width > 200 && box.height > 150) {
-            const buf = await page.screenshot({ clip: box, type: 'png' }).catch(() => null);
-            if (buf && buf.length) {
-              const bpp = buf.length / (box.width * box.height); // bytes de PNG por pixel
+            const gameLike = !!(started || (meta && (meta.webgl || meta.lib || meta.coversMost)));
+            // captura frames do MESMO clip: 1 sempre (check de tela preta); +2 espaçados ~500ms se
+            // for jogo (check de MOVIMENTO). Screenshot do compositor do Chrome (captura WebGL certo).
+            const frames = [];
+            const nFrames = gameLike ? 3 : 1;
+            for (let f = 0; f < nFrames; f++) {
+              const fb = await page.screenshot({ clip: box, type: 'png' }).catch(() => null);
+              if (fb && fb.length) frames.push(fb);
+              if (f < nFrames - 1) await new Promise(r => setTimeout(r, 500));
+            }
+            frameCount = frames.length;
+            // (1) TELA PRETA/UNIFORME (check histórico — INALTERADO): PNG comprime absurdamente.
+            if (frames[0] && frames[0].length) {
+              const bpp = frames[0].length / (box.width * box.height); // bytes de PNG por pixel
               // < 0.02 B/px ≈ imagem quase uniforme (preta/cor sólida). Cena viva fica bem acima.
               if (bpp < 0.02) canvasDead = { bpp: +bpp.toFixed(4), w: box.width, h: box.height, started };
             }
+            // (2) MOVIMENTO (camada A MAIS, só p/ jogo/cena 3D): 2+ quadros ~idênticos = cena
+            // PARADA/CONGELADA (T-pose, mixer parado, loop de animação sem avançar o tempo).
+            if (!canvasDead && gameLike && frames.length >= 2) {
+              const mv = _pngFramesDiff(frames);
+              if (mv < WEB_CANVAS_MOVE_MIN) canvasFrozen = { mv: +mv.toFixed(4), w: box.width, h: box.height, started, webgl: !!(meta && meta.webgl) };
+            }
+            // (3) OLHO DE DOMÍNIO (jogo/cena 3D): se passou nos checks baratos, um modelo com VISÃO
+            // COMPARA os 2 quadros e cobra o CHECKLIST (personagem? animando? pés no chão? virado
+            // certo?). Gate DE VERDADE — reprova bloqueia o "concluído". Capado por opts.eyeGate.
+            if (!canvasDead && !canvasFrozen && gameLike && frames.length >= 2
+                && opts.token && opts.eye && opts.eyeGate && !errs.length && !bad.length) {
+              try {
+                const prompt = 'Você é um DIRETOR TÉCNICO DE JOGOS 3D revisando 2 QUADROS consecutivos (capturados com ~0,5s de intervalo) do MESMO jogo/cena 3D rodando de verdade no navegador. COMPARE os dois quadros e responda ao CHECKLIST, item a item:\n'
+                  + '1) Há um PERSONAGEM/objeto principal visível na cena? (cena vazia / só chão / só céu = REPROVA)\n'
+                  + '2) O personagem ANIMA de verdade entre os 2 quadros (pose/membros mudando)? Personagem em T-POSE (braços rígidos abertos em cruz) ou totalmente imóvel enquanto deveria se mover = REPROVA.\n'
+                  + '3) Os PÉS estão no chão (apoiado no piso, não flutuando no ar nem afundado)?\n'
+                  + '4) O personagem está VIRADO para a direção certa (de frente / na direção do movimento — não de costas por engano, de lado, nem de cabeça pra baixo)?\n'
+                  + '5) A CÂMERA enquadra a cena (não está dentro do personagem nem apontada pro vazio)?\n'
+                  + 'Liste os problemas encontrados com o FIX técnico (ex.: chamar mixer.update(clock.getDelta()) no loop, carregar/tocar o clip com .play(), ajustar object.position.y pra apoiar os pés, girar rotation.y pra virar o personagem, reposicionar a câmera).\n'
+                  + 'TERMINE com UMA linha, exatamente um veredicto: "VEREDITO: OK" (cena viva e correta) ou "VEREDITO: REPROVADO" (qualquer item acima falhou).';
+                const ev = await _llmVision({ token: opts.token, model: opts.eye, text: prompt, images: [frames[0].toString('base64'), frames[frames.length - 1].toString('base64')], maxTokens: 900 });
+                eyeCredits += ev.credits || 0;
+                if (/VEREDITO:\s*REPROVAD/i.test(String(ev.text || ''))) eyeProblem = String(ev.text || '').trim();
+              } catch (_) {}
+            }
           }
         }
       } catch (_) {}
@@ -331,16 +402,27 @@ async function webRunGate(b) {
       const canvasProblem = canvasDead
         ? `O CANVAS gráfico (${canvasDead.w}×${canvasDead.h}) está renderizando PRATICAMENTE VAZIO (tela preta/uniforme)${canvasDead.started ? ', mesmo depois de clicar em iniciar' : ''} — o app NÃO está desenhando a cena. Causas típicas: câmera/posição em NaN (ex: delta indefinido no 1º frame do loop), objetos fora do frustum, erro silencioso no setup do WebGL, ou o loop de render não começou. Verifique a inicialização da câmera e do requestAnimationFrame.`
         : '';
-      if (errs.length || bad.length || authProblem || canvasProblem) {
+      const canvasFrozenProblem = canvasFrozen
+        ? `O CANVAS do jogo/cena 3D (${canvasFrozen.w}×${canvasFrozen.h}) está PARADO/CONGELADO: capturei ${frameCount} quadros ao longo de ~1s e eles saíram praticamente IDÊNTICOS (variação ${canvasFrozen.mv}, abaixo do mínimo ${WEB_CANVAS_MOVE_MIN} esperado numa cena viva)${canvasFrozen.started ? ', mesmo depois de clicar em iniciar' : ''}. A cena RENDERIZA mas NÃO ANIMA — sintoma clássico de personagem em T-pose, AnimationMixer não atualizado, ou loop de render sem avançar o tempo. Verifique: (1) o AnimationMixer tem uma action com .play() E é atualizado com mixer.update(clock.getDelta()) DENTRO do requestAnimationFrame; (2) o delta do 1º frame não é 0/NaN; (3) o loop chama requestAnimationFrame recursivamente (a animação não parou após 1 frame).`
+        : '';
+      const credits = eyeCredits;
+      // Falhas DETERMINÍSTICAS (erro real / tela preta / cena congelada) → correção normal via gate.
+      if (errs.length || bad.length || authProblem || canvasProblem || canvasFrozenProblem) {
         kill();
-        return { ok: false, shot: shotFile, authed, crash: 'A verificação web falhou' + (authed ? ' (APÓS LOGIN, nas telas autenticadas)' : '') + ' (Chrome headless — corrija a CAUSA-RAIZ no código):\n'
+        return { ok: false, credits, shot: shotFile, authed, crash: 'A verificação web falhou' + (authed ? ' (APÓS LOGIN, nas telas autenticadas)' : '') + ' (Chrome headless — corrija a CAUSA-RAIZ no código):\n'
           + (errs.length ? 'Console/erros: ' + errs.slice(0, 8).join(' | ') + '\n' : '')
           + (bad.length ? 'Texto quebrado VISÍVEL na tela: ' + bad.join(', ') + ' (ex: data não formatada, valor undefined/NaN)\n' : '')
           + (canvasProblem ? canvasProblem + '\n' : '')
+          + (canvasFrozenProblem ? canvasFrozenProblem + '\n' : '')
           + (authProblem || '') };
       }
+      // Reprovação SUBJETIVA de DOMÍNIO pelo olho (T-pose sutil, pés no ar, virado errado, cena vazia).
+      if (eyeProblem) {
+        kill();
+        return { ok: false, visual: true, credits, shot: shotFile, authed, crash: 'A revisão da CENA 3D pelo olho crítico (visão, comparando 2 quadros reais do jogo rodando) REPROVOU. Corrija a CAUSA-RAIZ no código do jogo:\n' + eyeProblem };
+      }
       kill();
-      return { ok: true, shot: shotFile, authed };
+      return { ok: true, credits, shot: shotFile, authed };
     } catch (_) { /* puppeteer falhou → segue só com a verificação do servidor */ }
   }
   kill();
@@ -1026,14 +1108,21 @@ async function run(goal, opts = {}) {
           } else if (runGate && b.kind === 'web') {
             // ── GATE WEB: sobe o servidor de verdade + Chrome headless (console/erros/print).
             onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? 'Starting the web server and testing in the browser (web gate)…' : 'Subindo o servidor web e testando no navegador (gate web)…'), attempt: 1 });
-            let wg = { ok: true }; try { wg = await webRunGate(b); } catch (_) {}
+            // eyeGate: libera o olho de domínio (jogo/cena 3D) enquanto não estourou o teto de
+            // polimento visual — assim a crítica cara de cena roda no máx MAX_VISUAL_FIXES vezes.
+            let wg = { ok: true }; try { wg = await webRunGate(b, { token, eye, eyeGate: !!eye && (st.visualFixes || 0) < MAX_VISUAL_FIXES }); } catch (_) {}
+            st.creditsSpent += wg.credits || 0;
             if (wg.ok) {
               st.buildVerified = true; st.runVerified = true; st.visualOk = true;
               if (wg.shot) st.webShot = wg.shot;
               st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
             } else {
               st.buildFixes = (st.buildFixes || 0) + 1;
-              errText = 'GATE WEB — o servidor precisa SUBIR e a página abrir SEM erro de console/runtime. Corrija a CAUSA-RAIZ (backend ou frontend):\n' + wg.crash;
+              if (wg.visual) { st.visualFixes = (st.visualFixes || 0) + 1; onAlert({ type: 'design', text: `👁 ts: o olho crítico REPROVOU a CENA 3D do jogo (${st.visualFixes}/${MAX_VISUAL_FIXES}) — personagem/animação/enquadramento. Mandando corrigir e vou reavaliar.` }); }
+              errText = (wg.visual
+                ? 'GATE WEB (CENA 3D) — o jogo SOBE mas a CENA foi REPROVADA pelo olho crítico comparando 2 quadros reais. Corrija a CAUSA-RAIZ no código do jogo (Three.js/WebGL):\n'
+                : 'GATE WEB — o servidor precisa SUBIR e a página abrir SEM erro de console/runtime, e — se for jogo/cena 3D — a cena precisa ANIMAR de verdade (não pode ficar em T-pose/congelada). Corrija a CAUSA-RAIZ (backend, frontend ou loop de animação):\n')
+                + wg.crash;
               st.buildError = errText;
             }
           } else {

package/lib/tools.js

@@ -205,6 +205,119 @@ function _guardTsHome(p) {
   return null;
 }
 
+// ── RECUSA INSTANTÂNEA de comandos AUTO-DESTRUTIVOS ──────────────────────────
+// Diferente do gate destrutivo comum (que PEDE aprovação humana): estes comandos matam a
+// PRÓPRIA missão — o processo do agente, o dev server de que a missão depende — ou a
+// máquina inteira. Esperar aprovação (local, ou remota via Telegram ~150s POR tentativa)
+// por algo que JAMAIS deve rodar é desperdício puro: recusamos NA HORA, apontando a
+// alternativa cirúrgica. Retorna a mensagem (motivo pro modelo) quando é auto-destrutivo,
+// ou null quando é seguro (aí segue o fluxo normal, inclusive o gate de aprovação comum).
+function selfDestructiveReason(cmd, opts = {}) {
+  const c = String(cmd || '');
+  if (!c.trim()) return null;
+
+  // 1) Desligar/reiniciar a máquina — derruba tudo, nunca ajuda a tarefa.
+  if (/(?:^|[\s;&|(])(?:sudo\s+)?(shutdown|reboot|halt|poweroff)\b/i.test(c) || /\b(Stop|Restart)-Computer\b/i.test(c))
+    return 'AUTO-DESTRUTIVO recusado na hora: desligar/reiniciar a máquina (shutdown/reboot) aborta a missão e derruba tudo — nunca ajuda a tarefa. Não faça.';
+
+  // 2) Matar Node em MASSA (por NOME) — mata ESTE agente E o dev server da missão de uma vez.
+  if (/\btaskkill\b[^\n]*\/im\s*:?\s*"?node(\.exe)?"?/i.test(c))
+    return 'AUTO-DESTRUTIVO recusado na hora: "taskkill /IM node" mata TODOS os node.exe — inclusive ESTE agente e o dev server da missão. Para reiniciar UM servidor, ache o PID que ouve a porta ("netstat -ano | findstr :PORTA") e mate SÓ ele ("taskkill /F /PID <pid>").';
+  if (/\b(killall|pkill)\b[^\n]*\bnode\b/i.test(c))
+    return 'AUTO-DESTRUTIVO recusado na hora: matar node em massa (killall/pkill node) derruba ESTE agente e o dev server da missão. Mate só o processo da porta certa (ex: "lsof -ti:PORTA | xargs kill").';
+  if (/\bStop-Process\b[^\n]*-Name\s*"?node/i.test(c))
+    return 'AUTO-DESTRUTIVO recusado na hora: "Stop-Process -Name node" mata TODOS os node — inclusive a própria missão. Use -Id <pid> do processo certo.';
+
+  // 3) Matar o PRÓPRIO PID (o processo desta run) ou o próprio shell.
+  const selfPid = String(opts.pid || process.pid);
+  if (new RegExp('\\bkill\\b(?:\\s+-[a-z0-9]+)*\\s+' + selfPid + '\\b', 'i').test(c) ||
+      new RegExp('\\btaskkill\\b[^\\n]*\\/pid\\s+' + selfPid + '\\b', 'i').test(c))
+    return 'AUTO-DESTRUTIVO recusado na hora: ' + selfPid + ' é o PID do PRÓPRIO processo do agente — matá-lo aborta a missão. Mate só o PID do processo alvo.';
+  if (/\bkill\b(?:\s+-[a-z0-9]+)*\s+\$\$/i.test(c) || /\bkill\s+-?9?\s*-1\b/.test(c))
+    return 'AUTO-DESTRUTIVO recusado na hora: "kill $$"/"kill -1" derruba o próprio shell da missão. Mate só o PID do processo alvo.';
+
+  // 4) Apagar em massa a RAIZ do sistema, o HOME, ou a própria pasta de trabalho da missão.
+  const nukeDir = (/\brm\b/i.test(c) && /(?:\s-[a-z]*r|--recursive)/i.test(c))
+    || /\b(rd|rmdir)\b[^\n]*\/s\b/i.test(c) || /\bdel\b[^\n]*\/s\b/i.test(c)
+    || /\bRemove-Item\b[^\n]*-(Recurse|R|Force)\b/i.test(c);
+  if (nukeDir) {
+    // normaliza separador (\ e /) → "/" pra comparar caminhos sem depender do SO
+    const norm = (s) => String(s || '').replace(/[\\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+    const home = norm(os.homedir());
+    const cwd = String(opts.cwd || '').replace(/[\\\/]+$/, '');
+    const cwdLow = norm(opts.cwd);
+    // tira o verbo e as flags (unix -rf / windows /s /q) — sobra a lista de ALVOS
+    const rest = c.replace(/^[\s\S]*?\b(rm|rd|rmdir|del|Remove-Item)\b/i, '');
+    const toks = rest.split(/[\s,;]+/).map(t => t.replace(/^["']|["']$/g, '')).filter(Boolean)
+      .filter(t => !/^-/.test(t) && !/^\/[a-z]$/i.test(t));
+    for (const raw of toks) {
+      const tl = raw.toLowerCase();
+      // atalhos catastróficos literais (raiz, home, cwd inteiro, curinga)
+      if (['/', '/*', '.', './', './*', '*', '~', '~/', '~\\', '$home', '${home}', '%userprofile%', '$env:userprofile', 'c:', 'c:\\', 'c:/', 'c:\\*'].includes(tl))
+        return 'AUTO-DESTRUTIVO recusado na hora: apagar "' + raw + '" em modo recursivo destruiria a raiz do sistema / seu HOME / a própria pasta da missão. Apague só a SUBPASTA específica (caminho completo até ela), nunca a raiz nem um atalho.';
+      let abs;
+      if (raw === '~' || raw.startsWith('~/') || raw.startsWith('~\\')) abs = path.join(os.homedir(), raw.slice(1));
+      else { try { abs = path.resolve(cwd || process.cwd(), raw); } catch (_) { continue; } }
+      const absLow = norm(abs);
+      if (home && absLow === home)
+        return 'AUTO-DESTRUTIVO recusado na hora: "' + raw + '" é a sua pasta HOME — apagá-la levaria a config do ts e seus arquivos junto. Apague só a subpasta específica.';
+      if (/^([a-z]:)?$/i.test(absLow))
+        return 'AUTO-DESTRUTIVO recusado na hora: "' + raw + '" aponta pra raiz do disco. Apague só a subpasta específica.';
+      // é o próprio cwd da missão OU um ancestral dele (apagar isso mata a missão + o dev server)
+      if (cwdLow && (absLow === cwdLow || (cwdLow + '/').startsWith(absLow + '/')))
+        return 'AUTO-DESTRUTIVO recusado na hora: "' + raw + '" é a própria pasta de trabalho da missão (ou um ancestral dela) — apagá-la aborta a missão e o dev server. Apague só as subpastas/arquivos específicos DENTRO dela.';
+    }
+  }
+  return null;
+}
+
+// ── INTROSPECÇÃO: sugerir o nome REAL mais próximo ───────────────────────────
+// O modelo costuma CHUTAR nomes (tool "buscar_arquivo" quando é "buscar_arquivos";
+// arquivo "input.js" quando é "Input.js"). Distância de edição (Levenshtein) simples,
+// sem lib: acha o candidato mais parecido pra devolver na mensagem de erro — o modelo
+// se corrige na hora, sem gastar rodadas com "não encontrado" seco.
+function _levenshtein(a, b) {
+  a = String(a); b = String(b);
+  const m = a.length, n = b.length;
+  if (!m) return n; if (!n) return m;
+  let prev = new Array(n + 1); for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    let cur = [i];
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+    }
+    prev = cur;
+  }
+  return prev[n];
+}
+// candidatos "perto o suficiente" do nome chutado (limiar cresce com o tamanho do nome)
+function _maisParecidos(nome, candidatos, max = 3) {
+  const nm = String(nome || '').toLowerCase();
+  if (!nm) return [];
+  const lim = Math.max(2, Math.ceil(nm.length * 0.4));
+  return candidatos
+    .map(c => ({ c, d: _levenshtein(nm, String(c).toLowerCase()) }))
+    .filter(x => x.d <= lim)
+    .sort((a, b) => a.d - b.d)
+    .slice(0, max)
+    .map(x => x.c);
+}
+// nomes parecidos com o basename NO MESMO diretório (pra erro "arquivo/pasta não encontrado")
+function _vizinhos(absPath) {
+  try {
+    const dir = path.dirname(absPath);
+    const alvo = path.basename(absPath);
+    const nomes = fs.readdirSync(dir);
+    let cand = _maisParecidos(alvo, nomes, 5);
+    if (!cand.length) { // fallback por substring / mesmo radical (antes da extensão)
+      const al = alvo.toLowerCase();
+      cand = nomes.filter(n => { const nl = n.toLowerCase(); return nl.includes(al) || al.includes(nl) || nl.split('.')[0] === al.split('.')[0]; }).slice(0, 5);
+    }
+    return cand;
+  } catch (_) { return []; }
+}
+
 async function execute(name, input, opts = {}) {
   // BASE de trabalho: cwd da sessão do agente (opts.baseDir) → pasta confinada da
   // missão (opts.confineDir) → process.cwd(). É a raiz de todo caminho relativo.
@@ -217,6 +330,9 @@ async function execute(name, input, opts = {}) {
     switch (name) {
       case 'executar_comando': {
         const comando = String(input.comando || '');
+        // RECUSA INSTANTÂNEA (defesa em profundidade — o gate do agent.js já pega antes):
+        // comando auto-destrutivo NUNCA roda e NUNCA espera aprovação.
+        { const sd = selfDestructiveReason(comando, { cwd: baseDir }); if (sd) return { erro: sd }; }
         const timeout = Math.min(300, Math.max(5, Number(input.timeout_s) || 60)) * 1000;
         const cmd = process.platform === 'win32' ? `chcp 65001>nul & ${comando}` : comando;
         return await new Promise((res) => {
@@ -251,6 +367,12 @@ async function execute(name, input, opts = {}) {
       case 'ler_arquivo': {
         const p = _abs(input.caminho, baseDir);
         if (BIN_RE.test(p)) return { erro: 'Arquivo binário — ler_arquivo só lê texto. Use executar_comando com uma ferramenta adequada.' };
+        // Não achou? Sugere nomes PARECIDOS na mesma pasta (o modelo chuta o nome do recurso).
+        if (!fs.existsSync(p)) {
+          const v = _vizinhos(p);
+          return { erro: 'Arquivo não encontrado: ' + p + (v.length ? '. Nomes parecidos na mesma pasta: ' + v.join(', ') + ' — confira o nome EXATO (maiúsculas/plural contam).' : '. Confira o caminho (use listar_diretorio/buscar_arquivos).') };
+        }
+        try { if (fs.statSync(p).isDirectory()) return { erro: p + ' é uma PASTA, não um arquivo. Use listar_diretorio pra ver o conteúdo.' }; } catch (_) {}
         const txt = fs.readFileSync(p, 'utf8');
         const linhas = txt.split('\n'); const total = linhas.length; const MAXL = 400;
         const ini = parseInt(input.inicio) || 0;
@@ -301,7 +423,10 @@ async function execute(name, input, opts = {}) {
             p = path.join(base, i >= 0 ? parts.slice(i).join(path.sep) : parts[parts.length - 1]);
           }
         }
-        if (!fs.existsSync(p)) return { erro: 'Arquivo não existe: ' + p + '. Pra criar arquivo NOVO use escrever_arquivo.' };
+        if (!fs.existsSync(p)) {
+          const v = _vizinhos(p);
+          return { erro: 'Arquivo não existe: ' + p + (v.length ? '. Nomes parecidos na mesma pasta: ' + v.join(', ') + ' — confira se não errou o nome.' : '') + ' Pra criar arquivo NOVO use escrever_arquivo.' };
+        }
         const orig = fs.readFileSync(p, 'utf8');
         let buscar = String(input.buscar ?? ''), substituir = String(input.substituir ?? '');
         if (!buscar) return { erro: 'buscar vazio.' };
@@ -347,7 +472,7 @@ async function execute(name, input, opts = {}) {
         // Muda o cwd da SESSÃO. O loop do agente lê _setCwd e passa a resolver os
         // próximos caminhos relativos (e comandos) a partir daqui.
         const alvo = _abs(input.caminho || input.diretorio || '.', baseDir);
-        let st; try { st = fs.statSync(alvo); } catch (_) { return { erro: 'Pasta não existe: ' + alvo + '. Confira o caminho (use listar_diretorio/buscar_arquivos).' }; }
+        let st; try { st = fs.statSync(alvo); } catch (_) { const v = _vizinhos(alvo); return { erro: 'Pasta não existe: ' + alvo + (v.length ? '. Nomes parecidos na pasta acima: ' + v.join(', ') : '') + '. Confira o caminho (use listar_diretorio/buscar_arquivos).' }; }
         if (!st.isDirectory()) return { erro: 'Não é uma pasta: ' + alvo };
         return { ok: true, cwd: alvo, _setCwd: alvo };
       }
@@ -440,13 +565,16 @@ async function execute(name, input, opts = {}) {
           hubs: m.hubs, mapa: m.edges.map(([a, b]) => a + ' -> ' + b) };
       }
       default: {
-        // sugere o nome REAL mais parecido (o modelo às vezes inventa uma variante)
+        // sugere o nome REAL mais parecido (o modelo às vezes inventa uma variante):
+        // 1) substring óbvia, 2) menor distância de edição, 3) mesmo radical antes do "_".
         const nomes = DEFS.map(d => d.function.name);
-        const alvo = nomes.find(n => n.includes(name) || name.includes(n)) || nomes.find(n => n.split('_')[0] === String(name).split('_')[0]);
+        const alvo = nomes.find(n => n.includes(name) || name.includes(n))
+          || _maisParecidos(name, nomes, 1)[0]
+          || nomes.find(n => n.split('_')[0] === String(name).split('_')[0]);
         return { erro: 'Ferramenta desconhecida: ' + name + (alvo ? ('. Você quis dizer "' + alvo + '"? Use esse nome EXATO.') : ('. Ferramentas válidas: ' + nomes.join(', '))) };
       }
     }
   } catch (e) { return { erro: String((e && e.message) || e).slice(0, 400) }; }
 }
 
-module.exports = { DEFS, execute, isDestructive, buildProjectMap };
+module.exports = { DEFS, execute, isDestructive, selfDestructiveReason, buildProjectMap };

package/package.json

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