terminal-smart-cli 0.60.0 → 0.62.0

package/README.md

@@ -29,7 +29,12 @@ ts "como libero a porta 443 no ufw?"
 | `ts agente --ler` / `--plano` | Modo só-leitura (Ask) / propõe um plano sem agir |
 | `ts agente --worktree` | Isola a run num git worktree (não toca a árvore principal) |
 | `ts agente --stream-json` | Modo headless/CI: só NDJSON tipado no stdout |
-| `ts meta "objetivo grande"` | Missão: checklist + rodadas até terminar (modo noturno) |
+| `ts diagnosticar "erro"` | **Investiga a causa raiz**: hipótese → sonda (só-leitura) → verificação adversarial → veredito. `--remoto "ssh user@host"` investiga uma VPS |
+| `ts sentinela add "nome" --cmd "..."` | **Vigia determinístico (zero token)**: check por regra (`--contem`/`--sem`/`exit0`); falhou → avisa no Telegram (`--escalar` anexa o diagnóstico). `ts sentinela instalar` agenda no cron/Task Scheduler |
+| `ts indexar` · `ts buscar "..."` | **Busca semântica no código** (BM25 local, sem custo); o agente usa via `buscar_codigo` |
+| `ts sonhar` | Consolida a memória episódica do projeto em camadas (dream session); `ts sonhar listar` mostra o histórico |
+| `ts perfil usar <nome>` | Personas com **cofre de memória isolado**; `--perfil <nome>` usa um pontualmente |
+| `ts meta "objetivo grande"` | Missão: checklist + rodadas até terminar (modo noturno). Reporta verificação **honesta**: verificada / build-ok-execução-não / não-verificada |
 | `ts eval suite.json` | Avalia o agente numa suíte de casos (juiz de IA + nota; `--json`/exit 1 pra CI) |
 | `ts acp` | Servidor Agent Client Protocol — pluga o `ts` em editores tipo Zed |
 | `ts run "objetivo"` | Orquestra agentes na nuvem (plano + aprovação) |

package/bin/ts.js

@@ -879,7 +879,7 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null } = {})
   // HEADLESS stream-json: fecha com assistant (texto) + result (métricas) e sai.
   if (streamJson) {
     _emit(core.AgentEvents.assistant(out.text || ''));
-    _emit(core.AgentEvents.result({ steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, needHuman: out.needHuman || null, cwd: effCwd, duration_ms: Date.now() - t0, worktree: _wt ? { path: _wt.path, branch: _wt.branch, base: _wt.base, changed: (_wtInfo && _wtInfo.changed) || 0 } : null }));
+    _emit(core.AgentEvents.result({ steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, needHuman: out.needHuman || null, toolErrors: out.toolErrors || [], cwd: effCwd, duration_ms: Date.now() - t0, worktree: _wt ? { path: _wt.path, branch: _wt.branch, base: _wt.base, changed: (_wtInfo && _wtInfo.changed) || 0 } : null }));
     return;
   }
   if (JSON_OUT) { console.log(JSON.stringify({ ok: true, result: out.text, steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context, needHuman: out.needHuman })); return; }
@@ -1304,8 +1304,11 @@ async function metaCmd() {
   console.log('\n' + _metaChecklistBox(st.checklist));
   if (JSON_OUT) { console.log(JSON.stringify(st)); }
   if (st.status === 'done') {
-    console.log(ui.okLine(C.bold(T.meta_done) + C.dim(` · ${st.rounds.length} rodada(s) · ${st.creditsSpent} créditos · ${secs} min` + (st.escalations ? ` · ${st.escalations} escalonamento(s)` : ''))));
-    metaMod.notify(token, T.meta_notify_done(st.goal, done, st.creditsSpent));
+    const _vl = metaMod.verificationLabel(st.verification, cfg.lang);
+    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() + ')' : '')));
+    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));
     console.log('  ' + C.dim(st.humanRequest.o_que_fazer));
