terminal-smart-cli 0.97.65 → 0.97.66

package/lib/agent.js

@@ -2296,7 +2296,13 @@ async function run(task, opts = {}) {
         if (!_tr.ok && _tr.status !== 'blocked') {
           const _shellHint = name === 'executar_comando' ? commandRecoveryHint(input.comando, _tr.evidence) : '';
           if (_shellHint && result && typeof result === 'object') result = Object.assign({}, result, { _recovery: _shellHint });
-          _toolErrs.push({ tool: name, class: _tr.errorClass, retryable: _tr.retryable, evidence: _tr.evidence });
+          // O sinal estruturado vem do ToolResult tipado — exitCode, errno e hadStderr, que
+          // o core ja calculava e descartava — mais o pathKind, derivado AQUI a partir dos
+          // argumentos da ferramenta: so o resultado ('relative' | 'absolute') viaja, o
+          // caminho em si nunca sai da maquina.
+          _toolErrs.push({ tool: name, class: _tr.errorClass, retryable: _tr.retryable, evidence: _tr.evidence,
+            exitCode: _tr.exitCode, errno: _tr.errno, hadStderr: _tr.hadStderr,
+            pathKind: require('./evolution-telemetry').pathKindOf(input) });
           const _failureKey = failureFingerprint(name, _tr, result);
           const _equivalentFailures = (_failureCounts.get(_failureKey) || 0) + 1;
           _failureCounts.set(_failureKey, _equivalentFailures);

package/lib/core.js

@@ -167,11 +167,44 @@ function classifyError(msg) {
   return 'unknown';
 }
 
-// raw = retorno de uma ferramenta (execute). Devolve { ok, status, errorClass, retryable, evidence }.
+// raw = retorno de uma ferramenta (execute). Devolve
+// { ok, status, errorClass, retryable, evidence, exitCode, errno, hadStderr }.
 // 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.
+//
+// Os três últimos campos entraram em 12/09/2026 e são o SINAL ESTRUTURADO que a telemetria
+// do harness passou a aceitar. Eles já estavam aqui dentro: `exit` e `errMsg` eram
+// calculados e descartados. Sem eles, três falhas com correções completamente diferentes
+// chegavam ao banco como a mesma linha:
+//
+//   ENOENT  o arquivo não existe           -> criar, ou corrigir o caminho
+//   EACCES  existe, mas sem permissão      -> permissão, ou outro caminho
+//   EISDIR  pediram para ler um diretório  -> usar listar_diretorio
+//
+// As três eram `not_found`. O mesmo vale para o código de saída: 127 é comando que não
+// existe, 126 é arquivo sem permissão de execução, 1 é o programa rodou e reprovou.
+//
+// Nada aqui carrega conteúdo de usuário: errno é vocabulário do sistema operacional e sai
+// de uma lista fechada, exitCode é um inteiro e hadStderr é booleano.
+const ERRNOS_CONHECIDOS = new Set(['ENOENT', 'EACCES', 'EPERM', 'EISDIR', 'ENOTDIR', 'EEXIST',
+  'ENOTEMPTY', 'ENOSPC', 'EROFS', 'EMFILE', 'ENFILE', 'ENAMETOOLONG', 'EBUSY', 'EIO', 'EINVAL',
+  'EAGAIN', 'ETIMEDOUT', 'ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'EHOSTUNREACH', 'ENETUNREACH',
+  'EADDRINUSE', 'ENOTFOUND', 'EAI_AGAIN']);
+
+// Lista fechada, e não um regex solto: `\bE[A-Z]+\b` casaria com a palavra "ERROR", que
+// aparece em quase toda mensagem de falha, e o campo viraria ruído em vez de sinal.
+function extractErrno(msg) {
+  const candidatos = String(msg || '').toUpperCase().match(/\bE[A-Z_]{2,11}\b/g);
+  if (!candidatos) return '';
+  for (const c of candidatos) if (ERRNOS_CONHECIDOS.has(c)) return c;
+  return '';
+}
+
 function classifyToolResult(raw) {
-  if (raw == null) return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: '' };
+  if (raw == null) {
+    return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: '',
+      exitCode: -1, errno: '', hadStderr: false };
+  }
   // 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.
@@ -181,13 +214,17 @@ function classifyToolResult(raw) {
     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) };
