terminal-smart-cli 0.69.0 → 0.74.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');
@@ -1200,6 +1231,7 @@ async function metaCmd() {
   }
 
   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;
@@ -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/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

@@ -1410,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/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/lib/shared.js

@@ -0,0 +1,55 @@
+// ⌁ NÚCLEO CANÔNICO PORTÁVEL do Terminal Smart — o "@terminal-smart/agent-core" mínimo.
+//
+// Convergência F4 (análises GPT): a Web e o App reimplementavam de forma divergente a mesma
+// lógica de gate/erro/verificação → risco de comportamento inconsistente entre superfícies
+// (um comando bloqueado no CLI e liberado no App). Este ponto de entrada reúne o subconjunto
+// do motor que NÃO depende do CLI (nada de api/ui/config/agent/tools) — só Node builtins e
+// estes 4 módulos — pra QUALQUER superfície consumir a MESMA fonte de verdade.
+//
+// Como a Web/App consomem: copiar core.js + verify.js + recovery.js + stack.js + shared.js
+// para o backend (ou publicar como pacote npm e depender dele). ZERO mudança de runtime.
+//
+// Garantia: test/core.test.js tem um GUARDA que falha se qualquer um destes módulos passar a
+// importar algo específico do CLI — mantendo o núcleo portável para sempre.
+'use strict';
+const core = require('./core');
+const verify = require('./verify');
+const recovery = require('./recovery');
+const stack = require('./stack');
+
+module.exports = {
+  // namespaces completos
+  core, verify, recovery, stack,
+
+  // ── atalhos das capacidades mais usadas (a superfície importa daqui) ──
+  // Gate de destrutivo (fonte única — App/Web param de ter regex divergente)
+  isDestructive: core.isDestructive,
+  DESTRUCTIVE: core.DESTRUCTIVE,
+  // ToolResult tipado + classes de erro (erro nunca vira "concluído")
+  classifyToolResult: core.classifyToolResult,
+  classifyError: core.classifyError,
+  ERROR_CLASSES: core.ERROR_CLASSES,
+  RETRYABLE_CLASSES: core.RETRYABLE_CLASSES,
+  // Janela de contexto / compactação
+  winFor: core.winFor,
+  estMsgsTok: core.estMsgsTok,
+  COMPACT_AT: core.COMPACT_AT,
+  KEEP_TAIL: core.KEEP_TAIL,
+  DEFAULT_EXECUTOR: core.DEFAULT_EXECUTOR,
+  // Envelope de eventos (contrato stream-json único)
+  AgentEvents: core.AgentEvents,
+  EVENT_TYPES: core.EVENT_TYPES,
+  // Verificadores + TaskSpec (o modelo propõe, o harness valida e prova)
+  runCriteria: verify.runAll,
+  runCriterion: verify.runCriterion,
+  compileCriteria: verify.compileCriteria,
+  deriveFromStack: verify.deriveFromStack,
+  // Recovery Engine (estratégia de conserto por classe de erro)
+  recoveryHint: recovery.recoveryHint,
+  strategiesFor: recovery.strategiesFor,
+  // Detector de stack
+  detectStack: stack.detectStack,
+
+  // versão do contrato (bump quando a forma dos exports/eventos mudar)
+  CORE_CONTRACT: 1,
+};

package/package.json

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