@@ -1616,7 +1619,7 @@ function buscarCmd(args) {
   if (!hits.length) { console.log('\n' + ui.infoLine(en ? 'nothing relevant — try other terms' : 'nada relevante — tente outros termos')); return; }
   console.log('\n' + ui.box([
     C.bold(en ? 'Code search' : 'Busca no código') + C.dim('  "' + q.slice(0, 48) + '"'),
-    ...hits.flatMap(h => ['', C.cyan(h.file + ':' + h.l0 + '-' + h.l1) + C.dim('  ' + h.score),
+    ...hits.flatMap(h => ['', C.cyan(h.file + ':' + h.l0 + '-' + h.l1) + C.dim('  ' + h.score) + (h.sig && h.sig.length ? C.dim('  · define: ' + h.sig.slice(0, 4).join(', ')) : ''),
       ...h.snippet.split('\n').filter(l => l.trim()).slice(0, 2).map(l => C.dim('  ' + l.slice(0, 74)))]),
   ], { title: 'ts buscar' }));
 }

package/lib/agent.js

@@ -355,6 +355,7 @@ async function run(task, opts = {}) {
   const acc = { inTok: 0, outTok: 0, cachedTok: 0 };
   const _mcpSeen = new Set(); // servidores MCP já autorizados NESTA sessão (1ª chamada pede OK)
   const actions = []; // ações REAIS bem-sucedidas (evidência objetiva pro marcador do meta)
+  const _toolErrs = []; // erros de ferramenta TIPADOS na run (core.classifyToolResult) — sinal duro anti-done-falso
   let finalText = '', usedModel = 'smart', steps = 0, charged = 0, _visionCredits = 0;
   const ctxWindow = winFor(model);
   // MEMÓRIA EPISÓDICA: ao fim da run, grava UM episódio (o que fez aqui) → a próxima run
@@ -649,9 +650,13 @@ async function run(task, opts = {}) {
         onStep({ name, detail: argsShort(name, input) });
         result = await tools.execute(name, input, { confineDir, baseDir: cwd, token });
         steps++;
-        // LEDGER DE ERROS (Evolve 3): registro determinístico de erro REAL de ferramenta
-        // (só neste branch — recusa de gate/roMode NÃO é erro do projeto). Zero IA.
-        if (result && (result.erro || (typeof result.codigo === 'number' && result.codigo !== 0))) {
+        // TOOLRESULT TIPADO (core.classifyToolResult): classe de erro DETERMINÍSTICA. A verdade
+        // sobre "deu certo?" vem daqui, não da narrativa do modelo. 'blocked' = política (gate),
+        // não falha de execução — não conta pro ledger nem pro sinal de erro da run.
+        const _tr = core.classifyToolResult(result);
+        if (!_tr.ok && _tr.status !== 'blocked') {
+          _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 (_) {}
         }
         // HOOK PostToolUse (determinístico): feedback (ex: lint/format) vai pro modelo ver.
@@ -717,7 +722,10 @@ async function run(task, opts = {}) {
   if (_hooks._any) { try { _hooksMod.run(_hooks, 'Stop', { cwd, text: finalText, steps }); } catch (_) {} }
   _logEp(stopped ? 'cancel' : (loopedOut ? 'stuck' : 'done'));
   await _bill();
-  return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx };
+  // toolErrors: erros de ferramenta que NÃO foram seguidos de uma ação bem-sucedida da MESMA
+  // ferramenta depois (heurística leve de "não-recuperado") — sinal duro pro meta não marcar done falso.
+  const _lastErr = _toolErrs.length ? _toolErrs[_toolErrs.length - 1] : null;
+  return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, toolErrors: _toolErrs, lastToolError: _lastErr };
 }
 
 module.exports = { run, llm, _test: { winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision } };

package/lib/core.js

@@ -74,8 +74,62 @@ const AgentEvents = {
 // nomes dos eventos, pra quem for validar/mapear (App/Web)
 const EVENT_TYPES = ['system', 'tool', 'assistant', 'result'];
 
+// ── 4) TOOLRESULT TIPADO — classificação DETERMINÍSTICA (o modelo não decide sucesso) ──
+// Insight das análises externas (GPT): "o modelo propõe; o harness autoriza, executa,
+// observa e COMPROVA". Erro de ferramenta NUNCA pode virar etapa `done`. Aqui uma função
+// PURA transforma o retorno bruto de qualquer ferramenta num envelope tipado sem alterar o
+// raw (retrocompatível). Classe de erro alimenta o Recovery Engine e o ledger; `ok:false`
+// deve barrar a marcação de sucesso a montante (meta/orquestrador).
+const ERROR_CLASSES = ['permission_denied', 'not_found', 'port_in_use', 'missing_dep', 'package_lock',
+  'timeout', 'compile_error', 'test_failed', 'network', 'auth', 'git_conflict', 'invalid_schema',
+  'blocked', 'unknown'];
+// classes transitórias → vale re-tentar (mesma abordagem); as demais exigem mudar de abordagem.
+const RETRYABLE_CLASSES = new Set(['network', 'timeout', 'package_lock', 'port_in_use']);
+
+function classifyError(msg) {
+  const s = String(msg || '').toLowerCase();
+  // POLÍTICA (nossos gates) — não é erro do mundo, é recusa: não re-tenta, não conta como falha de exec
+  if (/\bbloquead|\brecus|read-only|só-leitura|loop detectad|\bloop:|aprova(ção|r) neg|negou.*aprova/i.test(s)) return 'blocked';
+  if (/eacces|permission denied|access is denied|operation not permitted|acesso negado|permissão negada/i.test(s)) return 'permission_denied';
+  if (/could not get lock|dpkg was interrupted|resource temporarily unavailable.*lock|another (app|process) .*lock|unable to (acquire|lock)/i.test(s)) return 'package_lock';
+  if (/eaddrinuse|address already in use|porta .*(ocupad|em uso)|already running/i.test(s)) return 'port_in_use';
+  if (/cannot find module|command not found|not recognized as|modulenotfounderror|no module named|no such command|is not installed|não (foi )?encontrad[oa] o comando/i.test(s)) return 'missing_dep';
+  if (/enoent|no such file|não encontrad|not found|arquivo inexistente|404/i.test(s)) return 'not_found';
+  if (/etimedout|timed out|timeout|excedeu o tempo/i.test(s)) return 'timeout';
+  if (/econnrefused|enotfound|getaddrinfo|network|connection refused|conexão recusada|conn|dns/i.test(s)) return 'network';
+  if (/401|403|unauthorized|authentication failed|invalid credentials|credenciais inválidas|não autorizado/i.test(s)) return 'auth';
+  if (/merge conflict|\bconflict\b|needs merge|conflito de merge/i.test(s)) return 'git_conflict';
+  if (/syntaxerror|unexpected token|compile error|erro de compilação|error ts\d|cannot compile|parse error na compil/i.test(s)) return 'compile_error';
+  if (/\d+ (failing|failed)\b|test(s)? failed|assertion|expected .* (to|but)|falhou.*teste|teste(s)? falhar/i.test(s)) return 'test_failed';
+  if (/invalid json|json.*(parse|inválido)|schema|malformed/i.test(s)) return 'invalid_schema';
+  return 'unknown';
+}
+
+// raw = retorno de uma ferramenta (execute). Devolve { ok, status, errorClass, retryable, evidence }.
+// 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) : '' };
+  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);
+  if (failed) {
+    const errorClass = classifyError(errMsg);
+    return {
+      ok: false,
+      status: errorClass === 'blocked' ? 'blocked' : 'failed',
+      errorClass,
+      retryable: RETRYABLE_CLASSES.has(errorClass),
+      evidence: String(errMsg).replace(/\s+/g, ' ').slice(0, 300),
+    };
+  }
+  const ev = raw.written || raw.created || raw.resumo || raw.arquivo || (raw.stdout != null ? String(raw.stdout).slice(0, 200) : '') || (raw.total != null ? (raw.total + ' resultado(s)') : '');
+  return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: String(ev || '').replace(/\s+/g, ' ').slice(0, 200) };
+}
+
 module.exports = {
   DESTRUCTIVE, isDestructive,
   MODEL_WINDOWS, CTX_WINDOW_DEFAULT, DEFAULT_EXECUTOR, COMPACT_AT, KEEP_TAIL, winFor, estMsgsTok,
   AgentEvents, EVENT_TYPES,
+  ERROR_CLASSES, RETRYABLE_CLASSES, classifyError, classifyToolResult,
 };

package/lib/meta.js

@@ -1100,7 +1100,7 @@ async function run(goal, opts = {}) {
           if (runGate && (b.kind === 'android' || b.kind === 'flutter')) {
             onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? 'Launching the app on the emulator (run gate)…' : 'Abrindo o app no emulador (run gate)…'), attempt: 1 });
             const rg = runApp(b, dir, onAlert);
