terminal-smart-cli 0.73.0 → 0.75.0

package/lib/core.js

@@ -109,7 +109,20 @@ function classifyError(msg) {
 // NÃO muta o raw. Convenções do TS: {erro} = falha; {codigo|exitCode}≠0 = falha de shell;
 // {written|created|resumo|stdout|...} = evidência de sucesso.
 function classifyToolResult(raw) {
-  if (raw == null || typeof raw !== 'object') return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: raw != null ? String(raw).slice(0, 200) : '' };
+  if (raw == null) return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: '' };
+  // Alguns adaptadores legados retornam falhas como texto. Tratar todo texto como sucesso
+  // permitia que "ERRO ao executar..." virasse etapa concluída. Mantém strings normais como
+  // sucesso, mas reconhece prefixos inequívocos de falha/bloqueio.
+  if (typeof raw !== 'object') {
+    const text = String(raw);
+    const failedText = /^\s*(?:(?:erro|error|falha|failed|bloquead[oa])(?:\s*[:\-]|\s+(?:ao|a|de|do|da|em|no|na|to|while|executing|calling|opening|reading|writing|request|operation)\b|\s*$)|operação cancelada\b|o usuário recusou\b)/i.test(text);
+    if (failedText) {
+      const errorClass = classifyError(text);
+      return { ok: false, status: errorClass === 'blocked' ? 'blocked' : 'failed', errorClass,
+        retryable: RETRYABLE_CLASSES.has(errorClass), evidence: text.replace(/\s+/g, ' ').slice(0, 300) };
+    }
+    return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: text.slice(0, 200) };
+  }
   const exit = raw.codigo != null ? raw.codigo : (raw.exitCode != null ? raw.exitCode : null);
   const errMsg = raw.erro || raw.error || (exit != null && exit !== 0 ? (raw.stderr || raw.stdout || ('exit ' + exit)) : '');
   const failed = !!raw.erro || !!raw.error || (exit != null && exit !== 0);

package/lib/meta.js

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

package/lib/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.73.0",
+  "version": "0.75.0",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"