+        retryable: RETRYABLE_CLASSES.has(errorClass), evidence: text.replace(/\s+/g, ' ').slice(0, 300),
+        exitCode: -1, errno: extractErrno(text), hadStderr: false };
     }
-    return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: text.slice(0, 200) };
+    return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: text.slice(0, 200),
+      exitCode: -1, errno: '', hadStderr: false };
   }
   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);
+  const exitCode = exit != null && Number.isFinite(Number(exit)) ? Number(exit) : -1;
+  const hadStderr = !!(raw.stderr && String(raw.stderr).trim());
   if (failed) {
     const errorClass = classifyError(errMsg);
     return {
@@ -196,10 +233,14 @@ function classifyToolResult(raw) {
       errorClass,
       retryable: RETRYABLE_CLASSES.has(errorClass),
       evidence: String(errMsg).replace(/\s+/g, ' ').slice(0, 300),
+      exitCode,
+      errno: extractErrno(errMsg),
+      hadStderr,
     };
   }
   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) };
+  return { ok: true, status: 'ok', errorClass: null, retryable: false, evidence: String(ev || '').replace(/\s+/g, ' ').slice(0, 200),
+    exitCode, errno: '', hadStderr };
 }
 
 // ── SEGREDOS: nunca imprimir chave/token na saída (B18) ───────────────────────

package/lib/evolution-telemetry.js

@@ -18,6 +18,54 @@ function sanitizePattern(value) {
     .replace(/\s+/g, ' ').trim().slice(0, 300);
 }
 
