terminal-smart-cli 0.97.69 → 0.98.1

package/bin/ts.js

@@ -2743,6 +2743,156 @@ function trilhaCmd() {
 }
 
 // ── ts tema — paleta do CLI (cor é SEMÂNTICA: ok/aprovação/bloqueado) ────────
+// ── ts modelos — o catálogo em vigor, e o que o seu plano permite ───────────
+//
+// O catálogo do produto é curado à mão e envelhece. A camada dinâmica resolve
+// isso buscando o catálogo público do OpenRouter; este comando é a porta de
+// entrada dela na linha de comando.
+//
+// Funciona OFFLINE: o piso é o catálogo embutido, e o cache em disco (buscado
+// antes) entra por cima. Só `--atualizar` toca a rede.
+async function modelosCmd(words) {
+  const en = (cfg.lang === 'en');
+  const _path = require('path');
+  const _os = require('os');
+  const core = require('../lib/intelligence-core');
+  const servico = require('../lib/catalog-service').createCatalogService({
+    // Ao lado do config.json, que é onde a CLI já guarda o estado dela.
+    cacheFile: _path.join(_path.dirname(config.FILE), 'model-catalog.json'),
+    core,
+  });
+
+  const forcar = FLAGS.has('--atualizar') || FLAGS.has('--update') || FLAGS.has('-u');
+  const soGratis = FLAGS.has('--gratis') || FLAGS.has('--grátis') || FLAGS.has('--free');
+  const soFerramentas = FLAGS.has('--ferramentas') || FLAGS.has('--tools');
+  const termo = words.filter((w) => !w.startsWith('-')).join(' ').trim().toLowerCase();
+
+  servico.boot();
+  let aviso = '';
+  if (forcar) {
+    const r = await servico.refresh({ force: true });
+    if (!r.ok) aviso = (en ? 'could not update: ' : 'não consegui atualizar: ') + r.motivo;
+  }
+
+  /* Quais modelos ESTE usuário pode pedir. Vem do servidor, que é quem aplica a
+     regra — a CLI não a reimplementa. Sem login ou sem rede, `null`: aí o
+     comando mostra o catálogo inteiro e diz que não sabe do plano, em vez de
+     esconder tudo ou mentir que tudo está liberado. */
+  let permitidos = null;
+  let plano = '';
+  if (cfg.token) {
+    try {
+      const r = await api('/api/intelligence/catalog', { token: cfg.token, timeoutMs: 8000 });
+      if (r && Array.isArray(r.allowed)) { permitidos = r.allowed; plano = String(r.plan || ''); }
+    } catch (_) { /* offline ou sessão expirada: segue sem a informação */ }
+  }
+  const liberado = (id) => !permitidos || permitidos.includes('*') || permitidos.includes(id);
+
+  const ativo = core.activeCatalog();
+  const lista = Object.keys(ativo)
+    .filter((id) => id !== 'smart')
+    .map((id) => {
+      const m = ativo[id] || {};
+      return {
+        id,
+        nome: m.name || id,
+        provedor: m.upstreamProvider || m.provider || '',
+        contexto: m.contextWindow || 0,
+        entrada: (m.price && m.price.input) || 0,
+        saida: (m.price && m.price.output) || 0,
+        capacidades: m.capabilities || [],
+        gratis: !!m.free,
+        varianteGratis: m.freeVariant || null,
+        avaliado: m.rated !== false,
+        noPlano: liberado(id),
+      };
+    })
+    .filter((m) => !soGratis || m.gratis || m.varianteGratis)
+    .filter((m) => !soFerramentas || m.capacidades.includes('tools'))
+    .filter((m) => !termo || m.id.toLowerCase().includes(termo)
+      || m.nome.toLowerCase().includes(termo) || m.provedor.toLowerCase().includes(termo))
+    .sort((a, b) => (a.noPlano === b.noPlano)
+      ? ((a.avaliado === b.avaliado) ? a.nome.localeCompare(b.nome) : (a.avaliado ? -1 : 1))
+      : (a.noPlano ? -1 : 1));
+
+  const st = servico.status();
+
+  if (JSON_OUT) {
+    console.log(JSON.stringify({
+      ok: true, fonte: st.fonte, total: st.total, curados: st.curados,
+      atualizadoEm: st.fetchedAt || null, divergencias: st.divergencias,
+      plano: plano || null, permitidos, modelos: lista,
+    }));
+    return;
+  }
+
+  const fmtCtx = (n) => (!n ? '—'
+    : n >= 1000000 ? (n / 1000000).toFixed(n % 1000000 ? 1 : 0) + 'M'
+    : n >= 1000 ? Math.round(n / 1000) + 'k' : String(n));
+  const fmtPreco = (m) => (!m.entrada && !m.saida) ? (en ? 'free' : 'grátis')
+    : '$' + (m.entrada >= 1 ? m.entrada.toFixed(2) : m.entrada.toFixed(3)) +
+      '/$' + (m.saida >= 1 ? m.saida.toFixed(2) : m.saida.toFixed(3));
+
+  const linhas = [];
+  if (aviso) linhas.push(C.warn('▲ ') + aviso, '');
+  if (!lista.length) {
+    linhas.push(C.dim(en ? 'no model matches that.' : 'nenhum modelo com esse filtro.'));
+  }
+
+  /* DUAS linhas por modelo, de propósito. Numa linha só, nome + contexto + preço
+     + marcas estourava a largura da caixa e a borda direita ia embora. A segunda
+     linha também é onde o id aparece — que é o que se copia para `--modelo`. */
+  const largura = Math.min(32, Math.max(14, ...lista.map((m) => m.nome.length)));
+  for (const m of lista.slice(0, 60)) {
+    /* A cor É o estado, como no resto da CLI: normal = pode usar, apagado = está
+       no catálogo mas fora do seu plano. Esconder o que está fora esconderia
+       também o motivo de assinar. */
+    const cor = m.noPlano ? C.cyan : C.dim;
+    linhas.push('  ' + cor(m.nome.slice(0, largura).padEnd(largura)) + ' ' +
+      C.dim(fmtCtx(m.contexto).padStart(5)) + '  ' + C.dim(fmtPreco(m)));
+
+    /* `medido` marca o que o produto AVALIOU, e não o contrário. Com a camada
+       instalada são 31 de 436: marcar os 405 restantes como "não avaliado" seria
+       escrever a mesma coisa em quase toda linha, que é o mesmo que não escrever
+       nada. É também o que explica por que só alguns entram no Automático. */
+    const marcas = [
+      m.gratis ? C.ok(en ? 'free' : 'grátis') : '',
+      (!m.gratis && m.varianteGratis) ? C.ok(en ? 'has free' : 'tem grátis') : '',
+      m.capacidades.includes('vision') ? (en ? 'vision' : 'visão') : '',
+      m.capacidades.includes('tools') ? '' : (en ? 'no tools' : 'sem ferramentas'),
+      m.avaliado ? C.indigo(en ? 'measured' : 'medido') : '',
+      m.noPlano ? '' : C.warn(en ? 'not in your plan' : 'fora do seu plano'),
+    ].filter(Boolean);
+    linhas.push('  ' + C.dim(' '.repeat(largura) + ' ' + m.id) +
+      (marcas.length ? C.dim('  · ') + marcas.join(C.dim(' · ')) : ''));
+  }
+  if (lista.length > 60) {
+    linhas.push('', C.dim((en ? `+${lista.length - 60} more — narrow it down: ` : `+${lista.length - 60} — refine: `) + 'ts modelos <termo>'));
+  }
+
+  linhas.push('');
+  linhas.push(C.dim((en ? 'source: ' : 'fonte: ') +
+    (st.fonte === 'openrouter' ? 'OpenRouter' : (en ? 'built-in' : 'embutido')) +
+    ' · ' + st.total + (en ? ' models' : ' modelos') +
+    (st.divergencias ? ' · ' + st.divergencias + (en ? ' price diffs' : ' preços divergentes') : '')));
+  if (plano) {
+    linhas.push(C.dim((en ? 'your plan: ' : 'seu plano: ') + plano +
+      (permitidos && permitidos.includes('*')
+        ? (en ? ' (all models)' : ' (todos os modelos)')
+        : (permitidos ? ` (${permitidos.length - 1}${en ? ' models' : ' modelos'})` : ''))));
+  } else if (!permitidos) {
+    linhas.push(C.dim(en
+      ? 'plan unknown (offline or not signed in): showing the whole catalog.'
+      : 'plano desconhecido (offline ou sem login): mostrando o catálogo inteiro.'));
+  }
+  if (st.vencido && !forcar) {
+    linhas.push(C.dim((en ? 'catalog may be stale — ' : 'catálogo pode estar velho — ') + 'ts modelos --atualizar'));
+  }
+  linhas.push(C.dim((en ? 'use one: ' : 'usar um: ') + C.cyan('ts --modelo <id> "sua pergunta"')));
+
+  console.log('\n' + ui.box(linhas, { title: 'ts modelos' }));
+}
+
 function temaCmd(words) {
   const en = (cfg.lang === 'en');
   const temas = require('../lib/temas');
@@ -3481,6 +3631,7 @@ function recallCmd(args) {
     case 'hooks': case 'ganchos': return hooksCmd(POS.slice(1));
     case 'worktrees': case 'worktree': case 'wt': return worktreesCmd(POS.slice(1));
     case 'eval': case 'avaliar': case 'evals': return evalCmd(POS.slice(1));
+    case 'modelos': case 'modelo': case 'models': case 'model': return modelosCmd(POS.slice(1));
     case 'tema': case 'theme': return temaCmd(POS.slice(1));
     case 'politica': case 'política': case 'policy': return politicaCmd(POS.slice(1));
     case 'checkpoints': case 'checkpoint': return checkpointsCmd(POS.slice(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/catalog-service.js

@@ -0,0 +1,235 @@
+'use strict';
+
+/* ═══ Serviço do catálogo — onde a camada encosta no mundo ═══════════════════
+
+   Divisão de responsabilidades, de propósito:
+
+     model-catalog-sync.js   PURO. Sabe o formato do OpenRouter e a política de
+                             validade do cache. Não lê disco, não abre socket.
+     intelligence-core.js    Guarda o piso congelado e aceita uma camada.
+     este arquivo            Tem os EFEITOS: rede e disco. E só ele.
+
+   Rede e disco entram por injeção (`fetchJson`, `fs`, `now`), então o teste
+   exercita todos os caminhos — inclusive falha de rede, JSON corrompido e disco
+   somente-leitura — sem tocar em nenhum dos dois.
+
+   REGRA DESTE ARQUIVO: nada aqui lança. O catálogo é uma MELHORIA sobre um piso
+   que já funciona; se a rede cair, o disco encher ou o upstream mudar de
+   formato, o app tem que continuar com o catálogo congelado. Toda função
+   devolve um objeto com `ok` e, quando falha, `motivo` legível.
+
+   Byte-idêntico nas três superfícies: os dois módulos de que ele depende são
+   irmãos dele em cli/lib, app-electron/ e backend/services. */
+
+const sync = require('./model-catalog-sync');
+
+/* Teto do corpo baixado. O catálogo real mede 0,70 MB para 445 modelos — 8 MB
+   comporta cerca de cinco mil. O teto existe para que uma resposta errada (um
+   portal de captura, um proxy devolvendo HTML infinito) não vire memória sem
+   limite: o pedido é abortado ao cruzar a marca. */
+const MAX_BODY_BYTES = 8 * 1024 * 1024;
+const FETCH_TIMEOUT_MS = 15000;
+
+/* Busca padrão, em Node puro. Sem dependência e sem `fetch` global de propósito:
+   este mesmo arquivo roda no processo principal do Electron, na CLI e no backend,
+   e nem todos garantem a mesma versão de runtime. */
+function _fetchHttpsJson(url, timeoutMs) {
+  return new Promise((resolve) => {
+    let alvo;
+    try { alvo = new URL(url); } catch (_) { return resolve({ ok: false, motivo: 'URL inválida' }); }
+    const mod = alvo.protocol === 'http:' ? require('http') : require('https');
+
+    let req;
+    const falhar = (motivo) => {
+      try { req && req.destroy(); } catch (_) {}
+      resolve({ ok: false, motivo });
+    };
+
+    try {
+      req = mod.get({
+        hostname: alvo.hostname,
+        port: alvo.port || (alvo.protocol === 'http:' ? 80 : 443),
+        path: alvo.pathname + alvo.search,
+        headers: { 'Accept': 'application/json', 'User-Agent': 'terminal-smart' },
+        timeout: timeoutMs || FETCH_TIMEOUT_MS,
+      }, (res) => {
+        /* O catálogo do OpenRouter é público: responde 200 sem chave. Qualquer
+           outra coisa é tratada como falha e não escreve nada — não há redirect
+           a seguir aqui, e seguir um às cegas seria buscar noutro lugar. */
+        if (res.statusCode !== 200) {
+          res.resume();
+          return falhar('HTTP ' + res.statusCode);
+        }
+        let bytes = 0;
+        const partes = [];
+        res.on('data', (c) => {
+          bytes += c.length;
+          if (bytes > MAX_BODY_BYTES) return falhar('resposta acima do teto de ' + MAX_BODY_BYTES + ' bytes');
+          partes.push(c);
+        });
+        res.on('end', () => {
+          if (bytes > MAX_BODY_BYTES) return;
+          try {
+            resolve({ ok: true, corpo: JSON.parse(Buffer.concat(partes).toString('utf8')) });
+          } catch (e) {
+            resolve({ ok: false, motivo: 'resposta não é JSON: ' + e.message });
+          }
+        });
+      });
+      req.on('timeout', () => falhar('tempo esgotado em ' + (timeoutMs || FETCH_TIMEOUT_MS) + 'ms'));
+      req.on('error', (e) => falhar(e.message));
+    } catch (e) {
+      resolve({ ok: false, motivo: e.message });
+    }
+  });
+}
+
+function createCatalogService(opcoes) {
+  const o = opcoes || {};
+  const fs = o.fs || require('fs');
+  const core = o.core || require('./intelligence-core');
+  const fetchJson = o.fetchJson || _fetchHttpsJson;
+  const agora = o.now || (() => Date.now());
+  const cacheFile = o.cacheFile || '';
+  const url = o.url || sync.OPENROUTER_MODELS_URL;
+  const aviso = o.log || (() => {});
+
+  /* Quando foi a última TENTATIVA — não o último sucesso. É o que segura o piso
+     de MIN_REFRESH_MS quando o upstream está fora do ar: sem isso, uma falha
+     rápida viraria laço apertado. Fica só em memória de propósito: reiniciar o
+     app é ação do usuário e merece uma tentativa nova. */
+  let ultimaTentativa = 0;
+  let instalado = null;
+
+  function readCache() {
+    if (!cacheFile) return null;
+    try {
+      const bruto = fs.readFileSync(cacheFile, 'utf8');
+      const payload = JSON.parse(bruto);
+      return sync.isCacheValid(payload) ? payload : null;
+    } catch (_) {
+      /* Arquivo ausente no primeiro uso é o caso NORMAL, não um erro. Corrompido
+         também cai aqui e o tratamento é o mesmo: ignora e busca de novo. */
+      return null;
+    }
+  }
+
+  function writeCache(payload) {
+    if (!cacheFile) return { ok: false, motivo: 'sem caminho de cache' };
+    try {
+      /* Escreve em temporário e renomeia: sem isso, um desligamento no meio da
+         escrita deixaria um JSON pela metade, que o próximo boot leria como
+         cache corrompido e jogaria fora — perdendo o catálogo por um corte de
+         energia. O rename é atômico no mesmo volume. */
+      const tmp = cacheFile + '.tmp';
+      fs.writeFileSync(tmp, JSON.stringify(payload), 'utf8');
+      try { fs.renameSync(tmp, cacheFile); }
+      catch (_) { fs.writeFileSync(cacheFile, JSON.stringify(payload), 'utf8'); }
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, motivo: e.message };
+    }
+  }
+
+  /* Instala a camada a partir de um payload de cache. Devolve o relatório de
+     divergência junto, porque é a única hora em que ele está calculado. */
+  function install(payload) {
+    if (!sync.isCacheValid(payload)) return { ok: false, motivo: 'cache inválido' };
+    let fusao;
+    try {
+      fusao = sync.mergeWithCurated(core.MODEL_CATALOG, payload.models);
+    } catch (e) {
+      return { ok: false, motivo: 'fusão falhou: ' + e.message };
+    }
+    const r = core.installCatalogOverlay(fusao.models);
+    if (!r.ok) return { ok: false, motivo: r.motivo };
+
+    instalado = {
+      total: r.total,
+      curados: r.curados,
+      novos: fusao.added.length,
+      precoAtualizado: fusao.priceUpdated.length,
+      divergencias: fusao.drift.length,
+      sumiramDoUpstream: fusao.upstreamMissing,
+      fetchedAt: payload.fetchedAt || '',
+    };
+    return Object.assign({ ok: true }, instalado);
+  }
+
+  /* Boot é SÍNCRONO e não toca a rede: o app precisa de um catálogo antes de
+     desenhar a primeira tela. Sem cache em disco, fica no piso congelado — que
+     já é um catálogo utilizável — e quem chama decide se dispara o refresh. */
+  function boot() {
+    const payload = readCache();
+    if (!payload) return { ok: false, motivo: 'sem cache utilizável', usandoPiso: true };
+    const r = install(payload);
+    if (!r.ok) aviso('catálogo: cache em disco recusado — ' + r.motivo);
+    return r;
+  }
+
+  async function refresh(op) {
+    const forcar = !!(op && op.force);
+    const t = agora();
+    const payloadAtual = readCache();
+
+    if (!forcar && !sync.shouldRefresh(payloadAtual, t, ultimaTentativa)) {
+      return { ok: true, pulou: true, motivo: 'cache ainda válido', fetchedAt: payloadAtual && payloadAtual.fetchedAt };
+    }
+    ultimaTentativa = t;
+
+    const resp = await fetchJson(url, o.timeoutMs);
+    if (!resp || !resp.ok) {
+      const motivo = (resp && resp.motivo) || 'falha desconhecida';
+      aviso('catálogo: busca falhou — ' + motivo);
+      /* Falhou a rede: se havia cache, ele CONTINUA instalado. Não desinstala
+         nada — um catálogo de ontem é melhor que nenhum. */
+      return { ok: false, motivo, usandoCache: !!payloadAtual };
+    }
+
+    let parsed;
+    try { parsed = sync.parseOpenRouterCatalog(resp.corpo); }
+    catch (e) { return { ok: false, motivo: 'formato inesperado: ' + e.message }; }
+
+    if (!parsed || !parsed.models || !parsed.models.length) {
+      /* Zero modelos é resposta bem-formada e inútil. Se gravasse, o cache de
+         amanhã seria um catálogo vazio e o app ficaria sem modelo nenhum. */
+      return { ok: false, motivo: 'upstream devolveu catálogo vazio', usandoCache: !!payloadAtual };
+    }
+
+    const payload = sync.buildCachePayload(parsed.models, new Date(t).toISOString());
+    const r = install(payload);
+    if (!r.ok) return { ok: false, motivo: r.motivo, usandoCache: !!payloadAtual };
+
+    /* Grava só DEPOIS de instalar: um catálogo que o núcleo recusou não merece
+       ficar no disco esperando o próximo boot para ser recusado de novo. */
+    const gravou = writeCache(payload);
+    return Object.assign({}, r, {
+      gravou: gravou.ok,
+      motivoGravacao: gravou.ok ? undefined : gravou.motivo,
+      ignorados: parsed.skipped || 0,
+    });
+  }
+
+  function status() {
+    const payload = readCache();
+    const t = agora();
+    const buscadoEm = payload ? Date.parse(payload.fetchedAt || '') : NaN;
+    return {
+      instalado: !!instalado,
+      total: instalado ? instalado.total : Object.keys(core.MODEL_CATALOG).length,
+      curados: Object.keys(core.MODEL_CATALOG).length,
+      novos: instalado ? instalado.novos : 0,
+      divergencias: instalado ? instalado.divergencias : 0,
+      fetchedAt: payload ? payload.fetchedAt : '',
+      idadeMs: Number.isFinite(buscadoEm) ? t - buscadoEm : null,
+      vencido: sync.shouldRefresh(payload, t, 0),
+      fonte: instalado ? 'openrouter' : 'embutido',
+    };
+  }
+
+  function reset() { instalado = null; core.resetCatalogOverlay(); }
+
+  return { boot, refresh, status, install, readCache, writeCache, reset };
+}
+
+module.exports = { createCatalogService, MAX_BODY_BYTES, FETCH_TIMEOUT_MS, _fetchHttpsJson };

package/lib/i18n.js

@@ -81,6 +81,8 @@ const STR = {
         ['ts diagnosticos status', 'controla telemetria sanitizada de erros (ativar/desativar)'],
         ['ts doctor', 'diagnóstico do ambiente (Node, login, gateway, versão, deps opcionais)'],
         ['ts privacidade', 'mostra o endereço da Política de Privacidade'],
+        ['ts modelos', 'lista os modelos disponíveis, o preço e o que o seu plano libera'],
+        ['ts modelos --atualizar', 'busca o catálogo mais novo no OpenRouter'],
         ['ts tema', 'paleta do terminal (7 temas; a cor indica o ESTADO)'],
         ['ts idioma pt|en', 'idioma (padrão pt-BR)'],
       ] },
@@ -250,6 +252,8 @@ const STR = {
         ['ts account open', 'open Account for privacy controls and safe deletion'],
         ['ts diagnostics status', 'controls sanitized error telemetry (on/off)'],
         ['ts privacy', 'shows the Privacy Policy address'],
+        ['ts modelos', 'list available models, prices and what your plan unlocks'],
+        ['ts modelos --atualizar', 'fetch the latest catalog from OpenRouter'],
         ['ts tema', 'terminal palette (7 themes; color means STATE)'],
         ['ts idioma pt|en', 'language (default pt-BR)'],
       ] },

package/lib/intelligence-core.js

@@ -176,6 +176,41 @@ const MODEL_CATALOG = Object.freeze({
   },
 });
 
