terminal-smart-cli 0.98.1 → 0.99.0

package/lib/chat-local.js

@@ -0,0 +1,139 @@
+// lib/chat-local.js — o `ts chat` rodando no PC do usuário, com a IA DELE.
+//
+// Ordem de escolha da IA (sem a IA da casa como reserva no chat):
+//   1) modo da conta escolhido em `ts ia usar` (chatgpt/claude/paralelo) → a CLI oficial
+//      logada neste PC (lib/ia-local); no paralelo, a preferida é o ChatGPT/Codex e o Claude
+//      entra se ela falhar;
+//   2) senão, a chave própria ativa (`ts conectar`, inclusive Ollama local) — chamada
+//      OpenAI-compatível, a mesma do agente;
+//   3) senão, erro amigável dizendo como configurar.
+//
+// O histórico da conversa fica SÓ neste PC: um arquivo por pasta de trabalho (escopo
+// `chat:<hash>`) em ~/.ts/chat/, com as últimas N mensagens e permissão 0600.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const LIMITE_MENSAGENS = 20;   // 10 trocas
+const LIMITE_CONTEUDO = 12000; // por mensagem guardada (transcrição de vídeo, pipe grande…)
+
+function sistemaChat(lang) {
+  return lang === 'en'
+    ? 'You are Terminal Smart, a DevOps assistant in the user\'s terminal. Answer in plain text (Markdown is fine), directly, in the user\'s language. In this conversation you do not run commands or change files: when something needs action on the machine, suggest the command or tell the user to use `ts agente "..."`.'
+    : 'Você é o Terminal Smart, assistente DevOps no terminal do usuário. Responda em texto (Markdown é permitido), de forma direta, no idioma do usuário. Nesta conversa você não executa comandos nem altera arquivos: quando algo exigir ação na máquina, sugira o comando ou diga para usar `ts agente "..."`.';
+}
+
+function nomeArquivo(escopo) {
+  return String(escopo || 'chat').replace(/[^a-z0-9_-]+/gi, '-').slice(0, 80) + '.json';
+}
+
+function criarChatLocal(opcoes = {}) {
+  const dir = opcoes.dir || path.join(path.dirname(require('./config').FILE), 'chat');
+  const limite = Math.max(2, Number(opcoes.limite) || LIMITE_MENSAGENS);
+  const iaLocal = opcoes.iaLocal || require('./ia-local');
+  const keyring = opcoes.keyring || require('./keyring');
+  const providers = opcoes.providers || require('./providers');
+  const llm = opcoes.llm || ((args) => require('./agent').llm(args));
+
+  const arquivo = (escopo) => path.join(dir, nomeArquivo(escopo));
+
+  function carregar(escopo) {
+    try {
+      const j = JSON.parse(fs.readFileSync(arquivo(escopo), 'utf8'));
+      const msgs = Array.isArray(j && j.mensagens) ? j.mensagens : [];
+      return msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant') && typeof m.content === 'string').slice(-limite);
+    } catch (_) { return []; }
+  }
+
+  function salvar(escopo, mensagens) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const alvo = arquivo(escopo);
+    const tmp = alvo + '.tmp-' + process.pid;
+    const dados = { escopo, atualizadoEm: new Date().toISOString(), mensagens: mensagens.slice(-limite) };
+    fs.writeFileSync(tmp, JSON.stringify(dados, null, 2), { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmp, alvo);
+    try { fs.chmodSync(alvo, 0o600); } catch (_) { /* Windows: sem chmod */ }
+  }
+
+  function limpar(escopo) {
+    try { fs.unlinkSync(arquivo(escopo)); return true; }
+    catch (e) { if (e && e.code === 'ENOENT') return false; throw e; }
+  }
+
+  // Qual IA responde: { tipo:'conta', modo } | { tipo:'chave', chave } | null.
+  function escolherFonte(modo) {
+    if (modo && modo !== 'automatico' && iaLocal.MODOS.includes(modo)) return { tipo: 'conta', modo };
+    const a = keyring.ativo();
+    if (a && (a.key || (providers.info(a.id) || {}).semChave)) return { tipo: 'chave', chave: a };
+    return null;
+  }
+
+  function semIa(lang) {
+    const e = new Error(lang === 'en'
+      ? 'No AI configured for the chat on this PC. Use your key with `ts conectar <provider>` (or local Ollama: `ts conectar ollama`) or your account with `ts ia usar claude|chatgpt` (Claude Code or Codex logged in on this PC).'
+      : 'Nenhuma IA configurada para o chat neste PC. Use sua chave com `ts conectar <provedor>` (ou o Ollama local: `ts conectar ollama`) ou sua conta com `ts ia usar claude|chatgpt` (Claude Code ou Codex logado neste PC).');
+    e.code = 'sem_ia_local';
+    return e;
+  }
+
+  // Histórico + mensagem nova num prompt só (as CLIs rodam um turno por execução).
+  function montarPrompt(historico, conteudo, lang) {
+    const en = lang === 'en';
+    const linhas = historico.map(m => `${m.role === 'user' ? (en ? 'USER' : 'USUÁRIO') : (en ? 'ASSISTANT' : 'ASSISTENTE')}:\n${m.content}`);
+    return [
+      linhas.length ? (en ? 'CONVERSATION SO FAR (oldest first):\n\n' : 'CONVERSA ATÉ AQUI (mais antiga primeiro):\n\n') + linhas.join('\n\n') : '',
+      (en ? 'NEW USER MESSAGE:\n' : 'NOVA MENSAGEM DO USUÁRIO:\n') + conteudo,
+    ].filter(Boolean).join('\n\n---\n\n');
+  }
+
+  async function viaConta(modo, prompt, lang, timeoutMs) {
+    const st = await iaLocal.status();
+    const ordem = modo === 'paralelo' ? ['chatgpt', 'claude'] : [modo];
+    const prontas = ordem.filter(p => iaLocal.pronto(p, st));
+    if (!prontas.length) {
+      const e = new Error(`${lang === 'en' ? 'mode' : 'modo'} ${modo}: ${iaLocal.faltando(modo === 'paralelo' ? 'paralelo' : modo, st)}. ` + (lang === 'en'
+        ? `Log in with \`ts ia conectar ${modo === 'paralelo' ? 'chatgpt|claude' : modo}\` or switch with \`ts ia usar automatico\` (then your key from \`ts conectar\` is used).`
+        : `Faça o login com \`ts ia conectar ${modo === 'paralelo' ? 'chatgpt|claude' : modo}\` ou troque com \`ts ia usar automatico\` (aí vale a sua chave do \`ts conectar\`).`));
+      e.code = 'ia_local_indisponivel';
+      throw e;
+    }
+    let ultimoErro = null;
+    for (const prov of prontas) {
+      try { return await iaLocal.executar(prov, prompt, { sistema: sistemaChat(lang), timeoutMs }); }
+      catch (e) { ultimoErro = e; }
+    }
+    throw ultimoErro;
+  }
+
+  async function viaChave(chave, historico, conteudo, lang, timeoutMs) {
+    const modelo = chave.modelo || (providers.info(chave.id) || {}).modeloPadrao || null;
+    const r = await llm({
+      baseUrl: chave.baseUrl || providers.baseUrlDe(chave.id), key: chave.key || 'local', model: modelo,
+      messages: [{ role: 'system', content: sistemaChat(lang) }, ...historico, { role: 'user', content: conteudo }],
+      noTools: true, signalMs: timeoutMs, tries: 2,
+    });
+    const texto = String((r && r.msg && r.msg.content) || '').replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+    if (!texto) throw new Error(lang === 'en' ? 'your provider returned an empty answer.' : 'o seu provedor devolveu uma resposta vazia.');
+    return { provedor: chave.id, texto, uso: (r && r.usage) || {}, modelo: (r && r.model) || modelo || '' };
+  }
+
+  // Responde e grava a troca no histórico local do escopo.
+  async function responder({ escopo, conteudo, modo = 'automatico', lang = 'pt', timeoutMs = 180000 } = {}) {
+    const pergunta = String(conteudo || '').trim();
+    if (!pergunta) throw new Error(lang === 'en' ? 'empty message.' : 'mensagem vazia.');
+    const fonte = escolherFonte(modo);
+    if (!fonte) throw semIa(lang);
+    const historico = carregar(escopo);
+    const r = fonte.tipo === 'conta'
+      ? await viaConta(fonte.modo, montarPrompt(historico, pergunta, lang), lang, timeoutMs)
+      : await viaChave(fonte.chave, historico, pergunta, lang, timeoutMs);
+    salvar(escopo, [...historico,
+      { role: 'user', content: pergunta.slice(0, LIMITE_CONTEUDO) },
+      { role: 'assistant', content: String(r.texto).slice(0, LIMITE_CONTEUDO) }]);
+    return { texto: r.texto, fonte: fonte.tipo, provedor: r.provedor, modelo: r.modelo, uso: r.uso };
+  }
+
+  return { responder, carregar, salvar, limpar, escolherFonte, montarPrompt, arquivo, dir };
+}
+
+module.exports = { criarChatLocal, sistemaChat, LIMITE_MENSAGENS };

