terminal-smart-cli 0.97.7 → 0.97.9

package/bin/ts.js

@@ -119,7 +119,37 @@ function help() {
   console.log(out.join('\n'));
 }
 
+function privacyCmd() {
+  const privacyUrl = 'https://terminalsmart.com.br/privacidade';
+  console.log((cfg.lang === 'en' ? 'Privacy Policy: ' : 'Política de Privacidade: ') + privacyUrl);
+}
+
 // ── Login por código (device-code) ───────────────────────────────────────────
+async function accountCmd(args) {
+  const action = String((args && args[0]) || '').toLowerCase();
+  const accountUrl = base() + '/minha-conta';
+  if (!action || ['abrir', 'open', 'excluir', 'delete'].includes(action)) {
+    console.log((cfg.lang === 'en' ? 'Account, data export and deletion: ' : 'Conta, exportação de dados e exclusão: ') + accountUrl);
+    if (process.env.TS_NO_BROWSER !== '1') try {
+      const { exec } = require('child_process');
+      const cmd = process.platform === 'win32' ? `start "" "${accountUrl}"` : process.platform === 'darwin' ? `open "${accountUrl}"` : `xdg-open "${accountUrl}"`;
+      exec(cmd, () => {});
+    } catch (_) {}
+    return;
+  }
+  if (['exportar', 'export', 'baixar', 'download'].includes(action)) {
+    const token = needToken();
+    const data = await api('/api/account/export', { token, retry: false });
+    const fs = require('fs'), path = require('path');
+    const safeUser = String(cfg.username || 'usuario').replace(/[^a-z0-9_-]/gi, '-');
+    const file = path.resolve(`terminal-smart-dados-${safeUser}-${new Date().toISOString().slice(0, 10)}.json`);
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
+    console.log(ui.okLine((cfg.lang === 'en' ? 'Data saved to: ' : 'Dados salvos em: ') + file));
+    return;
+  }
+  console.log(ui.infoLine(cfg.lang === 'en' ? 'Use: ts account export | ts account open' : 'Use: ts conta exportar | ts conta abrir'));
+}
+
 async function login() {
   if (cfg.token) {
     try {
@@ -1134,16 +1164,19 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   const token = needToken();
   // flags que levam VALOR: o filtro remove só a flag (começa com "-"), deixando o VALOR nos
   // words → tira o valor daqui pra ele não virar parte do texto da tarefa.
-  for (const flag of ['--modelo', '--model', '--output-format']) {
+  for (const flag of ['--modelo', '--model', '--output-format', '--orcamento-creditos', '--max-creditos', '--tempo-max-seg', '--max-tokens']) {
     const _i = process.argv.findIndex(a => a === flag); const _v = _i >= 0 ? process.argv[_i + 1] : null;
     if (_v) { const j = words.indexOf(_v); if (j >= 0) words = words.slice(0, j).concat(words.slice(j + 1)); }
   }
   let task = words.join(' ').trim();
   // Flags INLINE no texto (pro REPL, onde não há argv): --passos N / --steps N / --yolo.
   // Assim "faça tudo ... --passos 60 --yolo" digitado no chat vale igual à linha de comando.
-  let _inlinePassos, _inlineYolo = false;
+  let _inlinePassos, _inlineYolo = false, _inlineMaxCredits, _inlineMaxSeconds, _inlineMaxTokens;
   task = task
     .replace(/(?:^|\s)--(?:passos|steps|max-passos)[\s=]+(\d{1,3})\b/gi, (_m, n) => { _inlinePassos = Number(n); return ' '; })
+    .replace(/(?:^|\s)--(?:orcamento-creditos|max-creditos)[\s=]+(\d{1,5})\b/gi, (_m, n) => { _inlineMaxCredits = Number(n); return ' '; })
+    .replace(/(?:^|\s)--tempo-max-seg[\s=]+(\d{1,5})\b/gi, (_m, n) => { _inlineMaxSeconds = Number(n); return ' '; })
+    .replace(/(?:^|\s)--max-tokens[\s=]+(\d{3,7})\b/gi, (_m, n) => { _inlineMaxTokens = Number(n); return ' '; })
     .replace(/(?:^|\s)--(?:yolo|full-auto|auto-tudo)\b/gi, () => { _inlineYolo = true; return ' '; })
     .replace(/\s{2,}/g, ' ').trim();
   const piped = await readStdin();
@@ -1221,8 +1254,15 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
     // Pra missões grandes ("faça tudo de uma vez") sem o pára-e-continua.
     const _pi = process.argv.findIndex(a => a === '--passos' || a === '--steps' || a === '--max-passos');
     const _maxPassos = _pi >= 0 ? Number(process.argv[_pi + 1]) : (_inlinePassos ?? maxIterIn ?? undefined);
+    const _ci = process.argv.findIndex(a => a === '--orcamento-creditos' || a === '--max-creditos');
+    const _ti = process.argv.findIndex(a => a === '--tempo-max-seg');
+    const _tki = process.argv.findIndex(a => a === '--max-tokens');
+    const _maxCredits = _ci >= 0 ? Number(process.argv[_ci + 1]) : _inlineMaxCredits;
+    const _maxDurationMs = 1000 * (_ti >= 0 ? Number(process.argv[_ti + 1]) : (_inlineMaxSeconds || 0));
+    const _maxTokens = _tki >= 0 ? Number(process.argv[_tki + 1]) : _inlineMaxTokens;
     out = await agent.run(task, {
       token, lang: cfg.lang || 'pt', yes: YES, autoAll: (YOLO || _inlineYolo || autoAllIn), model, priorMessages, cwd: startCwd, readOnly, plan, browser: useBrowser, maxIter: _maxPassos,
+      maxCredits: _maxCredits, maxDurationMs: _maxDurationMs || undefined, maxTokens: _maxTokens,
       onThinking: (p) => {
         if (p && typeof p === 'object') {
           _live.steps = p.steps ?? _live.steps; _live.inTok = p.inTok ?? _live.inTok; _live.outTok = p.outTok ?? _live.outTok;
@@ -1288,10 +1328,10 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   // HEADLESS stream-json: fecha com assistant (texto) + result (métricas) e sai.
   if (streamJson) {
     _emit(core.AgentEvents.assistant(out.text || ''));
-    _emit(core.AgentEvents.result({ steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, needHuman: out.needHuman || null, toolErrors: out.toolErrors || [], cwd: effCwd, duration_ms: Date.now() - t0, worktree: _wt ? { path: _wt.path, branch: _wt.branch, base: _wt.base, changed: (_wtInfo && _wtInfo.changed) || 0 } : null }));
+    _emit(core.AgentEvents.result({ steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context || null, needHuman: out.needHuman || null, toolErrors: out.toolErrors || [], guard: out.guard || null, cwd: effCwd, duration_ms: Date.now() - t0, worktree: _wt ? { path: _wt.path, branch: _wt.branch, base: _wt.base, changed: (_wtInfo && _wtInfo.changed) || 0 } : null }));
     return;
   }
-  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, result: out.text, steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context, needHuman: out.needHuman })); return; }
+  if (JSON_OUT) { console.log(JSON.stringify({ ok: true, result: out.text, steps: out.steps, credits: out.credits, tokens: out.tokens, context: out.context, needHuman: out.needHuman, guard: out.guard || null })); return; }
   // BLOQUEIO HUMANO: o agente pediu uma ação que só o usuário faz — mostra o pedido
   // (antes o retorno vinha com texto vazio e o usuário via só um cabeçalho em branco).
   if (out.needHuman) {
@@ -2594,6 +2634,9 @@ async function doctorCmd() {
     cfg, version: pkg.version, base: base(),
     // backend no ar? 401 conta como "respondeu" (só não autenticado).
     pingBackend: async () => { try { await api('/api/auth/check', { token: cfg.token, timeoutMs: 8000 }); return true; } catch (e) { return (e && e.status === 401); } },
+    // Plano autoritativo. O de ~/.ts é do último login e envelhece a cada assinatura,
+    // troca ou cancelamento — o diagnóstico mostrava um plano que já não existe mais.
+    planoAtual: async () => { try { const r = await api('/api/credits', { token: cfg.token, timeoutMs: 8000 }); return (r && r.plan) || null; } catch (_) { return null; } },
     // última versão publicada no npm (best-effort).
     latestVersion: async () => { try { const r = await fetch('https://registry.npmjs.org/terminal-smart-cli/latest', { signal: AbortSignal.timeout(8000) }); const j = await r.json(); return j && j.version; } catch (_) { return null; } },
   });
@@ -2662,9 +2705,10 @@ async function siteCmd(args) {
       if (JSON_OUT) return console.log(JSON.stringify(r));
       if (!r.sites || !r.sites.length) return console.log(ui.infoLine('Nenhum site criado. Use: ts site criar <nome> "<descrição>"'));
       console.log('\n' + ui.box(r.sites.map(s =>
-        C.bold(s.slug) + C.dim('  ·  ') + (s.status === 'active' ? C.ok('online') : C.dim(s.status)) +
-        C.dim(s.preview ? '  ·  prévia grátis' : '') + '\n  ' + C.cyan(s.url)
-      ), { title: `ts site · ${r.plan} · limite ${r.siteLimit || 'demo'}` }) + '\n');
+        C.bold(s.name || s.slug) + C.dim('  ·  ') + (s.status === 'active' ? C.ok('online') : C.dim(s.status)) +
+        C.dim(`  ·  ${s.kind || (s.preview ? 'preview' : 'permanente')}`) + '\n  ' + C.cyan(s.url) +
+        (s.expiresAt ? C.dim('\n  expira: ' + s.expiresAt) : '')
+      ), { title: `ts site · ${r.plan} · ${(r.limits && r.limits.used) ?? r.sites.length}/${(r.limits && r.limits.maximum) || r.siteLimit || 'demo'}` }) + '\n');
       return;
     }
     if (['criar', 'create', 'gerar', 'generate', 'editar', 'edit', 'alterar', 'update'].includes(sub)) {
@@ -2871,7 +2915,8 @@ async function uso() {
     '',
     unlimited
       ? C.ok(T.uso_unlimited) + C.dim(` · ${r.used || 0} ${T.uso_credits}`)
-      : ui.bar((r.used || 0) / Math.max(1, r.granted || 1)) + `  ${C.bold(r.remaining ?? '?')} ${C.dim(`/ ${r.granted} ${T.uso_remaining}`)}`,
+      // A barra mostra o que RESTA, igual ao número ao lado dela.
+      : ui.bar(Math.max(0, r.remaining ?? 0) / Math.max(1, r.granted || 1), 22, { restante: true }) + `  ${C.bold(r.remaining ?? '?')} ${C.dim(`/ ${r.granted} ${T.uso_remaining}`)}`,
   ];
   const ledger = (r.ledger || []).slice(0, 5);
   if (ledger.length) {
@@ -2893,6 +2938,43 @@ async function quem() {
   ], { title: T.quem_title }) + '\n');
 }
 
