terminal-smart-cli 0.74.0 → 0.76.0

package/bin/ts.js

@@ -19,12 +19,54 @@ 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 } = {}) {
+  const raw = String(cmd || '');
+  const { shown, hidden } = ui.cmdSummary(raw);
+  const more = hidden > 0 ? C.dim(`  … +${hidden} ${en ? 'lines' : 'linhas'}`) : '';
+  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 }) : 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 +866,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 +1324,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 +1338,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();
@@ -1812,8 +1861,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

@@ -153,6 +153,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 +224,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 +481,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);
@@ -517,9 +534,28 @@ 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).
+          const dec = await askApprove({ kind: 'destructive', cmd: String(input.comando || '') });
+          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 +585,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 +603,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 +630,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 +640,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 +678,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 +686,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 +723,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 +777,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,6 +12,14 @@
 // — 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 || '')); }
+
 // 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 = [
@@ -25,11 +33,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 || ''))); }
 
@@ -109,7 +113,20 @@ function classifyError(msg) {
 // NÃO muta o raw. Convenções do TS: {erro} = falha; {codigo|exitCode}≠0 = falha de shell;
 // {written|created|resumo|stdout|...} = evidência de sucesso.
 function classifyToolResult(raw) {
-  if (raw == null || typeof raw !== 'object') return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: raw != null ? String(raw).slice(0, 200) : '' };
+  if (raw == null) return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: '' };
+  // Alguns adaptadores legados retornam falhas como texto. Tratar todo texto como sucesso
+  // permitia que "ERRO ao executar..." virasse etapa concluída. Mantém strings normais como
+  // sucesso, mas reconhece prefixos inequívocos de falha/bloqueio.
+  if (typeof raw !== 'object') {
+    const text = String(raw);
+    const failedText = /^\s*(?:(?:erro|error|falha|failed|bloquead[oa])(?:\s*[:\-]|\s+(?:ao|a|de|do|da|em|no|na|to|while|executing|calling|opening|reading|writing|request|operation)\b|\s*$)|operação cancelada\b|o usuário recusou\b)/i.test(text);
+    if (failedText) {
+      const errorClass = classifyError(text);
+      return { ok: false, status: errorClass === 'blocked' ? 'blocked' : 'failed', errorClass,
+        retryable: RETRYABLE_CLASSES.has(errorClass), evidence: text.replace(/\s+/g, ' ').slice(0, 300) };
+    }
+    return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: text.slice(0, 200) };
+  }
   const exit = raw.codigo != null ? raw.codigo : (raw.exitCode != null ? raw.exitCode : null);
   const errMsg = raw.erro || raw.error || (exit != null && exit !== 0 ? (raw.stderr || raw.stdout || ('exit ' + exit)) : '');
   const failed = !!raw.erro || !!raw.error || (exit != null && exit !== 0);
