terminal-smart-cli 0.61.0 → 0.63.0

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; }
@@ -1432,13 +1432,14 @@ async function sentinelaCmd(args) {
       regra: _regraFromFlags(),
       avisar: _val(['--avisar', '--notify']) || 'falha',
       escalar: FLAGS.has('--escalar') || FLAGS.has('--escalate'),
+      autofix: FLAGS.has('--autofix') || FLAGS.has('--auto-fix'),
     });
     console.log('\n' + ui.box([
       C.ok(en ? 'Sentinel added' : 'Sentinela adicionada') + C.dim('  ' + check.id),
       '',
       C.bold(check.nome) + C.dim('  ' + (check.target ? check.target.split(' ').pop() : (en ? 'local' : 'local'))),
       C.dim('$ ') + check.cmd.slice(0, 70),
-      C.dim((en ? 'rule: ' : 'regra: ') + _regraTxt(check.regra) + (en ? '  ·  every ' : '  ·  a cada ') + (check.cron || sen.parseEvery(_val(['--cada']) || '').ms / 60000 + 'm') + (check.escalar ? C.warn('  ·  escala p/ IA se falhar') : '')),
+      C.dim((en ? 'rule: ' : 'regra: ') + _regraTxt(check.regra) + (en ? '  ·  every ' : '  ·  a cada ') + (check.cron || sen.parseEvery(_val(['--cada']) || '').ms / 60000 + 'm') + (check.autofix ? C.warn('  ·  🔧 autofix (conserta c/ aprovação)') : check.escalar ? C.warn('  ·  escala p/ IA se falhar') : '')),
     ], { title: 'ts sentinela' }));
     console.log('\n' + C.dim(en ? 'Activate the schedule with: ' : 'Ative o agendamento com: ') + 'ts sentinela instalar');
     return;