-            if (rg.skipped) { st.buildVerified = true; st.visualOk = true; st.status = 'done'; st.runNote = 'run gate pulado: ' + rg.reason; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st; }
+            if (rg.skipped) { st.buildVerified = true; st.verification = 'built_not_run'; st.status = 'done'; st.runNote = 'run gate pulado: ' + rg.reason; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st; }
             if (rg.ok) {
               st.buildVerified = true; st.runVerified = true;
               // ── VISUAL GATE: app abre → tira print e o "olho" critica o layout.
@@ -1126,9 +1126,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.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+                  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.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 {
               // CRASHOU ao abrir → trata como erro pro executor corrigir (loop igual ao build)
               st.buildFixes = (st.buildFixes || 0) + 1;
@@ -1143,7 +1143,7 @@ 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.buildVerified = true; st.runVerified = true; st.visualOk = true; st.verification = 'verified';
               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 {
@@ -1156,7 +1156,7 @@ async function run(goal, opts = {}) {
               st.buildError = errText;
             }
           } else {
-            st.buildVerified = true; st.visualOk = true; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+            st.buildVerified = true; st.verification = 'built_not_run'; st.runNote = (st.runNote || '') + ' sem gate de execução pra este tipo de projeto — build ok, execução NÃO verificada'; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
           }
         } else { st.buildFixes = (st.buildFixes || 0) + 1; errText = r.out; st.buildError = r.out; }
         // ── ESCALONAMENTO: só em erro REAL de build/crash. Mesmo erro de novo → PENSADOR caro diagnostica ──
@@ -1180,12 +1180,18 @@ async function run(goal, opts = {}) {
           pend = [fixItem];
         }
       } else if (!st.buildVerified || (eye && !st.visualOk)) {
-        // Portão precisava rodar mas estourou o teto (build ou visual): encerra registrando a limitação.
-        st.buildVerified = true; st.visualOk = true;
-        st.status = 'done'; st.finished_at = new Date().toISOString();
-        st.runNote = (st.runNote || '') + (visualCapLeft ? '' : ' visual: teto de polimentos atingido');
+        // Portão precisava rodar mas estourou o teto (build ou visual). HONESTIDADE: NÃO forjar
+        // buildVerified/visualOk (ausência de prova NÃO é sucesso). Encerra com status honesto.
+        st.status = 'done';
+        st.verification = st.buildVerified ? 'built_not_run' : 'unverified';
+        st.runNote = (st.runNote || '') + (st.buildVerified
+          ? ' visual: teto de polimentos atingido — aprovação visual NÃO confirmada'
+          : ' build: teto de correções atingido — NÃO compilou/rodou de forma verificada');
+        st.finished_at = new Date().toISOString();
         save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
       } else {
+        // Não precisava de gate (tarefa não-compilável: análise/relatório/config). Honesto: sem gate a aplicar.
+        st.verification = st.verification || 'no_gate';
         st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir);
         return st;
       }
