terminal-smart-cli 0.97.65 → 0.97.67

package/lib/agent.js

@@ -89,11 +89,18 @@ function missionGuardDecision({ credits = 0, maxCredits = DEFAULT_MISSION_CREDIT
 // primeiro e os fallbacks permanecem dentro do contrato do plano.
 function planUpgradeLimit(plan) {
   const id = intelligence.normalizeAgentPlan ? intelligence.normalizeAgentPlan(plan) : String(plan || 'free').toLowerCase();
-  return id === 'pro' ? 2 : (id === 'basic' ? 1 : 0);
+  // O Free passou de 0 para 1 degrau. Não é upgrade comercial: a contingência
+  // do Free é Luna (0.10/0.60), MAIS BARATA que o principal DeepSeek Pro
+  // (0.63/1.26). Com 0 degraus a contingência anunciada no plano ("DeepSeek Pro
+  // no chat, com contingência Luna") era cortada pelo slice e nunca existia.
+  return id === 'pro' ? 2 : 1;
 }
 
 function executorFallbackChain({ selectedModel, forced = false, source = 'cloud', plan = 'free', complex = false } = {}) {
-  const first = String(selectedModel || DEFAULT_EXECUTOR).trim();
+  // Um id aposentado pode chegar aqui de config antiga, de histórico ou do
+  // roteador de outra versão. Converter na entrada é o que impede a cadeia
+  // inteira de apontar para um modelo que o gateway não serve mais.
+  const first = intelligence.supportedModelId(String(selectedModel || DEFAULT_EXECUTOR).trim());
   if (forced) return [first];
   const role = intelligence.agentRoleContract('executor', plan, { complex });
   // O roteador pode selecionar um executor mais específico que o contrato padrão.
@@ -2296,7 +2303,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

@@ -95,7 +95,10 @@ const MODEL_WINDOWS = {
   'minimax': 200000, 'qwen': 64000, 'gemini': 500000, 'mimo': 128000,
 };
 const CTX_WINDOW_DEFAULT = 100000; // modelo desconhecido → conservador
-const DEFAULT_EXECUTOR = 'deepseek-v4-flash'; // executor padrão (venceu o bake-off de código)
+// deepseek-v4-flash venceu o bake-off de código em 2026-08 e era o executor
+// padrão, mas foi aposentado do gateway. O padrão passa a ser o executor do
+// contrato oficial (AGENT_ROLES.executor), que é o mesmo nas três superfícies.
+const DEFAULT_EXECUTOR = 'deepseek-v4-pro';
 // limiar/rabo têm override por env (TS_COMPACT_AT / TS_COMPACT_TAIL) — usado nos testes.
 const COMPACT_AT = Number(process.env.TS_COMPACT_AT) > 0 ? Number(process.env.TS_COMPACT_AT) : 0.65;
 // piso de 6: rabo curto demais apaga a memória de trabalho e o agente relê arquivos em loop
@@ -167,11 +170,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 +217,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 +236,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/eval.js

@@ -24,7 +24,9 @@ const agent = require('./agent');
 const intelligence = require('./intelligence-core');
 
 // modelo default do JUIZ: barato e suficiente pra avaliar critério objetivo.
-const DEFAULT_JUDGE = 'deepseek-v4-flash';
+// Era deepseek-v4-flash, aposentado. Luna custa 0.10/0.60, tem `review` no
+// catálogo e é mais barata que o Flash aposentado era.
+const DEFAULT_JUDGE = 'gpt-5.6-luna';
 
 // ── suíte ────────────────────────────────────────────────────────────────────
 function loadSuite(p) {

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/lib/intelligence-core.js

@@ -171,14 +171,27 @@ const MODEL_CATALOG = Object.freeze({
 });
 
 const MODEL_ALIASES = Object.freeze({
-  deepseek: 'deepseek-v4-flash',
-  'deepseek-v4': 'deepseek-v4-flash',
+  deepseek: 'deepseek-v4-pro',
+  'deepseek-v4': 'deepseek-v4-pro',
   glm: 'glm-4.6',
   mimo: 'mimo-v2.5',
-  'gemini-lite': 'gemini-2.5-flash-lite',
+  'gemini-lite': 'gemini-2.5-flash',
   'claude-haiku': 'claude-haiku-4-5',
 });
 
+// Modelos aposentados do gateway do produto. Eles PERMANECEM no catalogo porque
+// historico de consumo antigo ainda precisa ser precificado com o preco que
+// valia na epoca; o que eles nao podem mais e entrar em contrato ativo ou em
+// roteamento. A conversao mora AQUI, em cada superficie, e nao na reescrita que
+// o backend faz no gate do proxy: uma superficie que dependesse daquela correcao
+// ficaria errada em offline, em BYOK e em qualquer caminho que nao passe pelo
+// proxy — foi exatamente o caso do CLI, cuja cadeia de executor do plano Free
+// apontava inteira para os dois ids abaixo.
+const RETIRED_MODELS = Object.freeze({
+  'deepseek-v4-flash': 'deepseek-v4-pro',
+  'gemini-2.5-flash-lite': 'gemini-2.5-flash',
+});
+
 // Equipe oficial do modo Automático: especialização e prova objetiva vêm antes
 // de cascatas longas de modelos. Premium fica fora até validação real.
 const OFFICIAL_AUTOMATIC_TEAM = Object.freeze({
@@ -194,23 +207,23 @@ const OFFICIAL_AUTOMATIC_TEAM = Object.freeze({
 const AGENT_ROLES = Object.freeze({
   classifier: Object.freeze({
     prompt: 'Classifique a intenção e devolva somente a estrutura pedida. Não execute ferramentas nem invente dados.',
-    models: Object.freeze({ free: ['gemini-2.5-flash-lite'], basic: ['gemini-2.5-flash-lite', 'gpt-4o-mini'], pro: ['gemini-2.5-flash-lite', 'gpt-4o-mini'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro', 'gpt-4o-mini'], pro: ['deepseek-v4-pro', 'gpt-4o-mini'] }),
   }),
   planner: Object.freeze({
     prompt: 'Decomponha o objetivo em etapas executáveis, dependências, riscos, critérios de aceite e provas. Não execute a tarefa.',
-    models: Object.freeze({ free: ['deepseek-v4-flash', 'gemini-2.5-flash-lite'], basic: ['gpt-5.6-luna', 'glm-5.2', 'deepseek-v4-pro'], pro: ['gpt-5.6-luna', 'glm-5.2', 'deepseek-v4-pro'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['gpt-5.6-luna', 'glm-5.2', 'deepseek-v4-pro'], pro: ['gpt-5.6-luna', 'glm-5.2', 'deepseek-v4-pro'] }),
   }),
   executor: Object.freeze({
     prompt: 'Execute somente a etapa recebida com as ferramentas autorizadas. Não declare sucesso sem resultado verificável.',
-    models: Object.freeze({ free: ['deepseek-v4-flash', 'gemini-2.5-flash-lite'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'] }),
   }),
   inspector: Object.freeze({
     prompt: 'Inspecione em modo somente leitura e compare evidências com os critérios de aceite. Não altere nada e não elogie por cortesia.',
-    models: Object.freeze({ free: ['gemini-2.5-flash-lite'], basic: ['gpt-5.6-luna', 'glm-5.2'], pro: ['gpt-5.6-luna', 'glm-5.2'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['gpt-5.6-luna', 'glm-5.2'], pro: ['gpt-5.6-luna', 'glm-5.2'] }),
   }),
   corrector: Object.freeze({
     prompt: 'Corrija apenas falhas confirmadas pelo inspetor, preserve o que funciona e repita as provas afetadas. Não amplie o escopo.',
-    models: Object.freeze({ free: ['deepseek-v4-flash', 'gemini-2.5-flash-lite'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'] }),
   }),
   vision: Object.freeze({
     prompt: 'Extraia fatos observáveis da imagem e separe leitura, inferência e incerteza. Não invente texto ilegível.',
@@ -222,11 +235,11 @@ const AGENT_ROLES = Object.freeze({
   }),
   site_builder: Object.freeze({
     prompt: 'Crie ou edite o site completo, responsivo e acessível. Preserve o existente quando editar e valide a URL publicada.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
   }),
   cloud_box: Object.freeze({
     prompt: 'Opere a box com mudanças mínimas, registre comandos e valide serviço, porta e URL. Nunca exponha segredos.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
+    models: Object.freeze({ free: ['deepseek-v4-pro', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
   }),
 });
 
@@ -256,6 +269,14 @@ function normalizeModelId(model) {
   return upstream ? upstream[0] : transportFree;
 }
 
+// Camada de compatibilidade: recebe qualquer id (alias, id do upstream, id
+// aposentado) e devolve um id que o produto ainda serve. Use isto — e nao
+// normalizeModelId — em qualquer ponto que va CHAMAR um modelo.
+function supportedModelId(model) {
+  const id = normalizeModelId(model);
+  return RETIRED_MODELS[id] || id;
+}
+
 function modelInfo(model, now) {
   const id = normalizeModelId(model);
   const info = MODEL_CATALOG[id] || {
@@ -512,7 +533,12 @@ function routeModel(task, reliability) {
   if (t.kind === 'code') required.add('code');
   if (t.kind === 'review') required.add('review');
   if (t.kind === 'vision') required.add('vision');
-  const candidates = (t.candidates || Object.keys(MODEL_CATALOG)).map(normalizeModelId).filter(id => MODEL_CATALOG[id] && id !== 'smart');
+  // Aposentado nao volta por roteamento. Sem este filtro o CLI devolvia
+  // deepseek-v4-flash como melhor candidato de codigo e dependia do backend
+  // reescrever depois — o que nao acontece em BYOK nem offline.
+  const candidates = (t.candidates || Object.keys(MODEL_CATALOG)).map(supportedModelId)
+    .filter(id => MODEL_CATALOG[id] && id !== 'smart')
+    .filter((id, i, list) => list.indexOf(id) === i);
   const rel = reliability || {};
   const plan = String(t.plan || '').toLowerCase();
   const isPaid = plan && plan !== 'free' && plan !== 'gratuito';
@@ -527,12 +553,13 @@ function routeModel(task, reliability) {
     const score = (observed * 0.35) + (m.quality * qualityWeight) + ((1 / (1 + price)) * costWeight) - (missing * 2);
     return { id, score: +score.toFixed(6), missing };
   }).sort((a, b) => b.score - a.score);
-  return { model: scored[0] ? scored[0].id : (isPaid ? 'deepseek-v4-pro' : 'deepseek-v4-flash'), ranked: scored };
+  return { model: scored[0] ? scored[0].id : 'deepseek-v4-pro', ranked: scored };
 }
 
 module.exports = {
   INTELLIGENCE_CONTRACT, PRICE_REVISION, MODEL_CATALOG, MODEL_ALIASES, DEFAULT_PRICE,
   MEMORY_TYPES, MEMORY_TRUST, CONTEXT_SOURCES, OFFICIAL_AUTOMATIC_TEAM, AGENT_ROLES,
+  RETIRED_MODELS, supportedModelId,
   normalizeModelId, modelInfo, legacyPriceMap, normalizeUsage, estimateCostUsd, catalogFreshness,
   createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff, cleanOperationalText, buildOperationalSummary,
   normalizeAgentPlan, agentRoleContract, routeModel,

package/lib/mission-tool-cache.js

@@ -44,6 +44,18 @@ class MissionToolCache {
   stats() { return { entries: this.entries.size, hits: this.hits, invalidations: this.invalidations, charactersSaved: this.charactersSaved, estimatedTokensSaved: Math.ceil(this.charactersSaved / 4) }; }
 }
 
+// O terceiro parâmetro é IGNORADO de propósito, e continua na assinatura só para
+// não quebrar os três pontos de chamada (cli/lib/agent.js, app-electron/main.js e
+// backend/server/index.js), que ainda o calculam para a métrica de economia.
+//
+// Ele era `originalStillVisible`, e a decisão de encurtar dependia dele. O cálculo
+// nas três superfícies verificava se existia uma mensagem com o mesmo
+// `tool_call_id` — ou seja, se o ID estava visível, NÃO se o conteúdo ainda estava.
+// Transports de assinatura pessoal reconstroem a conversa preservando o id e
+// descartando o payload: o check aprovava, o modelo recebia "use o resultado
+// anterior", não achava nada, relia o mesmo arquivo, recebia o mesmo ponteiro — e a
+// missão só terminava quando o watchdog a matava. Não há como esta função saber se
+// o payload sobreviveu, porque ela não vê a conversa; então ela não aposta.
 function cacheReference(entry, tool, originalStillVisible) {
   // Sempre devolva o conteúdo ao modelo. Alguns transports de assinatura pessoal
   // reconstroem a conversa e preservam o id da tool call, mas não o payload antigo.

package/lib/router.js

@@ -7,6 +7,13 @@
 const { api } = require('./api');
 const keyring = require('./keyring');
 
+// Modelo da camada 2 (classificacao de intencao). Era gemini-2.5-flash-lite,
+// aposentado do gateway: a chamada falhava e o catch devolvia "chat" para tudo,
+// o que fazia pedido de acao virar conversa. gemini-2.5-flash e o substituto
+// da mesma familia, tem `classification` no catalogo, e a chamada usa
+// max_completion_tokens: 5 — o custo por classificacao segue irrelevante.
+const INTENT_MODEL = 'gemini-2.5-flash';
+
 // Pergunta/conversa: forma interrogativa ou pedido de explicação
 const Q_RE = /^(como|por ?qu[eê]|o ?que|qual|quais|quando|onde|quem|ser[aá] que|devo|posso|vale a pena|existe|tem como|é melhor|what|how|why|which|when|where|explique|me explica|explica|o que significa|diferen[çc]a entre)\b|\?\s*$/i;
 
@@ -67,7 +74,10 @@ async function classify(msg, token) {
       method: 'POST', signal: ctrl.signal,
       headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + k.key },
       body: JSON.stringify({
-        model: keyring.modeloPara(k, 'gemini-2.5-flash-lite'), stream: false, max_completion_tokens: 5,
+        // Era gemini-2.5-flash-lite, aposentado: o gateway devolvia erro ou o
+        // backend reescrevia, e a classificação de intenção caía silenciosamente
+        // no catch que devolve "chat" para tudo.
+        model: keyring.modeloPara(k, INTENT_MODEL), stream: false, max_completion_tokens: 5,
         messages: [
           { role: 'system', content: 'Classifique a intenção da mensagem de um usuário de um CLI DevOps. Responda APENAS uma palavra: "chat" (pergunta, conversa, pedido de explicação), "agente" (quer que algo seja FEITO nesta máquina: comandos, arquivos, diagnóstico, instalação) ou "orquestrar" (objetivo GRANDE com vários entregáveis para uma equipe de agentes).' },
           { role: 'user', content: String(msg).slice(0, 500) },
@@ -79,7 +89,7 @@ async function classify(msg, token) {
     const word = String(j?.choices?.[0]?.message?.content || '').toLowerCase();
     // cobra a classificação (mesmo padrão do web-intent) — best-effort
     const u = j?.usage || {};
-    if (u.prompt_tokens && !k.billingAuthoritative) api('/api/credit/charge', { method: 'POST', token, body: { model: 'gemini-2.5-flash-lite', inTok: u.prompt_tokens || 0, outTok: u.completion_tokens || 0 } }).catch(() => {});
+    if (u.prompt_tokens && !k.billingAuthoritative) api('/api/credit/charge', { method: 'POST', token, body: { model: INTENT_MODEL, inTok: u.prompt_tokens || 0, outTok: u.completion_tokens || 0 } }).catch(() => {});
     if (word.includes('agente')) return 'agente';
     if (word.includes('orquestrar')) return 'run';
     return 'chat';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.97.65",
+  "version": "0.97.67",
   "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 scripts/run-tests.js"
   },
   "files": [
     "bin",