terminal-smart-cli 0.97.7 → 0.97.9

package/lib/intelligence-core.js

@@ -9,7 +9,7 @@
 const crypto = require('crypto');
 
 const INTELLIGENCE_CONTRACT = 1;
-const PRICE_REVISION = '2026-07-28';
+const PRICE_REVISION = '2026-08-06';
 
 const MODEL_CATALOG = Object.freeze({
   smart: {
@@ -42,8 +42,8 @@ const MODEL_CATALOG = Object.freeze({
     capabilities: ['tools', 'vision', 'classification', 'summarization', 'review', 'long-context'], toolReliability: 0.84, quality: 0.80,
   },
   'qwen-plus': {
-    upstreamId: 'qwen/qwen-plus',
-    provider: 'qwen', contextWindow: 1000000, price: { input: 0.26, output: 0.78, cachedInput: 0.052 },
+    upstreamId: 'qwen3.7-plus',
+    provider: 'qwen', contextWindow: 1000000, price: { input: 0.42, output: 1.68, cachedInput: 0.042 },
     capabilities: ['tools', 'content', 'code', 'summarization'], toolReliability: 0.76, quality: 0.76,
   },
   'kimi-k2.7-code-highspeed': {
@@ -89,7 +89,7 @@ const MODEL_CATALOG = Object.freeze({
   'gpt-5.6-luna': {
     upstreamId: 'openai/gpt-5.6-luna',
     provider: 'openai', contextWindow: 1000000, price: { input: 1.00, output: 6.00, cachedInput: 0.10 },
-    capabilities: ['tools', 'code', 'summarization', 'review', 'long-context'], toolReliability: 0.93, quality: 0.89,
+    capabilities: ['tools', 'code', 'planning', 'execution', 'summarization', 'review', 'long-context'], toolReliability: 0.93, quality: 0.89,
   },
   'claude-sonnet-5': {
     upstreamId: 'anthropic/claude-sonnet-5',
@@ -101,6 +101,24 @@ const MODEL_CATALOG = Object.freeze({
     provider: 'anthropic', contextWindow: 1000000, price: { input: 3.00, output: 15.00, cachedInput: 0.30 },
     capabilities: ['tools', 'code', 'planning', 'review'], toolReliability: 0.96, quality: 0.95,
   },
+  'claude-haiku-4-5': {
+    upstreamId: 'anthropic/claude-haiku-4.5',
+    provider: 'anthropic', contextWindow: 200000, price: { input: 1.00, output: 5.00, cachedInput: 0.10 },
+    capabilities: ['tools', 'code', 'planning', 'execution', 'review', 'vision'], toolReliability: 0.94, quality: 0.88,
+  },
+  // Não é um modelo que o produto oferece ao cliente — é o que o assistente interno usa
+  // quando o provedor configurado é o Anthropic. Entra no catálogo pelo PREÇO: sem entrada
+  // própria o cálculo cai no `_default` (US$ 0,30 entrada / US$ 2,50 saída), o que superestima
+  // pouco na entrada e o DOBRO na saída.
+  //
+  // Isso passou a importar quando o painel começou a decidir preço de plano com esse custo:
+  // modelo interno mal precificado empurra a margem medida para baixo e leva a corrigir preço
+  // sem precisar. E, ao contrário de um erro que quebra, este só produz um número plausível.
+  'claude-3-haiku-20240307': {
+    upstreamId: 'anthropic/claude-3-haiku',
+    provider: 'anthropic', contextWindow: 200000, price: { input: 0.25, output: 1.25, cachedInput: 0.03 },
+    capabilities: ['tools'], toolReliability: 0.75, quality: 0.62,
+  },
   'grok-4.5': {
     upstreamId: 'x-ai/grok-4.5',
     provider: 'xai', contextWindow: 500000, price: { input: 2.00, output: 6.00, cachedInput: 0.30 },
@@ -130,6 +148,49 @@ const MODEL_ALIASES = Object.freeze({
   glm: 'glm-4.6',
   mimo: 'mimo-v2.5',
   'gemini-lite': 'gemini-2.5-flash-lite',
+  'claude-haiku': 'claude-haiku-4-5',
+});
+
+// Contrato dos agentes funcionais. Isto não é fine-tuning: cada papel recebe um
+// prompt curto, uma cadeia de modelos por plano e continua sujeito à prova das
+// ferramentas. O primeiro modelo permitido é o padrão; os seguintes são fallback.
+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'] }),
+  }),
+  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'], basic: ['deepseek-v4-pro', 'deepseek-v4-flash'], pro: ['gpt-5.6-luna', 'deepseek-v4-pro', 'glm-5.2'] }),
+  }),
+  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'], basic: ['deepseek-v4-flash', 'deepseek-v4-pro'], pro: ['deepseek-v4-flash', 'deepseek-v4-pro', 'claude-haiku-4-5'] }),
+  }),
+  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: ['gemini-2.5-flash', 'gpt-4o-mini'], pro: ['claude-haiku-4-5', 'gemini-2.5-flash', 'gpt-5.6-luna'] }),
+  }),
+  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'], basic: ['deepseek-v4-pro', 'deepseek-v4-flash'], pro: ['deepseek-v4-pro', 'claude-haiku-4-5', '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.',
+    models: Object.freeze({ free: ['smart'], basic: ['gemini-2.5-flash'], pro: ['gemini-2.5-flash', 'claude-haiku-4-5'] }),
+  }),
+  document: Object.freeze({
+    prompt: 'Produza conteúdo estruturado e use o motor nativo do formato solicitado. Preserve editabilidade e valide o arquivo gerado.',
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'deepseek-v4-flash'], pro: ['gpt-5.6-luna', 'deepseek-v4-pro', 'claude-haiku-4-5'] }),
+  }),
+  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-flash', 'deepseek-v4-pro'], pro: ['deepseek-v4-pro', 'deepseek-v4-flash', 'claude-haiku-4-5'] }),
+  }),
+  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-flash'], pro: ['deepseek-v4-flash', 'deepseek-v4-pro', 'claude-haiku-4-5'] }),
+  }),
 });
 
 const DEFAULT_PRICE = Object.freeze({ input: 0.30, output: 2.50, cachedInput: 0.03 });