@@ -1359,4 +1365,20 @@ async function notify(token, text) {
   try { await api('/api/cli/notify', { method: 'POST', token, body: { text }, timeoutMs: 15000 }); } catch (_) {}
 }
 
-module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision };
+// Rótulo HONESTO da verificação da missão (nunca finge que provou o que não provou).
+//   verified      = build + execução (e visual, se houve olho) passaram de verdade nos gates
+//   built_not_run = compilou, mas a execução não foi verificada (sem gate do tipo, gate pulado, teto visual)
+//   unverified    = teto de correções esgotado SEM compilar/rodar de forma verificada
+//   no_gate       = tarefa não-compilável (análise/relatório/config) — não havia o que verificar
+function verificationLabel(ver, lang) {
+  const en = lang === 'en';
+  switch (ver) {
+    case 'verified':      return { icon: '✓', txt: en ? 'verified (build + run)' : 'verificada (build + execução)', ok: true };
+    case 'built_not_run': return { icon: '≈', txt: en ? 'build OK — run NOT verified' : 'build OK — execução NÃO verificada', ok: false };
+    case 'unverified':    return { icon: '⚠', txt: en ? 'NOT verified (fix limit reached)' : 'NÃO verificada (teto de correções atingido)', ok: false };
+    case 'no_gate':       return { icon: '·', txt: en ? 'no build/run gate for this task' : 'sem gate de build/execução p/ esta tarefa', ok: true };
+    default:              return { icon: '·', txt: en ? 'not applicable' : 'não aplicável', ok: true };
+  }
+}
+
+module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision, verificationLabel };

package/lib/tools.js

@@ -522,7 +522,7 @@ async function execute(name, input, opts = {}) {
         const k = Math.min(15, Math.max(1, Number(input.max) || 6));
         const hits = ix.search(baseDir, consulta, k, idx);
         if (!hits.length) return { resultados: [], aviso: 'nada relevante no índice — tente outros termos, ou rode "ts indexar" se o projeto mudou muito.' };
-        return { resultados: hits.map(h => ({ arquivo: h.file, linhas: h.l0 + '-' + h.l1, score: h.score, previa: h.snippet })), ...(construiu ? { nota: 'índice construído agora (' + idx.N + ' trechos)' } : {}) };
+        return { resultados: hits.map(h => ({ arquivo: h.file, linhas: h.l0 + '-' + h.l1, score: h.score, ...(h.sig && h.sig.length ? { define: h.sig } : {}), previa: h.snippet })), ...(construiu ? { nota: 'índice construído agora (' + idx.N + ' trechos)' } : {}) };
       }
       case 'buscar_web': {
         const q = String(input.consulta || '').trim();

package/package.json

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