terminal-smart-cli 0.97.13 → 0.97.15

package/lib/audit-packs.js

@@ -0,0 +1,56 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const PACKS = Object.freeze({
+  web: Object.freeze({
+    id: 'web', label: 'Web/App',
+    prompt: 'Se a interface for criada ou alterada, prove em navegador real: desktop e mobile sem overflow, fluxo principal completo, validacao de entrada, persistencia apos reload, console/rede sem erros e screenshots. Prefira navegador ja instalado com playwright-core, sem baixar binario. Mantenha um script reproduzivel e AUTOCONTIDO chamado audit:browser (ou audit:web/audit:e2e): ele deve iniciar o servidor quando necessario, aguardar a URL, testar e encerrar somente o processo que iniciou em bloco finally. Rode-o antes de concluir.',
+  }),
+  office: Object.freeze({
+    id: 'office', label: 'Office/Arquivos',
+    prompt: 'Edite o arquivo original por padrao; crie copia somente se o usuario pedir. Preserve backup e formato. Em XLSX, agrupe celulas e formulas do mesmo arquivo em UMA chamada editar_planilha. Em DOCX, agrupe todas as mudancas em UMA chamada atomica editar_documento: use substituicoes para texto e alteracoes_tabela com rotulo/valor para celulas de tabela; nunca envie varias chamadas paralelas para o mesmo DOCX. Reabra com o leitor nativo do formato e prove conteudo, estrutura, formulas/tabelas/slides relevantes e caminho final. Hash ou existencia do arquivo nao provam conteudo. Nunca declare uma alteracao bloqueada ou falha como concluida.',
+  }),
+  productivity: Object.freeze({
+    id: 'productivity', label: 'E-mail/Drive',
+    prompt: 'Cheque o status da integracao antes de agir. Para leitura, registre ids e filtros usados. Para mutacao, confirme alvo e estado final pela API. Nunca infira destinatario ausente. Crie rascunho por padrao quando o pedido nao autorizar explicitamente envio; envio, exclusao e movimentacao exigem os gates normais.',
+  }),
+  vps: Object.freeze({
+    id: 'vps', label: 'VPS/Infra',
+    prompt: 'Antes de mudar, registre status, configuracao e porta afetados; preserve snapshot/backup. Aplique mudanca minima. Depois prove config valida, servico ativo, porta/HTTP esperado e logs sem regressao. Nao use exclusao ampla nem reinicio indiscriminado.',
+  }),
+  generic: Object.freeze({
+    id: 'generic', label: 'Geral',
+    prompt: 'Defina criterios executaveis antes de concluir. Prove o fluxo principal e pelo menos uma falha relevante; registre comandos, codigos de saida e artefatos. Nao aceite narrativa como substituto de evidencia.',
+  }),
+});
+
+function _has(cwd, name) { try { return fs.existsSync(path.join(cwd || process.cwd(), name)); } catch (_) { return false; } }
+
+function selectAuditPack(taskText, cwd) {
+  const t = String(taskText || '').toLocaleLowerCase();
+  if (/\b(?:gmail|outlook|hotmail|e-?mail|drive|google docs|google sheets|workspace|onedrive|calend[aá]rio|agenda)\b/i.test(t)) return PACKS.productivity;
+  if (/\b(?:vps|servidor|ssh|deploy|docker|nginx|traefik|systemd|firewall|porta|produ[cç][aã]o)\b/i.test(t)) return PACKS.vps;
+  if (/\b(?:excel|xlsx|planilha|word|docx|powerpoint|pptx|apresenta[cç][aã]o|pdf)\b/i.test(t)) return PACKS.office;
+  if (/\b(?:site|p[aá]gina|web|frontend|front-end|interface|navegador|dashboard|painel|html|css|jogo)\b/i.test(t)
+      || _has(cwd, 'index.html') || _has(cwd, 'vite.config.js') || _has(cwd, 'next.config.js')) return PACKS.web;
+  return PACKS.generic;
+}
+
+function promptBlock(pack, lang = 'pt') {
+  if (!pack) return '';
+  const title = lang === 'en' ? 'MANDATORY AUDIT PACK' : 'PACOTE DE AUDITORIA OBRIGATORIO';
+  return `\n\n${title} [${pack.id} — ${pack.label}]: ${pack.prompt}`;
+}
+
+function deriveCriteria(cwd, pack) {
+  if (!pack || pack.id !== 'web') return [];
+  let pkg = null;
+  try { pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')); } catch (_) {}
+  const scripts = (pkg && pkg.scripts) || {};
+  const names = ['audit:browser', 'audit:web', 'audit:e2e'];
+  const picked = names.find(n => scripts[n]);
+  return picked ? [{ type: 'command', cmd: `npm run ${picked}`, exit: 0, timeout_s: 300, label: `auditoria real (${picked})` }] : [];
+}
+
+module.exports = { PACKS, selectAuditPack, promptBlock, deriveCriteria };

package/lib/evolution-telemetry.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const crypto = require('crypto');
+const core = require('./core');
+
+function sanitizePattern(value) {
+  return String(core.redactSecrets(value || ''))
+    .replace(/[\u0000-\u001f\u007f]/g, ' ')
+    .replace(/\b(?:nvapi-|AIza)[A-Za-z0-9._-]{12,}/gi, '<secret>')
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '<email>')
+    .replace(/https?:\/\/[^\s"']+/gi, '<url>')
+    .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '<ip>')
+    .replace(/[A-Za-z]:\\[^\s"']+/g, '<path>')
+    .replace(/\/(?:home|root|opt|var|tmp|Users|mnt)\/[^\s"']+/g, '<path>')
+    .replace(/\b[0-9a-f]{32,}\b/gi, '<id>')
+    .replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, '<id>')
+    .replace(/\b\d{5,}\b/g, '#')
+    .replace(/\s+/g, ' ').trim().slice(0, 300);
+}
+
+function buildEvents(toolErrors = [], actions = [], context = {}) {
+  const recoveredTools = new Set((actions || []).map(action => action && action.name).filter(Boolean));
+  const seen = new Set(); const events = [];
+  for (const error of (Array.isArray(toolErrors) ? toolErrors : []).slice(-50)) {
+    const tool = String(error.tool || 'unknown').slice(0, 80);
+    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');
+    if (seen.has(fingerprint)) continue;
+    seen.add(fingerprint);
+    events.push({ tool, errorClass, pattern, stage, fingerprint,
+      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;
+  }
+  return events;
+}
+
+function enabled(config = {}, env = process.env) {
+  if (String(env.TS_DIAGNOSTICS || '').toLowerCase() === '0' || String(env.TS_DIAGNOSTICS || '').toLowerCase() === 'off') return false;
+  return config.diagnosticsEnabled !== false;
+}
+
+module.exports = { sanitizePattern, buildEvents, enabled };

package/lib/i18n.js

@@ -78,6 +78,7 @@ const STR = {
         ['ts quem', 'conta conectada'],
         ['ts conta exportar', 'baixa seus dados sem senhas, tokens ou chaves privadas'],
         ['ts conta abrir', 'abre Minha Conta para privacidade e exclusão segura'],
+        ['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 tema', 'paleta do terminal (7 temas; a cor indica o ESTADO)'],
@@ -247,6 +248,7 @@ const STR = {
         ['ts quem', 'connected account'],
         ['ts account export', 'download your data without passwords, tokens or private keys'],
         ['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 tema', 'terminal palette (7 themes; color means STATE)'],
         ['ts idioma pt|en', 'language (default pt-BR)'],

package/lib/image-job.js

@@ -0,0 +1,31 @@
+'use strict';
+
+function imageJobError(message, code) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+async function waitForImageJob(jobId, options = {}) {
+  const request = options.request;
+  if (typeof request !== 'function') throw new TypeError('request é obrigatório');
+  const sleep = options.sleep || (ms => new Promise(resolve => setTimeout(resolve, ms)));
+  const intervalMs = Math.max(0, Number(options.intervalMs) || 2000);
+  const maxAttempts = Math.max(1, Number(options.maxAttempts) || 180);
+  const id = String(jobId || '').trim();
+  if (!id) throw imageJobError('Job de imagem inválido.', 'image_job_invalid');
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt > 1) await sleep(intervalMs);
+    const job = await request('/api/ia/image/jobs/' + encodeURIComponent(id));
+    if (job && job.status === 'completed' && job.url) return job;
+    if (job && job.status === 'failed') throw imageJobError(job.message || 'Falha ao gerar imagem Premium.', 'image_job_failed');
+    if (job && !['processing', 'queued'].includes(job.status)) {
+      throw imageJobError(job.message || `Estado inesperado da geração: ${job.status || 'vazio'}.`, 'image_job_protocol');
+    }
+    if (typeof options.onProgress === 'function') options.onProgress({ attempt, maxAttempts, job });
+  }
+  throw imageJobError('A imagem continua sendo processada. Consulte a conversa no Terminal Smart para acompanhar.', 'image_job_timeout');
+}
+
+module.exports = { waitForImageJob, imageJobError };

package/lib/intelligence-core.js

@@ -197,7 +197,7 @@ const AGENT_ROLES = Object.freeze({
   }),
   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'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-flash', 'deepseek-v4-pro'], pro: ['deepseek-v4-flash', 'deepseek-v4-pro', 'glm-5.2', '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.',

package/lib/office-editors.js

@@ -92,27 +92,82 @@ function _replaceInXmlText(xml, search, replacement, replaceAll) {
   return { xml: output, count: selected.length };
 }
 
+function _replaceTableValueByLabel(xml, label, value, replaceAll = false) {
+  const rowRe = /<w:tr(?:\s[^>]*)?>[\s\S]*?<\/w:tr>/g;
+  const rows = []; let match;
+  while ((match = rowRe.exec(xml))) {
+    const raw = match[0];
+    const cells = [...raw.matchAll(/<w:tc(?:\s[^>]*)?>[\s\S]*?<\/w:tc>/g)].map(cell => ({
+      raw: cell[0], start: cell.index,
+      text: _decodeXml([...cell[0].matchAll(/<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>/g)].map(node => node[1]).join('')),
+    }));
+    const labelIndex = cells.findIndex(cell => cell.text.trim() === label.trim());
+    if (labelIndex >= 0 && cells[labelIndex + 1]) rows.push({ start: match.index, end: rowRe.lastIndex, raw, cells, labelIndex });
+  }
+  if (!rows.length) return { xml, count: 0 };
+  if (rows.length > 1 && !replaceAll) throw new Error(`Rótulo de tabela ambíguo: ${rows.length} ocorrências para ${label}.`);
+  const selected = replaceAll ? rows : rows.slice(0, 1);
+  let output = xml;
+  for (let index = selected.length - 1; index >= 0; index--) {
+    const row = selected[index];
+    const target = row.cells[row.labelIndex + 1];
+    const changed = _replaceInXmlText(target.raw, target.text, String(value ?? ''), false);
+    if (!changed.count) throw new Error(`Não foi possível alterar a célula ao lado de ${label}.`);
+    const rowXml = row.raw.slice(0, target.start) + changed.xml + row.raw.slice(target.start + target.raw.length);
+    output = output.slice(0, row.start) + rowXml + output.slice(row.end);
+  }
+  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 rules = Array.isArray(input.substituicoes) && input.substituicoes.length
+      ? input.substituicoes.slice(0, 50)
+      : (input.buscar != null ? [{ buscar: input.buscar, substituir: input.substituir, todas: input.todas }] : []);
+    const tableRules = Array.isArray(input.alteracoes_tabela) ? input.alteracoes_tabela.slice(0, 50) : [];
+    if (!rules.length && !tableRules.length) throw new Error('Informe substituicoes ou alteracoes_tabela.');
+    if (rules.some(rule => !String(rule && rule.buscar || ''))) {
+      throw new Error('Informe buscar com o texto exato em cada substituição.');
+    }
     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;
+    let changes = 0; const applied = [];
+    for (const rule of rules) {
+      const search = String(rule.buscar || '');
+      const replacement = String(rule.substituir ?? '');
+      const replaceAll = !!rule.todas;
+      let ruleChanges = 0;
+      for (const name of xmlFiles) {
+        const xml = await zip.file(name).async('string');
+        const result = _replaceInXmlText(xml, search, replacement, replaceAll);
+        if (result.count) { zip.file(name, result.xml); ruleChanges += result.count; }
+        if (ruleChanges && !replaceAll) break;
+      }
+      if (!ruleChanges) throw new Error(`Texto não encontrado no documento: ${search.slice(0, 100)}`);
+      changes += ruleChanges;
+      applied.push({ buscar: search.slice(0, 120), ocorrencias: ruleChanges });
+    }
+    for (const rule of tableRules) {
+      const label = String(rule && rule.rotulo || '');
+      if (!label) throw new Error('Informe rotulo em cada alteração de tabela.');
+      let ruleChanges = 0;
+      for (const name of xmlFiles) {
+        const xml = await zip.file(name).async('string');
+        const result = _replaceTableValueByLabel(xml, label, rule.valor, !!rule.todas);
+        if (result.count) { zip.file(name, result.xml); ruleChanges += result.count; }
+        if (ruleChanges && !rule.todas) break;
+      }
+      if (!ruleChanges) throw new Error(`Rótulo não encontrado em tabela: ${label.slice(0, 100)}`);
+      changes += ruleChanges;
+      applied.push({ rotulo: label.slice(0, 120), ocorrencias: ruleChanges });
     }
-    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 };
+    return { ok: true, caminho: destination, editou_original: destination === original,
+      ocorrencias: changes, substituicoes_aplicadas: applied, backup };
   } catch (error) { return { ok: false, erro: 'Falha ao editar DOCX: ' + error.message }; }
 }
 
@@ -128,7 +183,9 @@ async function editarPlanilha(input = {}) {
       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 };
+      return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: result.changes.length,
+        alteracoes: result.changes.slice(0, 100), formulas_invalidadas: result.formulasInvalidated,
+        recalcular_ao_abrir: result.recalculateOnOpen, backup, engine: result.engine, compatibilidade: readError.message };
     }
     const changes = [];
     for (const update of (Array.isArray(input.alteracoes) ? input.alteracoes : []).slice(0, 500)) {
@@ -162,10 +219,27 @@ async function editarPlanilha(input = {}) {
       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.');
+    // ExcelJS preserves cached formula results that may depend on edited input cells.
+    // Those caches become stale for previews/readers until Excel recalculates. Keep
+    // each formula, discard only its old result and request a full calculation on open.
+    let formulasInvalidated = 0;
+    for (const sheet of workbook.worksheets) {
+      sheet.eachRow({ includeEmpty: false }, row => row.eachCell({ includeEmpty: false }, cell => {
+        const value = cell.value;
+        if (!value || typeof value !== 'object' || (!value.formula && !value.sharedFormula)) return;
+        if (Object.prototype.hasOwnProperty.call(value, 'result')) {
+          const fresh = { ...value };
+          delete fresh.result;
+          cell.value = fresh;
+          formulasInvalidated++;
+        }
+      }));
+    }
+    workbook.calcProperties.fullCalcOnLoad = true;
     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' };
+    return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: changes.length, alteracoes: changes.slice(0, 100), formulas_invalidadas: formulasInvalidated, recalcular_ao_abrir: true, backup, engine: 'exceljs' };
   } catch (error) { return { ok: false, erro: 'Falha ao editar XLSX: ' + error.message }; }
 }
 
-module.exports = { editarDocumento, editarPlanilha, _replaceInXmlText };
+module.exports = { editarDocumento, editarPlanilha, _replaceInXmlText, _replaceTableValueByLabel };

package/lib/office-readers.js

@@ -103,4 +103,17 @@ async function lerApresentacao(input = {}) {
   }
 }
 
