terminal-smart-cli 0.64.0 → 0.66.0

package/bin/ts.js

@@ -1183,6 +1183,14 @@ async function metaCmd() {
   const intervaloMin = flagNum('--intervalo', 5); // min de espera entre janelas ao aguardar crédito
   // Anti-loop-infinito: se ninguém definiu teto, cai num limite de janelas seguro.
   const maxJanelasEff = maxJanelas || ((budgetTotal || maxHoras) ? 0 : 20);
+  // 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".
+  let criteria = [];
+  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')); criteria = Array.isArray(j) ? j : (j.criteria || []); }
+    catch (e) { console.error(ui.errLine((cfg.lang === 'en' ? 'criteria file: ' : 'arquivo de critérios: ') + (e.message || e))); process.exit(2); }
+  }
 
   const existing = metaMod.load(dir);
   if (FLAGS.has('--status')) {
@@ -1229,7 +1237,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,
+        token, lang: cfg.lang || 'pt', yes, budget, maxRounds, dir, model: forcedModel, thinker, maxMinutes, designer, design, eye, visualLadder, mockup, arch, criteria,
         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('⏱');
@@ -1304,6 +1312,11 @@ async function metaCmd() {
     const _vtag = (_vl.ok ? C.ok : C.warn)(` · ${_vl.icon} ${_vl.txt}`);
     console.log((_vl.ok ? ui.okLine : ui.infoLine)(C.bold(T.meta_done) + C.dim(` · ${st.rounds.length} rodada(s) · ${st.creditsSpent} créditos · ${secs} min` + (st.escalations ? ` · ${st.escalations} escalonamento(s)` : '')) + _vtag));
     if (!_vl.ok) console.log('  ' + C.dim((cfg.lang === 'en' ? 'Heads up: the deliverable was produced but NOT fully proven — check it before relying on it.' : 'Atenção: o entregável foi produzido mas NÃO foi totalmente provado — confira antes de confiar.') + (st.runNote ? ' (' + String(st.runNote).trim() + ')' : '')));
+    // Evidence Ledger da missão: mostra cada critério executável provado/falho.
+    if (st.verifyReport && st.verifyReport.total) {
+      console.log('  ' + C.dim((cfg.lang === 'en' ? 'Criteria: ' : 'Critérios: ') + st.verifyReport.passed + '/' + st.verifyReport.total));
+      for (const r of st.verifyReport.results) console.log('    ' + (r.ok ? C.ok('✔') : C.err('✗')) + ' ' + C.dim((r.label || '') + (r.ok ? '' : '  — ' + (r.detail || ''))));
+    }
     metaMod.notify(token, T.meta_notify_done(st.goal, done, st.creditsSpent) + (_vl.ok ? '' : `\n⚠️ ${_vl.txt}`));
   } else if (st.pause_reason === 'awaiting_human' && st.humanRequest) {
     console.log(ui.infoLine(C.bold('🙋 Preciso de você: ') + st.humanRequest.motivo));
@@ -1671,6 +1684,49 @@ function buscarCmd(args) {
   ], { title: 'ts buscar' }));
 }
 
