terminal-smart-cli 0.98.0 → 0.98.1

package/lib/agent.js

@@ -965,7 +965,7 @@ async function _subAgent({ task, k, model, cwd, lang, onStep }) {
       let inp = {}; try { inp = JSON.parse((tc.function && tc.function.arguments) || '{}'); } catch (_) {}
       if (onStep) onStep({ name: '  ↳ ' + nm, detail: argsShort(nm, inp) });
       const res = READONLY.has(nm) ? await tools.execute(nm, inp, { baseDir: cwd, token: k }) : { erro: 'ferramenta não permitida no sub-agente (só leitura).' };
-      msgs.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(res).slice(0, TOOL_RESULT_CAP) });
+      msgs.push({ role: 'tool', tool_call_id: tc.id, content: intelligence.compactToolResult(res, TOOL_RESULT_CAP) });
     }
   }
   // Esgotou os passos ainda chamando ferramentas? Fecha com UM resumo (sem ferramentas) —
@@ -2368,7 +2368,7 @@ async function run(task, opts = {}) {
         const _cacheClass = core.classifyToolResult(result);
         if (_cacheClass.ok && READONLY.has(name)) {
           const _resultCap = name === 'ler_arquivos' ? 24000 : TOOL_RESULT_CAP;
-          _missionCache.remember(name, input, { toolCallId: tc.id, content: JSON.stringify(result).slice(0, _resultCap) });
+          _missionCache.remember(name, input, { toolCallId: tc.id, content: intelligence.compactToolResult(result, _resultCap) });
         } else if (_cacheClass.ok && !READONLY.has(name)) {
           _missionCache.invalidate();
         }
@@ -2395,7 +2395,8 @@ async function run(task, opts = {}) {
         return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, cwd, context: lastCtx, needHuman: { motivo: result.motivo, o_que_fazer: result.o_que_fazer }, orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace } };
       }
       const _resultCap = name === 'ler_arquivos' ? 24000 : TOOL_RESULT_CAP;
-      const _rawToolContent = _cachedContent || JSON.stringify(result).slice(0, _resultCap);
+      // Era .slice() no JSON: cortava o FIM (onde está o erro) e entregava JSON quebrado.
+      const _rawToolContent = _cachedContent || intelligence.compactToolResult(result, _resultCap);
       messages.push({ role: 'tool', tool_call_id: tc.id, content: isUntrustedToolOutput(name)
         ? untrustedToolEnvelope(name, _rawToolContent, lang)
         : _rawToolContent });

package/lib/intelligence-core.js

@@ -424,6 +424,107 @@ function cleanOperationalText(value, max) {
     .replace(/\s+/g, ' ').trim().slice(0, max || 300);
 }
 