-module.exports = { lerDocumento, lerApresentacao };
+async function lerPlanilha(input = {}) {
+  try {
+    const p = path.resolve(String(input.caminho || ''));
+    if (!p.toLowerCase().endsWith('.xlsx')) throw new Error('O arquivo precisa terminar em .xlsx.');
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) throw new Error('Arquivo não encontrado: ' + p);
+    if (fs.statSync(p).size > 80 * 1048576) throw new Error('Arquivo maior que 80 MB.');
+    const data = await require('./xlsx-compat-editor').readXlsxCompat(p, input);
+    return { ok: true, arquivo: p, tamanho_bytes: fs.statSync(p).size, ...data };
+  } catch (error) {
+    return { ok: false, erro: 'Falha ao ler XLSX: ' + error.message };
+  }
+}
+
+module.exports = { lerDocumento, lerPlanilha, lerApresentacao };

package/lib/recovery.js

@@ -63,9 +63,17 @@ const RECOVERABLE = Object.keys(STRATEGIES); // classes com estratégia conhecid
 function strategiesFor(errorClass) { return STRATEGIES[errorClass] || null; }
 
 // Texto acionável pra INJETAR no resultado da ferramenta que o modelo lê. '' se classe sem estratégia.
-function recoveryHint(errorClass) {
+function recoveryHint(errorClass, options = {}) {
   const s = STRATEGIES[errorClass];
   if (!s) return '';
+  if (errorClass === 'not_found' && Array.isArray(options.availableTools)) {
+    const available = new Set(options.availableTools);
+    const probes = ['listar_diretorio', 'buscar_arquivos'].filter(name => available.has(name));
+    if (!probes.length) {
+      return 'ESCOPO ESTRITO: o alvo não foi encontrado e as ferramentas de procura não foram autorizadas. Não contorne a restrição, não invente outro caminho e não repita a mesma leitura. Encerre com a falha objetiva e informe que listar_diretorio ou buscar_arquivos permitiria investigar.';
+    }
+    return `ESTRATÉGIA CONHECIDA (not_found) — use somente ferramentas disponíveis:\n1) DIAGNOSTIQUE com ${probes.join(' ou ')} para confirmar o caminho exato.\n2) Se encontrar um candidato inequívoco, tente ler uma única vez; caso contrário, encerre com a evidência sem inventar caminho.`;
+  }
   return `ESTRATÉGIA CONHECIDA (${errorClass}) — não chute:\n1) DIAGNOSTIQUE: ${s.diag}\n2) CONSERTO: ${s.fix}`;
 }
 

package/lib/tools.js

@@ -54,6 +54,13 @@ const DEFS = [
       inicio: { type: 'number', description: 'linha inicial (1-based, opcional)' },
       fim: { type: 'number', description: 'linha final (opcional)' },
     }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'ler_arquivos',
+    description: 'Le em LOTE varios arquivos ou trechos de texto numa unica chamada. Prefira quando precisar inspecionar 2 ou mais arquivos/paginas; reduz tempo e custo.',
+    parameters: { type: 'object', properties: {
+      arquivos: { type: 'array', description: 'Ate 10 itens {caminho,inicio,fim}. Para arquivos grandes, use trechos de aproximadamente 100 linhas.', items: { type: 'object', properties: {
+        caminho: { type: 'string' }, inicio: { type: 'number' }, fim: { type: 'number' },
+      }, required: ['caminho'] } },
+    }, required: ['arquivos'] } } },
   { type: 'function', function: { name: 'escrever_arquivo',
     description: 'Cria ou sobrescreve um arquivo local com o conteúdo dado (cria as pastas se preciso). Para MUDAR UM TRECHO de arquivo que JÁ EXISTE, prefira editar_arquivo (mais barato e preciso).',
     parameters: { type: 'object', properties: {
@@ -162,11 +169,17 @@ const DEFS = [
       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.',
+    description: 'Edita um .docx EXISTENTE no próprio arquivo por padrão, preserva o restante e cria backup automático. Para várias mudanças no mesmo DOCX, agrupe todas em substituicoes numa ÚNICA chamada atômica. 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'] } } },
+      substituicoes: { type: 'array', description: 'Mudanças agrupadas e atômicas no mesmo DOCX.', items: { type: 'object', properties: {
+        buscar: { type: 'string' }, substituir: { type: 'string' }, todas: { type: 'boolean' },
+      }, required: ['buscar', 'substituir'] } },
+      alteracoes_tabela: { type: 'array', description: 'Altera atomicamente o valor da célula seguinte a um rótulo de tabela.', items: { type: 'object', properties: {
+        rotulo: { type: 'string' }, valor: { type: 'string' }, todas: { type: 'boolean' },
+      }, required: ['rotulo', 'valor'] } },
+    }, required: ['caminho'] } } },
   { 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: {
@@ -179,6 +192,12 @@ const DEFS = [
       }, required: ['buscar', 'substituir'] } },
       criar_copia: { type: 'boolean' }, caminho_copia: { type: 'string' },
     }, required: ['caminho'] } } },