+// ── Sinal estruturado, de vocabulário FECHADO ────────────────────────────────
+//
+// Estes quatro campos entraram em 12/09/2026, junto com as colunas correspondentes no
+// servidor. Antes, o incidente carregava três categorias (ferramenta, classe, estágio) e
+// um `pattern` derivado da própria classe — que, por derivar dela, não acrescentava
+// entropia nenhuma ao fingerprint. ENOENT e EACCES na mesma ferramenta viravam a MESMA
+// linha no banco, e o revisor automático respondia, com razão, que os dados agregados não
+// permitiam determinar a causa.
+//
+// O vocabulário é fechado de propósito, e validado AQUI e de novo no servidor: são os dois
+// únicos lugares em que um valor inesperado poderia virar texto livre, e texto livre nesta
+// tabela é conteúdo de usuário vazando.
+const ERRNOS_CONHECIDOS = new Set(['ENOENT', 'EACCES', 'EPERM', 'EISDIR', 'ENOTDIR', 'EEXIST',
+  'ENOTEMPTY', 'ENOSPC', 'EROFS', 'EMFILE', 'ENFILE', 'ENAMETOOLONG', 'EBUSY', 'EIO', 'EINVAL',
+  'EAGAIN', 'ETIMEDOUT', 'ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'EHOSTUNREACH', 'ENETUNREACH',
+  'EADDRINUSE', 'ENOTFOUND', 'EAI_AGAIN']);
+
+function safeErrno(value) {
+  const code = String(value || '').trim().toUpperCase().replace(/[^A-Z_0-9]/g, '').slice(0, 20);
+  return ERRNOS_CONHECIDOS.has(code) ? code : '';
+}
+
+function safeExitCode(value) {
+  if (value === null || value === undefined || value === '') return -1;
+  const n = Number(value);
+  if (!Number.isFinite(n)) return -1;
+  return Math.max(-1, Math.min(255, Math.trunc(n)));
+}
+
+// Relativo ou absoluto responde a pergunta que o revisor fez em duas propostas diferentes:
+// o harness errou o CAMINHO, ou errou o DIRETÓRIO DE TRABALHO? São correções distintas, e
+// hoje as duas chegam como `not_found`.
+//
+// A derivação acontece aqui, no CLI, onde os argumentos da ferramenta existem — e só o
+// resultado ('relative' | 'absolute') viaja. O caminho em si nunca sai da máquina.
+function pathKindOf(args) {
+  if (!args || typeof args !== 'object') return '';
+  const alvo = args.caminho || args.arquivo || args.diretorio || args.origem || '';
+  const s = String(alvo).trim();
+  if (!s) return '';
+  return /^(?:[a-zA-Z]:[\\/]|\\\\|\/)/.test(s) ? 'absolute' : 'relative';
+}
+
+function safePathKind(value) {
+  const kind = String(value || '').trim().toLowerCase();
+  return kind === 'relative' || kind === 'absolute' ? kind : '';
+}
+
 function buildEvents(toolErrors = [], actions = [], context = {}) {
   const recoveredTools = new Set((actions || []).map(action => action && action.name).filter(Boolean));
   const seen = new Set(); const events = [];
@@ -26,10 +74,18 @@ function buildEvents(toolErrors = [], actions = [], context = {}) {
     const errorClass = String(error.errorClass || error.class || 'unknown').slice(0, 80);
     const pattern = sanitizePattern(error.evidence || error.message || '');
     const stage = String(error.stage || 'execution').slice(0, 40);
-    const fingerprint = crypto.createHash('sha256').update([tool, errorClass, stage, pattern].join('|')).digest('hex');
+    const errno = safeErrno(error.errno);
+    const exitCode = safeExitCode(error.exitCode);
+    const pathKind = safePathKind(error.pathKind);
+    const hadStderr = error.hadStderr === true;
+    // O fingerprint inclui o sinal novo: sem isso, duas causas diferentes continuariam
+    // deduplicadas aqui antes mesmo de chegar ao servidor.
+    const fingerprint = crypto.createHash('sha256')
+      .update([tool, errorClass, stage, pattern, errno, String(exitCode), pathKind].join('|')).digest('hex');
     if (seen.has(fingerprint)) continue;
     seen.add(fingerprint);
     events.push({ tool, errorClass, pattern, stage, fingerprint,
+      errno, exitCode, pathKind, hadStderr,
       retryable: error.retryable === true, recovered: recoveredTools.has(tool),
       surface: context.surface || 'cli', appVersion: context.appVersion || 'unknown', model: context.model || 'unknown' });
     if (events.length >= 20) break;
@@ -42,4 +98,4 @@ function enabled(config = {}, env = process.env) {
   return config.diagnosticsEnabled !== false;
 }
 
-module.exports = { sanitizePattern, buildEvents, enabled };
+module.exports = { sanitizePattern, buildEvents, enabled, pathKindOf };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.97.65",
+  "version": "0.97.66",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"
   },
   "scripts": {
-    "test": "node test/durable-operation.test.js && node test/mission-tool-cache.test.js && node test/content-quality-runtime-files.test.js && node test/personal-agent-llm.test.js && node test/personal-inspector-efficiency.test.js && node test/personal-inspector-context.test.js && node test/planner-fallback.test.js && node test/cli-agent-regressions.test.js && node test/harness-hardening.test.js"
+    "test": "node test/durable-operation.test.js && node test/mission-tool-cache.test.js && node test/content-quality-runtime-files.test.js && node test/personal-agent-llm.test.js && node test/personal-inspector-efficiency.test.js && node test/personal-inspector-context.test.js && node test/planner-fallback.test.js && node test/cli-agent-regressions.test.js && node test/harness-hardening.test.js && node test/evolution-telemetry.test.js"
   },
   "files": [
     "bin",