+// ── Compactação de saída de ferramenta ──────────────────────────────────────
+// Saída de ferramenta é a maior fatia do contexto de um agente — bem maior que o que o
+// usuário escreve ou o que o modelo responde. E boa parte dela é ruído para o modelo:
+// código de cor, barra de progresso, a mesma linha de log repetida mil vezes.
+//
+// O jeito ingênuo de conter isso é cortar com slice(). Três coisas dão errado:
+//   1. corta o FIM, que é justamente onde fica o erro — a parte que importa;
+//   2. em JSON, rasga a estrutura no meio de uma string e entrega sintaxe inválida;
+//   3. mantém o ANSI e as repetições, que continuam ocupando espaço pago.
+// Head/tail resolve as três: preserva o começo (o que foi pedido) e o fim (como acabou).
+const TOOL_OUTPUT_MAX = 6000;   // ~1.500 tokens por resultado
+const _TOOL_FIELD_FLOOR = 240;  // nenhum campo encolhe abaixo disto: sobra virava enigma
+
+function _stripAnsi(value) {
+  return String(value == null ? '' : value)
+    .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, '');
+}
+
+// Linhas consecutivas idênticas viram uma com contador. O modelo não aprende nada na
+// milésima repetição que não soubesse na segunda — mas paga por todas.
+function _dedupeLines(value) {
+  const lines = String(value).split('\n');
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    let j = i;
+    while (j + 1 < lines.length && lines[j + 1] === lines[i] && lines[i].trim()) j++;
+    const reps = j - i + 1;
+    out.push(reps > 2 ? lines[i] + '   [repetida ' + reps + 'x]' : lines[i]);
+    if (reps === 2) out.push(lines[i]);
+    i = j;
+  }
+  return out.join('\n');
+}
+
+// 60% do orçamento para o começo, o resto para o fim. O começo diz o que a ferramenta
+// estava fazendo; o fim diz como terminou. O miolo de uma saída grande é quase sempre
+// a parte que se repete.
+function _headTail(value, max) {
+  const s = String(value);
+  if (s.length <= max) return s;
+  const marca = (n) => '\n… [' + n + ' chars omitidos] …\n';
+  const head = Math.floor(max * 0.6);
+  const tail = Math.max(0, max - head - marca(s.length).length);
+  return s.slice(0, head) + marca(s.length - head - tail) + s.slice(s.length - tail);
+}
+
+function _limparStrings(node, depth, orcamento) {
+  if (depth > 6 || orcamento.n <= 0) return node;
+  if (typeof node === 'string') { orcamento.n--; return _dedupeLines(_stripAnsi(node)); }
+  if (Array.isArray(node)) return node.map(v => _limparStrings(v, depth + 1, orcamento));
+  if (node && typeof node === 'object') {
+    const out = {};
+    for (const k of Object.keys(node)) out[k] = _limparStrings(node[k], depth + 1, orcamento);
+    return out;
+  }
+  return node;
+}
+
+function _maiorCampo(node, depth, achado) {
+  if (depth > 6) return achado;
+  if (Array.isArray(node)) { node.forEach((v, i) => _maiorCampo(v, depth + 1, _alvo(node, i, v, achado))); return achado; }
+  if (node && typeof node === 'object') {
+    for (const k of Object.keys(node)) { _alvo(node, k, node[k], achado); _maiorCampo(node[k], depth + 1, achado); }
+  }
+  return achado;
+}
+function _alvo(dono, chave, valor, achado) {
+  if (typeof valor === 'string' && valor.length > achado.len && valor.length > _TOOL_FIELD_FLOOR) {
+    achado.dono = dono; achado.chave = chave; achado.len = valor.length;
+  }
+  return achado;
+}
+
+// Recebe o que a ferramenta devolveu (texto ou objeto) e entrega o que vai para o
+// contexto. Objeto sai como JSON VÁLIDO: encolhe os campos de texto grandes, um de cada
+// vez, começando pelo maior — em vez de cortar o JSON inteiro e entregar sintaxe quebrada.
+function compactToolResult(value, max) {
+  const limite = Math.max(400, Number(max) || TOOL_OUTPUT_MAX);
+  if (value == null) return '';
+  if (typeof value !== 'object') return _headTail(_dedupeLines(_stripAnsi(value)), limite);
+
+  let obj = _limparStrings(value, 0, { n: 5000 });
+  let json = JSON.stringify(obj);
+  if (json == null) return '';
+  // Encolhe o maior campo de texto por vez. Cada volta tem que reduzir de verdade,
+  // senão isto viraria laço infinito num objeto que não dá mais para espremer.
+  for (let volta = 0; volta < 40 && json.length > limite; volta++) {
+    const alvo = _maiorCampo(obj, 0, { dono: null, chave: null, len: 0 });
+    if (!alvo.dono) break;
+    const sobra = json.length - limite;
+    const novo = Math.max(_TOOL_FIELD_FLOOR, alvo.len - sobra - 40);
+    if (novo >= alvo.len) break;
+    alvo.dono[alvo.chave] = _headTail(alvo.dono[alvo.chave], novo);
+    json = JSON.stringify(obj);
+  }
+  // Último recurso: objeto grande por QUANTIDADE de campos pequenos, não por tamanho de
+  // um campo. Aí não há o que espremer e o corte é assumido — mas ainda com o fim preservado.
+  return json.length > limite ? _headTail(json, limite) : json;
+}
+
 function _safeToolName(value) {
   const name = String(value || 'unknown').replace(/[^a-z0-9_-]/gi, '_').slice(0, 80);
   return name || 'unknown';
@@ -614,6 +715,7 @@ module.exports = {
   RETIRED_MODELS, supportedModelId,
   installCatalogOverlay, resetCatalogOverlay, activeCatalog,
   normalizeModelId, modelInfo, legacyPriceMap, normalizeUsage, estimateCostUsd, catalogFreshness,
+  TOOL_OUTPUT_MAX, compactToolResult,
   createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff, cleanOperationalText, buildOperationalSummary,
   normalizeAgentPlan, agentRoleContract, routeModel,
 };

package/package.json

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