+  { type: 'function', function: { name: 'ler_planilha',
+    description: 'Lê uma planilha .xlsx existente de forma tipada, retornando endereços, valores, fórmulas e resultados em cache. Use antes e depois de editar; não adivinhe células.',
+    parameters: { type: 'object', properties: {
+      caminho: { type: 'string' }, aba: { type: 'string' }, intervalo: { type: 'string', description: 'Ex.: A1:I30' },
+      limite: { type: 'number' }, incluir_vazias: { type: 'boolean' },
+    }, 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' } } } } },
@@ -377,7 +396,11 @@ function _shellGotcha(cmd) {
   // significado: `mkdir -p app` cria por engano uma pasta literal chamada `-p`.
   if (process.platform === 'win32' && /(^|[&|]\s*|\s)mkdir\s+-p(?:\s|$)/i.test(s))
     return 'Este shell é cmd.exe: "mkdir -p" criaria uma pasta chamada "-p". Use "mkdir pasta" ou PowerShell New-Item.';
-  if (process.platform === 'win32' && /(^|[&|]\s*|\s)ls(?:\s|$)/i.test(s))
+  // Bloqueie apenas `ls` como COMANDO. `npm ls` e texto dentro de um PowerShell
+  // explicito sao validos; o antigo `\sls` gerava falso positivo nos dois casos.
+  if (process.platform === 'win32'
+      && !/^\s*(?:powershell|pwsh)\b/i.test(s)
+      && /(?:^|(?:&&|\|\||[&|])\s*)ls(?:\s|$)/i.test(s))
     return 'Este shell é cmd.exe: use "dir" (ou chame PowerShell explicitamente) em vez de "ls".';
   if (process.platform === 'win32' && /(?:^|\s)\/[a-zA-Z]\//.test(s))
     return 'Caminho no formato /c/... não é válido no cmd.exe. Use C:\\... ou um caminho relativo ao diretório de trabalho.';
@@ -623,6 +646,25 @@ async function execute(name, input, opts = {}) {
         if (total > MAXL) return { conteudo: linhas.slice(0, MAXL).join('\n'), linhas_total: total, aviso: `Arquivo grande (${total} linhas): mostrando 1-${MAXL}. Chame de novo com inicio/fim.` };
         return { conteudo: txt, linhas_total: total };
       }
+      case 'ler_arquivos': {
+        const arquivos = Array.isArray(input.arquivos) ? input.arquivos.slice(0, 10) : [];
+        if (!arquivos.length) return { erro: 'Informe arquivos com pelo menos um item {caminho,inicio,fim}.' };
+        const resultados = [];
+        let caracteres = 0;
+        const LIMITE_TOTAL = 22000;
+        for (const item of arquivos) {
+          if (!item || !item.caminho) continue;
+          const r = await execute('ler_arquivo', item, opts);
+          let conteudo = r && typeof r.conteudo === 'string' ? r.conteudo : '';
+          const restante = Math.max(0, LIMITE_TOTAL - caracteres);
+          if (conteudo.length > restante) conteudo = conteudo.slice(0, restante) + '\n...[lote truncado; solicite um trecho menor]';
+          const saida = Object.assign({ caminho: item.caminho }, r || {}, conteudo ? { conteudo } : {});
+          resultados.push(saida);
+          caracteres += conteudo.length;
+          if (caracteres >= LIMITE_TOTAL) break;
+        }
+        return { total: resultados.length, resultados, aviso: resultados.length < arquivos.length ? 'Lote limitado pelo teto de contexto; peca os trechos restantes em outro lote.' : undefined };
+      }
       case 'escrever_arquivo': {
         let p = _abs(input.caminho, baseDir);
         { const g = _guardTsHome(p); if (g) return { erro: g }; }
@@ -707,7 +749,8 @@ async function execute(name, input, opts = {}) {
       case 'listar_diretorio': {
         const p = _abs(input.caminho || '.', baseDir);
         if (_outsideScope(p)) return _scopeError(p);
-        const items = fs.readdirSync(p, { withFileTypes: true }).slice(0, 200).map(d => {
+        const internos = new Set(['.ts-episodios.json', '.ts-erros.json', '.ts-indice.json']);
+        const items = fs.readdirSync(p, { withFileTypes: true }).filter(d => !internos.has(d.name)).slice(0, 200).map(d => {
           let size = null; try { if (d.isFile()) size = fs.statSync(path.join(p, d.name)).size; } catch (_) {}
           return { nome: d.name, tipo: d.isDirectory() ? 'dir' : 'arquivo', bytes: size };
         });
@@ -879,6 +922,11 @@ async function execute(name, input, opts = {}) {
         if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
         return result;
       }
+      case 'ler_planilha': {
+        const target = _abs(input.caminho, baseDir);
+        if (_outsideScope(target)) return _scopeError(target);
+        return await require('./office-readers').lerPlanilha({ ...input, caminho: target });
+      }
       case 'status_microsoft365':
         return await require('./api').api('/api/integrations/microsoft/status', { token: opts.token });
       case 'conectar_microsoft365': {

package/lib/xlsx-compat-editor.js

@@ -66,6 +66,15 @@ function cellRow(address) {
   return Number(address.match(/\d+$/)[0]);
 }
 
+function addressInRange(address, range) {
+  if (!range) return true;
+  const match = String(range).toUpperCase().match(/^([A-Z]+\d+)(?::([A-Z]+\d+))?$/);
+  if (!match) throw new Error(`Intervalo inválido: ${range}`);
+  const start = match[1]; const end = match[2] || start;
+  return cellColumn(address) >= cellColumn(start) && cellColumn(address) <= cellColumn(end)
+    && cellRow(address) >= cellRow(start) && cellRow(address) <= cellRow(end);
+}
+
 function setType(openTag, type) {
   let tag = openTag.replace(/\s+t="[^"]*"/i, '');
   if (type) tag = tag.replace(/\s*\/?>$/, ` t="${type}">`);
@@ -157,6 +166,42 @@ function parseSharedStrings(xml) {
   );
 }
 
+function inspectCell(cellXml, sharedStrings) {
+  const open = cellXml.match(/^<[^>]+>/)?.[0] || '';
+  const type = attr(open, 't');
+  const formula = cellXml.match(/<(?:\w+:)?f\b[^>]*>([\s\S]*?)<\/(?:\w+:)?f>/i)?.[1];
+  const raw = cellXml.match(/<(?:\w+:)?v\b[^>]*>([\s\S]*?)<\/(?:\w+:)?v>/i)?.[1];
+  let value = cellText(cellXml, sharedStrings);
+  if (value == null && raw != null) {
+    const decoded = xmlDecode(raw);
+    if (type === 'b') value = decoded === '1';
+    else value = Number.isFinite(Number(decoded)) ? Number(decoded) : decoded;
+  }
+  return { valor: value, formula: formula == null ? undefined : xmlDecode(formula), resultado_cache: formula == null ? undefined : value };
+}
+
+async function readXlsxCompat(source, input = {}) {
+  const zip = await JSZip.loadAsync(fs.readFileSync(source));
+  const sheets = await workbookSheets(zip);
+  const selected = input.aba
+    ? sheets.find(sheet => sheet.name.toLowerCase() === String(input.aba).toLowerCase())
+    : sheets[0];
+  if (!selected) throw new Error(`Aba não encontrada: ${input.aba}`);
+  const sharedXml = zip.file('xl/sharedStrings.xml') ? await zip.file('xl/sharedStrings.xml').async('string') : '';
+  const sharedStrings = parseSharedStrings(sharedXml);
+  const xml = await zip.file(selected.file).async('string');
+  const cells = [];
+  for (const match of xml.matchAll(/(?:<(?:\w+:)?c\b(?=[^>]*\br="([A-Z]+\d+)")[^>]*\/>|<(?:\w+:)?c\b(?=[^>]*\br="([A-Z]+\d+)")[^>]*>[\s\S]*?<\/(?:\w+:)?c>)/gi)) {
+    const address = match[1] || match[2];
+    if (!addressInRange(address, input.intervalo)) continue;
+    const inspected = inspectCell(match[0], sharedStrings);
+    if (inspected.valor == null && inspected.formula == null && !input.incluir_vazias) continue;
+    cells.push({ celula: address, ...inspected });
+    if (cells.length >= Math.min(2000, Math.max(1, Number(input.limite) || 500))) break;
+  }
+  return { abas: sheets.map(sheet => sheet.name), aba: selected.name, intervalo: input.intervalo || 'usado', celulas: cells };
+}
+
 function substituteInSheet(xml, rule, sharedStrings) {
   const search = String(rule.buscar || '');
   if (!search) return { xml, changes: [] };
@@ -180,6 +225,28 @@ function substituteInSheet(xml, rule, sharedStrings) {
   return { xml: changes.length ? output + xml.slice(cursor) : xml, changes };
 }
 
+function invalidateFormulaCaches(xml) {
+  let count = 0;
+  const output = String(xml).replace(/<(?:\w+:)?c\b[^>]*>[\s\S]*?<\/(?:\w+:)?c>/gi, cell => {
+    if (!/<(?:\w+:)?f\b/i.test(cell)) return cell;
+    const next = cell.replace(/<(?:\w+:)?v\b[^>]*>[\s\S]*?<\/(?:\w+:)?v>/gi, '');
+    if (next !== cell) count++;
+    return next;
+  });
+  return { xml: output, count };
+}
+
+function requestFullCalculation(xml) {
+  const source = String(xml || '');
+  if (/<(?:\w+:)?calcPr\b/i.test(source)) {
+    return source.replace(/<(\w+:)?calcPr\b([^>]*?)\/?\s*>/i, (_all, prefix = '', attrs = '') => {
+      const clean = attrs.replace(/\s+fullCalcOnLoad="[^"]*"/i, '');
+      return `<${prefix || ''}calcPr${clean} fullCalcOnLoad="1"/>`;
+    });
+  }
+  return source.replace(/<\/(\w+:)?workbook>\s*$/i, '<$1calcPr fullCalcOnLoad="1"/></$1workbook>');
+}
+
 async function editXlsxCompat(source, destination, input = {}) {
   const zip = await JSZip.loadAsync(fs.readFileSync(source));
   const sheets = await workbookSheets(zip);
@@ -219,10 +286,19 @@ async function editXlsxCompat(source, destination, input = {}) {
     if (!replaced) throw new Error(`Texto não encontrado na planilha: ${String(rule.buscar || '').slice(0, 80)}`);
   }
   if (!changes.length) throw new Error('Informe alteracoes ou substituicoes.');
+  let formulasInvalidated = 0;
+  for (const sheet of sheets) {
+    const invalidated = invalidateFormulaCaches(await readXml(sheet));
+    xmlByFile.set(sheet.file, invalidated.xml);
+    formulasInvalidated += invalidated.count;
+  }
   for (const [file, xml] of xmlByFile) zip.file(file, xml);
+  const workbookXml = await zip.file('xl/workbook.xml').async('string');
+  zip.file('xl/workbook.xml', requestFullCalculation(workbookXml));
   const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
   fs.writeFileSync(destination, buffer);
-  return { changes, engine: 'ooxml-compat' };
+  return { changes, engine: 'ooxml-compat', formulasInvalidated, recalculateOnOpen: true };
 }
 
-module.exports = { editXlsxCompat, _updateCell: updateCell, _substituteInSheet: substituteInSheet };
+module.exports = { editXlsxCompat, _updateCell: updateCell, _substituteInSheet: substituteInSheet,
+  readXlsxCompat, _invalidateFormulaCaches: invalidateFormulaCaches, _requestFullCalculation: requestFullCalculation };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.97.13",
+  "version": "0.97.15",
   "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/core.test.js && node test/intelligence-core.test.js && node test/cloud-slug.test.js && node test/eval-model.test.js && node test/project-cache.test.js && node test/memory-bus.test.js && node test/capabilities.test.js && node test/mcp-e2e.test.js && node test/erros.test.js && node test/capability-pack.test.js && node test/video-generation.test.js && node test/byok.test.js && node test/conhecimento.test.js && node test/policy.test.js && node test/temas.test.js && node test/skill-index.test.js && node test/doctor.test.js && node test/google-workspace-tools.test.js && node test/office-editors.test.js"
+    "test": "node test/core.test.js && node test/audit-packs.test.js && node test/intelligence-core.test.js && node test/cloud-slug.test.js && node test/eval-model.test.js && node test/project-cache.test.js && node test/memory-bus.test.js && node test/capabilities.test.js && node test/mcp-e2e.test.js && node test/erros.test.js && node test/evolution-telemetry.test.js && node test/capability-pack.test.js && node test/video-generation.test.js && node test/image-job.test.js && node test/byok.test.js && node test/conhecimento.test.js && node test/policy.test.js && node test/temas.test.js && node test/skill-index.test.js && node test/doctor.test.js && node test/google-workspace-tools.test.js && node test/office-editors.test.js"
   },
   "files": [
     "bin",