@@ -128,7 +145,7 @@ function classifyToolResult(raw) {
 }
 
 module.exports = {
-  DESTRUCTIVE, isDestructive,
+  DESTRUCTIVE, isDestructive, touchesTsConfig,
   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

@@ -1011,7 +1011,8 @@ async function makeChecklist(goal, token) {
 // CRITÉRIOS EXECUTÁVEIS (verify): a prova FINAL da missão. Rodados quando os gates de
 // build/run passam, ANTES de declarar 'verified'. Se algum critério do usuário falha, a
 // missão NÃO é verificada (honestidade — não basta compilar/abrir; tem que CUMPRIR o pedido).
-// Sem critérios → nada a provar (retorna true). runAll nunca lança.
+// Sem critérios explícitos, os gates de build/run continuam sendo a prova. Erro interno do
+// verificador é fail-closed: nunca transforma ausência de prova em `verified`.
 async function _checkCriteria(st, dir) {
   if (!st.criteria || !st.criteria.length) return true;
   try {
@@ -1019,11 +1020,15 @@ async function _checkCriteria(st, dir) {
     st.verifyReport = { passed: rep.passed, total: rep.total, allOk: rep.allOk, results: rep.results.map(r => ({ ok: r.ok, label: r.label, detail: r.detail })) };
     if (!rep.allOk) st.runNote = (st.runNote || '') + ` critérios: ${rep.passed}/${rep.total} passaram · falharam: ${rep.results.filter(r => !r.ok).map(r => r.label).slice(0, 3).join(' | ')}`;
     return rep.allOk;
-  } catch (_) { return true; }
+  } catch (e) {
+    st.verifyReport = { passed: 0, total: st.criteria.length, allOk: false, results: [], error: String((e && e.message) || e).slice(0, 300) };
+    st.runNote = (st.runNote || '') + ' verificador falhou internamente; missão não marcada como verified';
+    return false;
+  }
 }
 
 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 || (() => {});
@@ -1064,12 +1069,14 @@ async function run(goal, opts = {}) {
     }
     const mk = await makeChecklist(goal + (designBrief ? '\n\n[Há um DESIGN SYSTEM definido — o checklist deve refletir a aplicação desse visual]' : '') + (archBrief ? '\n\n[Há um CONTRATO DE ARQUITETURA definido — os itens devem seguir os componentes/arquivos dele]' : ''), token);
     // CRITÉRIOS (TaskSpec): usuário (--criterios) manda; senão, com --provar, combina o que o
-    // PLANNER propôs (mk.criteria, já validado) + os TESTES da stack — tudo recompilado. Sem
-    // --provar, só guarda o que o planner propôs (plannedCriteria) como referência, sem bloquear.
+    // PLANNER propôs (mk.criteria, já validado) + os TESTES da stack — tudo recompilado.
+    // Mesmo sem --provar, critérios determinísticos derivados da stack rodam por padrão;
+    // critérios inventados pelo planner ficam apenas como referência até o usuário pedir prova ampla.
     const _V = require('./verify');
     let _criteria = [], _planned = mk.criteria || [];
     if (Array.isArray(opts.criteria) && opts.criteria.length) _criteria = opts.criteria;
     else if (prove) _criteria = _V.compileCriteria([..._V.deriveFromStack(dir), ..._planned]).criteria.slice(0, 8);
+    else _criteria = _V.compileCriteria(_V.deriveFromStack(dir)).criteria.slice(0, 8);
     st = { goal: String(goal).slice(0, 4000), mockup: opts.mockup || null, archBrief, feasBrief, checklist: mk.itens, rounds: [], creditsSpent: (mk.credits || 0) + designCred + archCred + feasCred,
       budget, maxRounds, status: 'running', model: model || null, designBrief: designBrief || null, criteria: _criteria, plannedCriteria: _planned, created_at: new Date().toISOString() };
     save(st, dir);
@@ -1313,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)
@@ -1346,14 +1353,16 @@ async function run(goal, opts = {}) {
     // (Bug real do teste MultiApps: flash-lite bloqueou itens cujos arquivos existiam no disco.)
     let marks = [];
     const written = (out.actions || []).filter(a => a.name === 'escrever_arquivo' || a.name === 'editar_arquivo').map(a => String(a.target || ''));
-    const ranOk = (out.actions || []).some(a => a.name === 'executar_comando');
     const _basename = (p) => String(p).replace(/\\/g, '/').split('/').pop().toLowerCase();
     const _fileHints = (txt) => (String(txt).match(/[\w.\-]+\.(kt|java|xml|gradle|json|md|txt|kts|properties|pro|png|webp|py|js|ts|html|css|sh)\b/gi) || []).map(s => s.toLowerCase());
     const itemFiles = _fileHints(item.desc);
-    const wroteForItem = itemFiles.length
-      ? itemFiles.some(f => written.some(w => _basename(w) === f))
-      : written.length > 0; // item sem nome de arquivo explícito mas a rodada produziu algo
-    if (wroteForItem || (ranOk && !itemFiles.length)) marks.push(item.id);
+    // Uma escrita/comando genérico não prova um item sem vínculo. Só há marcação automática
+    // quando o próprio texto do item identifica o artefato e a rodada gravou esse artefato.
+    // Itens abstratos continuam podendo ser avaliados pelo marcador, mas não "vazam" sucesso
+    // para outros itens só porque algum arquivo/comando apareceu na mesma rodada.
+    const wroteForItem = itemFiles.length > 0
+      && itemFiles.some(f => written.some(w => _basename(w) === f));
+    if (wroteForItem) marks.push(item.id);
 
     // Item de correção de build: NÃO usa marcador — o PORTÃO DE BUILD é a única
     // autoridade (recompila de verdade). Marca provisório pra reabrir o gate; se o
@@ -1368,15 +1377,14 @@ async function run(goal, opts = {}) {
       continue;
     }
 
-    // Marcador IA como REFORÇO: confirma o alvo se a evidência objetiva não pegou, e
-    // credita OUTROS itens do checklist que a rodada também concluiu.
+    // Marcador IA como REFORÇO do ITEM ALVO. Não aceita mais `tambem_concluidos`: uma
+    // narrativa de uma rodada não é evidência suficiente para concluir itens não executados.
     try {
       const evid = written.length ? '\n\nARQUIVOS REALMENTE GRAVADOS nesta rodada (evidência objetiva):\n' + written.map(_basename).join(', ') : '';
       const mk = await _llmJson({ token, system: MARK_SYS,
         user: `OBJETIVO:\n${st.goal.slice(0, 600)}\n\nCHECKLIST (contexto):\n${fmtChecklist(st.checklist)}\n\nITEM ALVO: (${item.id}) ${item.desc}\n\nRESULTADO DA RODADA:\n${String(out.text || '').slice(0, 2000)}${evid}` });
       st.creditsSpent += mk.credits || 0;
       if (mk.json && mk.json.passou === true) marks.push(item.id);
-      if (Array.isArray(mk.json?.tambem_concluidos)) marks.push(...mk.json.tambem_concluidos.map(String));
     } catch (_) {}
     marks = [...new Set(marks)];
     for (const it of st.checklist) if (marks.includes(it.id)) it.passes = true;

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/package.json

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