terminal-smart-cli 0.67.0 → 0.73.0

package/bin/ts.js

@@ -1007,6 +1007,37 @@ async function evalCmd(words) {
     process.exit(2);
   }
 
+  // ── MODEL LAB: --modelos m1,m2,m3 → bake-off automático (mesma suíte em cada executor) ──
+  const _modelsArg = _val(['--modelos', '--models']);
+  if (_modelsArg) {
+    const models = _modelsArg.split(',').map(s => s.trim()).filter(Boolean);
+    if (models.length < 2) { _die(en ? '--modelos needs at least 2 models (comma-separated)' : '--modelos precisa de pelo menos 2 modelos (separados por vírgula)', 2); }
+    if (!JSON_OUT) {
+      console.log('\n  ' + ui.gradient('⌁ ' + (en ? 'Model Lab' : 'Model Lab')) + '  ' + C.bold(suite.name) + C.dim('  · ' + suite.cases.length + (en ? ' case(s) × ' : ' caso(s) × ') + models.length + (en ? ' models' : ' modelos')));
+      console.log('  ' + C.dim(en ? 'same suite on each executor; a fixed judge scores all (fair). Costs credits.' : 'mesma suíte em cada executor; um juiz fixo pontua todos (justo). Gasta créditos.') + '\n');
+    }
+    const spM = JSON_OUT ? { start() {}, stop() {}, text() {} } : ui.spinner('…').start();
+    let mx;
+    try {
+      mx = await evalMod.runMatrix(suite, {
+        token, lang: cfg.lang || 'pt', judgeModel, models,
+        onModel: ({ model, phase, row }) => { if (JSON_OUT) return; if (phase === 'start') spM.text((en ? 'testing ' : 'testando ') + model + '…'); else if (phase === 'done') { spM.stop(); console.log('  ' + C.cyan('◆') + ' ' + C.bold(model) + C.dim('  ' + row.passed + '/' + row.total + ' · score ' + row.avgScore + ' · ' + row.credits + ' cr') + (row.error ? C.err('  ' + row.error) : '')); spM.start(); } },
+        onCase: ({ phase, id, pass, score }) => { if (!JSON_OUT && phase === 'done') { spM.stop(); console.log('      ' + (pass ? C.ok('✔') : C.err('✗')) + C.dim(' ' + id + ' ' + score)); spM.start(); } },
+      });
+    } catch (e) { spM.stop(); if (e && (e.code === 'no_credits' || e.status === 402)) { console.error('\n' + ui.errLine(en ? 'AI limit reached — top up to run the bake-off.' : 'Limite de IA atingido — recarregue pra rodar o bake-off.')); process.exit(1); } throw e; }
+    spM.stop();
+    if (JSON_OUT) { console.log(JSON.stringify(mx)); return; }
+    // placar ordenado (qualidade → custo)
+    console.log('\n' + ui.box([
+      C.bold(en ? 'Bake-off ranking' : 'Placar do bake-off') + C.dim('  (' + (en ? 'quality then cost' : 'qualidade depois custo') + ')'),
+      '',
+      ...mx.ranked.map((r, i) => (i === 0 ? C.ok('①') : C.dim(' ' + (i + 1) + ' ')) + ' ' + C.bold(r.model.padEnd(20)) + C.dim(r.passed + '/' + r.total + ' ok · score ' + r.avgScore + ' · ' + r.credits + ' cr · ' + (r.ms / 1000).toFixed(1) + 's' + (r.error ? '  ⚠ ' + r.error : ''))),
+      '',
+      C.dim(en ? 'winner: ' : 'vencedor: ') + C.ok(C.bold(mx.winner || '—')),
+    ], { title: 'ts model lab' }));
+    return;
+  }
+
   if (!JSON_OUT) {
     console.log('\n  ' + ui.gradient('⌁ ' + (en ? 'Eval' : 'Avaliação')) + '  ' + C.bold(suite.name) + C.dim('  · ' + suite.cases.length + (en ? ' case(s)' : ' caso(s)')));
     console.log('  ' + C.dim(en ? 'runs the real agent per case (costs credits), an AI judge scores each' : 'roda o agente de verdade por caso (gasta créditos); um juiz de IA pontua cada um') + '\n');
@@ -1185,21 +1216,22 @@ async function metaCmd() {
   const maxJanelasEff = maxJanelas || ((budgetTotal || maxHoras) ? 0 : 20);
   // CRITÉRIOS EXECUTÁVEIS (verify): --criterios <arquivo.json> = a PROVA de que a missão
   // cumpriu o pedido (não basta compilar/abrir). Falhou → missão sai "NÃO verificada".
+  // CRITÉRIOS (TaskSpec): --criterios <arquivo> (usuário manda) OU --provar (o meta auto-monta:
+  // planner propõe + stack dá os testes, tudo dentro do run). Sem nada = comportamento atual.
   let criteria = [];
+  const prove = FLAGS.has('--provar') || FLAGS.has('--prove');
   const _verify = require('../lib/verify');
   const _critFile = (() => { const i = rawArgs.findIndex(a => a === '--criterios' || a === '--criteria'); return i >= 0 ? rawArgs[i + 1] : null; })();
   if (_critFile) {
     try { const j = JSON.parse(require('fs').readFileSync(_critFile, 'utf8')); const comp = _verify.compileCriteria(j); criteria = comp.criteria;
       if (comp.dropped.length) console.log('  ' + C.dim((cfg.lang === 'en' ? 'ignored ' : 'ignorei ') + comp.dropped.length + (cfg.lang === 'en' ? ' invalid criterion(s)' : ' critério(s) inválido(s)'))); }
     catch (e) { console.error(ui.errLine((cfg.lang === 'en' ? 'criteria file: ' : 'arquivo de critérios: ') + (e.message || e))); process.exit(2); }
-  } else if (FLAGS.has('--provar') || FLAGS.has('--prove')) {
-    // TaskSpec automático: deriva os critérios da stack (testes) — sem json na mão.
-    criteria = _verify.deriveFromStack(dir);
-    if (criteria.length) console.log('  ' + C.dim((cfg.lang === 'en' ? 'auto-derived proof: ' : 'prova auto-derivada: ') + criteria.map(c => c.label || c.type).join(' · ')) + '\n');
-    else console.log('  ' + C.dim(cfg.lang === 'en' ? '--provar: no test command detected in this project (nothing to auto-prove)' : '--provar: nenhum comando de teste detectado neste projeto (nada a auto-provar)') + '\n');
+  } else if (prove) {
+    console.log('  ' + C.dim(cfg.lang === 'en' ? 'proof mode: the planner proposes criteria + the stack tests will be verified at the end' : 'modo prova: o planner propõe critérios + os testes da stack serão verificados no fim') + '\n');
   }
 
   const existing = metaMod.load(dir);
+  if (FLAGS.has('--trilha') || FLAGS.has('--trail')) return trilhaCmd();
   if (FLAGS.has('--status')) {
     if (!existing) { console.log(ui.infoLine(T.meta_none)); return; }
     const done = existing.checklist.filter(i => i.passes).length;
@@ -1244,7 +1276,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,
+        token, lang: cfg.lang || 'pt', yes, 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('⏱');
@@ -1734,6 +1766,130 @@ async function verificarCmd(args) {
   process.exit(rep.allOk ? 0 : 1);
 }
 
+// ── ts runbook — procedimentos DevOps reexecutáveis e auto-verificáveis ──────
+async function runbookCmd(args) {
+  const en = (cfg.lang === 'en');
+  const rb = require('../lib/runbook');
+  const sub = String(args[0] || 'listar').toLowerCase();
+  const nome = args.slice(1).find(a => !a.startsWith('-'));
+
+  if (sub === 'listar' || sub === 'ls' || sub === 'list') {
+    const l = rb.list();
+    if (!l.length) { console.log('\n' + ui.infoLine(en ? 'no runbooks yet — create one: ts runbook novo <name>' : 'nenhum runbook ainda — crie um: ts runbook novo <nome>')); return; }
+    console.log('\n' + ui.box([
+      C.bold(en ? 'Runbooks' : 'Runbooks') + C.dim('  (' + l.length + ')'),
+      ...l.map(n => { const r = rb.load(n) || {}; return '  ' + C.bold(n) + C.dim('  ' + (r.passos ? r.passos.length : 0) + ' ' + (en ? 'step(s)' : 'passo(s)') + ' · ' + (r.criterios ? r.criterios.length : 0) + ' ' + (en ? 'check(s)' : 'checagem(ns)') + (r.descricao ? '  — ' + String(r.descricao).slice(0, 40) : '')); }),
+      '', C.dim(en ? 'run: ts runbook rodar <name>  ·  edit the .json in ~/.ts/runbooks/' : 'rodar: ts runbook rodar <nome>  ·  edite o .json em ~/.ts/runbooks/'),
+    ], { title: 'ts runbook' }));
+    return;
+  }
+  if (sub === 'novo' || sub === 'new' || sub === 'criar') {
+    if (!nome) { console.log(ui.errLine(en ? 'usage: ts runbook novo <name>' : 'uso: ts runbook novo <nome>')); return; }
+    const o = rb.save(nome, rb.template(nome));
+    console.log('\n' + ui.box([C.ok(en ? 'Runbook created' : 'Runbook criado') + C.dim('  ' + o.nome), C.dim(require('../lib/runbook').DIR + require('path').sep + o.nome + '.json'), C.dim(en ? 'edit it (passos + criterios), then: ts runbook rodar ' + o.nome : 'edite (passos + criterios) e rode: ts runbook rodar ' + o.nome)], { title: 'ts runbook' }));
+    return;
+  }
+  if (sub === 'ver' || sub === 'show' || sub === 'cat') {
+    const r = rb.load(nome); if (!r) { console.log(ui.errLine(en ? 'no such runbook' : 'runbook não encontrado')); return; }
+    const v = rb.validate(r);
+    console.log('\n' + ui.box([
+      C.bold(r.nome) + (r.descricao ? C.dim('  — ' + r.descricao) : '') + (v.ok ? C.ok('  ✓') : C.err('  ✗ ' + v.erros.join('; '))),
+      '', C.bold(en ? 'STEPS' : 'PASSOS') + ':',
+      ...(r.passos || []).map((p, i) => C.dim(' ' + (i + 1) + '. ') + (p.desc ? C.bold(p.desc) + C.dim('  ') : '') + C.cyan(String(p.cmd).slice(0, 60)) + (p.remoto ? C.dim('  @' + String(p.remoto).split(' ').pop()) : '') + (require('../lib/core').isDestructive(p.cmd) ? C.warn('  ⚠ destrutivo') : '')),
+      '', C.bold(en ? 'PROOF' : 'PROVA') + ':',
+      ...(r.criterios || []).map(c => C.dim(' • ') + C.dim(require('../lib/verify')._labelFor(c))),
+    ], { title: 'ts runbook' }));
+    return;
+  }
+  if (sub === 'remover' || sub === 'rm' || sub === 'remove' || sub === 'del') {
+    console.log('\n' + (rb.remove(nome) ? ui.infoLine((en ? 'removed ' : 'removido ') + nome) : ui.errLine(en ? 'no such runbook' : 'runbook não encontrado')));
+    return;
+  }
+  if (sub === 'rodar' || sub === 'run' || sub === 'exec') {
+    const r = rb.load(nome); if (!r) { console.log(ui.errLine(en ? 'no such runbook' : 'runbook não encontrado')); return; }
+    console.log('\n' + C.dim(en ? 'running runbook ' : 'rodando runbook ') + C.bold(r.nome) + C.dim(' — ' + (r.passos || []).length + (en ? ' step(s)' : ' passo(s)')) + '\n');
+    const out = await rb.run(r, {
+      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());
+      },
+      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)));
+        else if (e.phase === 'done') console.log('    ' + (e.ok ? C.ok('✔ exit 0') : C.err('✗ exit ' + e.code)) + (e.ok ? '' : C.dim('  ' + String(e.out || '').split('\n').slice(-1)[0].slice(0, 80))));
+        else if (e.phase === 'refused' || e.phase === 'denied') console.log('    ' + C.err('■ ' + (e.motivo || 'bloqueado')));
+        else if (e.phase === 'verify') console.log('\n  ' + C.dim((en ? 'proving result — ' : 'provando o resultado — ') + e.total + (en ? ' check(s)…' : ' checagem(ns)…')));
+      },
+    });
+    if (out.verify) for (const vr of out.verify.results) console.log('    ' + (vr.ok ? C.ok('✔') : C.err('✗')) + ' ' + C.dim((vr.label || '') + (vr.ok ? '' : '  — ' + (vr.detail || ''))));
+    if (out.ok) {
+      console.log('\n' + ui.okLine(C.bold('RUNBOOK OK') + C.dim(en ? ' — steps ran and the result is proven' : ' — passos rodaram e o resultado está provado')));
+    } else {
+      const _why = out.erro || (out.verify && !out.verify.allOk ? (en ? 'proof failed' : 'a prova falhou') : '');
+      console.log('\n' + ui.errLine(C.bold(en ? 'RUNBOOK FAILED' : 'RUNBOOK FALHOU') + C.dim('  ' + _why)));
+    }
+    process.exit(out.ok ? 0 : 1);
+  }
+  console.log(ui.infoLine(en ? 'ts runbook: listar | novo <name> | ver <name> | rodar <name> | remover <name>' : 'ts runbook: listar | novo <nome> | ver <nome> | rodar <nome> | remover <nome>'));
+}
+
+// ── ts trilha — timeline AUDITÁVEL da missão (Evidence Ledger: por que está done) ──
+function trilhaCmd() {
+  const en = (cfg.lang === 'en');
+  const metaMod = require('../lib/meta');
+  const st = metaMod.load(process.cwd());
+  if (!st) { console.log('\n' + ui.infoLine(en ? 'no mission in this folder (run ts meta first)' : 'nenhuma missão nesta pasta (rode ts meta primeiro)')); return; }
+  const t = metaMod.trailSummary(st, cfg.lang);
+  if (JSON_OUT) { console.log(JSON.stringify(t)); return; }
+  const _mark = { done: C.ok('✔'), blocked: C.err('!'), pending: C.dim('○') };
+  const lines = [
+    C.bold((en ? 'Goal: ' : 'Objetivo: ')) + C.dim(String(t.goal).slice(0, 66)),
+    (t.verification.ok ? C.ok : C.warn)(t.verification.icon + ' ' + t.verification.txt) + C.dim('  · ' + t.status + ' · ' + t.progress.done + '/' + t.progress.total + (en ? ' items' : ' itens')),
+    '',
+    C.bold(en ? 'CHECKLIST' : 'CHECKLIST') + ':',
+    ...t.checklist.map(i => '  ' + (_mark[i.state] || '○') + ' ' + C.dim(String(i.desc).slice(0, 70))),
+    '',
+    C.bold(en ? 'TIMELINE' : 'LINHA DO TEMPO') + C.dim('  (' + t.rounds.length + (en ? ' rounds)' : ' rodadas)')),
+    ...t.rounds.slice(-8).map(r => '  ' + C.indigo('R' + r.n) + ' ' + C.dim(String(r.item).slice(0, 44)) + C.dim('  · ' + r.steps + 'p · ' + r.credits + 'cr')),
+    '',
+    C.bold(en ? 'GATES' : 'GATES') + ': ' + C.dim((t.gates.build ? C.ok('build✔') : 'build○') + ' ' + (t.gates.run ? C.ok('run✔') : 'run○') + ' ' + (t.gates.visual ? C.ok('visual✔') : 'visual○')),
+  ];
+  if (t.proof) {
+    lines.push('', C.bold(en ? 'PROOF (criteria)' : 'PROVA (critérios)') + C.dim('  ' + t.proof.passed + '/' + t.proof.total));
+    for (const r of t.proof.results) lines.push('  ' + (r.ok ? C.ok('✔') : C.err('✗')) + ' ' + C.dim((r.label || '') + (r.ok ? '' : '  — ' + (r.detail || ''))));
+  }
+  lines.push('', C.dim(en ? 'cost: ' : 'custo: ') + t.cost.credits + ' cr · ' + t.cost.rounds + (en ? ' rounds' : ' rodadas') + (t.cost.escalations ? ' · ' + t.cost.escalations + ' esc' : '') + (t.cost.minutes != null ? ' · ' + t.cost.minutes + ' min' : ''));
+  lines.push('', (t.verification.ok ? C.ok : C.warn)(t.verdict));
+  console.log('\n' + ui.box(lines, { title: 'ts trilha' }));
+}
+
+// ── ts doctor — auto-diagnóstico do ambiente (Node/login/gateway/versão/deps) ──
+async function doctorCmd() {
+  const en = (cfg.lang === 'en');
+  const doc = require('../lib/doctor');
+  const sp = JSON_OUT ? { stop() {} } : ui.spinner(en ? 'checking your setup…' : 'checando seu ambiente…').start();
+  const out = await doc.run({
+    cfg, version: pkg.version, base: base(),
+    // backend no ar? 401 conta como "respondeu" (só não autenticado).
+    pingBackend: async () => { try { await api('/api/auth/check', { token: cfg.token, timeoutMs: 8000 }); return true; } catch (e) { return (e && e.status === 401); } },
+    // última versão publicada no npm (best-effort).
+    latestVersion: async () => { try { const r = await fetch('https://registry.npmjs.org/terminal-smart-cli/latest', { signal: AbortSignal.timeout(8000) }); const j = await r.json(); return j && j.version; } catch (_) { return null; } },
+  });
+  sp.stop();
+  if (JSON_OUT) { console.log(JSON.stringify(out)); process.exit(out.summary.healthy ? 0 : 1); }
+  const ic = { ok: C.ok('✔'), warn: C.warn('⚠'), fail: C.err('✗') };
+  const lines = [C.bold(en ? 'Environment check' : 'Diagnóstico do ambiente'), ''];
+  for (const r of out.results) {
+    lines.push('  ' + (ic[r.level] || '·') + ' ' + C.bold(r.nome.padEnd(16)) + C.dim(r.detail || ''));
+    if (r.dica) lines.push('      ' + C.dim('→ ' + r.dica));
+  }
+  const s = out.summary;
+  lines.push('', (s.healthy ? C.ok : C.warn)((s.healthy ? (en ? 'All good' : 'Tudo certo') : (en ? 'Attention needed' : 'Precisa de atenção')) + C.dim('  · ' + s.ok + ' ok · ' + s.warn + ' ' + (en ? 'warn' : 'avisos') + ' · ' + s.fail + ' ' + (en ? 'fail' : 'falhas'))));
+  console.log('\n' + ui.box(lines, { title: 'ts doctor' }));
+  process.exit(s.healthy ? 0 : 1);
+}
+
 // ── ts perfil — personas com COFRE DE MEMÓRIA isolado (Mempalace/Hermes) ──────
 function perfilCmd(args) {
   const en = (cfg.lang === 'en');
@@ -1997,6 +2153,9 @@ function recallCmd(args) {
     case 'buscar': case 'search': case 'procurar': return buscarCmd(POS.slice(1));
     case 'perfil': case 'persona': case 'profile': return perfilCmd(POS.slice(1));
     case 'verificar': case 'verify': case 'provar': return verificarCmd(POS.slice(1));
+    case 'runbook': case 'runbooks': case 'procedimento': return runbookCmd(POS.slice(1));
+    case 'trilha': case 'trail': case 'auditoria': return trilhaCmd();
+    case 'doctor': case 'diagnostico-ambiente': case 'checkup': return doctorCmd();
     case 'meta': case 'missao': case 'mission': return metaCmd();
     case 'runs':   return runsCmd();
     case 'status': return statusCmd(POS[1]);

package/lib/agent.js

@@ -658,6 +658,9 @@ async function run(task, opts = {}) {
           _toolErrs.push({ tool: name, class: _tr.errorClass, retryable: _tr.retryable, evidence: _tr.evidence });
           // LEDGER DE ERROS (Evolve 3): registro determinístico, zero IA.
           try { require('./memoria').logErro(confineDir || cwd, name, String(result.erro || result.stderr || ('exit ' + result.codigo))); } catch (_) {}
+          // RECOVERY ENGINE: erro de classe CONHECIDA → injeta a estratégia de conserto no
+          // resultado (o modelo aplica o padrão DevOps em vez de chutar/entrar em loop).
+          try { const _rh = require('./recovery').recoveryHint(_tr.errorClass); if (_rh && result && typeof result === 'object') result = Object.assign({}, result, { _recovery: _rh }); } catch (_) {}
         }
         // HOOK PostToolUse (determinístico): feedback (ex: lint/format) vai pro modelo ver.
         if (_hooks._any) {

package/lib/doctor.js

@@ -0,0 +1,82 @@
+// ts doctor — AUTO-DIAGNÓSTICO do ambiente do CLI (confiabilidade visível aplicada a si mesmo).
+// Checa o que o ts precisa pra funcionar (Node, login, gateway, versão) e o que habilita
+// recursos opcionais (git, Chrome p/ --navegador, yt-dlp p/ ts video, monolith p/ ts arquivar).
+// Cada check devolve { nome, level: 'ok'|'warn'|'fail', detail, dica? }. Puro onde dá (testável);
+// as checagens de rede degradam gracioso (nunca lançam).
+'use strict';
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// ── helpers PUROS (testáveis) ────────────────────────────────────────────────
+function _nodeMajor(v) { const m = String(v || '').replace(/^v/, '').split('.'); return Number(m[0]) || 0; }
+function _nodeOk(v) { return _nodeMajor(v) >= 18; }
+// estado de autenticação a partir do config carregado
+function _authLevel(cfg) {
+  if (!cfg || !cfg.token) return { level: 'fail', detail: 'não logado', dica: 'rode: ts login' };
+  return { level: 'ok', detail: 'logado' + (cfg.username ? ' como ' + cfg.username : '') + (cfg.plan ? ' · plano ' + cfg.plan : '') };
+}
+// compara versão instalada × última do npm → ok / warn (desatualizado)
+function _versionLevel(current, latest) {
+  if (!latest) return { level: 'warn', detail: 'v' + current + ' (não deu pra checar o npm)' };
+  if (current === latest) return { level: 'ok', detail: 'v' + current + ' (última)' };
+  return { level: 'warn', detail: 'v' + current + ' — última é v' + latest, dica: 'atualize: npm i -g terminal-smart-cli' };
+}
+// resumo agregado
+function _summary(results) {
+  return { total: results.length, ok: results.filter(r => r.level === 'ok').length,
+    warn: results.filter(r => r.level === 'warn').length, fail: results.filter(r => r.level === 'fail').length,
+    healthy: results.every(r => r.level !== 'fail') };
+}
+
+// binário presente? (cross-platform, best-effort — nunca lança)
+function hasBin(name) {
+  const cmd = process.platform === 'win32' ? 'where' : 'which';
+  try { const out = String(execFileSync(cmd, [name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 })).trim(); return out ? out.split(/\r?\n/)[0] : null; }
+  catch (_) { return null; }
+}
+
+// ── checks ────────────────────────────────────────────────────────────────────
+// opcionais: quando ausentes → warn (recurso desligado), não fail.
+const OPTIONAL_BINS = [
+  { bin: 'git', para: 'worktrees, versionamento', alt: [] },
+  { bin: 'yt-dlp', para: 'ts video (transcrição)', alt: ['youtube-dl'] },
+  { bin: 'monolith', para: 'ts arquivar (página→HTML)', alt: [] },
+];
+
+// run(opts): { cfg, version, base, api } — api opcional (fetch do backend/npm). Sempre resolve.
+async function run(opts = {}) {
+  const cfg = opts.cfg || {};
+  const results = [];
+
+  // 1) Node
+  const nv = process.version;
+  results.push({ nome: 'Node.js', level: _nodeOk(nv) ? 'ok' : 'fail', detail: nv + (_nodeOk(nv) ? '' : ' (precisa 18+)'), dica: _nodeOk(nv) ? undefined : 'instale Node 18 ou superior' });
+
+  // 2) config ~/.ts + login
+  const auth = _authLevel(cfg); results.push(Object.assign({ nome: 'Login' }, auth));
+  const dir = path.join(os.homedir(), '.ts');
+  results.push({ nome: 'Config (~/.ts)', level: fs.existsSync(dir) ? 'ok' : 'warn', detail: fs.existsSync(dir) ? dir : 'ainda não criado (normal se nunca rodou nada)' });
+
+  // 3) gateway/backend (rede, best-effort)
+  if (typeof opts.pingBackend === 'function') {
+    try { const ok = await opts.pingBackend(); results.push({ nome: 'Backend', level: ok ? 'ok' : 'warn', detail: ok ? (opts.base || 'acessível') : 'sem resposta', dica: ok ? undefined : 'cheque a conexão / status em terminalsmart.com.br' }); }
+    catch (_) { results.push({ nome: 'Backend', level: 'warn', detail: 'sem resposta' }); }
+  }
+
+  // 4) versão vs npm latest (rede, best-effort)
+  let latest = null;
+  if (typeof opts.latestVersion === 'function') { try { latest = await opts.latestVersion(); } catch (_) {} }
+  results.push(Object.assign({ nome: 'Versão' }, _versionLevel(opts.version || '?', latest)));
+
+  // 5) deps opcionais
+  for (const o of OPTIONAL_BINS) {
+    let found = hasBin(o.bin); for (const a of o.alt) if (!found) found = hasBin(a);
+    results.push({ nome: o.bin, level: found ? 'ok' : 'warn', detail: found ? found : ('ausente — ' + o.para + ' fica indisponível'), dica: found ? undefined : 'opcional; instale se for usar ' + o.para });
+  }
+
+  return { results, summary: _summary(results) };
+}
+
+module.exports = { run, hasBin, OPTIONAL_BINS, _test: { _nodeMajor, _nodeOk, _authLevel, _versionLevel, _summary } };

package/lib/eval.js

@@ -239,5 +239,38 @@ async function runSuite(suite, opts = {}) {
   return { summary, results };
 }
 
-module.exports = { loadSuite, normCases, runSuite, judge, smokeSuite, EXAMPLE,
-  _test: { _diff, _snap, _extractJson, normCases } };
+// ── MODEL LAB: roda a MESMA suíte em VÁRIOS executores e compara (bake-off automático) ──
+// Automatiza o "veredito modelo X" que antes era manual. O JUIZ é fixo (mesmo pra todos =
+// comparação justa); só o EXECUTOR muda. Ranqueia por qualidade VERIFICADA e depois por custo.
+function _rankModels(rows) {
+  // ordena: mais casos aprovados (passRate) → maior score médio → MENOR custo → mais rápido.
+  const sorted = [...rows].sort((a, b) =>
+    (b.passRate - a.passRate) || (b.avgScore - a.avgScore) || (a.credits - b.credits) || (a.ms - b.ms));
+  return { ranked: sorted, winner: sorted[0] ? sorted[0].model : null };
+}
+
+async function runMatrix(suite, opts = {}) {
+  const models = (opts.models || []).filter(Boolean);
+  if (!models.length) throw new Error('runMatrix precisa de opts.models (lista de executores)');
+  const onModel = opts.onModel || (() => {});
+  const rows = [];
+  for (const model of models) {
+    onModel({ model, phase: 'start' });
+    let sum;
+    try {
+      const r = await runSuite(suite, Object.assign({}, opts, { model, onCase: opts.onCase }));
+      sum = r.summary;
+    } catch (e) {
+      if (e && (e.code === 'no_credits' || e.status === 402)) throw e; // teto → aborta o bake-off
+      sum = { name: suite.name, total: suite.cases.length, passed: 0, failed: suite.cases.length, passRate: 0, avgScore: 0, credits: 0, judgeTokens: 0, ms: 0, error: String((e && e.message) || e).slice(0, 160) };
+    }
+    const row = { model, passRate: sum.passRate, avgScore: sum.avgScore, passed: sum.passed, total: sum.total, credits: sum.credits, judgeTokens: sum.judgeTokens, ms: sum.ms, error: sum.error || null };
+    rows.push(row);
+    onModel({ model, phase: 'done', row });
+  }
+  const rank = _rankModels(rows);
+  return { suite: suite.name, cases: suite.cases.length, rows, ranked: rank.ranked, winner: rank.winner };
+}
+
+module.exports = { loadSuite, normCases, runSuite, runMatrix, judge, smokeSuite, EXAMPLE,
+  _test: { _diff, _snap, _extractJson, normCases, _rankModels } };

package/lib/i18n.js

@@ -46,8 +46,11 @@ const STR = {
         ['ts meta "..." --criterios prova.json', 'só declara "verificada" se os critérios executáveis (verify) passarem de verdade'],
         ['ts meta "..." --provar', 'auto-deriva a prova da stack (roda os testes do projeto) — sem escrever json'],
         ['ts meta --status', 'estado da missão deste diretório'],
+        ['ts trilha', 'TIMELINE AUDITÁVEL da missão: checklist + rodadas + gates + PROVA + veredito (por que está pronta)'],
         ['ts eval suite.json', 'avalia o agente numa suíte de casos (juiz de IA + nota)'],
+        ['ts eval suite.json --modelos a,b,c', 'MODEL LAB: bake-off automático — mesma suíte em cada modelo + placar (qualidade→custo)'],
         ['ts verificar --cmd "npm test" --url ... --porta N', 'PROVA determinística de conclusão (build/http/porta/arquivo); exit 1 pra CI'],
+        ['ts runbook rodar <nome>', 'procedimento DevOps reexecutável: roda os passos (destrutivo pede OK) e PROVA o resultado'],
         ['ts acp', 'servidor Agent Client Protocol (conecta o ts a editores tipo Zed)'],
         ['ts mcp', 'servidores MCP: as ferramentas deles entram no agente'],
       ] },
@@ -61,6 +64,7 @@ const STR = {
         ['ts login · ts logout', 'conecta / desconecta este terminal'],
         ['ts uso', 'créditos e consumo do mês'],
         ['ts quem', 'conta conectada'],
+        ['ts doctor', 'diagnóstico do ambiente (Node, login, gateway, versão, deps opcionais)'],
         ['ts idioma pt|en', 'idioma (padrão pt-BR)'],
       ] },
     ],