@@ -302,6 +363,33 @@ function createHandoff(input) {
   };
 }
 
+function normalizeAgentPlan(value) {
+  const id = String(value || 'free').trim().toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+  if (['basic', 'basico'].includes(id)) return 'basic';
+  if (['pro', 'ultra', 'business', 'max', 'pro+'].includes(id)) return 'pro';
+  return 'free';
+}
+
+function agentRoleContract(role, plan, options) {
+  const id = Object.prototype.hasOwnProperty.call(AGENT_ROLES, role) ? role : 'executor';
+  const planId = normalizeAgentPlan(plan);
+  const spec = AGENT_ROLES[id];
+  const requested = spec.models[planId] || spec.models.free;
+  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])
+    .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');
+    if (safe) candidates.push(safe);
+  }
+  if (!candidates.length) candidates.push('smart');
+  return Object.freeze({ role: id, plan: planId, prompt: spec.prompt, model: candidates[0], candidates: Object.freeze(candidates) });
+}
+
 function routeModel(task, reliability) {
   const t = task || {};
   const required = new Set(t.capabilities || []);
@@ -326,7 +414,8 @@ function routeModel(task, reliability) {
 
 module.exports = {
   INTELLIGENCE_CONTRACT, PRICE_REVISION, MODEL_CATALOG, MODEL_ALIASES, DEFAULT_PRICE,
-  MEMORY_TYPES, MEMORY_TRUST, CONTEXT_SOURCES,
+  MEMORY_TYPES, MEMORY_TRUST, CONTEXT_SOURCES, AGENT_ROLES,
   normalizeModelId, modelInfo, legacyPriceMap, normalizeUsage, estimateCostUsd, catalogFreshness,
-  createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff, routeModel,
+  createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff,
+  normalizeAgentPlan, agentRoleContract, routeModel,
 };

package/lib/keyring.js

@@ -151,6 +151,15 @@ async function testar(id, { key = '', baseUrl = '', modelo = '', timeoutMs = 150
   if (!url) return { ok: false, erro: 'baseUrl não definida' };
   const mdl = modelo || p.modeloPadrao;
   if (!mdl) return { ok: false, erro: 'modelo não definido' };
+  const estado = providers.estadoModelo(id, mdl);
+  if (!estado.disponivel) {
+    return {
+      ok: false, aposentado: true, status: 410, modelo: mdl,
+      substituto: estado.substituto || '',
+      erro: 'o modelo "' + mdl + '" foi aposentado: ' + estado.motivo + '. ' +
+        (estado.substituto ? 'Troque para "' + estado.substituto + '" com `ts conectar ' + id + '`.' : 'Escolha outro modelo com `ts conectar ' + id + '`.')
+    };
+  }
   const _fetch = fetchImpl || fetch;
 
   const chamar = async (body) => {
@@ -191,6 +200,8 @@ async function testar(id, { key = '', baseUrl = '', modelo = '', timeoutMs = 150
   }
   if (r1.status === 401 || r1.status === 403) return { ok: false, erro: 'chave recusada pelo provedor (HTTP ' + r1.status + ')' };
   if (r1.status === 404) return { ok: false, erro: 'modelo "' + mdl + '" não existe nesse provedor (HTTP 404)' };
+  if (r1.status === 410) return { ok: false, aposentado: true, status: 410, modelo: mdl,
+    erro: 'o provedor aposentou o modelo "' + mdl + '" (HTTP 410). Escolha outro com `ts conectar ' + id + '`.' };
   if (r1.status >= 400) {
     const msg = (r1.json && (r1.json.error?.message || r1.json.message)) || ('HTTP ' + r1.status);
     return { ok: false, erro: String(msg).slice(0, 200) };

package/lib/mission-tool-cache.js

@@ -0,0 +1,55 @@
+'use strict';
+
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const key of Object.keys(value).sort()) out[key] = stable(value[key]);
+    return out;
+  }
+  return value;
+}
+
+function signature(tool, input) {
+  return String(tool || '') + '|' + JSON.stringify(stable(input || {}));
+}
+
+class MissionToolCache {
+  constructor({ maxEntries = 64 } = {}) {
+    this.maxEntries = Math.max(1, maxEntries);
+    this.entries = new Map();
+    this.hits = 0;
+    this.invalidations = 0;
+  }
+  get(tool, input) {
+    const key = signature(tool, input);
+    const entry = this.entries.get(key);
+    if (!entry) return null;
+    this.entries.delete(key); this.entries.set(key, entry);
+    this.hits++;
+    return entry;
+  }
+  remember(tool, input, entry) {
+    const key = signature(tool, input);
+    this.entries.delete(key);
+    this.entries.set(key, Object.assign({}, entry));
+    while (this.entries.size > this.maxEntries) this.entries.delete(this.entries.keys().next().value);
+  }
+  invalidate() {
+    if (this.entries.size) this.invalidations++;
+    this.entries.clear();
+  }
+  stats() { return { entries: this.entries.size, hits: this.hits, invalidations: this.invalidations }; }
+}
+
+function cacheReference(entry, tool, originalStillVisible) {
+  if (!originalStillVisible && entry && entry.content) return entry.content;
+  return JSON.stringify({
+    cached: true,
+    tool,
+    message: 'Resultado idêntico já fornecido nesta missão; a fonte não foi consultada novamente. Use o resultado anterior.',
+    originalToolCallId: entry && entry.toolCallId,
+  });
+}
+
+module.exports = { MissionToolCache, signature, cacheReference };

package/lib/office-editors.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const JSZip = require('jszip');
+
+const MAX_BYTES = 80 * 1024 * 1024;
+const BACKUP_ROOT = path.join(os.homedir(), '.terminal-smart', 'backups', 'office');
+
+function _existing(file, extension) {
+  const target = path.resolve(String(file || ''));
+  if (!target.toLowerCase().endsWith(extension)) throw new Error(`O arquivo precisa terminar em ${extension}.`);
+  if (!fs.existsSync(target) || !fs.statSync(target).isFile()) throw new Error('Arquivo não encontrado: ' + target);
+  if (fs.statSync(target).size > MAX_BYTES) throw new Error('Arquivo maior que 80 MB; edite um recorte ou uma cópia reduzida.');
+  return target;
+}
+
+function _destination(original, input, extension) {
+  if (!input.criar_copia) return original;
+  const copy = path.resolve(String(input.caminho_copia || ''));
+  if (!copy.toLowerCase().endsWith(extension)) throw new Error(`Para criar cópia, informe caminho_copia terminando em ${extension}.`);
+  if (copy === original) throw new Error('caminho_copia deve ser diferente do arquivo original.');
+  fs.mkdirSync(path.dirname(copy), { recursive: true });
+  return copy;
+}
+
+function _backup(file) {
+  const key = crypto.createHash('sha256').update(file.toLowerCase()).digest('hex').slice(0, 16);
+  const dir = path.join(BACKUP_ROOT, key);
+  fs.mkdirSync(dir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backup = path.join(dir, `${path.basename(file)}.${stamp}.bak`);
+  fs.copyFileSync(file, backup);
+  const backups = fs.readdirSync(dir).filter(name => name.endsWith('.bak')).sort();
+  while (backups.length > 10) fs.unlinkSync(path.join(dir, backups.shift()));
+  return backup;
+}
+
+function _decodeXml(value) {
+  return String(value || '').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, '&');
+}
+
+function _encodeXml(value) {
+  return String(value || '').replace(/&/g, '&amp;').replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+
+function _replaceInXmlText(xml, search, replacement, replaceAll) {
+  const re = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>/g;
+  const nodes = [];
+  let match;
+  while ((match = re.exec(xml))) nodes.push({ start: match.index, end: re.lastIndex, raw: match[0], text: _decodeXml(match[1]) });
+  const combined = nodes.map(node => node.text).join('');
+  const hits = [];
+  let at = 0;
+  while (search && (at = combined.indexOf(search, at)) >= 0) {
+    hits.push(at);
+    at += Math.max(1, search.length);
+  }
+  if (!hits.length) return { xml, count: 0 };
+  if (hits.length > 1 && !replaceAll) throw new Error(`Texto ambíguo: ${hits.length} ocorrências. Dê mais contexto ou use todas=true.`);
+
+  const starts = [];
+  let cursor = 0;
+  for (const node of nodes) { starts.push(cursor); cursor += node.text.length; }
+  const selected = replaceAll ? hits : hits.slice(0, 1);
+  for (let h = selected.length - 1; h >= 0; h--) {
+    const begin = selected[h];
+    const finish = begin + search.length;
+    let first = nodes.findIndex((node, index) => begin >= starts[index] && begin < starts[index] + node.text.length);
+    let last = nodes.findIndex((node, index) => finish > starts[index] && finish <= starts[index] + node.text.length);
+    if (first < 0 || last < 0) throw new Error('Não foi possível mapear o texto no DOCX.');
+    const left = begin - starts[first];
+    const right = finish - starts[last];
+    if (first === last) nodes[first].text = nodes[first].text.slice(0, left) + replacement + nodes[first].text.slice(right);
+    else {
+      nodes[first].text = nodes[first].text.slice(0, left) + replacement;
+      for (let index = first + 1; index < last; index++) nodes[index].text = '';
+      nodes[last].text = nodes[last].text.slice(right);
+    }
+  }
+  let output = ''; let sourceAt = 0;
+  for (const node of nodes) {
+    output += xml.slice(sourceAt, node.start);
+    output += node.raw.replace(/(<w:t(?:\s[^>]*)?>)[\s\S]*?(<\/w:t>)/, `$1${_encodeXml(node.text)}$2`);
+    sourceAt = node.end;
+  }
+  output += xml.slice(sourceAt);
+  return { xml: output, count: selected.length };
+}
+
+async function editarDocumento(input = {}) {
+  try {
+    const original = _existing(input.caminho, '.docx');
+    const search = String(input.buscar || '');
+    const replacement = String(input.substituir ?? '');
+    if (!search) throw new Error('Informe buscar com o texto exato que será alterado.');
+    const destination = _destination(original, input, '.docx');
+    const zip = await JSZip.loadAsync(fs.readFileSync(original));
+    const xmlFiles = Object.keys(zip.files).filter(name => /^word\/(document|header\d+|footer\d+|footnotes|endnotes)\.xml$/.test(name));
+    let changes = 0;
+    for (const name of xmlFiles) {
+      const xml = await zip.file(name).async('string');
+      const result = _replaceInXmlText(xml, search, replacement, !!input.todas);
+      if (result.count) { zip.file(name, result.xml); changes += result.count; }
+      if (changes && !input.todas) break;
+    }
+    if (!changes) throw new Error('Texto não encontrado no documento. Leia o arquivo e copie um trecho exato.');
+    const backup = destination === original ? _backup(original) : null;
+    const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
+    fs.writeFileSync(destination, buffer);
+    return { ok: true, caminho: destination, editou_original: destination === original, ocorrencias: changes, backup };
+  } catch (error) { return { ok: false, erro: 'Falha ao editar DOCX: ' + error.message }; }
+}
+
+async function editarPlanilha(input = {}) {
+  try {
+    const original = _existing(input.caminho, '.xlsx');
+    const destination = _destination(original, input, '.xlsx');
+    const ExcelJS = require('exceljs');
+    const workbook = new ExcelJS.Workbook();
+    try {
+      await workbook.xlsx.readFile(original);
+    } catch (readError) {
+      const backup = destination === original ? _backup(original) : null;
+      const { editXlsxCompat } = require('./xlsx-compat-editor');
+      const result = await editXlsxCompat(original, destination, input);
+      return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: result.changes.length, alteracoes: result.changes.slice(0, 100), backup, engine: result.engine, compatibilidade: readError.message };
+    }
+    const changes = [];
+    for (const update of (Array.isArray(input.alteracoes) ? input.alteracoes : []).slice(0, 500)) {
+      const sheet = workbook.getWorksheet(String(update.aba || '')) || (!update.aba ? workbook.worksheets[0] : null);
+      if (!sheet) throw new Error(`Aba não encontrada: ${update.aba}`);
+      const address = String(update.celula || '').toUpperCase();
+      if (!/^[A-Z]{1,3}[1-9][0-9]{0,6}$/.test(address)) throw new Error(`Célula inválida: ${update.celula}`);
+      const cell = sheet.getCell(address);
+      if (update.formula != null) cell.value = { formula: String(update.formula).replace(/^=/, '') };
+      else {
+        const raw = update.valor;
+        cell.value = typeof raw === 'string' && /^-?\d+(?:[.,]\d+)?$/.test(raw.trim())
+          ? Number(raw.trim().replace(',', '.'))
+          : (raw == null ? null : raw);
+      }
+      changes.push(`${sheet.name}!${address}`);
+    }
+    for (const rule of (Array.isArray(input.substituicoes) ? input.substituicoes : []).slice(0, 50)) {
+      const search = String(rule.buscar || '');
+      if (!search) continue;
+      let replaced = 0;
+      for (const sheet of workbook.worksheets) {
+        if (rule.aba && sheet.name.toLowerCase() !== String(rule.aba).toLowerCase()) continue;
+        sheet.eachRow(row => row.eachCell(cell => {
+          if (!rule.todas && replaced) return;
+          if (typeof cell.value !== 'string' || !cell.value.includes(search)) return;
+          cell.value = rule.todas ? cell.value.split(search).join(String(rule.substituir ?? '')) : cell.value.replace(search, String(rule.substituir ?? ''));
+          replaced++; changes.push(`${sheet.name}!${cell.address}`);
+        }));
+      }
+      if (!replaced) throw new Error(`Texto não encontrado na planilha: ${search.slice(0, 80)}`);
+    }
+    if (!changes.length) throw new Error('Informe alteracoes ou substituicoes.');
+    const backup = destination === original ? _backup(original) : null;
+    await workbook.xlsx.writeFile(destination);
+    return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: changes.length, alteracoes: changes.slice(0, 100), backup, engine: 'exceljs' };
+  } catch (error) { return { ok: false, erro: 'Falha ao editar XLSX: ' + error.message }; }
+}
+
+module.exports = { editarDocumento, editarPlanilha, _replaceInXmlText };

package/lib/providers.js

@@ -16,13 +16,11 @@ const PROVEDORES = {
   nvidia: {
     nome: 'NVIDIA NIM',
     baseUrl: 'https://integrate.api.nvidia.com/v1',
-    // MEDIDO na API real (28/07/2026): o 70b estourou 120s de COLD START e o
-    // nemotron-70b é listado em /v1/models mas devolve 404 no /chat/completions.
-    // O v4-flash respondeu em 16s E chamou ferramenta — é o mesmo executor que o
-    // resto do TS já usa, então é o padrão sensato aqui.
-    modeloPadrao: 'deepseek-ai/deepseek-v4-flash',
+    // O id sem sufixo foi retirado pela NVIDIA (HTTP 410). O catálogo atual expõe
+    // a revisão datada; manter o id antigo como padrão faria toda chave nova falhar.
+    modeloPadrao: 'deepseek-ai/deepseek-v4-flash-0731',
     sugestoes: [
-      ['deepseek-ai/deepseek-v4-flash', 'equilíbrio — chama ferramenta, ~16s'],
+      ['deepseek-ai/deepseek-v4-flash-0731', 'revisão atual do DeepSeek V4 Flash'],
       ['meta/llama-3.1-8b-instruct', 'o mais rápido — ~1s, bom pra chat/roteamento'],
       ['mistralai/mistral-medium-3.5-128b', 'mais capaz — ~43s'],
     ],
@@ -88,6 +86,17 @@ const PROVEDORES = {
   },
 };
 
+// IDs que o provedor encerrou. Esta lista é deliberadamente conservadora: só
+// bloqueamos localmente quando a aposentadoria foi confirmada na API real.
+const MODELOS_APOSENTADOS = {
+  nvidia: {
+    'deepseek-ai/deepseek-v4-flash': {
+      substituto: 'deepseek-ai/deepseek-v4-flash-0731',
+      motivo: 'a NVIDIA retirou esse id (HTTP 410)',
+    },
+  },
+};
+
 function info(id) { return PROVEDORES[String(id || '').toLowerCase()] || null; }
 function ids() { return Object.keys(PROVEDORES); }
 
@@ -115,4 +124,12 @@ function baseUrlDe(id, override) {
   return p ? p.baseUrl : '';
 }
 
-module.exports = { PROVEDORES, info, ids, validarChave, baseUrlDe };
+function estadoModelo(id, modelo) {
+  const pid = String(id || '').toLowerCase();
+  const mid = String(modelo || '').trim();
+  const aposentado = MODELOS_APOSENTADOS[pid] && MODELOS_APOSENTADOS[pid][mid];
+  return aposentado ? { disponivel: false, aposentado: true, modelo: mid, ...aposentado }
+    : { disponivel: true, aposentado: false, modelo: mid };
+}
+
+module.exports = { PROVEDORES, MODELOS_APOSENTADOS, info, ids, validarChave, baseUrlDe, estadoModelo };

package/lib/tools.js

@@ -161,6 +161,73 @@ const DEFS = [
       caminho: { type: 'string' }, buscar: { type: 'string' },
       inicio_char: { type: 'number' }, tamanho: { type: 'number' },
     }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'editar_documento',
+    description: 'Edita um .docx EXISTENTE no próprio arquivo por padrão, preserva o restante e cria backup automático. Só cria outro arquivo se o usuário pedir uma cópia.',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string' }, buscar: { type: 'string' }, substituir: { type: 'string' },
+      todas: { type: 'boolean' }, criar_copia: { type: 'boolean' }, caminho_copia: { type: 'string' },
+    }, required: ['caminho', 'buscar', 'substituir'] } } },
+  { type: 'function', function: { name: 'editar_planilha',
+    description: 'Edita uma planilha .xlsx EXISTENTE no próprio arquivo por padrão. Altera células/fórmulas ou substitui texto, preserva as demais abas e cria backup automático. Só cria outro arquivo se o usuário pedir cópia.',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string' },
+      alteracoes: { type: 'array', items: { type: 'object', properties: {
+        aba: { type: 'string' }, celula: { type: 'string' }, valor: { type: 'string' }, formula: { type: 'string' },
+      }, required: ['celula'] } },
+      substituicoes: { type: 'array', items: { type: 'object', properties: {
+        aba: { type: 'string' }, buscar: { type: 'string' }, substituir: { type: 'string' }, todas: { type: 'boolean' },
+      }, required: ['buscar', 'substituir'] } },
+      criar_copia: { type: 'boolean' }, caminho_copia: { type: 'string' },
+    }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'status_microsoft365', description: 'Verifica a conexão com Outlook e Microsoft 365.', parameters: { type: 'object', properties: {} } } },
+  { type: 'function', function: { name: 'conectar_microsoft365', description: 'Gera o link oficial para autorizar Outlook e Microsoft 365.', parameters: { type: 'object', properties: {} } } },
+  { type: 'function', function: { name: 'listar_emails_outlook', description: 'Lista, pesquisa e prioriza e-mails do Outlook sem alterar nada.', parameters: { type: 'object', properties: { limite: { type: 'number' }, somente_nao_lidos: { type: 'boolean' }, priorizar: { type: 'boolean' }, consulta: { type: 'string' }, pasta: { type: 'string' } } } } },
+  { type: 'function', function: { name: 'ler_email_outlook', description: 'Lê o corpo completo de um e-mail do Outlook sem marcá-lo como lido.', parameters: { type: 'object', properties: { id_email: { type: 'string' } }, required: ['id_email'] } } },
+  { type: 'function', function: { name: 'listar_pastas_outlook', description: 'Lista pastas de e-mail do Outlook.', parameters: { type: 'object', properties: {} } } },
+  { type: 'function', function: { name: 'alterar_email_outlook', description: 'Altera estado ou pasta de um e-mail do Outlook. Exige confirmação.', parameters: { type: 'object', properties: { id_email: { type: 'string' }, acao: { type: 'string', enum: ['lido','nao_lido','importante','normal','arquivar','caixa_entrada','spam','lixeira','restaurar','mover','excluir_permanente'] }, id_pasta: { type: 'string' } }, required: ['id_email','acao'] } } },
+  { type: 'function', function: { name: 'criar_resposta_outlook', description: 'Cria rascunho de resposta no Outlook. Não envia e exige confirmação.', parameters: { type: 'object', properties: { id_email: { type: 'string' }, corpo: { type: 'string' }, para_todos: { type: 'boolean' } }, required: ['id_email','corpo'] } } },
+  { type: 'function', function: { name: 'criar_encaminhamento_outlook', description: 'Cria rascunho de encaminhamento no Outlook. Não envia e exige confirmação.', parameters: { type: 'object', properties: { id_email: { type: 'string' }, para: { type: 'array', items: { type: 'string' } }, cc: { type: 'array', items: { type: 'string' } }, corpo: { type: 'string' } }, required: ['id_email','para'] } } },
+  { type: 'function', function: { name: 'obter_anexo_outlook', description: 'Obtém o link autenticado para baixar um anexo do Outlook.', parameters: { type: 'object', properties: { id_email: { type: 'string' }, id_anexo: { type: 'string' } }, required: ['id_email','id_anexo'] } } },
+  { type: 'function', function: { name: 'criar_rascunho_outlook', description: 'Cria rascunho no Outlook. Exige confirmação e não envia.', parameters: { type: 'object', properties: { para: { type: 'array', items: { type: 'string' } }, cc: { type: 'array', items: { type: 'string' } }, assunto: { type: 'string' }, corpo: { type: 'string' }, formato_html: { type: 'boolean' } }, required: ['para','assunto','corpo'] } } },
+  { type: 'function', function: { name: 'enviar_rascunho_outlook', description: 'Envia um rascunho existente do Outlook. Exige confirmação.', parameters: { type: 'object', properties: { rascunho_id: { type: 'string' } }, required: ['rascunho_id'] } } },
+  { type: 'function', function: { name: 'status_google_workspace', description: 'Verifica a conexão com Gmail, Drive, Docs e Sheets.', parameters: { type: 'object', properties: {} } } },
+  { type: 'function', function: { name: 'conectar_google_workspace', description: 'Gera o link oficial para autorizar Gmail, Drive, Docs e Sheets.', parameters: { type: 'object', properties: {} } } },
+  { type: 'function', function: { name: 'listar_emails_gmail', description: 'Lista e prioriza e-mails do Gmail, sem alterar nada.', parameters: { type: 'object', properties: {
+    limite: { type: 'number' }, somente_nao_lidos: { type: 'boolean' }, priorizar: { type: 'boolean' }, consulta: { type: 'string' }, pasta: { type: 'string', enum: ['inbox','sent','drafts','spam','trash','starred','important','all'] }
+  } } } },
+  { type: 'function', function: { name: 'ler_email_gmail', description: 'Lê o corpo completo de um e-mail ou a conversa inteira sem marcar como lido.', parameters: { type: 'object', properties: {
+    id_email: { type: 'string' }, conversa_completa: { type: 'boolean' }
+  }, required: ['id_email'] } } },
+  { type: 'function', function: { name: 'listar_pastas_gmail', description: 'Lista pastas e marcadores do Gmail.', parameters: { type: 'object', properties: {} } } },
+  { type: 'function', function: { name: 'alterar_email_gmail', description: 'Altera estado, pasta ou marcador de um e-mail. Exige confirmação.', parameters: { type: 'object', properties: {
+    id_email: { type: 'string' }, acao: { type: 'string', enum: ['lido','nao_lido','arquivar','caixa_entrada','estrela','remover_estrela','importante','remover_importante','spam','nao_spam','lixeira','restaurar','aplicar_marcador','remover_marcador','mover','excluir_permanente'] }, marcador: { type: 'string' }
+  }, required: ['id_email','acao'] } } },
+  { type: 'function', function: { name: 'criar_resposta_gmail', description: 'Cria rascunho de resposta na mesma conversa. Não envia e exige confirmação.', parameters: { type: 'object', properties: {
+    id_email: { type: 'string' }, corpo: { type: 'string' }, para_todos: { type: 'boolean' }, formato_html: { type: 'boolean' }
+  }, required: ['id_email','corpo'] } } },
+  { type: 'function', function: { name: 'criar_encaminhamento_gmail', description: 'Cria rascunho de encaminhamento. Não envia e exige confirmação.', parameters: { type: 'object', properties: {
+    id_email: { type: 'string' }, para: { type: 'array', items: { type: 'string' } }, cc: { type: 'array', items: { type: 'string' } }, corpo: { type: 'string' }
+  }, required: ['id_email','para'] } } },
+  { type: 'function', function: { name: 'obter_anexo_gmail', description: 'Obtém o link autenticado para baixar um anexo do Gmail.', parameters: { type: 'object', properties: {
+    id_email: { type: 'string' }, id_anexo: { type: 'string' }
+  }, required: ['id_email','id_anexo'] } } },
+  { type: 'function', function: { name: 'criar_rascunho_gmail', description: 'Cria rascunho no Gmail. Exige confirmação e não envia.', parameters: { type: 'object', properties: {
+    para: { type: 'array', items: { type: 'string' } }, cc: { type: 'array', items: { type: 'string' } }, assunto: { type: 'string' }, corpo: { type: 'string' }, formato_html: { type: 'boolean' }
+  }, required: ['para', 'assunto', 'corpo'] } } },
+  { type: 'function', function: { name: 'enviar_rascunho_gmail', description: 'Envia rascunho existente do Gmail. Exige confirmação.', parameters: { type: 'object', properties: { rascunho_id: { type: 'string' } }, required: ['rascunho_id'] } } },
+  { type: 'function', function: { name: 'listar_arquivos_drive', description: 'Lista arquivos no Google Drive por nome ou tipo.', parameters: { type: 'object', properties: {
+    busca: { type: 'string' }, tipo_mime: { type: 'string' }, limite: { type: 'number' }
+  } } } },
+  { type: 'function', function: { name: 'ler_google_docs', description: 'Lê texto de Google Docs pelo ID.', parameters: { type: 'object', properties: { id_documento: { type: 'string' } }, required: ['id_documento'] } } },
+  { type: 'function', function: { name: 'editar_google_docs', description: 'Edita o Google Docs original por padrão; cria cópia somente se solicitado. Exige confirmação.', parameters: { type: 'object', properties: {
+    id_documento: { type: 'string' }, localizar: { type: 'string' }, substituir_por: { type: 'string' }, diferenciar_maiusculas: { type: 'boolean' }, criar_copia: { type: 'boolean' }, nome_copia: { type: 'string' }
+  }, required: ['id_documento', 'localizar'] } } },
+  { type: 'function', function: { name: 'ler_google_sheets', description: 'Lê células de Google Sheets pelo ID e intervalo.', parameters: { type: 'object', properties: {
+    id_planilha: { type: 'string' }, intervalo: { type: 'string' }
+  }, required: ['id_planilha'] } } },
+  { type: 'function', function: { name: 'editar_google_sheets', description: 'Edita a Google Sheets original por padrão; cria cópia somente se solicitado. Exige confirmação.', parameters: { type: 'object', properties: {
+    id_planilha: { type: 'string' }, intervalo: { type: 'string' }, valores: { type: 'array', items: { type: 'array', items: {} } }, criar_copia: { type: 'boolean' }, nome_copia: { type: 'string' }
+  }, required: ['id_planilha', 'intervalo', 'valores'] } } },
   { type: 'function', function: { name: 'ler_apresentacao',
     description: 'Lê PowerPoint .pptx por slides, retornando o texto estruturado e a quantidade de imagens.',
     parameters: { type: 'object', properties: {
@@ -780,6 +847,97 @@ async function execute(name, input, opts = {}) {
         if (_outsideScope(target)) return _scopeError(target);
         return await require('./office-readers').lerDocumento({ ...input, caminho: target });
       }
+      case 'editar_documento': {
+        const target = _abs(input.caminho, baseDir);
+        if (_outsideScope(target)) return _scopeError(target);
+        const copy = input.caminho_copia ? _abs(input.caminho_copia, baseDir) : undefined;
+        if (copy && _outsideScope(copy)) return _scopeError(copy);
+        const result = await require('./office-editors').editarDocumento({ ...input, caminho: target, caminho_copia: copy });
+        if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
+        return result;
+      }
+      case 'editar_planilha': {
+        const target = _abs(input.caminho, baseDir);
+        if (_outsideScope(target)) return _scopeError(target);
+        const copy = input.caminho_copia ? _abs(input.caminho_copia, baseDir) : undefined;
+        if (copy && _outsideScope(copy)) return _scopeError(copy);
+        const result = await require('./office-editors').editarPlanilha({ ...input, caminho: target, caminho_copia: copy });
+        if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
+        return result;
+      }
+      case 'status_microsoft365':
+        return await require('./api').api('/api/integrations/microsoft/status', { token: opts.token });
+      case 'conectar_microsoft365': {
+        const data = await require('./api').api('/api/integrations/microsoft/connect', { method: 'POST', body: { source: 'cli' }, token: opts.token });
+        return { ok: true, authUrl: data.authUrl, instrucao: 'Abra o link no navegador, autorize sua conta Microsoft e volte ao Terminal Smart.' };
+      }
+      case 'listar_emails_outlook': {
+        const p = new URLSearchParams({ limit: String(Math.min(30, Math.max(1, parseInt(input.limite) || 15))) });
+        if (input.somente_nao_lidos) p.set('unread', '1'); if (input.priorizar) p.set('priority', '1');
+        if (input.consulta) p.set('query', input.consulta); if (input.pasta) p.set('folder', input.pasta);
+        return await require('./api').api('/api/integrations/microsoft/mail/messages?' + p, { token: opts.token });
+      }
+      case 'ler_email_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/message?' + new URLSearchParams({ id: input.id_email }), { token: opts.token });
+      case 'listar_pastas_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/folders', { token: opts.token });
+      case 'alterar_email_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/modify', { method: 'POST', token: opts.token, body: { messageId: input.id_email, action: input.acao, folderId: input.id_pasta, confirmed: true } });
+      case 'criar_resposta_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/replies', { method: 'POST', token: opts.token, body: { messageId: input.id_email, body: input.corpo, replyAll: input.para_todos === true, confirmed: true } });
+      case 'criar_encaminhamento_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/forwards', { method: 'POST', token: opts.token, body: { messageId: input.id_email, to: input.para, cc: input.cc || [], body: input.corpo || '', confirmed: true } });
+      case 'obter_anexo_outlook':
+        return { downloadUrl: '/api/integrations/microsoft/mail/attachments/download?' + new URLSearchParams({ messageId: input.id_email, attachmentId: input.id_anexo }), instrucao: 'Use uma sessão autenticada do Terminal Smart para baixar o anexo.' };
+      case 'criar_rascunho_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/drafts', { method: 'POST', token: opts.token, body: { to: input.para, cc: input.cc || [], subject: input.assunto, body: input.corpo, contentType: input.formato_html ? 'html' : 'text', confirmed: true } });
+      case 'enviar_rascunho_outlook':
+        return await require('./api').api('/api/integrations/microsoft/mail/send', { method: 'POST', token: opts.token, body: { draftId: input.rascunho_id, confirmed: true } });
+      case 'status_google_workspace':
+        return await require('./api').api('/api/integrations/google/status', { token: opts.token });
+      case 'conectar_google_workspace': {
+        const data = await require('./api').api('/api/integrations/google/connect', { method: 'POST', body: { source: 'cli' }, token: opts.token });
+        return { ok: true, authUrl: data.authUrl, instrucao: 'Abra o link no navegador, autorize sua conta Google e volte ao Terminal Smart.' };
+      }
+      case 'listar_emails_gmail': {
+        const p = new URLSearchParams({ limit: String(Math.min(30, Math.max(1, parseInt(input.limite) || 15))) });
+        if (input.somente_nao_lidos) p.set('unread', '1'); if (input.priorizar) p.set('priority', '1');
+        if (input.consulta) p.set('query', input.consulta); if (input.pasta) p.set('folder', input.pasta);
+        return await require('./api').api('/api/integrations/google/gmail/messages?' + p, { token: opts.token });
+      }
+      case 'ler_email_gmail': {
+        const p = new URLSearchParams({ id: input.id_email }); if (input.conversa_completa) p.set('thread', '1');
+        return await require('./api').api('/api/integrations/google/gmail/message?' + p, { token: opts.token });
+      }
+      case 'listar_pastas_gmail':
+        return await require('./api').api('/api/integrations/google/gmail/labels', { token: opts.token });
+      case 'alterar_email_gmail':
+        return await require('./api').api('/api/integrations/google/gmail/modify', { method: 'POST', token: opts.token, body: { messageId: input.id_email, action: input.acao, label: input.marcador, confirmed: true } });
+      case 'criar_resposta_gmail':
+        return await require('./api').api('/api/integrations/google/gmail/replies', { method: 'POST', token: opts.token, body: { messageId: input.id_email, body: input.corpo, replyAll: input.para_todos === true, contentType: input.formato_html ? 'html' : 'text', confirmed: true } });
+      case 'criar_encaminhamento_gmail':
+        return await require('./api').api('/api/integrations/google/gmail/forwards', { method: 'POST', token: opts.token, body: { messageId: input.id_email, to: input.para, cc: input.cc || [], body: input.corpo || '', confirmed: true } });
+      case 'obter_anexo_gmail':
+        return { downloadUrl: '/api/integrations/google/gmail/attachments/download?' + new URLSearchParams({ messageId: input.id_email, attachmentId: input.id_anexo }), instrucao: 'Use uma sessão autenticada do Terminal Smart para baixar o anexo.' };
+      case 'criar_rascunho_gmail':
+        return await require('./api').api('/api/integrations/google/gmail/drafts', { method: 'POST', token: opts.token, body: { to: input.para, cc: input.cc || [], subject: input.assunto, body: input.corpo, contentType: input.formato_html ? 'html' : 'text', confirmed: true } });
+      case 'enviar_rascunho_gmail':
+        return await require('./api').api('/api/integrations/google/gmail/send', { method: 'POST', token: opts.token, body: { draftId: input.rascunho_id, confirmed: true } });
+      case 'listar_arquivos_drive': {
+        const p = new URLSearchParams({ limit: String(Math.min(100, Math.max(1, parseInt(input.limite) || 30))) });
+        if (input.busca) p.set('query', input.busca); if (input.tipo_mime) p.set('mimeType', input.tipo_mime);
+        return await require('./api').api('/api/integrations/google/drive/files?' + p, { token: opts.token });
+      }
+      case 'ler_google_docs':
+        return await require('./api').api('/api/integrations/google/docs/document?id=' + encodeURIComponent(input.id_documento), { token: opts.token });
+      case 'editar_google_docs':
+        return await require('./api').api('/api/integrations/google/docs/replace', { method: 'POST', token: opts.token, body: { documentId: input.id_documento, search: input.localizar, replacement: input.substituir_por || '', matchCase: input.diferenciar_maiusculas !== false, createCopy: input.criar_copia === true, copyName: input.nome_copia, confirmed: true } });
+      case 'ler_google_sheets': {
+        const p = new URLSearchParams({ id: input.id_planilha }); if (input.intervalo) p.set('range', input.intervalo);
+        return await require('./api').api('/api/integrations/google/sheets/values?' + p, { token: opts.token });
+      }
+      case 'editar_google_sheets':
+        return await require('./api').api('/api/integrations/google/sheets/update', { method: 'POST', token: opts.token, body: { spreadsheetId: input.id_planilha, range: input.intervalo, values: input.valores, createCopy: input.criar_copia === true, copyName: input.nome_copia, confirmed: true } });
       case 'ler_apresentacao': {
         const target = _abs(input.caminho, baseDir);
         if (_outsideScope(target)) return _scopeError(target);