+// ── ts verificar — PROVA determinística de que a tarefa terminou (verificadores) ──
+async function verificarCmd(args) {
+  const en = (cfg.lang === 'en');
+  const _fs = require('fs');
+  const verify = require('../lib/verify');
+  const _val = (names) => { const i = rawArgs.findIndex(a => names.includes(a)); return i >= 0 ? rawArgs[i + 1] : null; };
+  const cwd = process.cwd();
+
+  // 1) arquivo de critérios (JSON: array ou {criteria:[...]}) OU 2) critérios inline via flags
+  let criteria = [];
+  const file = (args || []).find(a => !a.startsWith('-') && /\.json$/i.test(a));
+  if (file) {
+    try { const j = JSON.parse(_fs.readFileSync(file, 'utf8')); criteria = Array.isArray(j) ? j : (j.criteria || []); }
+    catch (e) { console.log(ui.errLine((en ? 'could not read criteria file: ' : 'não deu pra ler o arquivo de critérios: ') + (e.message || e))); process.exit(2); }
+  } else {
+    const cmd = _val(['--cmd', '--comando']); if (cmd) criteria.push({ type: 'command', cmd, exit: Number(_val(['--exit', '--codigo'])) || 0 });
+    const ex = _val(['--existe', '--exists']); if (ex) criteria.push({ type: 'file_exists', path: ex });
+    const arq = _val(['--arquivo', '--file']); const cont = _val(['--contem', '--contains']);
+    if (arq && cont != null) criteria.push({ type: 'file_contains', path: arq, text: cont });
+    const url = _val(['--url']); if (url) criteria.push({ type: 'http', url, status: Number(_val(['--status'])) || 200, ...(cont != null && !arq ? { contains: cont } : {}) });
+    const porta = _val(['--porta', '--port']); if (porta) criteria.push({ type: 'port', port: Number(porta) });
+  }
+  if (!criteria.length) {
+    console.log(ui.infoLine(en
+      ? 'usage: ts verificar criterios.json  OR  ts verificar --cmd "npm test" --url http://localhost:3000/health --status 200 --porta 3000 --existe dist/app.js'
+      : 'uso: ts verificar criterios.json  OU  ts verificar --cmd "npm test" --url http://localhost:3000/health --status 200 --porta 3000 --existe dist/app.js'));
+    return;
+  }
+
+  if (!JSON_OUT) console.log('\n' + C.dim(en ? 'proving completion — ' : 'provando conclusão — ') + criteria.length + (en ? ' criterion(s)…' : ' critério(s)…'));
+  const rep = await verify.runAll(criteria, { cwd });
+  if (JSON_OUT) { console.log(JSON.stringify(rep)); process.exit(rep.allOk ? 0 : 1); }
+
+  for (const r of rep.results) {
+    const mark = r.ok ? C.ok('✔') : C.err('✗');
+    console.log('  ' + mark + ' ' + C.bold(r.label || r.type) + C.dim('  ' + (r.detail || '')) + (r.errorClass ? C.dim('  [' + r.errorClass + ']') : ''));
+    if (!r.ok && r.evidence) console.log('    ' + C.dim('┄ ' + String(r.evidence).slice(0, 120)));
+  }
+  console.log('\n' + (rep.allOk ? ui.okLine : ui.errLine)(
+    (rep.allOk ? (en ? 'VERIFIED' : 'VERIFICADO') : (en ? 'NOT verified' : 'NÃO verificado')) + C.dim(`  ${rep.passed}/${rep.total} ` + (en ? 'passed' : 'ok'))));
+  process.exit(rep.allOk ? 0 : 1);
+}
+
 // ── ts perfil — personas com COFRE DE MEMÓRIA isolado (Mempalace/Hermes) ──────
 function perfilCmd(args) {
   const en = (cfg.lang === 'en');
@@ -1933,6 +1989,7 @@ function recallCmd(args) {
     case 'indexar': case 'index': return indexarCmd();
     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 'meta': case 'missao': case 'mission': return metaCmd();
     case 'runs':   return runsCmd();
     case 'status': return statusCmd(POS[1]);

package/lib/i18n.js

@@ -43,8 +43,10 @@ const STR = {
         ['ts agente --continuar "..."', 'retoma o trabalho anterior desta pasta'],
         ['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'],
         ['ts meta --status', 'estado da missão deste diretório'],
         ['ts eval suite.json', 'avalia o agente numa suíte de casos (juiz de IA + nota)'],
+        ['ts verificar --cmd "npm test" --url ... --porta N', 'PROVA determinística de conclusão (build/http/porta/arquivo); exit 1 pra CI'],
         ['ts acp', 'servidor Agent Client Protocol (conecta o ts a editores tipo Zed)'],
         ['ts mcp', 'servidores MCP: as ferramentas deles entram no agente'],
       ] },

package/lib/meta.js

@@ -1001,6 +1001,20 @@ async function makeChecklist(goal, token) {
  *       onStep/askApprove/onRemote (repassados pro agente)
  * Retorna o estado final {status: done|paused, ...}.
  */
+// 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.
+async function _checkCriteria(st, dir) {
+  if (!st.criteria || !st.criteria.length) return true;
+  try {
+    const rep = await require('./verify').runAll(st.criteria, { cwd: 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; }
+}
+
 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 onChecklist = opts.onChecklist || (() => {});
@@ -1043,7 +1057,7 @@ 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);
     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, created_at: new Date().toISOString() };
+      budget, maxRounds, status: 'running', model: model || null, designBrief: designBrief || null, criteria: Array.isArray(opts.criteria) ? opts.criteria : [], created_at: new Date().toISOString() };
     save(st, dir);
   } else {
     st.status = 'running';
@@ -1126,9 +1140,9 @@ async function run(goal, opts = {}) {
                   // Aprovado: impecável OU só com nitpicks cosméticos (não vale queimar rodada cara).
                   st.visualOk = true;
                   if (vg.severity === 'ressalvas') { st.runNote = (st.runNote || '') + ' visual aprovado com ressalvas cosméticas (sem defeito estrutural)'; onAlert({ type: 'design', text: `👁 ts: visual APROVADO — sobrou só nitpick cosmético (sem defeito estrutural). Não vou gastar polimento caro à toa.` }); }
-                  st.verification = 'verified'; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+                  st.verification = (await _checkCriteria(st, dir)) ? 'verified' : 'unverified'; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
                 }
-              } else { st.visualOk = true; st.verification = 'verified'; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st; }
+              } else { st.visualOk = true; st.verification = (await _checkCriteria(st, dir)) ? 'verified' : 'unverified'; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st; }
             } else {
               // CRASHOU ao abrir → trata como erro pro executor corrigir (loop igual ao build)
               st.buildFixes = (st.buildFixes || 0) + 1;
@@ -1143,7 +1157,8 @@ async function run(goal, opts = {}) {
             let wg = { ok: true }; try { wg = await webRunGate(b, { token, eye, eyeGate: !!eye && (st.visualFixes || 0) < MAX_VISUAL_FIXES }); } catch (_) {}
             st.creditsSpent += wg.credits || 0;
             if (wg.ok) {
-              st.buildVerified = true; st.runVerified = true; st.visualOk = true; st.verification = 'verified';
+              st.buildVerified = true; st.runVerified = true; st.visualOk = true;
+              st.verification = (await _checkCriteria(st, dir)) ? 'verified' : 'unverified';
               if (wg.shot) st.webShot = wg.shot;
               st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
             } else {
@@ -1381,4 +1396,4 @@ 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 };
+module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision, verificationLabel, _checkCriteria };

package/lib/verify.js

@@ -0,0 +1,104 @@
+// VERIFICADORES POR DOMÍNIO — a PROVA determinística de que uma tarefa terminou.
+// Insight das análises externas (GPT): "o modelo propõe; o harness observa e COMPROVA".
+// Cada critério é EXECUTÁVEL e checado por código (não pela narrativa do modelo nem por um
+// LLM-judge). É a base do TaskSpec (critérios executáveis) e do Evidence Ledger, e o motor
+// do comando `ts verificar` (o "Prove que terminou"). Usa o classificador de erro do core.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+const { execSync } = require('child_process');
+const core = require('./core');
+
+// ── verificadores individuais (cada um devolve { ok, detail }) ───────────────
+function _abs(cwd, p) { return path.isAbsolute(p) ? p : path.join(cwd || process.cwd(), p); }
+
+function vCommand(c, cwd) {
+  const want = c.exit != null ? Number(c.exit) : 0;
+  try {
+    const out = execSync(c.cmd, { cwd, encoding: 'utf8', timeout: (c.timeout_s || 120) * 1000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    const ok = want === 0;
+    return { ok, detail: ok ? 'exit 0' : `exit 0 mas esperava ${want}`, evidence: String(out).slice(-200).replace(/\s+/g, ' ') };
+  } catch (e) {
+    const code = typeof e.status === 'number' ? e.status : 1;
+    const ok = code === want;
+    const cls = core.classifyError(e.stderr || e.stdout || e.message);
+    return { ok, detail: ok ? `exit ${code} (esperado)` : `exit ${code} (esperava ${want})`, errorClass: ok ? null : cls, evidence: String(e.stderr || e.stdout || e.message || '').slice(-200).replace(/\s+/g, ' ') };
+  }
+}
+function vFileExists(c, cwd) { const p = _abs(cwd, c.path); const ok = fs.existsSync(p); return { ok, detail: ok ? 'existe' : 'não existe: ' + c.path }; }
+function vFileAbsent(c, cwd) { const p = _abs(cwd, c.path); const ok = !fs.existsSync(p); return { ok, detail: ok ? 'ausente (ok)' : 'existe (não deveria): ' + c.path }; }
+function vFileContains(c, cwd) {
+  const p = _abs(cwd, c.path);
+  let src = null; try { src = fs.readFileSync(p, 'utf8'); } catch (_) { return { ok: false, detail: 'não deu pra ler: ' + c.path }; }
+  const hit = c.regex ? new RegExp(c.text, c.flags || '').test(src) : src.includes(c.text);
+  const want = c.absent ? !hit : hit;
+  return { ok: want, detail: want ? 'ok' : (c.absent ? `contém "${c.text}" (não deveria)` : `NÃO contém "${c.text}"`) };
+}
+async function vHttp(c) {
+  const want = c.status != null ? Number(c.status) : 200;
+  const ctrl = new AbortController(); const t = setTimeout(() => ctrl.abort(), (c.timeout_s || 15) * 1000);
+  try {
+    const res = await fetch(c.url, { method: c.method || 'GET', signal: ctrl.signal, headers: c.headers || {}, ...(c.body ? { body: typeof c.body === 'string' ? c.body : JSON.stringify(c.body) } : {}) });
+    let body = ''; try { body = await res.text(); } catch (_) {}
+    const statusOk = res.status === want;
+    const containsOk = c.contains ? body.includes(c.contains) : true;
+    const ok = statusOk && containsOk;
+    return { ok, detail: ok ? `HTTP ${res.status}` : (!statusOk ? `HTTP ${res.status} (esperava ${want})` : `HTTP ${res.status} mas sem "${c.contains}"`), evidence: body.slice(0, 160).replace(/\s+/g, ' ') };
+  } catch (e) { return { ok: false, detail: 'sem resposta: ' + (e.message || e), errorClass: 'network' }; }
+  finally { clearTimeout(t); }
+}
+function vPort(c) {
+  return new Promise((resolve) => {
+    const host = c.host || '127.0.0.1'; const port = Number(c.port);
+    const sock = new net.Socket(); let done = false;
+    const finish = (ok, detail) => { if (done) return; done = true; try { sock.destroy(); } catch (_) {} resolve({ ok, detail }); };
+    sock.setTimeout((c.timeout_s || 5) * 1000);
+    sock.once('connect', () => finish(true, `porta ${port} escutando`));
+    sock.once('timeout', () => finish(false, `porta ${port} sem resposta (timeout)`));
+    sock.once('error', () => finish(false, `porta ${port} fechada/recusada`));
+    sock.connect(port, host);
+  });
+}
+
+const VERIFIERS = {
+  command: (c, cwd) => vCommand(c, cwd),
+  file_exists: (c, cwd) => vFileExists(c, cwd),
+  file_absent: (c, cwd) => vFileAbsent(c, cwd),
+  file_contains: (c, cwd) => vFileContains(c, cwd),
+  http: (c) => vHttp(c),
+  port: (c) => vPort(c),
+};
+const VERIFIER_TYPES = Object.keys(VERIFIERS);
+
+// Roda UM critério. Sempre resolve { ok, type, detail, ... } — nunca lança.
+async function runCriterion(c, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const type = c && c.type;
+  const fn = VERIFIERS[type];
+  if (!fn) return { ok: false, type: type || '?', detail: 'tipo de critério desconhecido: ' + type, unknown: true };
+  try { const r = await fn(c, cwd); return Object.assign({ type, label: c.label || _labelFor(c) }, r); }
+  catch (e) { return { ok: false, type, label: c.label || _labelFor(c), detail: 'erro no verificador: ' + (e.message || e) }; }
+}
+function _labelFor(c) {
+  switch (c.type) {
+    case 'command': return '`' + String(c.cmd).slice(0, 50) + '` → exit ' + (c.exit != null ? c.exit : 0);
+    case 'file_exists': return 'existe ' + c.path;
+    case 'file_absent': return 'ausente ' + c.path;
+    case 'file_contains': return c.path + (c.absent ? ' SEM ' : ' contém ') + '"' + String(c.text).slice(0, 30) + '"';
+    case 'http': return (c.method || 'GET') + ' ' + c.url + ' → ' + (c.status || 200);
+    case 'port': return 'porta ' + c.port + ' escutando';
+    default: return c.type || '?';
+  }
+}
+
+// Roda uma LISTA de critérios. Retorna resumo + resultados (o Evidence Ledger mínimo).
+async function runAll(criteria, opts = {}) {
+  const list = Array.isArray(criteria) ? criteria : (criteria && Array.isArray(criteria.criteria) ? criteria.criteria : []);
+  const results = [];
+  for (const c of list) results.push(await runCriterion(c, opts));
+  const passed = results.filter(r => r.ok).length;
+  return { allOk: results.length > 0 && passed === results.length, passed, total: results.length, results };
+}
+
+module.exports = { runCriterion, runAll, VERIFIERS, VERIFIER_TYPES, _labelFor };

package/package.json

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