@@ -1452,7 +1453,7 @@ async function sentinelaCmd(args) {
       C.bold(en ? 'Sentinels' : 'Sentinelas') + C.dim('  (' + list.length + ')'),
       ...list.flatMap(c => [
         '',
-        _icon(!c.ultimo || c.ultimo.ok) + ' ' + C.bold(c.nome) + C.dim('  ' + c.id + (c.escalar ? '  ⚡' : '') + (c.target ? '  ' + c.target.split(' ').pop() : '')),
+        _icon(!c.ultimo || c.ultimo.ok) + ' ' + C.bold(c.nome) + C.dim('  ' + c.id + (c.autofix ? '  🔧' : c.escalar ? '  ⚡' : '') + (c.target ? '  ' + c.target.split(' ').pop() : '')),
         C.dim('  $ ' + c.cmd.slice(0, 66)),
         C.dim('  ' + _regraTxt(c.regra) + '  ·  ' + (c.cron || ((c.every_ms / 60000) + 'm')) + (c.ultimo ? '  ·  ' + (en ? 'last: ' : 'último: ') + (c.ultimo.ok ? C.ok('ok') : C.err(c.ultimo.motivo)) : '  ·  ' + (en ? 'never run' : 'nunca rodou'))),
       ]),
@@ -1493,17 +1494,24 @@ async function sentinelaCmd(args) {
       const out = ((r.res.stdout || '') + (r.res.stderr || '')).trim();
       if (out && !r.verdict.ok) msg += '\n' + out.split('\n').slice(0, 6).join('\n').slice(0, 500);
       // ESCALA pra IA só quando falha e --escalar (aqui nasce a sugestão de conserto)
+      let diagResult = null;
       if (!r.verdict.ok && check.escalar && token) {
         try {
           const diag = require('../lib/diagnose');
-          const d = await diag.diagnose(`sentinela "${check.nome}" falhou: ${r.verdict.motivo}. comando: ${check.cmd}. saída: ${out.slice(0, 400)}`, {
+          diagResult = await diag.diagnose(`sentinela "${check.nome}" falhou: ${r.verdict.motivo}. comando: ${check.cmd}. saída: ${out.slice(0, 400)}`, {
             token, lang: cfg.lang || 'pt', target: check.target || '', maxRounds: 4, onEvent: () => {},
           });
-          if (d.status === 'solved') msg += '\n\n🧠 causa provável: ' + String(d.rootCause).slice(0, 200) + '\n🔧 conserto: ' + String(d.fix || '—').slice(0, 240);
+          if (diagResult.status === 'solved') msg += '\n\n🧠 causa provável: ' + String(diagResult.rootCause).slice(0, 200) + '\n🔧 conserto: ' + String(diagResult.fix || '—').slice(0, 240);
         } catch (_) { /* diagnose best-effort */ }
       }
       if (token) { try { await metaMod.notify(token, msg); } catch (_) {} }
       if (!quiet) console.log(msg);
+      // ── AUTOFIX (Incident Autopilot): conserto verificado + comando seguro → aprovação no Telegram → aplica → re-valida.
+      // NUNCA aplica sem OK humano (aprovação remota). Só quando o diagnóstico sobreviveu à refutação.
+      if (!r.verdict.ok && check.autofix && token && diagResult && diagResult.status === 'solved' && diagResult.verified && diagResult.fixCommand) {
+        const applied = await _sentinelaAutofix(check, diagResult, r, token, quiet, en);
+        if (applied != null) alerts++;
+      }
     }
     sen._save(list);
     if (!quiet) console.log(C.dim(`\n${en ? 'ran' : 'rodou'} ${ran} · ${alerts} ${en ? 'alert(s)' : 'alerta(s)'}`));
@@ -1556,6 +1564,49 @@ async function sentinelaCmd(args) {
 }
 function execSyncQuiet(c) { return require('child_process').execSync(c, { stdio: 'ignore', windowsHide: true }); }
 
+// AUTOFIX da sentinela (Incident Autopilot): propõe o conserto no Telegram, e SÓ aplica com
+// aprovação humana. Aplica no alvo (local ou ssh remoto), re-valida o check e reporta. Retorna
+// true/false se aplicou (consertou ou não), null se não houve aprovação/canal.
+async function _sentinelaAutofix(check, diag, r, token, quiet, en) {
+  const sen = require('../lib/sentinela');
+  const metaMod = require('../lib/meta');
+  const cmd = String(diag.fixCommand).trim();
+  const alvo = check.target ? check.target.split(' ').pop() : os.hostname();
+  // 1) aprovação remota (mesmo canal do agente): /api/cli/approval/start → poll
+  let st = null;
+  try { st = await api('/api/cli/approval/start', { method: 'POST', token, body: { comando: `[sentinela ${check.nome}@${alvo}] ${cmd}`, host: alvo }, timeoutMs: 20000 }); } catch (_) { return null; }
+  if (!st || !st.success || !st.id) { // sem canal Telegram → só propõe e para
+    if (!quiet) console.log('  ' + C.dim(en ? 'autofix: no Telegram channel to approve — proposed only.' : 'autofix: sem canal Telegram pra aprovar — só proposto.'));
+    return null;
+  }
+  if (!quiet) console.log('  ' + C.warn('🔧 ') + C.dim((en ? 'autofix: sent to Telegram for approval — ' : 'autofix: enviei pro Telegram pra aprovar — ') + cmd.slice(0, 60)));
+  let approved = false;
+  const t0 = Date.now();
+  while (Date.now() - t0 < 150000) {
+    await new Promise(rs => setTimeout(rs, 3000));
+    let p = null;
+    try { p = await api('/api/cli/approval/poll', { method: 'POST', token, body: { id: st.id }, timeoutMs: 15000 }); } catch (_) { continue; }
+    if (p && p.status === 'approved') { approved = true; break; }
+    if (p && (p.status === 'denied' || p.status === 'expired')) break;
+  }
+  if (!approved) {
+    try { await metaMod.notify(token, `⏹️ [sentinela] ${check.nome}: conserto NÃO aplicado (não aprovado). Comando proposto: ${cmd}`); } catch (_) {}
+    if (!quiet) console.log('  ' + C.dim(en ? 'autofix: not approved — nothing applied.' : 'autofix: não aprovado — nada aplicado.'));
+    return null;
+  }
+  // 2) aplica no alvo + 3) re-valida o check
+  const ap = sen.runShell(cmd, { target: check.target, timeoutMs: 60000 });
+  const rr = sen.runOne(check); // re-roda o check → atualiza estado
+  const fixedOk = rr.verdict.ok;
+  const rerun = ((rr.res.stdout || '') + (rr.res.stderr || '')).trim().split('\n').slice(0, 4).join('\n').slice(0, 300);
+  const finalMsg = fixedOk
+    ? `✅ [sentinela] ${check.nome}: CONSERTADO por autofix. Apliquei \`${cmd}\` e o check voltou a passar.`
+    : `⚠️ [sentinela] ${check.nome}: autofix aplicado (\`${cmd}\`) mas o check AINDA falha (${rr.verdict.motivo}). Precisa de você.\n${rerun}`;
+  try { await metaMod.notify(token, finalMsg); } catch (_) {}
+  if (!quiet) console.log('  ' + (fixedOk ? C.ok('✔ ') + (en ? 'autofix worked — check passes again' : 'autofix funcionou — check voltou a passar') : C.err('✗ ') + (en ? 'applied but still failing' : 'aplicado mas ainda falha')) + C.dim((ap.code !== 0 ? ' (fix exit ' + ap.code + ')' : '')));
+  return fixedOk;
+}
+
 // ── ts sonhar — DREAM SESSION: consolida a memória episódica em camadas ───────
 async function sonharCmd(args) {
   const en = (cfg.lang === 'en');
@@ -1619,7 +1670,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/diagnose.js

@@ -25,13 +25,13 @@ ${where}
 METHOD each round: pick your single strongest HYPOTHESIS and ONE cheap READ-ONLY probe that would CONFIRM or REFUTE it. Read the probe output next round, then keep or discard the hypothesis and move on. Rank likely causes first (recent changes, environment, config, permissions, resources, data/version, then logic).
 HARD RULES: (1) probe must be READ-ONLY (ldd, strace -f, cat, head, tail, ls, stat, file, readelf, md5sum, ss, ps, grep, find, ldconfig -p, dpkg -l, journalctl, "mysql ... SELECT/SHOW"). NEVER install/rm/mv/chmod/restart/write. (2) Don't repeat a probe already run. (3) A missing library that "exists" often means its OWN dependency is missing — probe the lib itself. (4) Distinguish ENVIRONMENT (missing lib, perm, port, config) from DATA/INTERNAL (version mismatch, corrupt/incompatible file, logic). (5) When the evidence proves the cause, STOP and report it with a concrete fix.
 Reply ONLY with a JSON object, no prose:
-{"thought":"1-2 sentences reasoning from the latest evidence","status":"investigating|solved|stuck","hypothesis":"current leading hypothesis (short)","category":"environment|config|permission|resource|network|data|version|logic|unknown","probe":"ONE read-only shell command (empty if solved/stuck)","expect_if_true":"what in the output confirms it","root_cause":"(only if solved) the confirmed root cause","fix":"(only if solved) the concrete fix — commands/steps","confidence":0}`
+{"thought":"1-2 sentences reasoning from the latest evidence","status":"investigating|solved|stuck","hypothesis":"current leading hypothesis (short)","category":"environment|config|permission|resource|network|data|version|logic|unknown","probe":"ONE read-only shell command (empty if solved/stuck)","expect_if_true":"what in the output confirms it","root_cause":"(only if solved) the confirmed root cause","fix":"(only if solved) the concrete fix — commands/steps","fix_command":"(only if solved AND the fix is ONE safe idempotent shell command that applies it — e.g. restart a service, free a port, install a dep; empty if it needs code edits/multiple steps/anything risky)","confidence":0}`
     : `Você é um DIAGNOSTICADOR SÊNIOR. Dado um sintoma, ache a CAUSA RAIZ investigando — nunca chute o conserto às cegas.
 ${where}
 MÉTODO por rodada: escolha sua HIPÓTESE mais forte e UMA sonda barata SÓ-LEITURA que a CONFIRME ou REFUTE. Leia a saída na rodada seguinte, mantenha ou descarte a hipótese e siga. Rankeie causas prováveis primeiro (mudanças recentes, ambiente, config, permissões, recursos, dado/versão, e por fim lógica).
 REGRAS DURAS: (1) a sonda tem que ser SÓ-LEITURA (ldd, strace -f, cat, head, tail, ls, stat, file, readelf, md5sum, ss, ps, grep, find, ldconfig -p, dpkg -l, journalctl, "mysql ... SELECT/SHOW"). NUNCA install/rm/mv/chmod/restart/escrever. (2) Não repita uma sonda já feita. (3) Biblioteca "não encontrada" que EXISTE quase sempre é DEPENDÊNCIA-DA-DEPENDÊNCIA faltando — sonde a própria lib. (4) Distinga AMBIENTE (lib faltando, permissão, porta, config) de DADO/INTERNO (mismatch de versão, arquivo corrompido/incompatível, lógica). (5) Quando a evidência provar a causa, PARE e reporte com um conserto concreto.
 Responda SÓ com um objeto JSON, sem prosa:
-{"thought":"raciocínio de 1-2 frases a partir da última evidência","status":"investigating|solved|stuck","hypothesis":"hipótese atual (curta)","category":"environment|config|permission|resource|network|data|version|logic|unknown","probe":"UM comando shell só-leitura (vazio se solved/stuck)","expect_if_true":"o que na saída confirma","root_cause":"(só se solved) a causa raiz confirmada","fix":"(só se solved) o conserto concreto — comandos/passos","confidence":0}`;
+{"thought":"raciocínio de 1-2 frases a partir da última evidência","status":"investigating|solved|stuck","hypothesis":"hipótese atual (curta)","category":"environment|config|permission|resource|network|data|version|logic|unknown","probe":"UM comando shell só-leitura (vazio se solved/stuck)","expect_if_true":"o que na saída confirma","root_cause":"(só se solved) a causa raiz confirmada","fix":"(só se solved) o conserto concreto — comandos/passos","fix_command":"(só se solved E o conserto for UM comando shell seguro e idempotente que o aplica — ex.: reiniciar um serviço, liberar uma porta, instalar uma dep; vazio se exigir edição de código/vários passos/qualquer coisa arriscada)","confidence":0}`;
 }
 
 function extractJson(s) {
@@ -95,7 +95,7 @@ async function diagnose(symptom, opts = {}) {
           continue; // a própria conclusão caiu na verificação → volta a investigar
         }
       }
-      result = { status: 'solved', rootCause: claim, fix: j.fix || '', category: j.category || 'unknown', confidence: j.confidence || 0, verified: !!rprobe, evidence, rounds: round };
+      result = { status: 'solved', rootCause: claim, fix: j.fix || '', fixCommand: String(j.fix_command || '').trim(), category: j.category || 'unknown', confidence: j.confidence || 0, verified: !!rprobe, evidence, rounds: round };
       onEvent({ type: 'solved', rootCause: result.rootCause, fix: result.fix, category: result.category, verified: result.verified });
       break;
     }

package/lib/i18n.js

@@ -38,7 +38,7 @@ const STR = {
         ['ts agente "..." --yes', 'autônomo (destrutivo pede aprovação no Telegram)'],
         ['ts diagnosticar "erro"', 'INVESTIGA a causa raiz: hipótese→sonda→veredito (só-leitura)'],
         ['ts diagnosticar "..." --remoto "ssh user@host"', 'investiga uma máquina remota'],
-        ['ts sentinela add "nome" --cmd "..."', 'VIGIA determinístico (regra do if, ZERO token); escala p/ IA só se falhar'],
+        ['ts sentinela add "nome" --cmd "..."', 'VIGIA determinístico (regra do if, ZERO token); --escalar diagnostica se falhar; --autofix conserta (com aprovação no Telegram)'],
         ['ts sentinela instalar', 'agenda os checks no SO (cron/Task Scheduler) e avisa no Telegram'],
         ['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)'],

package/lib/sentinela.js

@@ -91,7 +91,8 @@ function add(def) {
     every_ms: ev.ms, cron: ev.cron,
     regra: def.regra || { tipo: 'exit0' },
     avisar: def.avisar || 'falha',      // 'falha' | 'sempre' | 'mudanca'
-    escalar: !!def.escalar,             // escala pro diagnose quando falha
+    escalar: !!def.escalar || !!def.autofix, // escala pro diagnose quando falha (autofix implica escalar)
+    autofix: !!def.autofix,             // propõe o conserto no Telegram (aprovação) e re-valida
     criado: Date.now(),
     proximo: ev.ms ? Date.now() : 0,    // cron: 0 = decide por horário
     ultimo: null,                        // { ts, ok, motivo, hash }

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