+/* ═══ Camada dinâmica sobre o catálogo ═══
+
+   MODEL_CATALOG continua congelado e é o PISO: o que vale offline, no primeiro
+   uso e sempre que a camada não tiver sido instalada. As leituras internas
+   passam por ACTIVE_CATALOG, que começa sendo exatamente ele.
+
+   Sem overlay instalado o comportamento é idêntico ao de antes — é isso que
+   permite que os testes antigos continuem valendo sem alterar uma linha.
+
+   Quem monta a camada é model-catalog-sync.js, a partir do catálogo público do
+   OpenRouter. Aqui só existe o ponto de encaixe: este arquivo não busca nada,
+   não lê disco e não conhece o formato do provedor. */
+let ACTIVE_CATALOG = MODEL_CATALOG;
+
+function installCatalogOverlay(models) {
+  if (!models || typeof models !== 'object') return { ok: false, motivo: 'camada inválida' };
+  const ids = Object.keys(models);
+  if (!ids.length) return { ok: false, motivo: 'camada vazia' };
+  // Toda entrada curada precisa sobreviver. Uma camada que perdesse modelo do
+  // piso deixaria o app sem o que ele garante funcionar offline.
+  for (const id of Object.keys(ACTIVE_CATALOG)) {
+    if (!models[id]) return { ok: false, motivo: 'a camada perderia o modelo curado ' + id };
+  }
+  ACTIVE_CATALOG = models;
+  return { ok: true, total: ids.length, curados: Object.keys(MODEL_CATALOG).length };
+}
+
+// Volta ao piso. Existe para o teste poder isolar casos sem carregar o módulo
+// de novo, e para o app cair no embutido se a camada se mostrar ruim.
+function resetCatalogOverlay() { ACTIVE_CATALOG = MODEL_CATALOG; }
+
+// O catálogo em vigor, para quem precisa LISTAR (o seletor de modelos) em vez
+// de consultar um id.
+function activeCatalog() { return ACTIVE_CATALOG; }
+
 const MODEL_ALIASES = Object.freeze({
   deepseek: 'deepseek-v4.1-flash',
   'deepseek-v4.1': 'deepseek-v4.1-flash',
@@ -270,11 +305,11 @@ function normalizeModelId(model) {
   // sobrecobrado e Opus subcobrado, com risco direto de margem negativa.
   const transportFree = raw.replace(/^openrouter:/i, '');
   const lower = transportFree.toLowerCase();
-  if (MODEL_CATALOG[raw]) return raw;
-  if (MODEL_CATALOG[transportFree]) return transportFree;
-  if (MODEL_CATALOG[lower]) return lower;
+  if (ACTIVE_CATALOG[raw]) return raw;
+  if (ACTIVE_CATALOG[transportFree]) return transportFree;
+  if (ACTIVE_CATALOG[lower]) return lower;
   if (MODEL_ALIASES[lower]) return MODEL_ALIASES[lower];
-  const upstream = Object.entries(MODEL_CATALOG)
+  const upstream = Object.entries(ACTIVE_CATALOG)
     .find(([, info]) => String(info.upstreamId || '').toLowerCase() === lower);
   return upstream ? upstream[0] : transportFree;
 }
@@ -289,11 +324,11 @@ function supportedModelId(model) {
 
 function modelInfo(model, now) {
   const id = normalizeModelId(model);
-  const info = MODEL_CATALOG[id] || {
+  const info = ACTIVE_CATALOG[id] || {
     provider: 'unknown', contextWindow: 100000, price: DEFAULT_PRICE,
     capabilities: [], toolReliability: 0.50, quality: 0.50,
   };
-  const result = Object.assign({ id, known: !!MODEL_CATALOG[id] }, info);
+  const result = Object.assign({ id, known: !!ACTIVE_CATALOG[id] }, info);
   const at = now ? new Date(now) : new Date();
   if (id === 'claude-sonnet-5' && at.getTime() >= Date.parse('2026-09-01T00:00:00Z')) {
     result.price = { input: 3.00, output: 15.00, cachedInput: 0.30 };
@@ -389,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';
@@ -396,7 +532,7 @@ function _safeToolName(value) {
 
 function _safeModelId(value) {
   const normalized = normalizeModelId(value);
-  return MODEL_CATALOG[normalized] || normalized === 'smart' ? normalized : _safeToolName(value);
+  return ACTIVE_CATALOG[normalized] || normalized === 'smart' ? normalized : _safeToolName(value);
 }
 
 function buildOperationalSummary(input) {
@@ -527,12 +663,12 @@ function agentRoleContract(role, plan, options) {
   const allowedRaw = options && Array.isArray(options.allowedModels) ? options.allowedModels : null;
   const allowAll = !allowedRaw || allowedRaw.includes('*');
   const allowed = allowAll ? null : new Set(allowedRaw.map(normalizeModelId));
-  const candidates = requested.map(normalizeModelId).filter(model => model === 'smart' || MODEL_CATALOG[model])
+  const candidates = requested.map(normalizeModelId).filter(model => model === 'smart' || ACTIVE_CATALOG[model])
     .filter(model => !allowed || allowed.has(model) || model === 'smart');
   // O fallback nunca atravessa a fronteira comercial. Se a configuração vier
   // inconsistente, usa o primeiro modelo explicitamente permitido, ou smart.
   if (!candidates.length && allowed) {
-    const safe = [...allowed].find(model => MODEL_CATALOG[model] || model === 'smart');
+    const safe = [...allowed].find(model => ACTIVE_CATALOG[model] || model === 'smart');
     if (safe) candidates.push(safe);
   }
   if (!candidates.length) candidates.push('smart');
@@ -548,15 +684,20 @@ function routeModel(task, reliability) {
   if (t.kind === 'vision') required.add('vision');
   // Era um Set escrito a mao aqui dentro. Agora le a MESMA tabela que o CLI e
   // o App leem, para os tres nao divergirem de novo.
-  const candidates = (t.candidates || Object.keys(MODEL_CATALOG)).map(supportedModelId)
-    .filter(id => MODEL_CATALOG[id] && id !== 'smart')
+  const candidates = (t.candidates || Object.keys(ACTIVE_CATALOG)).map(supportedModelId)
+    .filter(id => ACTIVE_CATALOG[id] && id !== 'smart')
+    // rated:false é o modelo que veio do provedor sem ninguém medir como ele se
+    // comporta usando ferramenta. Ele aparece no seletor manual e no cálculo de
+    // custo, mas NÃO entra no roteamento automático: o score abaixo lê quality e
+    // toolReliability, que ele não tem — daria NaN e ordenaria por acidente.
+    .filter(id => ACTIVE_CATALOG[id].rated !== false)
     .filter((id, i, list) => list.indexOf(id) === i);
   const rel = reliability || {};
   const plan = String(t.plan || '').toLowerCase();
   const isPaid = plan && plan !== 'free' && plan !== 'gratuito';
 
   const scored = candidates.map(id => {
-    const m = MODEL_CATALOG[id];
+    const m = ACTIVE_CATALOG[id];
     const missing = [...required].filter(c => !m.capabilities.includes(c)).length;
     const observed = rel[id] && Number.isFinite(rel[id].successRate) ? rel[id].successRate : m.toolReliability;
     const price = m.price.input + m.price.output;
@@ -572,7 +713,9 @@ 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,
+  installCatalogOverlay, resetCatalogOverlay, activeCatalog,
   normalizeModelId, modelInfo, legacyPriceMap, normalizeUsage, estimateCostUsd, catalogFreshness,
+  TOOL_OUTPUT_MAX, compactToolResult,
   createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff, cleanOperationalText, buildOperationalSummary,
   normalizeAgentPlan, agentRoleContract, routeModel,
 };

package/lib/model-catalog-sync.js

@@ -0,0 +1,295 @@
+'use strict';
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   CATÁLOGO DE MODELOS — camada dinâmica sobre o catálogo curado
+
+   O MODEL_CATALOG do intelligence-core é mantido à mão e envelhece: há uma
+   constante PRICE_REVISION e uma função catalogFreshness() que marca `stale`
+   depois de 30 dias. Ou seja, o código já sabia do problema — só avisava.
+
+   A medição que originou este módulo: dos 27 upstreamIds do catálogo que ainda
+   existem no OpenRouter, 18 estavam com preço divergente e 3 com contexto
+   divergente; e 2 ids marcados como provider 'openrouter' (qwen3.8-max,
+   ling-2.6-flash) não existem mais lá.
+
+   O DESENHO, em uma frase: o catálogo congelado continua sendo o piso — o que
+   vale offline e no primeiro uso — e o que vem do OpenRouter entra como CAMADA
+   por cima, nunca substituindo o objeto congelado.
+
+   O QUE É DERIVÁVEL, e só isso é derivado:
+     upstreamId, contextWindow, price, e as capacidades `tools` (de
+     supported_parameters), `vision` (de architecture.input_modalities) e
+     `long-context` (do próprio contextWindow).
+
+   O QUE NÃO É, e por isso continua curado: toolReliability e quality são
+   JULGAMENTOS sobre como o modelo se comporta como agente, não fatos que uma
+   API publique. Um modelo novo entra com `rated: false` — aparece no seletor
+   manual e no cálculo de custo, mas fica FORA do roteamento automático até
+   alguém curá-lo. Deixar o roteador escolher sozinho um modelo cuja
+   confiabilidade ninguém mediu seria trocar "catálogo velho" por "catálogo
+   irresponsável".
+
+   SEM REDE E SEM DISCO AQUI. Este arquivo é função pura: recebe texto JSON e
+   devolve objeto. Quem busca e quem grava são os arranjos de cada superfície,
+   que passam um `transport` e um `store`. É isso que torna o módulo testável
+   sem tocar na rede — regra do projeto.
+
+   BYTE-IDÊNTICO nos três repos (cli/lib/, app-electron/, backend/services/),
+   como o intelligence-core. Há teste de paridade.
+   ═══════════════════════════════════════════════════════════════════════════ */
+
+const CATALOG_SCHEMA = 1;
+const OPENROUTER_MODELS_URL = 'https://openrouter.ai/api/v1/models';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;   // um dia
+const MIN_REFRESH_MS = 5 * 60 * 1000;       // piso entre duas tentativas
+const LONG_CONTEXT_MIN = 200000;
+
+// O preço do OpenRouter vem POR TOKEN, em string ("0.000003"). O catálogo do
+// produto trabalha por 1M de tokens. Converter no lugar errado produz erro de
+// seis ordens de grandeza no custo — daí a constante ter nome.
+const TOKENS_POR_UNIDADE_DE_PRECO = 1e6;
+
+function _num(valor) {
+  const n = Number(valor);
+  return Number.isFinite(n) ? n : 0;
+}
+
+// Arredonda para 6 casas. Sem isso, 0.000003 * 1e6 vira 3.0000000000000004 e o
+// teste de paridade entre superfícies passa a comparar ruído de ponto flutuante.
+function _preco1M(porToken) {
+  return Math.round(_num(porToken) * TOKENS_POR_UNIDADE_DE_PRECO * 1e6) / 1e6;
+}
+
+/* Converte UMA entrada do OpenRouter para o formato do catálogo. Devolve null
+   para entrada inutilizável — id ausente ou sem barra (o formato é sempre
+   `autor/modelo`), que é o que separa um modelo de um registro quebrado. */
+function parseModel(bruto) {
+  if (!bruto || typeof bruto !== 'object') return null;
+  const upstreamId = String(bruto.id || '').trim();
+  if (!upstreamId || upstreamId.indexOf('/') < 0) return null;
+
+  const params = Array.isArray(bruto.supported_parameters) ? bruto.supported_parameters : [];
+  const modalidades = (bruto.architecture && Array.isArray(bruto.architecture.input_modalities))
+    ? bruto.architecture.input_modalities : [];
+  const preco = bruto.pricing || {};
+
+  const contextWindow = Math.max(0, Math.trunc(_num(bruto.context_length)));
+  const input = _preco1M(preco.prompt);
+  const output = _preco1M(preco.completion);
+
+  const capabilities = [];
+  if (params.includes('tools')) capabilities.push('tools');
+  if (modalidades.includes('image')) capabilities.push('vision');
+  if (contextWindow >= LONG_CONTEXT_MIN) capabilities.push('long-context');
+
+  return {
+    // O id local é o upstreamId sem o sufixo de variante `:free`, para que o
+    // mesmo modelo pago e gratuito não vire duas entradas concorrendo no
+    // seletor. A variante fica registrada em `free`.
+    id: upstreamId.replace(/:free$/, ''),
+    upstreamId,
+    provider: 'openrouter',
+    upstreamProvider: upstreamId.split('/')[0],
+    name: String(bruto.name || upstreamId),
+    contextWindow,
+    price: {
+      input,
+      output,
+      cachedInput: _preco1M(preco.input_cache_read),
+    },
+    capabilities,
+    free: input === 0 && output === 0,
+    rated: false,   // sem toolReliability/quality: fora do roteamento automático
+  };
+}
+
+/* Converte o corpo inteiro. Aceita texto ou objeto já parseado. Nunca lança por
+   causa de conteúdo: devolve {ok:false, erro} — uma resposta estranha do
+   provedor não pode derrubar a inicialização do app. */
+function parseOpenRouterCatalog(corpo) {
+  let dados = corpo;
+  if (typeof corpo === 'string') {
+    try { dados = JSON.parse(corpo); }
+    catch (e) { return { ok: false, erro: 'json inválido: ' + (e && e.message), models: [] }; }
+  }
+  const lista = dados && Array.isArray(dados.data) ? dados.data : null;
+  if (!lista) return { ok: false, erro: 'resposta sem campo data[]', models: [] };
+
+  const models = [];
+  const porId = new Map();
+  let ignorados = 0;
+  for (const bruto of lista) {
+    const m = parseModel(bruto);
+    if (!m) { ignorados++; continue; }
+
+    const anterior = porId.get(m.id);
+    if (!anterior) { porId.set(m.id, m); models.push(m); continue; }
+
+    /* Mesmo id local duas vezes — é o par `modelo` e `modelo:free`. O registro
+       principal é sempre o PAGO, porque é dele que sai o preço real e é ele que
+       costuma ter a cota maior; a existência da variante gratuita fica em
+       `freeVariant`.
+
+       Uma versão anterior fazia `anterior.free = true` aqui e marcava o registro
+       PAGO como gratuito — o preço continuava lá, e o teste pegou a contradição
+       (`marcado free com preço de entrada`). Marcar errado teria feito o seletor
+       anunciar como grátis um modelo que cobra. */
+    if (m.free && !anterior.free) { anterior.freeVariant = m.upstreamId; continue; }
+    if (anterior.free && !m.free) {
+      // O gratuito chegou primeiro: o pago assume como principal, e a gratuita
+      // vira a variante. Sem isto a ordem da resposta decidiria o preço.
+      const idx = models.indexOf(anterior);
+      m.freeVariant = anterior.upstreamId;
+      models[idx] = m;
+      porId.set(m.id, m);
+      continue;
+    }
+    // Duas variantes do mesmo tipo: fica a primeira, sem inventar nada.
+  }
+  return { ok: true, models, ignorados, total: lista.length };
+}
+
+/* Funde o catálogo curado com a camada dinâmica. NÃO muta o curado — ele é
+   Object.freeze e é o piso offline. Devolve um objeto novo mais o relatório do
+   que mudou, que é o que o dono precisa ver para decidir o que curar. */
+function mergeWithCurated(curated, overlayModels) {
+  const base = curated || {};
+  const lista = Array.isArray(overlayModels) ? overlayModels : [];
+  const porUpstream = new Map();
+  for (const [id, info] of Object.entries(base)) {
+    if (info && info.upstreamId) porUpstream.set(info.upstreamId, id);
+  }
+
+  const models = {};
+  for (const [id, info] of Object.entries(base)) models[id] = info;
+
+  const added = [];
+  const priceUpdated = [];
+  const drift = [];
+
+  for (const m of lista) {
+    const idLocal = porUpstream.get(m.upstreamId) || (base[m.id] ? m.id : null);
+
+    if (idLocal) {
+      // Entrada JÁ CURADA: os campos de julgamento ficam como estão; só preço e
+      // contexto acompanham o upstream, porque esses são fatos e mudam sozinhos.
+      const atual = base[idLocal];
+      const precoAntigo = atual.price || {};
+      const mudouPreco = _preco1M(precoAntigo.input) !== m.price.input
+        || _preco1M(precoAntigo.output) !== m.price.output;
+      const mudouContexto = Number(atual.contextWindow) !== m.contextWindow && m.contextWindow > 0;
+
+      if (mudouPreco || mudouContexto) {
+        drift.push({
+          id: idLocal,
+          upstreamId: m.upstreamId,
+          nossoPreco: { input: precoAntigo.input, output: precoAntigo.output },
+          precoUpstream: { input: m.price.input, output: m.price.output },
+          nossoContexto: atual.contextWindow,
+          contextoUpstream: m.contextWindow,
+        });
+      }
+      /* Fatos do upstream que a entrada curada não tem como saber sozinha, e
+         que por isso acompanham mesmo quando o preço não mexeu:
+
+           freeVariant  o mesmo modelo publicado também como `:free`
+           name         o nome legível ("Anthropic: Claude Opus 5")
+
+         Nenhuma das entradas curadas declara `name` — o campo não existe nelas —
+         então isto não sobrescreve escolha de ninguém. É a diferença entre o
+         seletor mostrar o nome do modelo ou mostrar o id cru para o usuário. */
+      const mudancas = {};
+      if (mudouPreco || mudouContexto) {
+        mudancas.price = Object.assign({}, precoAntigo, m.price);
+        mudancas.contextWindow = m.contextWindow > 0 ? m.contextWindow : atual.contextWindow;
+        priceUpdated.push(idLocal);
+      }
+      if (m.freeVariant) mudancas.freeVariant = m.freeVariant;
+      if (m.name && !atual.name) mudancas.name = m.name;
+      models[idLocal] = Object.keys(mudancas).length ? Object.assign({}, atual, mudancas) : atual;
+      continue;
+    }
+
+    // Entrada NOVA: entra com rated:false e sem toolReliability/quality. Quem
+    // lê esses campos precisa tratar ausência — o roteador filtra por rated.
+    models[m.id] = {
+      upstreamId: m.upstreamId,
+      provider: 'openrouter',
+      upstreamProvider: m.upstreamProvider,
+      name: m.name,
+      contextWindow: m.contextWindow,
+      price: m.price,
+      capabilities: m.capabilities,
+      free: m.free,
+      rated: false,
+    };
+    /* Só quando existe: declarar a chave com undefined mudaria a forma de
+       centenas de registros para não dizer nada. */
+    if (m.freeVariant) models[m.id].freeVariant = m.freeVariant;
+    added.push(m.id);
+  }
+
+  // Curado que aponta para upstream que não existe mais. Não remove sozinho:
+  // sumir com um modelo que alguém está usando é pior do que avisar. O relatório
+  // é que diz ao dono o que aposentar.
+  const idsUpstream = new Set(lista.map((m) => m.upstreamId));
+  const upstreamMissing = [];
+  for (const [id, info] of Object.entries(base)) {
+    if (!info || !info.upstreamId) continue;
+    if (info.provider !== 'openrouter') continue;
+    if (!idsUpstream.has(info.upstreamId)) upstreamMissing.push({ id, upstreamId: info.upstreamId });
+  }
+
+  return { models, added, priceUpdated, drift, upstreamMissing };
+}
+
+/* Relatório legível do que divergiu. Existe porque "18 preços divergentes" só
+   vira ação quando alguém consegue ver QUAIS. */
+function priceDriftReport(curated, overlayModels) {
+  const r = mergeWithCurated(curated, overlayModels);
+  return {
+    total: Object.keys(curated || {}).length,
+    novos: r.added.length,
+    precoAtualizado: r.priceUpdated.length,
+    divergencias: r.drift,
+    sumiramDoUpstream: r.upstreamMissing,
+  };
+}
+
+/* Envelope do cache em disco. `schema` existe para que uma versão futura com
+   outro formato não seja lida como se fosse desta — quem lê rejeita o que não
+   reconhece em vez de adivinhar. */
+function buildCachePayload(models, fetchedAt) {
+  return {
+    schema: CATALOG_SCHEMA,
+    source: OPENROUTER_MODELS_URL,
+    fetchedAt: String(fetchedAt || ''),
+    count: Array.isArray(models) ? models.length : 0,
+    models: Array.isArray(models) ? models : [],
+  };
+}
+
+function isCacheValid(payload) {
+  return !!payload
+    && payload.schema === CATALOG_SCHEMA
+    && Array.isArray(payload.models)
+    && payload.models.length > 0;
+}
+
+/* Decide se vale buscar de novo. Separado da busca de propósito: assim o teste
+   exercita a política sem precisar de relógio nem de rede. */
+function shouldRefresh(payload, agoraMs, ultimaTentativaMs) {
+  if (Number.isFinite(ultimaTentativaMs) && ultimaTentativaMs > 0) {
+    if (agoraMs - ultimaTentativaMs < MIN_REFRESH_MS) return false;
+  }
+  if (!isCacheValid(payload)) return true;
+  const buscadoEm = Date.parse(payload.fetchedAt || '');
+  if (!Number.isFinite(buscadoEm)) return true;
+  return (agoraMs - buscadoEm) >= CACHE_TTL_MS;
+}
+
+module.exports = {
+  CATALOG_SCHEMA, OPENROUTER_MODELS_URL, CACHE_TTL_MS, MIN_REFRESH_MS, LONG_CONTEXT_MIN,
+  parseModel, parseOpenRouterCatalog, mergeWithCurated, priceDriftReport,
+  buildCachePayload, isCacheValid, shouldRefresh,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.97.69",
+  "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"