+async function integracoesCmd(args) {
+  const token = needToken(); const en = cfg.lang === 'en';
+  const sub = String(args[0] || 'status').toLowerCase();
+  const rawProvider = String(args[1] || '').toLowerCase();
+  const provider = ['google', 'gmail', 'drive'].includes(rawProvider) ? 'google'
+    : ['microsoft', 'outlook', 'hotmail', 'office'].includes(rawProvider) ? 'microsoft' : '';
+  const names = { google: 'Google Workspace', microsoft: 'Microsoft/Outlook' };
+  const getStatus = async p => {
+    try { return await api(`/api/integrations/${p}/status`, { token }); }
+    catch (e) { return { connected: false, error: e.message }; }
+  };
+  if (['status', 'listar', 'list', 'ls'].includes(sub)) {
+    const [google, microsoft] = await Promise.all([getStatus('google'), getStatus('microsoft')]);
+    const data = { google, microsoft };
+    if (JSON_OUT) { console.log(JSON.stringify(data)); return; }
+    const line = (label, item) => C.bold(label.padEnd(22)) + (item.connected ? C.ok(en ? 'connected' : 'conectado') + C.dim(item.email ? ` · ${item.email}` : '') : C.dim(en ? 'not connected' : 'não conectado'));
+    console.log('\n' + ui.box([line('Google Workspace', google), line('Microsoft/Outlook', microsoft), '', C.dim(en ? 'Connect: ts integrations connect google|microsoft' : 'Conectar: ts integracoes conectar google|microsoft'), C.dim(en ? 'Manage on web: terminalsmart.com.br/integracoes' : 'Gerenciar na Web: terminalsmart.com.br/integracoes')], { title: en ? 'Integrations' : 'Integrações' }) + '\n');
+    return;
+  }
+  if (!provider) { console.error(ui.infoLine(en ? 'Choose google or microsoft.' : 'Escolha google ou microsoft.')); process.exit(2); }
+  if (['conectar', 'connect', 'reconectar', 'reconnect'].includes(sub)) {
+    const data = await api(`/api/integrations/${provider}/connect`, { method: 'POST', token, body: { source: 'cli' } });
+    if (JSON_OUT) { console.log(JSON.stringify({ provider, authUrl: data.authUrl })); return; }
+    console.log('\n' + ui.box([C.bold(en ? `Authorize ${names[provider]}` : `Autorize ${names[provider]}`), '', data.authUrl, '', C.dim(en ? 'After authorization, run: ts integrations' : 'Depois de autorizar, rode: ts integracoes')], { title: 'OAuth' }) + '\n');
+    try { require('child_process').exec(process.platform === 'win32' ? `start "" "${data.authUrl}"` : process.platform === 'darwin' ? `open "${data.authUrl}"` : `xdg-open "${data.authUrl}"`); } catch (_) {}
+    return;
+  }
+  if (['desconectar', 'disconnect', 'remover', 'remove'].includes(sub)) {
+    let confirmed = FLAGS.has('--confirmar') || FLAGS.has('--confirm');
+    if (!confirmed && process.stdin.isTTY) confirmed = ['s','sim','y','yes'].includes(String(await ui.ask(C.warn(`Desconectar ${names[provider]}? (s/N) `))).trim().toLowerCase());
+    if (!confirmed) { console.log(ui.infoLine(en ? 'Cancelled. Use --confirm to automate this specific action.' : 'Cancelado. Use --confirmar para automatizar esta ação específica.')); return; }
+    await api(`/api/integrations/${provider}/disconnect`, { method: 'POST', token, body: { confirmed: true } });
+    console.log(ui.okLine(`${names[provider]} ${en ? 'disconnected' : 'desconectado'}`)); return;
+  }
+  console.log(ui.infoLine(en ? 'Usage: ts integrations [status|connect|disconnect] [google|microsoft]' : 'Uso: ts integracoes [status|conectar|desconectar] [google|microsoft]'));
+}
+
 function idioma(l) {
   const lang = String(l || '').toLowerCase();
   if (!['pt', 'en'].includes(lang)) { console.error(ui.infoLine(T.lang_invalid)); process.exit(2); }
@@ -2993,6 +3075,9 @@ function recallCmd(args) {
     case 'runbook': case 'runbooks': case 'procedimento': return runbookCmd(POS.slice(1));
     case 'trilha': case 'trail': case 'auditoria': return trilhaCmd();
     case 'doctor': case 'diagnostico-ambiente': case 'checkup': return doctorCmd();
+    case 'privacidade': case 'privacy': return privacyCmd();
+    case 'conta': case 'account': return accountCmd(POS.slice(1));
+    case 'integracoes': case 'integrações': case 'integrations': return integracoesCmd(POS.slice(1));
     case 'meta': case 'missao': case 'mission': return metaCmd();
     case 'runs':   return runsCmd();
     case 'status': return statusCmd(POS[1]);

package/lib/agent.js

@@ -8,10 +8,12 @@ const fs = require('fs');
 const path = require('path');
 const { api, ApiError, withRetry } = require('./api');
 const keyring = require('./keyring');
+const providers = require('./providers');
 const policy = require('./policy');
 const checkpoint = require('./checkpoint');
 const skillIndex = require('./skill-index');
 const tools = require('./tools');
+const { MissionToolCache, cacheReference } = require('./mission-tool-cache');
 
 // SKILLS INSTALADAS (~/.ts/skills/<slug>/SKILL.md): lê nome+descrição do frontmatter pra
 // oferecer ao agente. O agente LÊ o SKILL.md completo (com ler_arquivo) quando a skill é útil.
@@ -36,6 +38,44 @@ function installedSkills() {
 
 const MAX_ITER = 15;
 const TOOL_RESULT_CAP = 6000; // chars por resultado no contexto (compactor já reduz antes)
+const DEFAULT_MISSION_CREDIT_CAP = 40;
+const DEFAULT_MISSION_TOKEN_CAP = 180000;
+const DEFAULT_MISSION_TIME_MS = 120000;
+const DEFAULT_EQUIVALENT_FAILURE_CAP = 2;
+
+function failureFingerprint(tool, classified, result) {
+  const evidence = String((classified && classified.evidence) || (result && (result.erro || result.stderr)) || '')
+    .toLowerCase()
+    .replace(/[a-f0-9]{16,}/g, '<id>')
+    .replace(/\d+/g, '#')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 180);
+  return `${String(tool || 'tool')}|${String((classified && classified.errorClass) || 'unknown')}|${evidence}`;
+}
+
+function validarModeloByok(k) {
+  if (!k || k.source !== 'byok') return null;
+  const estado = providers.estadoModelo(k.provedor, k.modelo);
+  if (estado.disponivel) return null;
+  const dica = estado.substituto ? ' Troque para "' + estado.substituto + '"' : ' Escolha outro modelo';
+  return new ApiError('O modelo BYOK "' + k.modelo + '" foi aposentado: ' + estado.motivo + '.' + dica +
+    ' com `ts conectar ' + k.provedor + '`. O modo Automático pode usar fallback com `ts conectar nuvem`.',
+    { status: 410, code: 'model_retired' });
+}
+
+function missionGuardDecision({ credits = 0, maxCredits = DEFAULT_MISSION_CREDIT_CAP,
+  tokens = 0, maxTokens = DEFAULT_MISSION_TOKEN_CAP, elapsedMs = 0,
+  maxMs = DEFAULT_MISSION_TIME_MS, equivalentFailures = 0,
+  maxEquivalentFailures = DEFAULT_EQUIVALENT_FAILURE_CAP } = {}) {
+  if (maxCredits > 0 && credits >= maxCredits) return { kind: 'credits', limit: maxCredits, spent: credits };
+  if (maxTokens > 0 && tokens >= maxTokens) return { kind: 'tokens', limit: maxTokens, spent: tokens };
+  if (maxMs > 0 && elapsedMs >= maxMs) return { kind: 'time', limit: maxMs, spent: elapsedMs };
+  if (maxEquivalentFailures > 0 && equivalentFailures >= maxEquivalentFailures) {
+    return { kind: 'equivalent_failures', limit: maxEquivalentFailures, spent: equivalentFailures };
+  }
+  return null;
+}
 
 // ── NÚCLEO CANÔNICO ──────────────────────────────────────────────────────────
 // Executor padrão, janelas de contexto e auto-compactação vêm de lib/core.js (fonte
@@ -122,8 +162,9 @@ RULES:
 // fechamento garantido pra o modelo não tentar chamar ferramenta de novo).
 // Ferramentas SÓ-LEITURA: usadas no modo Ask (--ler), no Plan (--plano) e no sub-agente
 // de exploração (nunca escrevem/rodam comando destrutivo → seguras por construção).
-const READONLY = new Set(['ler_arquivo', 'ler_documento', 'ler_apresentacao', 'listar_diretorio', 'buscar_arquivos', 'buscar_codigo', 'mapa_projeto', 'info_sistema', 'buscar_web', 'buscar_skill', 'android_dispositivos', 'android_logs']);
+const READONLY = new Set(['ler_arquivo', 'ler_documento', 'ler_apresentacao', 'listar_diretorio', 'buscar_arquivos', 'buscar_codigo', 'mapa_projeto', 'info_sistema', 'buscar_web', 'buscar_skill', 'android_dispositivos', 'android_logs', 'status_microsoft365', 'listar_emails_outlook', 'ler_email_outlook', 'listar_pastas_outlook', 'obter_anexo_outlook', 'status_google_workspace', 'listar_emails_gmail', 'ler_email_gmail', 'listar_pastas_gmail', 'obter_anexo_gmail', 'listar_arquivos_drive', 'ler_google_docs', 'ler_google_sheets']);
 const DEVICE_MUTATING = new Set(['android_parear', 'android_conectar', 'android_instalar', 'android_iniciar', 'android_capturar_tela']);
+const CLOUD_MUTATING = new Set(['conectar_microsoft365', 'alterar_email_outlook', 'criar_resposta_outlook', 'criar_encaminhamento_outlook', 'criar_rascunho_outlook', 'enviar_rascunho_outlook', 'alterar_email_gmail', 'criar_resposta_gmail', 'criar_encaminhamento_gmail', 'criar_rascunho_gmail', 'enviar_rascunho_gmail', 'editar_google_docs', 'editar_google_sheets']);
 async function llm({ baseUrl, key, messages, model, signalMs = 180000, noTools = false, toolsOverride = null, onRetry = null }) {
   // RESILIÊNCIA: o gateway CDC pode reiniciar/oscilar no meio de uma missão longa.
   // withRetry cobre conn/timeout/5xx (backoff+jitter); NUNCA re-tenta no_credits/auth.
@@ -268,6 +309,11 @@ async function _remoteApprove(comando, token, onRemote) {
 async function run(task, opts = {}) {
   const { token, lang = 'pt', yes = false, autoAll = false, model = null, confineDir = null, onStep = () => {}, onStepDone = () => {}, askApprove = async () => false, onThinking = () => {}, onRemote = () => {} } = opts;
   const maxIter = Math.max(1, Math.min(Number(opts.maxIter) || MAX_ITER, 120)); // --passos N (teto 120)
+  const maxCredits = Math.max(1, Math.min(Number(opts.maxCredits) || DEFAULT_MISSION_CREDIT_CAP, 5000));
+  const maxTokens = Math.max(1000, Math.min(Number(opts.maxTokens) || DEFAULT_MISSION_TOKEN_CAP, 2000000));
+  const maxDurationMs = Math.max(10000, Math.min(Number(opts.maxDurationMs) || DEFAULT_MISSION_TIME_MS, 3600000));
+  const maxEquivalentFailures = Math.max(1, Math.min(Number(opts.maxEquivalentFailures) || DEFAULT_EQUIVALENT_FAILURE_CAP, 10));
+  const missionStartedAt = Date.now();
   // FULL-AUTO (autoridade total): aprova destrutivos sem perguntar. Começa por --yolo/--full-auto
   // (opts.autoAll) e pode ser LIGADO no meio da sessão quando o humano responde "a" (aprovar tudo).
   let autoApproveDestructive = !!autoAll;
@@ -296,6 +342,11 @@ async function run(task, opts = {}) {
   //    o gate por plano no backend (402 plan_limit → mensagem de upgrade).
   const k = await keyring.resolve(token, { feature: 'cli_agent' });
   if (!k || !k.key) throw new ApiError('ai_key', {});
+  // BYOK é uma escolha explícita do usuário: nunca substituímos silenciosamente
+  // o modelo. Se ele foi aposentado, paramos ANTES da primeira chamada e indicamos
+  // como trocar. No modo TS Cloud/Automático, o gateway continua livre para fallback.
+  const erroModeloByok = validarModeloByok(k);
+  if (erroModeloByok) throw erroModeloByok;
   let selectedModel = model;
   // BYOK: o catálogo do roteador é do GATEWAY (ids tipo "deepseek-v4-flash"); o provedor
   // do usuário tem os seus ("deepseek-ai/deepseek-v4-flash") e devolve 404 pro id errado.
@@ -444,6 +495,7 @@ async function run(task, opts = {}) {
   // ação (mesmo comando falhando, ciclo A/B/A/B). WARN = empurra a mudar de abordagem; 2º strike
   // (ou já avisado e ainda em ciclo) = encerra o loop e cai no fechamento honesto garantido.
   const _callCounts = new Map(); const _recentSigs = []; const _warnedSigs = new Set();
+  const _missionCache = new MissionToolCache();
   let _loopWarned = false, loopedOut = false;
   const LOOP_WARN = Number(process.env.TS_LOOP_WARN) > 0 ? Number(process.env.TS_LOOP_WARN) : 3;
   const LOOP_BREAK = Number(process.env.TS_LOOP_BREAK) > 0 ? Number(process.env.TS_LOOP_BREAK) : 5;
@@ -491,7 +543,15 @@ async function run(task, opts = {}) {
   const _mcpSeen = new Set(); // servidores MCP já autorizados NESTA sessão (1ª chamada pede OK)
   const actions = []; // ações REAIS bem-sucedidas (evidência objetiva pro marcador do meta)
   const _toolErrs = []; // erros de ferramenta TIPADOS na run (core.classifyToolResult) — sinal duro anti-done-falso
+  const _failureCounts = new Map();
   let finalText = '', usedModel = 'smart', steps = 0, charged = 0, _visionCredits = 0;
+  let guardStopped = null;
+  const _guard = (equivalentFailures = 0) => missionGuardDecision({
+    credits: charged + _visionCredits, maxCredits,
+    tokens: acc.inTok + acc.outTok, maxTokens,
+    elapsedMs: Date.now() - missionStartedAt, maxMs: maxDurationMs,
+    equivalentFailures, maxEquivalentFailures,
+  });
   const ctxWindow = winFor(selectedModel);
   // MEMÓRIA EPISÓDICA: ao fim da run, grava UM episódio (o que fez aqui) → a próxima run
   // deste projeto LEMBRA e dá continuidade (resolve o "esquecimento entre execuções").
@@ -569,6 +629,8 @@ async function run(task, opts = {}) {
   let stopped = false;
   for (let iter = 0; iter < maxIter; iter++) {
     if (opts.shouldStop && opts.shouldStop()) { stopped = true; break; }
+    guardStopped = _guard();
+    if (guardStopped) break;
     // passa o snapshot de progresso pra a status line ao vivo (tempo é contado no cliente)
     onThinking({ iter, inTok: acc.inTok, outTok: acc.outTok, cachedTok: acc.cachedTok, steps, model: usedModel });
     await _compactIfNeeded(false); // proativo: compacta ao cruzar ~65% da janela
@@ -600,12 +662,29 @@ async function run(task, opts = {}) {
     }
     messages.push({ role: 'assistant', content: r.msg.content || '', tool_calls: tcs });
 
+    // A chamada que acabou de responder já consumiu créditos/tokens. Se ela atingiu o
+    // teto, não executamos as ferramentas propostas nem fazemos outra chamada cara.
+    guardStopped = _guard();
+    if (guardStopped) {
+      for (const tc of tcs) messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({
+        erro: 'MISSÃO INTERROMPIDA PELO LIMITE DE CUSTO/TEMPO. Nenhuma ferramenta deste lote foi executada.',
+        guard: guardStopped,
+      }) });
+      break;
+    }
+
     for (const tc of tcs) {
       const name = (tc.function && tc.function.name) || '';
       let input = {}; try { input = JSON.parse((tc.function && tc.function.arguments) || '{}'); } catch (_) {}
       let result;
+      let _cachedContent = '';
       let _ran = false; // true só quando uma ferramenta REALMENTE executou (não gate/bloqueio) → status ✓/✗
 
+      guardStopped = _guard();
+      if (guardStopped) {
+        result = { erro: 'MISSÃO INTERROMPIDA PELO LIMITE DE CUSTO/TEMPO. Esta ferramenta não foi executada.', guard: guardStopped };
+      }
+
       // ── WATCHDOG anti-loop: mede repetição ANTES de qualquer gate/execução ──
       const _sig = loopSig(name, input);
       _recentSigs.push(_sig); if (_recentSigs.length > 8) _recentSigs.shift();
@@ -722,6 +801,24 @@ async function run(task, opts = {}) {
       // Dispositivos físicos: parear/conectar/instalar/iniciar/capturar alteram o
       // aparelho ou coletam sua tela. Passam por consentimento explícito sem
       // transformar IP/código/caminho em comando shell.
+      // Nuvem pessoal: cada alteração exige consentimento específico. Nem --yes nem
+      // "aprovar tudo" silenciam este gate.
+      if (result === undefined && CLOUD_MUTATING.has(name)) {
+        const payload = JSON.stringify(input || {});
+        const provider = name.includes('outlook') || name.includes('microsoft365') ? 'MICROSOFT 365' : 'GOOGLE WORKSPACE';
+        const label = `${provider} → ${name}: ${payload.length > 1500 ? payload.slice(0, 1500) + ` …(+${payload.length - 1500} chars)` : payload}`;
+        let approved = false, remoteTried = false;
+        if (!yes) {
+          const dec = await askApprove({ kind: 'cloud_mutation', cmd: label, warning: name.includes('enviar_') ? 'O e-mail será enviado ao destinatário.' : `Dados da conta ${provider} serão alterados.` });
+          approved = decideApproval({ autoAll: false, decision: dec }).approved;
+        } else ({ approved, remoteTried } = await _remoteApprove(label, token, onRemote));
+        if (!approved) {
+          result = { erro: yes
+            ? (remoteTried ? `RECUSADO: o dono negou ou não respondeu à alteração ${provider}.` : `RECUSADO: alteração ${provider} exige aprovação remota no modo --yes.`)
+            : `O usuário recusou a alteração na conta ${provider}. Não repita nesta sessão.` };
+          onStep({ name, detail: argsShort(name, input), blocked: true });
+        }
+      }
       if (result === undefined && DEVICE_MUTATING.has(name)) {
         const safe = name === 'android_parear'
           ? `${input.host || '?'}:${input.porta || '?'} (código oculto)`
@@ -877,6 +974,15 @@ async function run(task, opts = {}) {
         result = { resumo: sub.resumo };
         steps++; _ran = true;
       }
+      if (result === undefined && READONLY.has(name)) {
+        const _cached = _missionCache.get(name, input);
+        if (_cached) {
+          const _visible = messages.some(m => m && m.role === 'tool' && m.tool_call_id === _cached.toolCallId);
+          _cachedContent = cacheReference(_cached, name, _visible);
+          result = { cached: true, tool: name };
+          onStep({ name, detail: 'cache da missão: ' + argsShort(name, input) });
+        }
+      }
       if (result === undefined) {
         onStep({ name, detail: argsShort(name, input) });
         result = await tools.execute(name, input, { confineDir, baseDir: cwd, token, allowedTools: _allowedToolNames });
@@ -887,6 +993,16 @@ async function run(task, opts = {}) {
         const _tr = core.classifyToolResult(result);
         if (!_tr.ok && _tr.status !== 'blocked') {
           _toolErrs.push({ tool: name, class: _tr.errorClass, retryable: _tr.retryable, evidence: _tr.evidence });
+          const _failureKey = failureFingerprint(name, _tr, result);
+          const _equivalentFailures = (_failureCounts.get(_failureKey) || 0) + 1;
+          _failureCounts.set(_failureKey, _equivalentFailures);
+          const _failureGuard = _guard(_equivalentFailures);
+          if (_failureGuard && _failureGuard.kind === 'equivalent_failures') {
+            guardStopped = Object.assign({}, _failureGuard, { tool: name, evidence: String(_tr.evidence || '').slice(0, 240) });
+            result = Object.assign({}, result, {
+              _guard: `A mesma falha operacional ocorreu ${_equivalentFailures} vezes. O agente foi interrompido para não gastar tentando variações sem prova de progresso.`,
+            });
+          }
           // LEDGER DE ERROS (Evolve 3): registro determinístico, zero IA.
           try { require('./memoria').logErro(confineDir || cwd, name, String(result.erro || result.stderr || ('exit ' + result.codigo))); } catch (_) {}
           // RECOVERY ENGINE: erro de classe CONHECIDA → injeta a estratégia de conserto no
@@ -901,7 +1017,7 @@ async function run(task, opts = {}) {
         if (result && result._setCwd) { cwd = result._setCwd; delete result._setCwd; }
         // registra a ação se deu certo (arquivo escrito / comando com código 0)
         if (!result.erro) {
-          if ((name === 'escrever_arquivo' || name === 'editar_arquivo') && result.ok) {
+          if (['escrever_arquivo', 'editar_arquivo', 'editar_documento', 'editar_planilha'].includes(name) && result.ok) {
             actions.push({ name, target: result.caminho });
             // CHECKPOINT da sessão: anota o que mudou e onde está o backup (que o _snapshot
             // já criou). É o que permite "desfaz tudo o que o agente fez", em vez de só um
@@ -919,6 +1035,12 @@ async function run(task, opts = {}) {
         if (result && (result._backup !== undefined || result._acao !== undefined)) {
           result = Object.assign({}, result); delete result._backup; delete result._acao;
         }
+        const _cacheClass = core.classifyToolResult(result);
+        if (_cacheClass.ok && READONLY.has(name)) {
+          _missionCache.remember(name, input, { toolCallId: tc.id, content: JSON.stringify(result).slice(0, TOOL_RESULT_CAP) });
+        } else if (_cacheClass.ok && !READONLY.has(name)) {
+          _missionCache.invalidate();
+        }
       }
       // AVISO SUAVE de convergência: a partir de 2/3 do teto de pesquisa, empurra o modelo a
       // concluir (o limite DURO acima corta de vez; este só sinaliza antes, sem bloquear).
@@ -938,15 +1060,24 @@ async function run(task, opts = {}) {
         _logEp('human');
         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 } };
       }
-      messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(result).slice(0, TOOL_RESULT_CAP) });
+      messages.push({ role: 'tool', tool_call_id: tc.id, content: _cachedContent || JSON.stringify(result).slice(0, TOOL_RESULT_CAP) });
+      if (guardStopped) break;
     }
-    if (loopedOut) break; // watchdog cortou → vai pro fechamento honesto garantido
+    if (loopedOut || guardStopped) break; // watchdog/trava de orçamento cortou → fechamento determinístico
 
   }
 
   // CANCELADO cooperativamente: não faz a chamada de fechamento (não gastar mais IA);
   // devolve um texto curto e o que já rolou.
   if (stopped && !finalText) finalText = lang !== 'en' ? '(execução cancelada)' : '(run cancelled)';
+  if (guardStopped && !finalText) {
+    const labels = lang !== 'en'
+      ? { credits: 'o teto de créditos', tokens: 'o teto de tokens', time: 'o tempo máximo', equivalent_failures: 'a mesma falha repetida' }
+      : { credits: 'the credit cap', tokens: 'the token cap', time: 'the time limit', equivalent_failures: 'the same repeated failure' };
+    finalText = lang !== 'en'
+      ? `Interrompi esta missão porque ela atingiu ${labels[guardStopped.kind] || 'o limite de segurança'}. Foram executados ${steps} passo(s) e consumidos ${charged + _visionCredits} crédito(s). O que já foi concluído permanece válido; a etapa que falhou não foi declarada como pronta. Revise o último erro antes de continuar ou aumente o orçamento explicitamente.`
+      : `I stopped this mission because it reached ${labels[guardStopped.kind] || 'the safety limit'}. ${steps} step(s) ran and ${charged + _visionCredits} credit(s) were consumed. Completed work remains valid; the failed step was not reported as done. Review the last error before continuing or explicitly raise the budget.`;
+  }
   // FECHAMENTO GARANTIDO: o loop NUNCA termina em silêncio. Se saiu sem texto
   // (esgotou MAX_ITER ainda chamando ferramentas, ou o modelo devolveu vazio),
   // faz UMA chamada final SEM ferramentas pedindo um resumo honesto ao usuário.
@@ -974,7 +1105,7 @@ async function run(task, opts = {}) {
   }
 
   if (_hooks._any) { try { _hooksMod.run(_hooks, 'Stop', { cwd, text: finalText, steps }); } catch (_) {} }
-  _logEp(stopped ? 'cancel' : (loopedOut ? 'stuck' : 'done'));
+  _logEp(stopped ? 'cancel' : ((loopedOut || guardStopped) ? 'stuck' : 'done'));
   await _bill();
   // toolErrors: erros de ferramenta que NÃO foram seguidos de uma ação bem-sucedida da MESMA
   // ferramenta depois (heurística leve de "não-recuperado") — sinal duro pro meta não marcar done falso.
@@ -1000,12 +1131,12 @@ async function run(task, opts = {}) {
     const _handoff = {
       workstreamId: _workstreamId,
       goal: taskText,
-      status: stopped ? 'paused' : (loopedOut ? 'blocked' : 'done'),
-      changedFiles: actions.filter(a => a.name === 'escrever_arquivo' || a.name === 'editar_arquivo').map(a => a.target),
+      status: stopped ? 'paused' : ((loopedOut || guardStopped) ? 'blocked' : 'done'),
+      changedFiles: actions.filter(a => ['escrever_arquivo', 'editar_arquivo', 'editar_documento', 'editar_planilha'].includes(a.name)).map(a => a.target),
       evidence: actions.map(a => `${a.name}: ${a.target}`),
       failedApproaches: _toolErrs.map(e => `${e.tool || 'tool'}: ${e.errorClass || e.message || 'failed'}`),
-      nextActions: loopedOut ? ['Retomar com outra abordagem; a execução anterior entrou em repetição.'] : [],
-      budget: { currency: 'credits', spent: charged + _visionCredits, remaining: null },
+      nextActions: (loopedOut || guardStopped) ? ['Revisar o último erro e retomar com outra abordagem ou orçamento explícito.'] : [],
+      budget: { currency: 'credits', spent: charged + _visionCredits, limit: maxCredits, remaining: Math.max(0, maxCredits - charged - _visionCredits), stoppedBy: guardStopped && guardStopped.kind },
     };
     const _actionExpected = /\b(cri|fa[cç]|implemente|corrija|edite|altere|instale|execute|rode|deploy|publique|remova|apague|delete|escreva|salve)\w*/i.test(taskText);
     const _syncTasks = [
@@ -1021,8 +1152,8 @@ async function run(task, opts = {}) {
           model: usedModel,
           taskKind: /\b(c[oó]digo|code|bug|teste|test|node|javascript|typescript|python|html|css|api|arquivo|projeto)\b/i.test(taskText) ? 'code' : 'general',
           usedTools: steps > 0,
-          success: !stopped && !loopedOut,
-          falseDone: !stopped && !loopedOut && _actionExpected && actions.length === 0,
+          success: !stopped && !loopedOut && !guardStopped,
+          falseDone: !stopped && !loopedOut && !guardStopped && _actionExpected && actions.length === 0,
           protocolError: _toolErrs.some(e => e.class === 'invalid_schema'),
           usage: { input_tokens: acc.inTok, output_tokens: acc.outTok, cached_tokens: acc.cachedTok },
           source: 'cli',
@@ -1030,7 +1161,7 @@ async function run(task, opts = {}) {
       }));
     await Promise.all(_syncTasks);
   } catch (_) {}
-  return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, toolErrors: _toolErrs, lastToolError: _lastErr };
+  return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, toolErrors: _toolErrs, lastToolError: _lastErr, guard: guardStopped };
 }
 
-module.exports = { run, llm, _test: { winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval } };
+module.exports = { run, llm, _test: { winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, validarModeloByok } };

package/lib/doctor.js

@@ -12,10 +12,16 @@ const { execFileSync } = require('child_process');
 // ── helpers PUROS (testáveis) ────────────────────────────────────────────────
 function _nodeMajor(v) { const m = String(v || '').replace(/^v/, '').split('.'); return Number(m[0]) || 0; }
 function _nodeOk(v) { return _nodeMajor(v) >= 18; }
-// estado de autenticação a partir do config carregado
-function _authLevel(cfg) {
+// Estado de autenticação. O plano vem do SERVIDOR quando disponível: o valor em ~/.ts é
+// só o que estava valendo no login, e continua lá depois de assinar, trocar ou cancelar
+// um plano — o diagnóstico exibia "ultra" para uma conta que o servidor já tratava como
+// "pro". Sem rede, o valor guardado ainda é melhor que nada, mas fica marcado como tal.
+function _authLevel(cfg, planoDoServidor) {
   if (!cfg || !cfg.token) return { level: 'fail', detail: 'não logado', dica: 'rode: ts login' };
-  return { level: 'ok', detail: 'logado' + (cfg.username ? ' como ' + cfg.username : '') + (cfg.plan ? ' · plano ' + cfg.plan : '') };
+  const plano = planoDoServidor || cfg.plan;
+  const local = !planoDoServidor && cfg.plan;
+  return { level: 'ok', detail: 'logado' + (cfg.username ? ' como ' + cfg.username : '')
+    + (plano ? ' · plano ' + plano + (local ? ' (do último login)' : '') : '') };
 }
 // compara versão instalada × última do npm → ok / warn (desatualizado)
 function _versionLevel(current, latest) {
@@ -55,7 +61,9 @@ async function run(opts = {}) {
   results.push({ nome: 'Node.js', level: _nodeOk(nv) ? 'ok' : 'fail', detail: nv + (_nodeOk(nv) ? '' : ' (precisa 18+)'), dica: _nodeOk(nv) ? undefined : 'instale Node 18 ou superior' });
 
   // 2) config ~/.ts + login
-  const auth = _authLevel(cfg); results.push(Object.assign({ nome: 'Login' }, auth));
+  let planoDoServidor = null;
+  if (typeof opts.planoAtual === 'function') { try { planoDoServidor = await opts.planoAtual(); } catch (_) {} }
+  const auth = _authLevel(cfg, planoDoServidor); results.push(Object.assign({ nome: 'Login' }, auth));
   const dir = path.join(os.homedir(), '.ts');
   results.push({ nome: 'Config (~/.ts)', level: fs.existsSync(dir) ? 'ok' : 'warn', detail: fs.existsSync(dir) ? dir : 'ainda não criado (normal se nunca rodou nada)' });
 

package/lib/i18n.js

@@ -75,7 +75,10 @@ const STR = {
         ['ts login · ts logout', 'conecta / desconecta este terminal'],
         ['ts uso', 'créditos e consumo do mês'],
         ['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 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)'],
         ['ts idioma pt|en', 'idioma (padrão pt-BR)'],
       ] },
@@ -240,6 +243,9 @@ const STR = {
         ['ts login · ts logout', 'connect / disconnect this terminal'],
         ['ts uso', 'monthly credits and usage'],
         ['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 privacy', 'shows the Privacy Policy address'],
         ['ts tema', 'terminal palette (7 themes; color means STATE)'],
         ['ts idioma pt|en', 'language (default pt-BR)'],
       ] },