package/lib/core.js

@@ -111,10 +111,107 @@ function winFor(model) {
 // heurística chars/4 — suficiente pra decidir QUANDO compactar
 const estMsgsTok = (msgs) => msgs.reduce((n, m) => n + Math.ceil(((typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')).length + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0)) / 4), 0);
 
+// ── 2b) RESUMO FIXO e CORTE SEGURO do histórico ──────────────────────────────
+// Depois de compactar, o histórico vira [system, RESUMO, ...rabo]. O resumo é a única
+// memória da parte antiga: se um corte posterior (sessão salva, --continuar, prompt do
+// modo pessoal) o descartar, o agente perde o objetivo e o que já fez. Ele vai marcado
+// com _tsPinned (o llm() tira o campo antes de enviar) e com um rótulo fixo — o rótulo
+// é o que sobrevive em sessões antigas, gravadas antes da marca existir.
+const SUMMARY_LABEL = {
+  pt: 'RESUMO DA CONVERSA ATÉ AQUI (contexto antigo, condensado automaticamente):\n',
+  en: 'CONVERSATION SUMMARY SO FAR (older context, auto-condensed):\n',
+};
+const SUMMARY_RE = /^(?:RESUMO DA CONVERSA ATÉ AQUI|CONVERSATION SUMMARY SO FAR)\b[^\n]*\n?/;
+function isPinnedSummary(m) {
+  if (!m || typeof m !== 'object') return false;
+  if (m._tsPinned === true) return true;
+  return m.role === 'user' && typeof m.content === 'string' && SUMMARY_RE.test(m.content);
+}
+// texto do resumo sem o rótulo (pra recompactar ou montar a seção própria do modo pessoal)
+function pinnedSummaryText(m) {
+  if (!isPinnedSummary(m)) return '';
+  return String(m.content || '').replace(SUMMARY_RE, '').trim();
+}
+// A TAREFA desta execução também é fixa (_tsTask, o llm() tira o campo antes de enviar):
+// depois de compactar, o pedido original iria só para dentro do resumo e o rabo costuma ter
+// apenas assistant/tool — o modelo (sobretudo o pessoal, que vê 8 mensagens) perdia a missão.
+function isPinnedTask(m) {
+  return !!(m && typeof m === 'object' && m._tsTask === true);
+}
+// Últimas `n` mensagens SEM perder as fixas (o último resumo e a última tarefa marcada) e
+// SEM começar numa resposta de ferramenta órfã ('tool' sem o assistant que a pediu → 400
+// no provedor). Mesma regra do corte da compactação. Cada fixa que fica fora da janela
+// ocupa uma das `n` vagas e volta na ordem original, antes do rabo.
+function safeTail(msgs, n) {
+  const list = Array.isArray(msgs) ? msgs.filter(Boolean) : [];
+  const max = Math.max(1, Math.floor(Number(n) || 1));
+  let pinS = -1, pinT = -1;
+  for (let i = list.length - 1; i >= 0 && (pinS < 0 || pinT < 0); i--) {
+    if (pinS < 0 && isPinnedSummary(list[i])) pinS = i;
+    if (pinT < 0 && isPinnedTask(list[i])) pinT = i;
+  }
+  const pins = [pinS, pinT].filter(i => i >= 0).sort((a, b) => a - b);
+  let start = Math.max(0, list.length - max);
+  for (let round = 0; round < 3; round++) { // no máximo 2 fixas → estabiliza em poucas voltas
+    const next = Math.max(0, list.length - Math.max(1, max - pins.filter(i => i < start).length));
+    if (next === start) break;
+    start = next;
+  }
+  while (start < list.length && list[start].role === 'tool') start++;
+  return [...pins.filter(i => i < start).map(i => list[i]), ...list.slice(start)];
+}
+
+// ── 2c) MEDIDOR DE CONTEXTO ───────────────────────────────────────────────────
+// A conta é sobre o limite ÚTIL (janela menos a reserva da resposta), não sobre a janela
+// cheia: um prompt que ocupa a janela inteira não deixa espaço pro modelo responder.
+const CTX_OUTPUT_RESERVE = 8000;
+function usableWindow(window) {
+  const w = Math.max(1, Number(window) || CTX_WINDOW_DEFAULT);
+  return Math.max(Math.floor(w * 0.75), w - CTX_OUTPUT_RESERVE);
+}
+// ctx = { used, window, usable?, measured? } → números prontos pra exibir, ou null.
+// measured=true só quando o provedor devolveu prompt_tokens da última chamada.
+function contextMeter(ctx) {
+  if (!ctx || typeof ctx !== 'object') return null;
+  const window = Number(ctx.window) || 0;
+  const used = Math.max(0, Math.round(Number(ctx.used) || 0));
+  if (!window || !used) return null;
+  const usable = Number(ctx.usable) > 0 ? Number(ctx.usable) : usableWindow(window);
+  const pct = Math.round(100 * used / usable);
+  return { used, window, usable, pct, measured: ctx.measured === true, level: pct >= 95 ? 'full' : pct >= 80 ? 'warn' : 'ok' };
+}
+function _fmtK(n) {
+  if (n >= 10000) return Math.round(n / 1000) + 'k';
+  if (n >= 1000) return (n / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
+  return String(n);
+}
+// Ao RETOMAR uma sessão (--continuar/REPL): a partir de 95% do limite útil (contando a
+// mensagem nova) pede decisão a quem está no terminal; sem pessoa na frente, compacta
+// sozinho. action: 'none' | 'ask' | 'auto'. No meio da execução vale a compactação automática.
+const CTX_DECISION_AT = 95;
+function resumeContextDecision(ctx, { extraTok = 0, interactive = false } = {}) {
+  const m = contextMeter(ctx);
+  if (!m) return { action: 'none', pct: 0, meter: null };
+  const pct = Math.round(100 * (m.used + Math.max(0, Number(extraTok) || 0)) / m.usable);
+  if (pct < CTX_DECISION_AT) return { action: 'none', pct, meter: m };
+  return { action: interactive ? 'ask' : 'auto', pct, meter: m };
+}
+// "contexto 52k/120k (43%) medido" | "contexto 52k/120k (43%) ≈estimado"
+function formatContextMeter(ctx, lang = 'pt') {
+  const m = contextMeter(ctx);
+  if (!m) return '';
+  const en = lang === 'en';
+  const seal = m.measured ? (en ? 'measured' : 'medido') : (en ? '≈estimated' : '≈estimado');
+  return `${en ? 'context' : 'contexto'} ${_fmtK(m.used)}/${_fmtK(m.usable)} (${m.pct}%) ${seal}`;
+}
+
 // ── 3) ENVELOPE DE EVENTOS (contrato interno único) ───────────────────────────
 // Formaliza os eventos que o modo headless (stream-json) já emite. Este é o CONTRATO
 // canônico: quando App (IPC ai:event) e Web (SSE) convergirem, mapeiam pra ESTAS formas.
-// Tipos: system(init) · tool(started|blocked|approval_denied|approval_remote) · assistant · result.
+// Tipos: system(init) · tool(started|blocked|retry|loop|auto_approved|approval_denied|
+// approval_remote|context_auto_compact) · assistant · result. system(init) é SEMPRE o
+// primeiro evento da execução: avisos anteriores a ele (ex.: context_auto_compact, quando a
+// sessão retomada passou de 95% do contexto útil) esperam o init e saem logo depois.
 const AgentEvents = {
   systemInit: ({ model, cwd, mode }) => ({ type: 'system', subtype: 'init', model, cwd, mode }),
   tool: ({ subtype, tool, detail, reason, command, ttl }) => {
@@ -252,37 +349,253 @@ function classifyToolResult(raw) {
 // segura. Aqui a saída de ferramenta passa por uma máscara determinística ANTES de
 // virar contexto/log. Mantém o prefixo (o agente ainda reconhece "é uma chave sk-…")
 // mas o valor não circula. Não altera o que é ENVIADO ao comando, só o que é EXIBIDO.
-const _SECRET_RES = [
-  // chaves com prefixo conhecido: sk-…, sk-cdc-…, ghp_…, xoxb-…, AKIA…, AIza…
-  [/\b((?:sk|pk|rk)-(?:[a-z0-9]+-)?)[A-Za-z0-9_-]{16,}/gi, (m, p) => p + '••••REDACTED'],
-  [/\b(gh[pousr]_)[A-Za-z0-9]{16,}/g, (m, p) => p + '••••REDACTED'],
-  [/\b(xox[baprs]-)[A-Za-z0-9-]{10,}/gi, (m, p) => p + '••••REDACTED'],
-  [/\b(AKIA)[0-9A-Z]{12,}/g, (m, p) => p + '••••REDACTED'],
-  [/\b(AIza)[A-Za-z0-9_-]{20,}/g, (m, p) => p + '••••REDACTED'],
-  // JWT (header.payload.signature)
-  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, () => 'eyJ••••REDACTED_JWT'],
-  // atribuição de env/JSON com nome sensível: API_KEY=…, "password": "…", Bearer …
-  // O mínimo era 8 e deixava passar senha CURTA — `senha=hunter2` (7) vazava inteira pro
-  // log e pro contexto do modelo. Agora 4, com uma exceção explícita para valores que são
-  // metadado e não segredo (`password: true`, `token: null`), senão o ganho viraria ruído.
-  [/((?:api[_-]?key|apikey|secret|token|password|passwd|senha|authorization|auth[_-]?token|private[_-]?key)["']?\s*[:=]\s*["']?)(?!(?:true|false|null|none|nil|undefined|yes|no|N\/A)\b)([^\s"',;&|)]{4,})/gi,
-    (m, p) => p + '••••REDACTED'],
-  [/\b(Bearer\s+)[A-Za-z0-9._~+/-]{16,}=*/g, (m, p) => p + '••••REDACTED'],
-];
+// Valor de flag/variável (exibição): entre aspas escapadas de um texto JSON (\"…\"), entre
+// aspas simples, entre aspas duplas (com escapes) ou, sem aspas, até o espaço.
+const _SECRET_VAL = String.raw`(\\"(?:[^"\\]|\\.)*?\\"|'[^']*'|"(?:[^"\\]|\\.)*"|(?:[^\s'"\\]|\\(?!"))+)`;
+// Variante da APROVAÇÃO REMOTA: o valor mascarado nunca contém a outra aspa, barra invertida,
+// quebra de linha nem metacaractere do shell (; & | $ ` < > ( )). O regex não acompanha o
+// estado de aspas do shell; se a senha tiver um desses caracteres, ela aparece para quem
+// aprova — melhor do que esconder um pedaço que o shell executa.
+const _SECRET_VAL_SAFE = String.raw`('[^'"\\\n;&|$\x60<>()]*'|"[^"'\\\n;&|$\x60<>()]*"|[^\s'"\\;&|$\x60<>()]+)`;
+const _MASK = '••••REDACTED';
+// troca só o valor e mantém as aspas: a estrutura do comando/JSON continua legível
+function _maskVal(v) {
+  if (v.startsWith('\\"')) return '\\"' + _MASK + '\\"';
+  if (v[0] === "'" || v[0] === '"') return v[0] + _MASK + v[0];
+  return _MASK;
+}
+// cliente MySQL/MariaDB como COMANDO: o nome seguido de espaço, depois de espaço, ; | & ( ` ou
+// aspas, com sudo opcional e caminho opcional (/usr/bin/mysql, "C:\…\bin\mysql.exe"). O nome
+// dentro de caminho (/var/lib/mysql:/x) ou de imagem (mysql:8) não conta, e `-p` com
+// mapeamento de porta (`-p3306:3306`) passa. Também não conta o nome que é VALOR de flag
+// (`docker run --name mysql -p3306 mysql:8`, `-v /srv/mysql`, `sudo -u mysql`) ou o host de
+// ssh/nc/telnet (`ssh mysql -p2222`): aí o `-p` é porta. Até 4 espaços entre a flag e o nome —
+// o lookbehind roda em toda posição e não pode varrer uma sequência longa de espaços.
+const _NOT_CLIENT_AFTER = '--name|--hostname|-h|--network|--net|--network-alias|--link|--pod|-n|--namespace|-u|--user|-g|--group|-v|--volume|--volumes-from|--tmpfs|-w|--workdir|-l|--label|ssh|nmap|nc|ncat|telnet';
+const _MYSQL_CLIENT = String.raw`(?<=^|[\s;|&(\x60"'])(?<!(?:^|[\s;|&(\x60"'])(?:${_NOT_CLIENT_AFTER})\s{1,4}["']?)((?:sudo\s+)?(?:[^\s;|&(\x60"'<>]*[\\\/])?(?:mysql|mariadb|mysqldump|mysqladmin|mariadb-dump|mysqlimport|mysqlcheck|mysqlshow)(?:\.exe)?["']?(?=\s)[^\n;|&]*?\s-p)(?!\s)(?![\d.]+(?::[\d.]+)+(?:\/(?:tcp|udp))?(?:\s|$))`;
+function _secretRules(safe) {
+  const VAL = safe ? _SECRET_VAL_SAFE : _SECRET_VAL;
+  const flag = (m, p, v) => p + _maskVal(v);
+  return [
+    ...(safe ? [
+      // APROVAÇÃO: só o corpo base64 (linhas reais ou \n literal de JSON) até o END; sem END,
+      // só a sequência base64 colada ao cabeçalho. Espaço ou metacaractere encerram o corpo.
+      [/(-----BEGIN ([A-Z0-9 ]*)PRIVATE KEY-----)(?:\r?\n|\\[rn])*[A-Za-z0-9+/=]+(?:(?:\r?\n|\\[rn])+[A-Za-z0-9+/=]+)*(?:\r?\n|\\[rn])*(-----END \2PRIVATE KEY-----)/g,
+        (m, b, t, e) => `${b} ${_MASK} ${e}`],
+      [/(-----BEGIN ([A-Z0-9 ]*)PRIVATE KEY-----)(?:\r?\n|\\[rn])*[A-Za-z0-9+/=]{16,}(?:(?:\r?\n|\\[rn])+[A-Za-z0-9+/=]+)*/g,
+        (m, b) => `${b} ${_MASK}`],
+    ] : [
+      // bloco de chave privada (PEM/OpenSSH) inteiro — vem antes das regras de token,
+      // que mascarariam só pedaços do base64. Sem END (saída cortada): mascara até o fim.
+      [/-----BEGIN ([A-Z0-9 ]*)PRIVATE KEY-----[\s\S]*?(?:-----END \1PRIVATE KEY-----|$)/g,
+        (m, t) => `-----BEGIN ${t}PRIVATE KEY----- ${_MASK} -----END ${t}PRIVATE KEY-----`],
+    ]),
+    // senha COLADA na flag do cliente MySQL/MariaDB: `mysql -uroot -pSEGREDO`. Só nesses
+    // comandos — `-p` é porta/pasta em ssh, docker, mkdir. `-p` sozinho (pede a senha) passa.
+    [new RegExp(_MYSQL_CLIENT + VAL, 'g'), flag],
+    // sshpass -p SEGREDO ssh … (com ou sem espaço; outras flags antes do -p)
+    [new RegExp(String.raw`(\bsshpass\s+(?:-[a-oq-zA-Z]\S*\s+)*-p\s*)` + VAL, 'g'), flag],
+    // --password=x / --password x (a regra genérica abaixo não pega o espaço nem senha curta)
+    [new RegExp(String.raw`(--pass(?:word|wd)?(?:=|\s+))(?!-)` + VAL, 'gi'), flag],
+    // variáveis de ambiente que SÃO a senha: PGPASSWORD=x psql …, MYSQL_PWD, SSHPASS
+    [new RegExp(String.raw`\b((?:PGPASSWORD|MYSQL_PWD|SSHPASS)\s*=\s*)` + VAL, 'g'), flag],
+    // chave "pass" em JSON/objeto (perfil SSH do ts: { "vps": { "pass": "…" } }). Uma regra por
+    // aspa de abertura: entre aspas duplas vale o escape do JSON (apóstrofo no meio não encerra);
+    // entre aspas simples não há escape, como no shell.
+    [safe ? /((?<![\w-])["']?pass["']?\s*:\s*")([^"'\\\n;&|$\x60<>()]+)(?=")/gi
+      : /((?<![\w-])["']?pass["']?\s*:\s*")((?:[^"\\\n]|\\.)+)(?=")/gi, (m, p) => p + _MASK],
+    [safe ? /((?<![\w-])["']?pass["']?\s*:\s*')([^'"\\\n;&|$\x60<>()]+)(?=')/gi
+      : /((?<![\w-])["']?pass["']?\s*:\s*')([^'\n]+)(?=')/gi, (m, p) => p + _MASK],
+    // usuário:senha do curl (-u / --user): a senha some, o usuário fica. Só no curl — em
+    // `docker run -u 1000:1000` o par é uid:gid. Entre aspas, o valor vai até a aspa.
+    [safe ? /(\bcurl(?:\.exe)?\b[^\n|;&]*?\s(?:-u|--user(?![\w-]))(?:\s*|=)(["'])[^\s:"'@]*:)([^"'\\\n;&|$\x60<>()]+)(?=\2)/gi
+      : /(\bcurl(?:\.exe)?\b[^\n|;&]*?\s(?:-u|--user(?![\w-]))(?:\s*|=)(["'])[^\s:"'@]*:)([^"'\n]+)(?=\2)/gi, (m, p) => p + _MASK],
+    [safe ? /(\bcurl(?:\.exe)?\b[^\n|;&]*?\s(?:-u|--user(?![\w-]))(?:\s*|=)(?!["'])[^\s:"'@]*:)([^\s"'\\;&|$\x60<>()]+)/gi
+      : /(\bcurl(?:\.exe)?\b[^\n|;&]*?\s(?:-u|--user(?![\w-]))(?:\s*|=)(?!["'])[^\s:"'@]*:)([^\s"']+)/gi, (m, p) => p + _MASK],
+    // campo "key" de JSON com valor de cara de chave (providers.json: "key": "<valor sem
+    // prefixo>"): 16+ caracteres, sem espaço, com letra e dígito — "key": "app.kubernetes.io/name"
+    // e chaves curtas de dicionário (PROJ-123) continuam legíveis.
+    [/((?<![\w-])["']key["']\s*:\s*["'])(?=[A-Za-z0-9._~+\/=-]*\d)(?=[A-Za-z0-9._~+\/=-]*[A-Za-z])[A-Za-z0-9._~+\/=-]{16,}(?=["'])/gi, (m, p) => p + _MASK],
+    // chaves com prefixo conhecido: sk-…, sk-cdc-…, ghp_…, xoxb-…, AKIA…, AIza…
+    [/\b((?:sk|pk|rk)-(?:[a-z0-9]+-)?)[A-Za-z0-9_-]{16,}/gi, (m, p) => p + _MASK],
+    // NVIDIA (nvapi-), Groq (gsk_), Cerebras (csk-), xAI (xai-), Perplexity (pplx-): com dígito
+    // no corpo, para não pegar nome de pacote ou de função
+    [/\b(nvapi-|gsk_|csk-|xai-|pplx-)(?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{16,}/g, (m, p) => p + _MASK],
+    [/\b(gh[pousr]_)[A-Za-z0-9]{16,}/g, (m, p) => p + _MASK],
+    [/\b(xox[baprs]-)[A-Za-z0-9-]{10,}/gi, (m, p) => p + _MASK],
+    [/\b(AKIA)[0-9A-Z]{12,}/g, (m, p) => p + _MASK],
+    [/\b(AIza)[A-Za-z0-9_-]{20,}/g, (m, p) => p + _MASK],
+    // JWT (header.payload.signature)
+    [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, () => 'eyJ••••REDACTED_JWT'],
+    // atribuição de env/JSON com nome sensível: API_KEY=…, "password": "…", Bearer …
+    // O mínimo era 8 e deixava passar senha CURTA — `senha=hunter2` (7) vazava inteira pro
+    // log e pro contexto do modelo. Agora 4, com uma exceção explícita para valores que são
+    // metadado e não segredo (`password: true`, `token: null`), senão o ganho viraria ruído.
+    // O esquema de autenticação (`Authorization: Bearer <token>`, Basic, Token) fica no
+    // prefixo: antes a regra mascarava a PALAVRA "Bearer" e deixava o token inteiro à mostra.
+    [safe
+      ? /((?:api[_-]?key|apikey|secret|token|password|passwd|senha|authorization|auth[_-]?token|private[_-]?key)["']?\s*[:=]\s*["']?(?:(?:Bearer|Basic|Token|Digest|Bot)\s+)?)(?!(?:true|false|null|none|nil|undefined|yes|no|N\/A)\b)([^\s"',;&|)($\x60<>\\]{4,})/gi
+      : /((?:api[_-]?key|apikey|secret|token|password|passwd|senha|authorization|auth[_-]?token|private[_-]?key)["']?\s*[:=]\s*["']?(?:(?:Bearer|Basic|Token|Digest|Bot)\s+)?)(?!(?:true|false|null|none|nil|undefined|yes|no|N\/A)\b)([^\s"',;&|)]{4,})/gi,
+    (m, p) => p + _MASK],
+    [/\b(Bearer\s+)[A-Za-z0-9._~+/-]{16,}=*/g, (m, p) => p + _MASK],
+  ];
+}
+const _SECRET_RES = _secretRules(false);
+const _SECRET_RES_APPROVAL = _secretRules(true);
+const _applySecretRules = (rules, s) => rules.reduce((acc, [re, fn]) => acc.replace(re, fn), s);
+
+// Objeto: máscara FOLHA A FOLHA. O caminho antigo (stringify → regras → parse) devolvia o
+// objeto ORIGINAL, sem máscara nenhuma, quando uma troca quebrava o JSON. Campo com nome de
+// segredo (pass, password, token, api_key…) tem o valor inteiro mascarado; as demais strings
+// passam pelas regras de texto.
+const _SECRET_KEY_RE = /(?:^pass|api[_-]?key|apikey|secret|token|password|passwd|senha|authorization|auth[_-]?token|private[_-]?key)$/i;
+const _META_VAL_RE = /^(?:true|false|null|none|nil|undefined|yes|no|N\/A)$/i;
+// Campo chamado só "key" (providers.json guarda a chave assim): mascara quando o valor tem
+// cara de chave — 16+ caracteres sem espaço, com letra e dígito. "key" também é nome comum de
+// campo que não é segredo (chave de dicionário, id de issue), por isso o critério.
+const _TOKENISH_RE = /^(?=[^\s]*\d)(?=[^\s]*[A-Za-z])[A-Za-z0-9._~+\/=-]{16,}$/;
+function _redactDeep(v, key) {
+  const sensitive = key != null && _SECRET_KEY_RE.test(key);
+  if (typeof v === 'string') {
+    if (sensitive && (/^pass$/i.test(key) ? v.length > 0 : v.length >= 4 && !_META_VAL_RE.test(v))) return _MASK;
+    if (key != null && /^key$/i.test(key) && _TOKENISH_RE.test(v)) return _MASK;
+    return _applySecretRules(_SECRET_RES, v);
+  }
+  if (typeof v === 'number') return sensitive && String(v).length >= 4 ? _MASK : v;
+  if (Array.isArray(v)) return v.map(x => _redactDeep(x, null));
+  if (v && typeof v === 'object') {
+    const out = {};
+    for (const k of Object.keys(v)) out[k] = _redactDeep(v[k], k);
+    return out;
+  }
+  return v;
+}
 function redactSecrets(input) {
   if (input == null) return input;
   if (typeof input !== 'string') {
-    try { return JSON.parse(redactSecrets(JSON.stringify(input))); } catch (_) { return input; }
+    // cópia JSON (Date vira texto, função some), como antes; objeto circular segue intacto
+    let plain;
+    try { plain = JSON.parse(JSON.stringify(input)); } catch (_) { return input; }
+    return _redactDeep(plain, null);
+  }
+  return _applySecretRules(_SECRET_RES, input);
+}
+
+// ── SEGREDOS CONHECIDOS: rede de segurança por VALOR ─────────────────────────
+// As regras acima reconhecem segredo pelo FORMATO (prefixo, nome do campo). O ts conhece os
+// próprios segredos pelo VALOR — token de sessão, chaves do providers.json, senha SSH do
+// config.json, auth de MCP — e qualquer ocorrência deles numa saída de ferramenta (grep no
+// home, tar | base64, hexdump, backup lido por outro caminho) é vazamento, seja qual for o
+// formato em volta. Quem lê os arquivos é o chamador (aqui não há I/O): esta função só recebe
+// os valores e devolve o mascarador. Cada valor (8+ caracteres) vira também as variações
+// óbvias: escapado em JSON, codificado para URL, hexadecimal e base64 (padrão e URL) — o
+// base64 nas três posições possíveis do valor dentro de um texto maior (o alinhamento de 3
+// bytes muda os caracteres), tolerando a quebra de linha que `base64`/`xxd -p` inserem.
+const SECRET_MIN_LEN = 8;
+const _reEsc = (s) => String(s).replace(/[.*+?^${}()|[\]\\\/]/g, '\\$&');
+const _NL_OPT = '(?:\\r?\\n)?';
+function _b64Cores(buf) {
+  const out = [];
+  for (let o = 0; o < 3; o++) {
+    const enc = Buffer.concat([Buffer.alloc(o), buf]).toString('base64').replace(/=+$/, '');
+    // só os caracteres que dependem APENAS do valor (as bordas misturam bits dos vizinhos)
+    const start = Math.ceil(4 * o / 3), end = Math.floor(8 * (o + buf.length) / 6);
+    if (end - start >= SECRET_MIN_LEN) out.push(enc.slice(start, end));
   }
-  let s = input;
-  for (const [re, fn] of _SECRET_RES) s = s.replace(re, fn);
-  return s;
+  return out;
+}
+function _maskDeepWith(v, fn, depth, seen) {
+  if (typeof v === 'string') return fn(v);
+  if (!v || typeof v !== 'object' || depth > 40) return v;
+  if (Buffer.isBuffer(v) || v instanceof Date || seen.has(v)) return v;
+  seen.add(v);
+  if (Array.isArray(v)) return v.map(x => _maskDeepWith(x, fn, depth + 1, seen));
+  const proto = Object.getPrototypeOf(v);
+  if (proto !== Object.prototype && proto !== null) return v;
+  const out = {};
+  for (const k of Object.keys(v)) out[k] = _maskDeepWith(v[k], fn, depth + 1, seen);
+  return out;
+}
+// values → { size, text(str), deep(valor) }. size=0: nada a mascarar (devolve a entrada).
+function buildSecretMasker(values) {
+  const seen = new Set(), parts = [];
+  const add = (lit, wrap, b64) => {
+    if (!lit || lit.length < SECRET_MIN_LEN) return;
+    const k = (wrap ? 'w' : 'x') + (b64 ? 'b' : '') + lit;
+    if (seen.has(k)) return;
+    seen.add(k);
+    const body = wrap ? lit.split('').map(_reEsc).join(_NL_OPT) : _reEsc(lit);
+    // no base64, os 1-2 caracteres de borda (bits do valor misturados aos vizinhos) também somem
+    parts.push({ lit, wrap, len: lit.length, src: b64 ? '[A-Za-z0-9+/_-]{0,2}' + body + '[A-Za-z0-9+/_-]{0,2}={0,2}' : body });
+  };
+  for (const raw of Array.isArray(values) ? values : []) {
+    if (typeof raw !== 'string') continue;
+    for (const v of new Set([raw, raw.trim()])) {
+      if (v.length < SECRET_MIN_LEN) continue;
+      add(v, false, false);
+      add(JSON.stringify(v).slice(1, -1), false, false);
+      try { add(encodeURIComponent(v), false, false); } catch (_) {}
+      const buf = Buffer.from(v, 'utf8');
+      for (const c of _b64Cores(buf)) {
+        add(c, true, true);
+        add(c.replace(/\+/g, '-').replace(/\//g, '_'), true, true);
+      }
+      const hex = buf.toString('hex');
+      add(hex, true, false);
+      add(hex.toUpperCase(), true, false);
+    }
+  }
+  if (!parts.length) return { size: 0, text: (s) => s, deep: (x) => x };
+  parts.sort((a, b) => b.len - a.len);
+  // Triagem barata antes da regex (que é lenta num texto grande com dezenas de variações):
+  // busca literal de cada variação — as que toleram quebra de linha, no texto sem as quebras —
+  // e a regex é montada só com as que apareceram.
+  const reCache = new Map();
+  const text = (s) => {
+    if (typeof s !== 'string' || s.length < SECRET_MIN_LEN) return s;
+    let flat = null;
+    const hits = parts.filter(p => {
+      if (!p.wrap) return s.includes(p.lit);
+      if (flat === null) flat = /[\r\n]/.test(s) ? s.replace(/\r?\n/g, '') : s;
+      return flat.includes(p.lit);
+    });
+    if (!hits.length) return s;
+    const src = hits.map(p => p.src).join('|');
+    let re = reCache.get(src);
+    if (!re) { re = new RegExp(src, 'g'); if (reCache.size < 64) reCache.set(src, re); }
+    return s.replace(re, _MASK);
+  };
+  return { size: parts.length, text, deep: (x) => _maskDeepWith(x, text, 0, new WeakSet()) };
+}
+
+// Texto mostrado para alguém APROVAR (e que pode sair da máquina num aviso): a máscara nunca atravessa
+// metacaractere do shell — quem aprova precisa ver tudo o que vai rodar. Defesa extra: compara
+// os operadores de controle e as aspas do original com os do mascarado; se algum sumiu, a
+// máscara escondeu um pedaço que o shell pode executar → hidden=true, e o chamador NÃO pede
+// aprovação com o comando mascarado (quem aprova não veria o que roda).
+// opts.known: valores dos segredos do ts (ver buildSecretMasker) — mascarados antes das regras
+// de formato; um valor com metacaractere do shell também marca hidden pela mesma comparação.
+const _CTRL_RE = /[;&|$\x60<>()'"\n]/g;
+function _ctrlCounts(s) {
+  const c = {};
+  for (const ch of String(s).match(_CTRL_RE) || []) c[ch] = (c[ch] || 0) + 1;
+  return c;
+}
+function redactForApproval(cmd, opts = {}) {
+  const original = String(cmd == null ? '' : cmd);
+  const known = opts && Array.isArray(opts.known) && opts.known.length ? buildSecretMasker(opts.known) : null;
+  const text = _applySecretRules(_SECRET_RES_APPROVAL, known && known.size ? known.text(original) : original);
+  const before = _ctrlCounts(original), after = _ctrlCounts(text);
+  return { text, hidden: Object.keys(before).some(ch => (after[ch] || 0) < before[ch]) };
 }
 
 module.exports = {
-  DESTRUCTIVE, isDestructive, touchesTsConfig, redactSecrets,
+  DESTRUCTIVE, isDestructive, touchesTsConfig, redactSecrets, redactForApproval,
+  SECRET_MASK: _MASK, SECRET_MIN_LEN, buildSecretMasker,
   GLOBAL_STATE, globalStateWarning, describeDestructive,
   MODEL_WINDOWS, CTX_WINDOW_DEFAULT, DEFAULT_EXECUTOR, COMPACT_AT, KEEP_TAIL, winFor, estMsgsTok,
+  SUMMARY_LABEL, isPinnedSummary, pinnedSummaryText, isPinnedTask, safeTail,
+  CTX_OUTPUT_RESERVE, usableWindow, contextMeter, formatContextMeter, resumeContextDecision,
   AgentEvents, EVENT_TYPES,
   ERROR_CLASSES, RETRYABLE_CLASSES, classifyError, classifyToolResult,
 };

package/lib/doctor.js

@@ -67,9 +67,12 @@ async function run(opts = {}) {
   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)' });
 
-  // 2b) de onde vem a IA: chave própria (BYOK) ou créditos do TS.
-  // Provedor ativo cujo modelo NÃO chama ferramenta é um aviso de verdade: o agente
-  // vira um chat que narra o que faria, sem executar nada.
+  // 2b) de onde vem a IA: a chave própria (BYOK/Ollama) ou, sem ela, a IA da conta — a sua
+  // assinatura (ChatGPT/Claude), se estiver selecionada e conectada, ou os créditos legados do
+  // TS. O TS não vende IA: sem IA própria confirmada é aviso, com o caminho para conectar.
+  // opts.fonteIa (opcional, rede) confirma a assinatura pelo mesmo critério do `ts agente`.
+  // Provedor ativo cujo modelo NÃO chama ferramenta também é aviso: o agente vira um chat que
+  // narra o que faria, sem executar nada.
   try {
     const keyring = require('./keyring');
     const a = keyring.ativo();
@@ -78,9 +81,14 @@ async function run(opts = {}) {
       results.push(a.toolsOk
         ? { nome: 'IA (sua chave)', level: 'ok', detail: prov + (a.modelo ? ' · ' + a.modelo : '') }
         : { nome: 'IA (sua chave)', level: 'warn', detail: prov + ' — o modelo não chama ferramentas',
-            dica: 'troque o modelo (ts conectar ' + a.id + ') ou volte: ts conectar nuvem' });
+            dica: 'troque o modelo: ts conectar ' + a.id });
     } else {
-      results.push({ nome: 'IA', level: 'ok', detail: 'TS Cloud (seus créditos)' });
+      let fonte = null;
+      if (typeof opts.fonteIa === 'function') { try { fonte = await opts.fonteIa(); } catch (_) {} }
+      if (fonte && fonte.via) results.push({ nome: 'IA', level: 'ok', detail: fonte.via });
+      else results.push({ nome: 'IA', level: 'warn',
+        detail: (fonte && fonte.hint) || 'sem IA própria confirmada — sem chave, a execução usa a IA da conta (sua assinatura, se selecionada, ou os créditos legados do TS)',
+        dica: 'ts conectar <provedor> (sua chave ou Ollama) · ts ia conectar chatgpt|claude (sua assinatura)' });
     }
   } catch (_) { /* keyring é opcional pro doctor: nunca derruba o diagnóstico */ }