package/lib/meta.js

@@ -977,7 +977,11 @@ function _tolerantJson(text) {
 
 const CHECKLIST_SYS = 'Quebre o OBJETIVO em itens VERIFICÁVEIS de entrega (3 a 15). Cada item deve ser '
   + 'concreto e conferível (arquivo criado, comando executado com sucesso, seção escrita) — nada vago tipo "melhorar". '
-  + 'Responda APENAS JSON: {"itens":[{"id":"i1","desc":"..."},...]}. Ordene na sequência lógica de execução.';
+  + 'Responda APENAS JSON: {"itens":[{"id":"i1","desc":"..."},...],"criterios":[...]}. Ordene os itens na sequência lógica de execução.\n'
+  + 'Em "criterios" (OPCIONAL, 0 a 6), proponha PROVAS EXECUTÁVEIS de que o objetivo foi cumprido — que uma MÁQUINA cheque sem julgamento. '
+  + 'Tipos válidos: {"type":"command","cmd":"npm test","exit":0} · {"type":"file_exists","path":"src/x.js"} · {"type":"file_contains","path":"server.js","text":"/api/login"} · {"type":"http","url":"http://localhost:3000/health","status":200} · {"type":"port","port":3000}. '
+  + 'PREFIRA file_exists/file_contains/command (seguros e baratos); só use http/port se o objetivo é claramente subir um servidor. '
+  + 'NÃO invente critério que possa FALHAR mesmo com a missão pronta. Na dúvida, "criterios":[].';
 
 // Pergunta BINÁRIA sobre o item alvo (modelo pequeno erra listas, mas acerta sim/não).
 const MARK_SYS = 'Você é o VERIFICADOR de uma missão. Recebe UM item do checklist e o RESULTADO da rodada que tentou executá-lo. '
@@ -987,11 +991,14 @@ const MARK_SYS = 'Você é o VERIFICADOR de uma missão. Recebe UM item do check
 const fmtChecklist = (itens) => itens.map(it => `[${it.passes ? 'x' : it.blocked ? '!' : ' '}] (${it.id}) ${it.desc}`).join('\n');
 
 async function makeChecklist(goal, token) {
-  const r = await _llmJson({ token, system: CHECKLIST_SYS, user: 'OBJETIVO:\n' + goal, maxTokens: 1600 });
+  const r = await _llmJson({ token, system: CHECKLIST_SYS, user: 'OBJETIVO:\n' + goal, maxTokens: 1800 });
   const itens = (Array.isArray(r.json?.itens) ? r.json.itens : []).slice(0, 15)
     .map((it, i) => ({ id: String(it.id || 'i' + (i + 1)), desc: String(it.desc || '').slice(0, 300), passes: false, attempts: 0 }))
     .filter(it => it.desc);
-  return { itens: itens.length ? itens : [{ id: 'i1', desc: String(goal).slice(0, 300), passes: false, attempts: 0 }], credits: r.credits };
+  // Critérios propostos pelo planner → VALIDADOS pelo compilador (formato conhecido; malformados caem fora).
+  let criteria = [];
+  try { criteria = require('./verify').compileCriteria(r.json?.criterios || []).criteria.slice(0, 6); } catch (_) {}
+  return { itens: itens.length ? itens : [{ id: 'i1', desc: String(goal).slice(0, 300), passes: false, attempts: 0 }], criteria, credits: r.credits };
 }
 
 /**
@@ -1016,7 +1023,7 @@ async function _checkCriteria(st, dir) {
 }
 
 async function run(goal, opts = {}) {
-  const { token, lang = 'pt', yes = false, budget = 400, maxRounds = 20, dir = process.cwd(), model = null, thinker = null, maxMinutes = 0, designer = null, design = 'auto', runGate = true, eye = null, visualLadder = true } = 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 onChecklist = opts.onChecklist || (() => {});
   const onRound = opts.onRound || (() => {});
   const onRoundDone = opts.onRoundDone || (() => {});
@@ -1056,8 +1063,15 @@ async function run(goal, opts = {}) {
       try { const a = await archPhase(goal, archModel, token, { dir }); archBrief = a.brief; archCred = a.credits || 0; try { fs.writeFileSync(path.join(dir, 'ARQUITETURA.md'), archBrief); } catch (_) {} onAlert({ type: 'design', text: `📐 ts: contrato de arquitetura criado pelo ${archModel} (${archCred} créditos) — componentes, arquivos e assinaturas fixados. Salvo em ARQUITETURA.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
     }
     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.
+    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);
     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: Array.isArray(opts.criteria) ? opts.criteria : [], created_at: new Date().toISOString() };
+      budget, maxRounds, status: 'running', model: model || null, designBrief: designBrief || null, criteria: _criteria, plannedCriteria: _planned, created_at: new Date().toISOString() };
     save(st, dir);
   } else {
     st.status = 'running';
@@ -1396,4 +1410,32 @@ function verificationLabel(ver, lang) {
   }
 }
 
-module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision, verificationLabel, _checkCriteria };
+// TRILHA AUDITÁVEL (Evidence Ledger da missão): responde "por que está concluída e como
+// cheguei aqui" a partir do estado salvo — SEM confiar na narrativa. Função PURA/testável.
+function trailSummary(st, lang) {
+  const en = lang === 'en';
+  const cl = Array.isArray(st.checklist) ? st.checklist : [];
+  const rounds = Array.isArray(st.rounds) ? st.rounds : [];
+  const ver = verificationLabel(st.verification, lang);
+  const done = cl.filter(i => i.passes).length;
+  const mins = (st.created_at && st.finished_at) ? Math.round((new Date(st.finished_at) - new Date(st.created_at)) / 60000) : null;
+  let verdict;
+  if (st.status !== 'done') verdict = (en ? 'Not finished — status: ' : 'Não concluída — status: ') + st.status + (st.pause_reason ? ' (' + st.pause_reason + ')' : '');
+  else if (st.verification === 'verified') verdict = en ? 'Done and VERIFIED: gates and criteria passed.' : 'Concluída e VERIFICADA: gates e critérios passaram.';
+  else if (st.verification === 'unverified') verdict = en ? 'Ended WITHOUT full proof (fix limit / gate) — check before relying.' : 'Encerrada SEM prova completa (teto de correções / gate) — confira antes de confiar.';
+  else if (st.verification === 'built_not_run') verdict = en ? 'Built, but execution was NOT verified.' : 'Compilou, mas a execução NÃO foi verificada.';
+  else verdict = en ? 'Done (no build/run gate applied for this task).' : 'Concluída (sem gate de build/execução p/ esta tarefa).';
+  return {
+    goal: st.goal, status: st.status, verification: ver,
+    checklist: cl.map(i => ({ id: i.id, desc: i.desc, state: i.passes ? 'done' : i.blocked ? 'blocked' : 'pending' })),
+    progress: { done, total: cl.length },
+    rounds: rounds.map((r, i) => ({ n: i + 1, item: r.item, steps: r.steps || 0, credits: r.credits || 0, snippet: String(r.result || '').replace(/\s+/g, ' ').slice(0, 120) })),
+    gates: { build: !!st.buildVerified, run: !!st.runVerified, visual: !!st.visualOk },
+    proof: st.verifyReport && st.verifyReport.total ? { passed: st.verifyReport.passed, total: st.verifyReport.total, results: st.verifyReport.results } : null,
+    cost: { credits: st.creditsSpent || 0, rounds: rounds.length, escalations: st.escalations || 0, minutes: mins },
+    note: st.runNote || null,
+    verdict,
+  };
+}
+
+module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision, verificationLabel, _checkCriteria, trailSummary };

package/lib/recovery.js

@@ -0,0 +1,72 @@
+// RECOVERY ENGINE — conhecimento de conserto codificado POR CLASSE de erro.
+// Insight das análises externas (GPT): "cada classe de erro deve ter sondas e estratégias
+// conhecidas; só escalar pro modelo forte após 2 estratégias falharem". Aqui, quando uma
+// ferramenta falha com classe CONHECIDA (core.classifyToolResult), injetamos a estratégia
+// certa no resultado que o modelo lê — ele aplica o conserto DevOps padrão em vez de chutar
+// (ex.: porta ocupada → matar SÓ o PID, nunca por nome; que era justo o loop do incidente).
+'use strict';
+
+// Cada classe: como DIAGNOSTICAR (sonda só-leitura) e como CONSERTAR (ação segura e cirúrgica).
+const STRATEGIES = {
+  port_in_use: {
+    diag: 'ache o PID que segura a porta — Linux: `ss -ltnp | grep :<porta>` ou `lsof -i:<porta>`; Windows: `netstat -ano | findstr :<porta>`',
+    fix: 'mate SÓ aquele PID (`kill <pid>` / `taskkill /F /PID <pid>`) — NUNCA por nome (mata processos demais, inclusive o seu). OU suba o serviço em outra porta.',
+  },
+  missing_dep: {
+    diag: 'confirme o nome EXATO do módulo/binário que faltou na mensagem de erro',
+    fix: 'instale-o: Node `npm i <pkg>` · Python `pip install <pkg>` · sistema `sudo DEBIAN_FRONTEND=noninteractive apt-get install -y <pkg>` (timeout_s alto). Depois re-tente o comando original.',
+  },
+  package_lock: {
+    diag: 'veja qual processo segura o lock (apt/dpkg/npm) — NÃO o mate no meio',
+    fix: 'espere o processo dono do lock terminar e re-tente. Se o dpkg foi interrompido antes: `sudo dpkg --configure -a`. Nunca apague o lockfile na força.',
+  },
+  permission_denied: {
+    diag: 'cheque dono e modo do alvo: `ls -l <caminho>` (Linux) / atributos do arquivo',
+    fix: 'ajuste o dono/modo do arquivo ESPECÍFICO (`chown user:grp <arquivo>` / `chmod u+w <arquivo>`) ou use sudo só onde apropriado. NUNCA `chmod 777` nem recursivo na raiz.',
+  },
+  not_found: {
+    diag: 'confirme o caminho/rota EXATO com `listar_diretorio`/`buscar_arquivos` (maiúsculas e plural contam)',
+    fix: 'crie o arquivo/rota que falta OU corrija a referência pro caminho certo. Não invente o caminho — verifique antes.',
+  },
+  network: {
+    diag: 'teste a conectividade: `curl -I <url>` / `ping <host>` / cheque DNS e se o serviço-alvo está no ar',
+    fix: 're-tente com backoff; confirme URL/porta/firewall. Se o alvo estiver fora, reporte isso ao usuário em vez de insistir.',
+  },
+  timeout: {
+    diag: 'o comando demorou mais que o limite — veja se é build/install pesado ou algo travado',
+    fix: 'aumente o timeout (`timeout_s` maior) OU quebre em passos menores. Para build/install use timeout longo (300s+).',
+  },
+  compile_error: {
+    diag: 'leia a mensagem: ela dá ARQUIVO e LINHA do erro',
+    fix: 'vá DIRETO à linha (`buscar_codigo`/`ler_arquivo`) e conserte só o trecho (`editar_arquivo` por âncora) — não reescreva o arquivo inteiro. Confira sintaxe/tipos ao redor.',
+  },
+  test_failed: {
+    diag: 'rode o teste específico que falhou e leia o assert (esperado × obtido)',
+    fix: 'corrija a CAUSA no código (não o teste, a menos que o teste esteja claramente errado). Re-rode só aquele teste até passar.',
+  },
+  auth: {
+    diag: 'cheque token/credencial/variável de ambiente exigida (sem logar o segredo)',
+    fix: 'corrija a credencial/escopo. Se depende de um segredo do usuário, PARE e peça a ele — não chute nem exponha valores.',
+  },
+  git_conflict: {
+    diag: 'veja os arquivos em conflito: `git status`',
+    fix: 'abra cada arquivo, resolva os marcadores `<<<<<<<`/`=======`/`>>>>>>>`, `git add` e conclua o merge/rebase. Não faça `push --force`.',
+  },
+  invalid_schema: {
+    diag: 'valide a estrutura (JSON/YAML): vírgulas, aspas, chaves balanceadas',
+    fix: 'corrija o campo apontado; valide de novo antes de reusar.',
+  },
+};
+
+const RECOVERABLE = Object.keys(STRATEGIES); // classes com estratégia conhecida (unknown/blocked não têm)
+
+function strategiesFor(errorClass) { return STRATEGIES[errorClass] || null; }
+
+// Texto acionável pra INJETAR no resultado da ferramenta que o modelo lê. '' se classe sem estratégia.
+function recoveryHint(errorClass) {
+  const s = STRATEGIES[errorClass];
+  if (!s) return '';
+  return `ESTRATÉGIA CONHECIDA (${errorClass}) — não chute:\n1) DIAGNOSTIQUE: ${s.diag}\n2) CONSERTO: ${s.fix}`;
+}
+
+module.exports = { STRATEGIES, RECOVERABLE, strategiesFor, recoveryHint };

package/lib/runbook.js

@@ -0,0 +1,93 @@
+// RUNBOOKS EXECUTÁVEIS — procedimentos DevOps reexecutáveis e AUTO-VERIFICÁVEIS.
+// Insight das análises externas (GPT): "transforme uma execução aprovada e bem-sucedida em
+// runbook tipado; na próxima vez o harness roda determinístico e só chama IA se houver desvio".
+// Um runbook = PASSOS (comandos) + CRITÉRIOS (verify). Roda os passos (destrutivo pede
+// aprovação; auto-destrutivo é recusado na hora) e PROVA o resultado com os verificadores.
+// Zero IA por padrão. Ex.: "deploy", "backup do banco", "configurar nginx", "renovar SSL".
+'use strict';
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const core = require('./core');
+const tools = require('./tools');
+const verify = require('./verify');
+
+const DIR = path.join(os.homedir(), '.ts', 'runbooks');
+const file = (nome) => path.join(DIR, _slug(nome) + '.json');
+function _slug(n) { return String(n || '').toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'runbook'; }
+
+// ── persistência ─────────────────────────────────────────────────────────────
+function list() {
+  try { return fs.readdirSync(DIR).filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, '')); } catch (_) { return []; }
+}
+function load(nome) { try { return JSON.parse(fs.readFileSync(file(nome), 'utf8')); } catch (_) { return null; } }
+function save(nome, rb) {
+  fs.mkdirSync(DIR, { recursive: true });
+  const obj = Object.assign({}, rb, { nome: _slug(nome) });
+  fs.writeFileSync(file(nome), JSON.stringify(obj, null, 2));
+  return obj;
+}
+function remove(nome) { try { fs.unlinkSync(file(nome)); return true; } catch (_) { return false; } }
+
+// template inicial pro `ts runbook novo`
+function template(nome) {
+  return {
+    nome: _slug(nome), descricao: '',
+    passos: [{ desc: 'exemplo — troque pelo comando real', cmd: 'echo hello', remoto: '' }],
+    criterios: [{ type: 'command', cmd: 'echo ok', exit: 0, label: 'prova de que deu certo' }],
+  };
+}
+
+// ── validação (determinística) ────────────────────────────────────────────────
+function validate(rb) {
+  const erros = [];
+  if (!rb || typeof rb !== 'object') return { ok: false, erros: ['runbook vazio/ inválido'] };
+  const passos = Array.isArray(rb.passos) ? rb.passos : [];
+  if (!passos.length) erros.push('sem passos');
+  passos.forEach((p, i) => { if (!p || !String(p.cmd || '').trim()) erros.push('passo ' + (i + 1) + ' sem "cmd"'); });
+  const crit = Array.isArray(rb.criterios) ? rb.criterios : [];
+  const comp = verify.compileCriteria(crit);
+  if (crit.length && !comp.criteria.length) erros.push('nenhum critério válido (' + crit.length + ' descartado[s])');
+  return { ok: erros.length === 0, erros, criterios: comp.criteria, droppedCriterios: comp.dropped.length };
+}
+
+// ── execução ──────────────────────────────────────────────────────────────────
+// Roda 1 comando (local ou ssh remoto), captura code/saída — nunca lança.
+function _run(cmd, remoto) {
+  const full = remoto ? `${remoto} ${JSON.stringify(cmd)}` : cmd;
+  try { const out = execSync(full, { encoding: 'utf8', timeout: 600000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }); return { code: 0, out }; }
+  catch (e) { return { code: typeof e.status === 'number' ? e.status : 1, out: String((e.stdout || '') + (e.stderr || '') || e.message || '').slice(0, 4000) }; }
+}
+
+// opts: { cwd, onStep({idx,total,desc,cmd,phase,code,ok}), askApprove(cmd)->bool, yes }
+// Passo destrutivo (core.isDestructive) → askApprove; auto-destrutivo local → RECUSA na hora.
+// Um passo que falha (code≠0) INTERROMPE a execução (não segue com o ambiente meio-quebrado).
+// No fim, roda os CRITÉRIOS (verify) e devolve o veredito honesto.
+async function run(rb, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const onStep = opts.onStep || (() => {});
+  const askApprove = opts.askApprove || (async () => false);
+  const v = validate(rb);
+  if (!v.ok) return { ok: false, erro: 'runbook inválido: ' + v.erros.join('; '), passos: [], verify: null };
+
+  const passos = rb.passos, total = passos.length, done = [];
+  for (let i = 0; i < total; i++) {
+    const p = passos[i]; const cmd = String(p.cmd).trim(); const remoto = p.remoto || '';
+    onStep({ idx: i, total, desc: p.desc || '', cmd, phase: 'start' });
+    // auto-destrutivo LOCAL (mata a própria máquina/missão) → recusa imediata, sem aprovação
+    if (!remoto) { const sd = tools.selfDestructiveReason(cmd, { cwd }); if (sd) { const r = { idx: i, cmd, ok: false, code: -1, motivo: sd }; done.push(r); onStep({ ...r, phase: 'refused' }); return { ok: false, erro: 'passo ' + (i + 1) + ' recusado: ' + sd, passos: done, verify: null }; } }
+    // destrutivo → precisa de aprovação (a menos de --yes, que o chamador decide via askApprove)
+    if (core.isDestructive(cmd)) { const okA = await askApprove(cmd); if (!okA) { const r = { idx: i, cmd, ok: false, code: -1, motivo: 'não aprovado' }; done.push(r); onStep({ ...r, phase: 'denied' }); return { ok: false, erro: 'passo ' + (i + 1) + ' (destrutivo) não aprovado', passos: done, verify: null }; } }
+    const res = _run(cmd, remoto);
+    const r = { idx: i, cmd, ok: res.code === 0, code: res.code, out: String(res.out).slice(-300) };
+    done.push(r); onStep({ ...r, phase: 'done' });
+    if (!r.ok) return { ok: false, erro: 'passo ' + (i + 1) + ' falhou (exit ' + res.code + ')', passos: done, verify: null };
+  }
+  // PROVA: roda os critérios de verificação
+  let rep = null;
+  if (v.criterios.length) { onStep({ phase: 'verify', total: v.criterios.length }); rep = await verify.runAll(v.criterios, { cwd }); }
+  return { ok: !rep || rep.allOk, passos: done, verify: rep };
+}
+
+module.exports = { list, load, save, remove, template, validate, run, DIR, _slug };

package/package.json

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