terminal-smart-cli 0.67.0 → 0.69.0

package/bin/ts.js

@@ -1185,18 +1185,18 @@ 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);
@@ -1244,7 +1244,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('⏱');

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/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';

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

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