terminal-smart-cli 0.98.0 → 0.99.0

package/lib/tools.js

@@ -37,7 +37,8 @@ function _snapshot(absPath) {
 
 // Gate de destrutivo: fonte ÚNICA no núcleo canônico (lib/core.js). Reexportado aqui
 // pra compatibilidade (tools.isDestructive segue funcionando pra quem já importava).
-const { isDestructive } = require('./core');
+const core = require('./core');
+const { isDestructive } = core;
 
 // `findstr`, `rg` e `grep` usam o código 1 para informar que a busca foi
 // executada corretamente, mas não encontrou ocorrências. Para o harness isso
@@ -397,18 +398,592 @@ function _abs(p, base) {
 // (skill_gerenciar/lembrar passam por aprovação; hooks/mcp são só do humano) —
 // prompt-injection persistente. Recusa com o caminho certo indicado.
 const _TS_HOME = path.join(os.homedir(), '.ts');
+// O caminho é ~/.ts ou fica dentro dela? Mesma régua da leitura: caminho CANÔNICO sem caixa
+// (Windows/macOS) e, para os outros nomes da mesma pasta (\\localhost\C$\…, nome 8.3, junção,
+// unidade mapeada, caixa trocada), a IDENTIDADE (volume + índice) do alvo e de cada pasta acima
+// dele. Antes era texto puro com startsWith: `<home>\.TS\providers.json` passava. Quem chama
+// vai abrir o caminho de qualquer forma, então aqui o stat vale também para UNC.
+function _statId(p) {
+  try { const s = fs.statSync(p, { bigint: true }); return s.ino ? s.dev + ':' + s.ino : null; } catch (_) { return null; }
+}
+function _insideTsHome(p) {
+  const abs = path.resolve(p);
+  const home = _normCase(_canonPath(_TS_HOME));
+  const c = _normCase(_canonPath(abs));
+  if (c === home || c.startsWith(home + path.sep)) return true;
+  const homeId = _statId(_TS_HOME);
+  if (!homeId) return false;
+  for (let cur = abs; ; ) {
+    if (_statId(cur) === homeId) return true;
+    const up = path.dirname(cur);
+    if (up === cur) break;
+    cur = up;
+  }
+  return false;
+}
+const _MASK_WRITE_REFUSAL = 'RECUSADO: o texto traz a máscara "' + core.SECRET_MASK + '", que esconde um segredo na leitura — gravar isso trocaria o valor real pela máscara. Edite com editar_arquivo só o trecho que precisa mudar, sem a linha mascarada; se for preciso trocar o segredo, peça ao usuário.';
 function _guardTsHome(p) {
   const abs = path.resolve(p);
-  if (abs === _TS_HOME || abs.startsWith(_TS_HOME + path.sep)) {
+  // _tsSecretMatch: o mesmo ARQUIVO de uma credencial do ts com outro nome fora de ~/.ts
+  // (hardlink) — gravar nele reescreveria a credencial
+  if (_insideTsHome(abs) || _tsSecretMatch(abs)) {
     return 'RECUSADO: "' + abs + '" está na área de configuração do ts (~/.ts) — ferramentas de arquivo NÃO escrevem aqui. Pra skill use skill_gerenciar; pra memória use lembrar; hooks/mcp/config só o USUÁRIO altera manualmente. Não tente por shell — será recusado também.';
   }
   return null;
 }
+// LEITURA: o que ler_arquivo devolve vira contexto do modelo — e vai pro provedor de IA.
+// Em ~/.ts ficam o token de sessão e o perfil SSH (config.json), as chaves BYOK
+// (providers.json), a auth dos servidores MCP (mcp*.json) e o histórico salvo das sessões
+// (sessions; no CLI, as sessões do `ts agente --continuar` ficam em agente/).
+// Skills e memória continuam legíveis. Compara pelo caminho CANÔNICO, sem caixa no Windows
+// e no macOS (sistemas de arquivos sem distinção de caixa por padrão), e pela identidade do
+// arquivo (outros caminhos para o mesmo conteúdo).
+const _TS_SECRET_READ = (rel) => /^(?:config\.json|providers\.json|mcp[^\\\/]*|sessions|agente)(?:[\\\/]|$)/i.test(rel);
+// Caminho canônico: realpath NATIVO (no Windows expande o nome curto 8.3 — PROVID~1.JSO —,
+// tira o "::$DATA" e devolve a caixa gravada no disco; resolve junções e links), com a versão
+// JS de reserva. Arquivo que não existe: tira o que o Windows ignoraria ao abrir (":stream",
+// pontos e espaços no fim de cada parte).
+function _canonPath(p) {
+  const abs = path.resolve(p);
+  if (!_remoteUnc(abs)) {
+    try { return fs.realpathSync.native(abs); } catch (_) {}
+    try { return fs.realpathSync(abs); } catch (_) {}
+  }
+  if (process.platform !== 'win32') return abs;
+  const root = path.parse(abs).root;
+  return root + abs.slice(root.length).split(/[\\\/]+/).map(seg => seg.replace(/:.*$/, '').replace(/[. ]+$/, '')).join(path.sep);
+}
+const _normCase = (s) => (process.platform === 'win32' || process.platform === 'darwin') ? s.toLowerCase() : s;
+// O caminho é (ou fica dentro de) um item protegido de ~/.ts? Devolve o caminho canônico ou
+// null. `ids` (opcional) evita reler a pasta quando o chamador testa vários caminhos.
+// fns (opcional): { canon, fid } com memória — a avaliação de um comando de shell testa dezenas
+// de palavras que dividem as mesmas pastas acima (_tsShellCtx).
+function _tsSecretMatch(raw, ids, fns) {
+  const canon = (fns && fns.canon) || _canonPath, fid = (fns && fns.fid) || _fileId;
+  const abs = canon(raw);
+  const rel = path.relative(_normCase(canon(_TS_HOME)), _normCase(abs));
+  if (rel && !rel.startsWith('..') && !path.isAbsolute(rel) && _TS_SECRET_READ(rel)) return abs;
+  // Mesmo arquivo com outro caminho: o compartilhamento administrativo (\\localhost\C$\...,
+  // \\127.0.0.1\c$, \\?\UNC\...), unidade mapeada ou subst e hardlink não passam pela
+  // comparação de texto — o realpath mantém o UNC. Compara a IDENTIDADE (volume + índice do
+  // arquivo) do alvo e de cada pasta acima dele com a dos itens protegidos de ~/.ts.
+  const set = ids || _tsSecretIds();
+  if (!set.size) return null;
+  for (let cur = abs; ; ) {
+    const id = fid(cur);
+    if (id && set.has(id)) return abs;
+    const up = path.dirname(cur);
+    if (up === cur) break;
+    cur = up;
+  }
+  return null;
+}
+function _guardTsSecretRead(p) {
+  const raw = path.resolve(p);
+  // stream alternativo do NTFS (arquivo:stream, arquivo::$DATA): é outro nome para o conteúdo
+  // do arquivo e driblava a comparação de caminho. ler_arquivo não precisa disso em lugar nenhum.
+  if (process.platform === 'win32' && raw.slice(path.parse(raw).root.length).includes(':')) {
+    return 'RECUSADO: "' + raw + '" usa um stream alternativo do NTFS (nome:stream) — ler_arquivo só lê arquivos pelo nome normal.';
+  }
+  const abs = _tsSecretMatch(raw);
+  if (!abs) return null;
+  return 'RECUSADO: "' + abs + '" guarda credenciais do ts (token de sessão, senha SSH, chaves de IA, auth de MCP ou histórico de sessões) — ferramentas de leitura não abrem esse arquivo, porque o conteúdo iria para o modelo. Se o usuário precisar de algo daí, peça que ele consulte manualmente.';
+}
+// Identidade "volume:índice" seguindo links. bigint porque no Windows o índice do NTFS pode
+// passar de 2^53; índice 0 (sistema de arquivos sem índice estável) não identifica nada.
+function _fileId(p) {
+  if (_remoteUnc(path.resolve(p))) return null;
+  try { const s = fs.statSync(p, { bigint: true }); return s.ino ? s.dev + ':' + s.ino : null; } catch (_) { return null; }
+}
+// Caminho UNC de OUTRA máquina (\\host\share, //host/x, \\?\UNC\host\…): realpath e stat abririam
+// uma conexão SMB/WebDAV com um host tirado do texto do comando — o Windows autentica sozinho
+// (NTLM) nesse host e o processo trava por segundos esperando a rede. As checagens de ~/.ts não
+// tocam nesses caminhos: fica só a comparação de texto. Contam como locais localhost, 127.0.0.1,
+// ::1, o nome desta máquina e o host do próprio ~/.ts (perfil em rede); \\?\C:\ e \\.\C:\ são a
+// unidade local. Outros dispositivos (\\.\pipe\…, \\?\Volume{…}) também ficam sem disco.
+const _LOCAL_UNC_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '[::1]', '0--1.ipv6-literal.net']);
+// host do UNC; null = \\?\C:\… ou \\.\C:\… (unidade local); '' = dispositivo sem host
+function _uncHost(abs) {
+  const parts = String(abs).slice(2).split(/[\\\/]+/);
+  if (parts[0] !== '?' && parts[0] !== '.') return parts[0] || '';
+  if (/^[A-Za-z]:$/.test(parts[1] || '')) return null;
+  return /^unc$/i.test(parts[1] || '') ? (parts[2] || '') : '';
+}
+for (const h of [os.hostname(), /^[\\\/]{2}/.test(_TS_HOME) ? _uncHost(_TS_HOME) : '']) if (h) _LOCAL_UNC_HOSTS.add(String(h).toLowerCase());
+function _remoteUnc(abs) {
+  if (process.platform !== 'win32' || !/^[\\\/]{2}/.test(String(abs))) return false;
+  const host = _uncHost(abs);
+  return host !== null && !_LOCAL_UNC_HOSTS.has(host.toLowerCase());
+}
+// Leitura do ler_arquivo pelo DESCRITOR aberto. Confere a identidade (volume:índice) do arquivo
+// aberto e de cada pasta acima dele contra os itens protegidos de ~/.ts ANTES de ler: pega
+// qualquer apelido do mesmo arquivo que o _guardTsSecretRead não reconhece pelo caminho — UNC
+// com o IP de rede desta máquina, 127.x, nome completo (FQDN), unidade mapeada — e fecha a janela
+// entre checar e ler. Aqui não há rede a evitar: o arquivo vai ser aberto de qualquer forma.
+// Devolve o texto ou { erro }.
+function _readTextNotTsSecret(p) {
+  const ids = _tsSecretIds();
+  const recusa = () => ({ erro: 'RECUSADO: "' + path.resolve(p) + '" é o mesmo arquivo de um item de ~/.ts que guarda credenciais do ts — ferramentas de leitura não abrem esse arquivo, porque o conteúdo iria para o modelo. Se o usuário precisar de algo daí, peça que ele consulte manualmente.' });
+  const fd = fs.openSync(p, 'r');
+  try {
+    if (ids.size) {
+      const s = fs.fstatSync(fd, { bigint: true });
+      if (s.ino && ids.has(s.dev + ':' + s.ino)) return recusa();
+      for (let cur = path.dirname(path.resolve(p)); ; ) {
+        try { const d = fs.statSync(cur, { bigint: true }); if (d.ino && ids.has(d.dev + ':' + d.ino)) return recusa(); } catch (_) {}
+        const up = path.dirname(cur);
+        if (up === cur) break;
+        cur = up;
+      }
+    }
+    return fs.readFileSync(fd, 'utf8');
+  } finally {
+    try { fs.closeSync(fd); } catch (_) {}
+  }
+}
+function _tsSecretIds() {
+  const ids = new Set();
+  let nomes = [];
+  try { nomes = fs.readdirSync(_TS_HOME); } catch (_) { return ids; }
+  for (const n of nomes) {
+    if (!_TS_SECRET_READ(n)) continue;
+    const id = _fileId(path.join(_TS_HOME, n));
+    if (id) ids.add(id);
+  }
+  return ids;
+}
+
+// ── SEGREDOS CONHECIDOS: rede de segurança por VALOR ────────────────────────
+// As recusas de leitura acima fecham os caminhos conhecidos; sempre vai existir outro (grep
+// recursivo no home, tar | base64, cópia antiga, um link). O ts conhece os próprios segredos:
+// o token de sessão e a senha SSH (config.json), as chaves BYOK (providers.json) e a auth dos
+// servidores MCP (mcp*.json). Carrega os VALORES (8+ caracteres) e toda saída de ferramenta
+// passa pelo mascarador do núcleo (core.buildSecretMasker: o valor e as variações óbvias, como
+// base64 e hexadecimal) antes de virar contexto do modelo. Os valores ficam só na memória do
+// processo: nunca são impressos nem registrados, e nada aqui os manda para fora.
+const _SECRET_FIELD_RE = /(?:^|_)(?:pass|passwd|password|pwd|senha|secret|token|key|apikey|auth|authorization|credential|credentials)$/;
+const _secretFieldName = (k) => _SECRET_FIELD_RE.test(String(k).replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/-/g, '_').toLowerCase());
+function _collectSecretValues(node, out, field, depth) {
+  if (depth > 8 || out.length > 500) return;
+  if (typeof node === 'string') {
+    if (field != null && _secretFieldName(field)) {
+      out.push(node);
+      // auth de MCP: "Header-Name: valor" ou "Bearer x" — o valor sozinho também é segredo
+      const header = node.match(/^[A-Za-z0-9-]+\s*:\s*(\S.*)$/);
+      if (header) out.push(header[1]);
+      const scheme = node.match(/^(?:[A-Za-z0-9-]+\s*:\s*)?(?:Bearer|Basic|Token|Bot)\s+(\S.*)$/i);
+      if (scheme) out.push(scheme[1]);
+    }
+    // URL com credencial (endpoint de MCP, baseUrl): senha do usuário:senha@ e parâmetros
+    // com nome de segredo (?token=…, ?api_key=…)
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(node)) {
+      try {
+        const u = new URL(node);
+        if (u.password) out.push(decodeURIComponent(u.password));
+        for (const [k, v] of u.searchParams) if (_secretFieldName(k)) out.push(v);
+      } catch (_) {}
+    }
+    return;
+  }
+  if (Array.isArray(node)) { for (const x of node) _collectSecretValues(x, out, field, depth + 1); return; }
+  if (node && typeof node === 'object') for (const k of Object.keys(node)) _collectSecretValues(node[k], out, k, depth + 1);
+}
+const _KNOWN_SECRET_FILE = (n) => /^(?:config|providers)\.json$/i.test(n) || /^mcp[^\\\/]*\.json$/i.test(n);
+let _knownCache = { sig: null, values: [] };
+// Valores dos segredos do ts. Releitura só quando algum arquivo muda (nome:mtime:tamanho).
+function knownSecretValues() {
+  let nomes = [];
+  try { nomes = fs.readdirSync(_TS_HOME).filter(_KNOWN_SECRET_FILE).sort(); } catch (_) { nomes = []; }
+  const sig = nomes.map(n => {
+    try { const s = fs.statSync(path.join(_TS_HOME, n)); return s.isFile() && s.size <= 4 * 1024 * 1024 ? `${n}:${s.mtimeMs}:${s.size}` : ''; } catch (_) { return ''; }
+  }).join('|');
+  if (sig === _knownCache.sig) return _knownCache.values;
+  const out = [];
+  for (const n of nomes) {
+    try {
+      const p = path.join(_TS_HOME, n);
+      if (fs.statSync(p).size > 4 * 1024 * 1024) continue;
+      _collectSecretValues(JSON.parse(fs.readFileSync(p, 'utf8')), out, null, 0);
+    } catch (_) { /* arquivo ausente ou inválido: nada a carregar dele */ }
+  }
+  _knownCache = { sig, values: [...new Set(out.filter(v => typeof v === 'string' && v.trim().length >= core.SECRET_MIN_LEN))] };
+  return _knownCache.values;
+}
+// Valores dos segredos do ts + extra: segredos da execução que não estão em arquivo (o token
+// passado ao executor, a chave de IA em uso). Aceita string ou o objeto de credencial ({ key }).
+// É o que vai em core.redactForApproval({ known }) no comando mostrado para aprovação.
+function knownSecretsFor(extra) {
+  const ext = (Array.isArray(extra) ? extra : [extra])
+    .map(v => (v && typeof v === 'object' ? v.key : v))
+    .filter(v => typeof v === 'string' && v.trim().length >= core.SECRET_MIN_LEN);
+  return knownSecretValues().concat(ext);
+}
+let _maskerCache = { key: null, masker: null };
+// Mascara (folha a folha, sem alterar a entrada) toda ocorrência de um segredo conhecido.
+function maskKnownSecrets(value, extra) {
+  const vals = knownSecretsFor(extra);
+  const key = vals.join('\u0000');
+  if (_maskerCache.key !== key) _maskerCache = { key, masker: core.buildSecretMasker(vals) };
+  return _maskerCache.masker.size ? _maskerCache.masker.deep(value) : value;
+}
+
+// ── LEITURA das credenciais do ts POR SHELL ──────────────────────────────────
+// O que ler_arquivo recusa também não sai por executar_comando. Um trecho do comando que CITA
+// ou recebe como argumento um item protegido de ~/.ts (config.json, providers.json, mcp*,
+// sessions, agente) — ou a pasta ~/.ts inteira — é RECUSADO, seja qual for o programa: cat, type,
+// Get-Content, jq, node -p "require(…)", tar | base64, zip, Compress-Archive… Antes só uma lista
+// de leitores conhecidos era barrada e `jq . ~/.ts/providers.json` passava sem aprovação,
+// inclusive em --yes. Fica livre só o que não lê o conteúdo (_tsSegmentNonRead): listar ou ver
+// metadados (ls, dir, Get-ChildItem, stat, find sem leitor no -exec), criar e apagar (o apagar
+// recursivo segue no gate de destrutivo), mudar permissão, ecoar o caminho, `sed -i` (escrita no
+// lugar) e a cópia/movimento cuja ORIGEM não é protegida — copiar PARA dentro de ~/.ts é escrita
+// e cai no gate de ~/.ts (touchesTsConfig), como `> ~/.ts/mcp.json`.
+// Duas checagens em cada trecho: o TEXTO (".ts/" seguido de item protegido, de curinga ou do fim
+// do caminho, depois de um prefixo que é a pasta pessoal — ~, $HOME, %USERPROFILE%,
+// $env:USERPROFILE, /home/<usuário>, C:\Users\<usuário>; ver _tsTextCitesSecret) e cada argumento
+// EXPANDIDO e resolvido (um `cd` anterior na mesma linha conta) pela régua do ler_arquivo:
+// caminho canônico e identidade (nome 8.3, UNC local, link). A busca RECURSIVA que entraria em
+// ~/.ts (grep -r, rg --hidden, findstr /s, Get-ChildItem -Recurse | Select-String, find -exec)
+// também é recusada, com a dica de excluir a pasta. Nada disso cobre todo jeito de ler um arquivo
+// por shell: a saída de qualquer comando ainda passa por redactSecrets e pela máscara dos
+// segredos conhecidos (maskKnownSecrets).
+const _TS_READERS = new Set(['cat', 'tac', 'nl', 'type', 'more', 'less', 'head', 'tail', 'get-content', 'gc', 'findstr', 'select-string', 'sls', 'grep', 'egrep', 'fgrep', 'rg', 'awk', 'sed', 'strings', 'xxd', 'od', 'hexdump', 'base64']);
+// cópia e movimento: só a ORIGEM conta
+const _TS_COPIERS = new Set(['copy', 'xcopy', 'robocopy', 'cp', 'copy-item', 'cpi', 'mv', 'move', 'move-item', 'mi', 'ren', 'rename', 'rename-item', 'rni']);
+const _TS_CD = new Set(['cd', 'chdir', 'pushd', 'set-location', 'sl', 'push-location']);
+// no PowerShell o pipe passa o ARQUIVO, não o texto: `Get-ChildItem ~/.ts/sessions | Get-Content`
+const _TS_PIPE_READERS = new Set(['get-content', 'gc', 'select-string', 'sls', 'copy-item', 'cpi']);
+// programas que leem, transformam ou transmitem conteúdo: no mesmo trecho de um comando que
+// "não lê" (find … -exec cat, ls $(cat …), xargs cat), tiram a isenção
+const _TS_CONTENT_CMDS = new Set([..._TS_READERS, 'node', 'nodejs', 'deno', 'bun', 'python', 'python3', 'py', 'perl', 'ruby', 'php', 'lua',
+  'powershell', 'pwsh', 'cmd', 'bash', 'sh', 'zsh', 'dash', 'ksh', 'fish', 'wsl', 'jq', 'yq', 'tar', 'zip', '7z', '7za', 'gzip', 'bzip2', 'xz', 'zstd',
+  'compress-archive', 'certutil', 'openssl', 'gpg', 'curl', 'wget', 'iwr', 'irm', 'invoke-webrequest', 'invoke-restmethod', 'scp', 'rsync',
+  'diff', 'cmp', 'sort', 'uniq', 'cut', 'tr', 'iconv', 'vim', 'vi', 'nano', 'code', 'notepad', 'get-filehash', 'md5sum', 'sha256sum', 'import-csv']);
+// o que pode citar um item protegido de ~/.ts sem ler o conteúdo dele
+const _TS_NONREAD = new Set(['ls', 'dir', 'gci', 'get-childitem', 'tree', 'stat', 'du', 'file', 'find', 'where', 'which', 'test-path', 'get-item', 'gi',
+  'get-acl', 'resolve-path', 'rvpa', 'realpath', 'readlink', 'basename', 'dirname', 'echo', 'printf', 'write-host', 'mkdir', 'md', 'new-item', 'ni',
+  'touch', 'rm', 'del', 'erase', 'rd', 'rmdir', 'remove-item', 'ri', 'chmod', 'chown', 'chgrp', 'chattr', 'icacls', 'attrib', 'takeown']);
+const _TS_CODE_READ_RE = /\b(?:readFileSync|readFile|ReadAllText|ReadAllBytes|ReadAllLines|OpenText|OpenRead|ReadToEnd|open|require|import)\s*\(/i;
+// prefixos que só executam o comando seguinte
+const _TS_WRAPPERS = new Set(['sudo', 'nohup', 'time', 'command', 'builtin', 'exec']);
+// ".ts" CITADO no texto como a pasta do ts: seguido de separador e item protegido (grupo 1), de
+// um nome com curinga (grupo 2: *.json, {config,providers}.json) ou do fim do caminho (a pasta
+// inteira: grep -r, findstr /s, xcopy). Quem decide se é caminho é o que vem ANTES, em
+// _tsTextCitesSecret: ".ts" também é a extensão do TypeScript e "\" também é o escape de regex.
+const _TS_TEXT_RE = /\.ts(?:[\\\/]+(?:(config\.json|providers\.json|mcp|sessions|agente)|[^\s\\\/"';|&]*([*?[{]))|[\\\/]*(?=$|[\s"';|&)]))/gi;
+const _TS_TEXT_DELIM = /[\s"'`=(<>,;|&]/;
+// raiz de pasta: ~, %USERPROFILE% (%HOMEDRIVE%%HOMEPATH%), $HOME, ${HOME}, $env:USERPROFILE, C:
+const _TS_ROOT_VAR = String.raw`(?:~|%[A-Za-z_][\w()]*%|\$\{?(?:env:)?[A-Za-z_]\w*\}?|[A-Za-z]:)`;
+const _TS_ROOT_VAR_ONLY_RE = new RegExp(String.raw`^${_TS_ROOT_VAR}+$`);
+// nome de pasta: sem metacaractere de regex (o prefixo já para nos delimitadores acima)
+const _TS_DIR_NAME = String.raw`[^\\\/*?^()[\]{}+]+`;
+// antes de "/.ts": raiz (acima, . ou ..) ou caminho absoluto do Unix, com qualquer separador
+const _TS_DIR_ANY_RE = new RegExp(String.raw`^(?:(?:${_TS_ROOT_VAR}+|\.{1,2})(?=[\\\/]|$)|(?=[\\\/]))(?:[\\\/]+${_TS_DIR_NAME})*$`);
+// antes de "\.ts": caminho Windows com raiz de verdade (acima ou \\host) e só "\" como separador
+const _TS_DIR_WIN_RE = new RegExp(String.raw`^(?:${_TS_ROOT_VAR}+|\\\\[^\\\/\s]+)(?:\\+${_TS_DIR_NAME})*$`);
+// pasta pessoal de QUALQUER usuário (outro perfil também guarda credenciais do ts)
+const _TS_HOME_LIKE_RE = /(?:^|[\\\/])(?:Users|home|Documents and Settings)[\\\/]+[^\\\/]+[\\\/]*$|^[\\\/]+(?:root|var[\\\/]+root)[\\\/]*$/i;
+// O prefixo antes de "/.ts" é uma pasta pessoal? Variável de raiz sozinha (~, $HOME,
+// %USERPROFILE%… — uma variável desconhecida também conta, por cautela), ~usuario, /home/<x>,
+// C:\Users\<x>, /root, ou um caminho que expande para a pasta pessoal deste usuário. Pasta
+// ".ts" de PROJETO (docs/.ts, C:/Users/x/proj/.ts) não é: quem pega o caso real é o argumento
+// expandido (_tsShellWordIsSecret).
+function _tsHomeLike(prefix, cwd) {
+  const p = String(prefix || '');
+  if (_TS_ROOT_VAR_ONLY_RE.test(p) && !/^[A-Za-z]:$/.test(p)) return true;
+  if (/^~[\w.-]+$/.test(p) || _TS_HOME_LIKE_RE.test(p)) return true;
+  const abs = _expandShellPath(p, cwd || process.cwd());
+  if (!abs || _remoteUnc(abs)) return false;
+  return _normCase(_canonPath(abs)) === _normCase(_canonPath(os.homedir()));
+}
+// O texto cita ~/.ts/{item protegido}, um curinga lá dentro ou a pasta inteira?
+//  - nada antes (início, espaço, aspas, =, (, <): ".ts/providers.json" relativo — item ou curinga,
+//    quando a pasta de trabalho é a pessoal (senão é uma pasta .ts do projeto);
+//  - "/" antes: depois de uma pasta pessoal (~/.ts, $HOME/.ts, /home/x/.ts, C:/Users/x/.ts); sem
+//    prefixo, o item protegido ou o curinga ('/.ts/providers.json' concatenado num código). Assim
+//    sed 's/\.js$/.ts/' e docs/.ts/config.json não são a pasta do ts;
+//  - "\" antes: depois de um caminho Windows com raiz que é pasta pessoal (%USERPROFILE%\.ts,
+//    $env:USERPROFILE\.ts, C:\Users\x\.ts, \\host\c$\Users\x\.ts); sem prefixo, só o item protegido
+//    com "\" também DEPOIS ('\.ts\providers.json' concatenado). "\.ts/mcp", grep "utils\.ts",
+//    rg "\w\.ts", "/utils\.ts", awk '/\.ts/' e "\.ts/[a-z]*" são regex. A recusa é definitiva,
+//    então na dúvida o texto fica livre: o argumento expandido e resolvido (_tsShellWordIsSecret)
+//    continua pegando o caminho real em qualquer forma.
+function _tsTextCitesSecret(text, cwd) {
+  const s = String(text || '');
+  for (const m of s.matchAll(_TS_TEXT_RE)) {
+    const named = m[1] != null, glob = m[2] != null;
+    let j = m.index;
+    while (j > 0 && (s[j - 1] === '\\' || s[j - 1] === '/')) j--;
+    const sep = s.slice(j, m.index);
+    let k = j;
+    while (k > 0 && !_TS_TEXT_DELIM.test(s[k - 1])) k--;
+    const prefix = s.slice(k, j).replace(/^(?:-{1,2}[A-Za-z][\w-]*:|@)/, ''); // -Path:C:\…, curl @arquivo
+    const after = s[m.index + 3] || ''; // separador logo depois de ".ts"
+    let ok;
+    if (!sep) ok = !prefix && (named || glob) && (cwd == null || _tsHomeLike('.', cwd));
+    else if (sep.includes('\\')) ok = prefix ? (_TS_DIR_WIN_RE.test(prefix) && _tsHomeLike(prefix, cwd)) : (named && after === '\\');
+    else ok = prefix ? (_TS_DIR_ANY_RE.test(prefix) && _tsHomeLike(prefix, cwd)) : (named || glob);
+    if (ok) return true;
+  }
+  return false;
+}
+const _TS_SHELL_READ_REFUSAL = 'RECUSADO: o comando lê credenciais do ts em ~/.ts (config.json, providers.json, mcp*, sessions ou agente: token de sessão, senha SSH, chaves de IA, auth de MCP, histórico de sessões). A saída iria para o modelo — nem ler_arquivo nem comandos (leitura, cópia, compactação, interpretadores) abrem esses arquivos. Se o usuário precisar de algo daí, peça que ele consulte manualmente; para ver só os nomes, use listar_diretorio.';
+const _tsRecursiveRefusal = (dir) => 'RECUSADO: a busca recursiva a partir de "' + dir + '" entraria em ~/.ts, onde ficam as credenciais do ts (token de sessão, chaves de IA, auth de MCP, histórico de sessões) — a saída iria para o modelo. Busque numa pasta abaixo (a do projeto) ou exclua a pasta do ts: grep -r --exclude-dir=.ts …, rg -g "!.ts" …, find … -path "*/.ts" -prune -o ….';
+
+// Trechos do comando, divididos em ; & | e quebra de linha FORA de aspas. pipe=true quando o
+// trecho veio depois de um `|` simples.
+function _shellSegments(cmd) {
+  const out = []; const s = String(cmd);
+  let cur = '', q = null, pipe = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (q) { cur += ch; if (ch === q) q = null; continue; }
+    if (ch === '"' || ch === "'") { q = ch; cur += ch; continue; }
+    if (ch === ';' || ch === '&' || ch === '|' || ch === '\n' || ch === '\r') {
+      out.push({ text: cur, pipe });
+      cur = '';
+      const dbl = (ch === '&' || ch === '|') && s[i + 1] === ch;
+      pipe = ch === '|' && !dbl;
+      if (dbl) i++;
+      continue;
+    }
+    cur += ch;
+  }
+  out.push({ text: cur, pipe });
+  return out;
+}
+// Palavras do trecho. top: o conteúdo entre aspas vale inteiro (posição dos argumentos);
+// flat: o conteúdo entre aspas também é quebrado em palavras (`powershell -Command "gc …"`).
+// Abertura de subcomando ($(, `, () fica fora da palavra: `ls $(cat x)` tem a palavra "cat".
+function _shellWords(seg) {
+  const top = [], flat = [];
+  const re = /"([^"]*)"|'([^']*)'|([^\s"']+)/g;
+  const clean = (w) => w.replace(/^(?:[@(`]|\$\()+|[;,)`]+$/g, '');
+  let m;
+  while ((m = re.exec(seg))) {
+    const q = m[1] != null ? m[1] : m[2];
+    if (q != null) {
+      if (q) top.push(q);
+      for (const w of q.split(/\s+/)) if (clean(w)) flat.push(clean(w));
+    } else if (clean(m[3])) { top.push(clean(m[3])); flat.push(clean(m[3])); }
+  }
+  return { top, flat };
+}
+const _shellCmdName = (w) => String(w).split(/[\\\/]/).pop().toLowerCase().replace(/\.(?:exe|com)$/, '');
+// Argumento → caminho absoluto, expandindo %VAR%, $env:VAR, $HOME, $VAR e ~ (como o shell faria).
+function _expandShellPath(w, cwd) {
+  let t = String(w);
+  const named = t.match(/^-{1,2}[A-Za-z][\w-]*[=:](.+)$/); // --arquivo=~/.ts/x, -Path:C:\x
+  if (named) t = named[1];
+  const env = (n) => (process.env[n] != null ? process.env[n] : null);
+  t = t.replace(/%([A-Za-z_][\w()]*)%/g, (m, n) => env(n) ?? m)
+    .replace(/\$\{?env:([A-Za-z_]\w*)\}?/gi, (m, n) => env(n) ?? m)
+    .replace(/\$\{?HOME\}?(?!\w)/gi, () => os.homedir())
+    .replace(/\$\{?([A-Za-z_]\w*)\}?/g, (m, n) => env(n) ?? m);
+  if (/^~(?=$|[\\\/])/.test(t)) t = os.homedir() + t.slice(1);
+  try { return path.resolve(cwd, t); } catch (_) { return null; }
+}
+function _tsShellCtx() {
+  // realpath e stat com memória nesta avaliação: as palavras de um comando dividem as pastas acima
+  const memo = (fn) => { const m = new Map(); return (p) => { if (!m.has(p)) m.set(p, fn(p)); return m.get(p); }; };
+  const canon = memo(_canonPath), fid = memo(_fileId);
+  const ctx = { ids: _tsSecretIds(), home: _normCase(canon(_TS_HOME)), homeId: fid(_TS_HOME), _up: null, canon, fid };
+  // identidade de ~/.ts e de cada pasta acima dela (raiz de busca recursiva com outro nome)
+  ctx.upIds = () => {
+    if (ctx._up) return ctx._up;
+    ctx._up = new Set();
+    for (let cur = _TS_HOME; ; ) {
+      const id = ctx.fid(cur);
+      if (id) ctx._up.add(id);
+      const up = path.dirname(cur);
+      if (up === cur) break;
+      cur = up;
+    }
+    return ctx._up;
+  };
+  return ctx;
+}
+const _isTsHomeDir = (abs, ctx) => _normCase(ctx.canon(abs)) === ctx.home || (!!ctx.homeId && ctx.fid(abs) === ctx.homeId);
+// Base de um caminho com curinga (*.json, {a,b}): a pasta onde ele começa. O "?" de \\?\ e o "."
+// de \\.\ (prefixos de caminho do Windows) não são curinga.
+function _globBase(abs) {
+  const off = /^\\\\[?.]\\/.test(abs) ? 4 : 0;
+  const g = abs.slice(off).search(/[*?[{]/);
+  return g >= 0 ? abs.slice(0, off + g).replace(/[^\\\/]*$/, '') : abs;
+}
+function _tsShellWordIsSecret(w, cwd, ctx) {
+  if (_tsTextCitesSecret(w, cwd)) return true;
+  const abs = _expandShellPath(w, cwd);
+  // UNC de outra máquina: só o texto vale (nenhum realpath/stat abre conexão com esse host)
+  if (!abs || _remoteUnc(abs)) return false;
+  const base = _globBase(abs);
+  if (base !== abs) return !!base && (_isTsHomeDir(base, ctx) || !!_tsSecretMatch(base, ctx.ids, ctx));
+  return _isTsHomeDir(abs, ctx) || !!_tsSecretMatch(abs, ctx.ids, ctx);
+}
+// A pasta é ~/.ts ou fica ACIMA dela (uma busca recursiva a partir daí entra em ~/.ts)?
+// posixGlob: o curinga é expandido no estilo do shell POSIX (grep, rg, find), em que "*" não pega
+// nome começado por ponto — `grep -r x *` na pasta pessoal não entra em .ts; só entra se a base
+// do curinga estiver ACIMA da pasta pessoal (C:/Users/* → C:/Users/<você>/.ts).
+function _tsRootCoversTsHome(w, cwd, ctx, posixGlob) {
+  const abs = _expandShellPath(w, cwd);
+  if (!abs || _remoteUnc(abs)) return null;
+  const dir = _globBase(abs);
+  if (!dir) return null;
+  const c = _normCase(ctx.canon(dir));
+  const withSep = c.endsWith(path.sep) ? c : c + path.sep;
+  if (posixGlob && dir !== abs && /^[*?[]/.test(abs.slice(dir.length))) {
+    const parent = path.dirname(ctx.home);
+    return parent !== c && parent.startsWith(withSep) ? dir : null;
+  }
+  if (c === ctx.home || ctx.home.startsWith(withSep)) return dir;
+  const id = ctx.fid(dir);
+  return id && ctx.upIds().has(id) ? dir : null;
+}
+// exclusão explícita da pasta do ts na própria busca
+const _TS_EXCLUDE_RE = /--exclude-dir(?:=|\s+)["']?(?:\*\*\/)?\.ts\b|(?:-g|--glob|--iglob)(?:=|\s*)["']?!(?:\*\*\/)?\.ts\b|-Exclude\s+["']?\.ts\b|-prune\b/i;
+const _TS_GREPS = new Set(['grep', 'egrep', 'fgrep', 'zgrep']);
+const _TS_LISTERS = new Set(['get-childitem', 'gci', 'dir', 'ls', 'find']);
+// Busca recursiva que entra em ~/.ts: { read: true, dir } (lê conteúdo: grep -r, rg --hidden,
+// findstr /s, lista recursiva + leitor no mesmo trecho) ou { read: false, dir } (só lista — vale se
+// o trecho seguinte do pipe ler os arquivos), ou null. Raiz omitida = pasta de trabalho.
+function _tsRecursiveReach(flat, names, seg, cwd, ctx) {
+  if (_TS_EXCLUDE_RE.test(seg)) return null;
+  const covers = (words, posixGlob = true) => { for (const w of words) { const d = _tsRootCoversTsHome(w, cwd, ctx, posixGlob); if (d) return d; } return null; };
+  for (let i = 0; i < names.length; i++) {
+    const n = names[i];
+    let args = flat.slice(i + 1);
+    const stop = args.findIndex(w => w === '|' || w === ';' || w === '&&' || w === '||');
+    if (stop >= 0) args = args.slice(0, stop);
+    const nonflag = args.filter(w => !/^-/.test(w));
+    const roots = () => (nonflag.length <= 1 ? ['.'] : nonflag.slice(1));
+    let dir = null;
+    if (_TS_GREPS.has(n)) {
+      const rec = args.some(w => (/^-[A-Za-z0-9]+$/.test(w) && /[rR]/.test(w)) || /^--(?:recursive|dereference-recursive|directories=recurse)$/.test(w))
+        || /(?:^|\s)-d\s+recurse\b/.test(args.join(' '));
+      if (rec) dir = covers(roots());
+    } else if (n === 'rg' || n === 'ag') {
+      // rg e ag pulam pastas ocultas; só entram em .ts com --hidden, -., -uu (rg) ou -u (ag)
+      const hidden = args.some(w => w === '--hidden' || w === '--unrestricted'
+        || (/^-[A-Za-z.]+$/.test(w) && (w.includes('.') || (w.match(/u/g) || []).length >= (n === 'ag' ? 1 : 2))));
+      if (hidden) dir = covers(roots());
+    } else if (n === 'findstr') {
+      // chaves do findstr: /s, /si, -s… (com ":" são /c:texto, /g:arquivo — não contam)
+      const sw = args.filter(w => /^[\/-]/.test(w));
+      if (sw.some(w => /^[\/-][a-z]+$/i.test(w) && /s/i.test(w))) {
+        const plain = args.filter(w => !/^[\/-]/.test(w));
+        const specs = sw.some(w => /^[\/-][cg]:/i.test(w)) ? plain : plain.slice(1);
+        // findstr é do Windows: o curinga pega nomes com ponto (sem a regra do shell POSIX)
+        dir = covers(specs.map(s => path.dirname(_expandShellPath(s, cwd) || s)), false);
+      }
+    }
+    if (dir) return { read: true, dir };
+    if (_TS_LISTERS.has(n)) {
+      const rec = n === 'find' || args.some(w => /^-rec/i.test(w) || /^-r$/i.test(w) || /^\/s$/i.test(w));
+      if (!rec) continue;
+      let rs;
+      if (n === 'find') {
+        const lead = [];
+        for (const w of args) { if (/^[-(!]/.test(w)) break; lead.push(w); }
+        rs = lead.length ? lead : ['.'];
+      } else {
+        rs = [];
+        for (let a = 0; a < args.length; a++) {
+          const w = args[a];
+          if (/^-(?:Path|LiteralPath)$/i.test(w)) { if (args[a + 1]) rs.push(args[++a]); continue; }
+          if (/^-(?:Filter|Include|Exclude|Depth|Attributes)$/i.test(w)) { a++; continue; }
+          if (!/^[-\/]/.test(w)) rs.push(w);
+        }
+        if (!rs.length) rs = ['.'];
+      }
+      const d = covers(rs, n === 'find' || n === 'ls');
+      if (!d) continue;
+      // lista recursiva com leitor no MESMO trecho (find -exec cat, PowerShell entre aspas com
+      // "| Select-String", for /f … type): lê
+      if (names.slice(i + 1).some(x => _TS_CONTENT_CMDS.has(x))) return { read: true, dir: d };
+      return { read: false, dir: d };
+    }
+  }
+  return null;
+}
+// Trecho que cita item protegido sem ler o conteúdo (ver o comentário da seção)?
+function _tsSegmentNonRead(head, names, flat, raw) {
+  if (/\$\(|`|<\(/.test(raw) || raw.includes('<') || _TS_CODE_READ_RE.test(raw)) return false;
+  if (names.slice(1).some(n => _TS_CONTENT_CMDS.has(n))) return false;
+  // copiador: a origem já foi conferida (_tsCopyOrigins); o que sobra citado é o destino
+  if (_TS_NONREAD.has(head) || _TS_COPIERS.has(head)) return true;
+  return head === 'sed' && flat.some(w => /^(?:-i\S*|--in-place\S*)$/.test(w));
+}
+// Cópia/movimento no trecho: as ORIGENS (o destino fica de fora), ou null sem copiador.
+function _tsCopyOrigins(top, flat) {
+  for (const words of [top, flat]) {
+    const ci = words.findIndex(w => _TS_COPIERS.has(_shellCmdName(w)));
+    if (ci < 0) continue;
+    const kind = _shellCmdName(words[ci]);
+    const winSwitch = kind === 'copy' || kind === 'xcopy' || kind === 'robocopy' || kind === 'move';
+    const args = []; let named = false;
+    for (let i = ci + 1; i < words.length; i++) {
+      const w = words[i];
+      if (/^(?:copy-item|cpi|move-item|mi|rename-item|rni)$/.test(kind) && /^-(?:d(?:estination|est)?|newname)$/i.test(w)) { i++; named = true; continue; }
+      if (/^-/.test(w) || (winSwitch && /^\/[A-Za-z?][\w:+-]*$/.test(w))) continue;
+      args.push(w);
+    }
+    return { kind, origins: kind === 'robocopy' ? args.slice(0, 1) : (named || args.length < 2 ? args : args.slice(0, -1)) };
+  }
+  return null;
+}
+function tsSecretReadReason(cmd, opts = {}) {
+  const text = String(cmd || '');
+  if (!text.trim()) return null;
+  let cwd = path.resolve(String(opts.cwd || process.cwd()));
+  let ctx = null;
+  const getCtx = () => ctx || (ctx = _tsShellCtx());
+  const secret = (w, dir) => _tsShellWordIsSecret(w, dir, getCtx());
+  const hit = (seg, dir) => {
+    if (_tsTextCitesSecret(seg, dir)) return true;
+    const { top, flat } = _shellWords(seg);
+    // teto de palavras: cada uma custa algumas chamadas ao disco
+    return [...new Set([...top, ...flat])].slice(0, 64).some(w => secret(w, dir));
+  };
+  let pipeline = [];
+  for (const part of _shellSegments(text)) {
+    if (!part.pipe) pipeline = [];
+    // destino de redirecionamento (> x, >> x, 2> x) é escrita, não leitura
+    const seg = part.text.replace(/(?:\d|&)?>>?\|?\s*(?:"[^"]*"|'[^']*'|[^\s"';|&<>]+)/g, ' ');
+    const { top, flat } = _shellWords(seg);
+    const head = top.length ? _shellCmdName(top[0]) : '';
+    if (_TS_CD.has(head)) {
+      const alvo = top.slice(1).find(w => !/^(?:\/d|-(?:Path|LiteralPath))$/i.test(w));
+      const d = alvo ? _expandShellPath(alvo, cwd) : null;
+      if (d) cwd = d;
+      continue;
+    }
+    const names = flat.map(_shellCmdName);
+    // cópia/movimento: a ORIGEM protegida recusa; o destino (copiar PARA dentro) é escrita
+    const copy = _tsCopyOrigins(top, flat);
+    if (copy && copy.origins.some(w => secret(w, cwd))) return _TS_SHELL_READ_REFUSAL;
+    const segHit = hit(seg, cwd);
+    // o programa de fato, sem prefixo (sudo ls ~/.ts, nohup, VAR=x comando)
+    let hi = 0;
+    while (hi < top.length - 1 && (_TS_WRAPPERS.has(_shellCmdName(top[hi])) || /^[A-Za-z_]\w*=/.test(top[hi]))) hi++;
+    // `<`, subcomando e leitura por código olham o trecho ORIGINAL (a limpeza dos
+    // redirecionamentos acima pode levar junto um pedaço de `=>` de arrow function)
+    if (segHit && !_tsSegmentNonRead(top.length ? _shellCmdName(top[hi]) : '', names, flat, part.text)) return _TS_SHELL_READ_REFUSAL;
+    const rec = _tsRecursiveReach(flat, names, part.text, cwd, getCtx());
+    if (rec && rec.read) return _tsRecursiveRefusal(rec.dir);
+    if (part.pipe) {
+      const reads = _TS_PIPE_READERS.has(head) || (head === 'xargs' && names.slice(1).some(n => _TS_CONTENT_CMDS.has(n)));
+      const from = reads && pipeline.find(p => p.hit || p.rec);
+      if (from) return from.hit ? _TS_SHELL_READ_REFUSAL : _tsRecursiveRefusal(from.rec);
+    }
+    pipeline.push({ hit: segHit, rec: rec ? rec.dir : null });
+  }
+  return null;
+}
 
 // ── RECUSA INSTANTÂNEA de comandos AUTO-DESTRUTIVOS ──────────────────────────
 // Diferente do gate destrutivo comum (que PEDE aprovação humana): estes comandos matam a
 // PRÓPRIA missão — o processo do agente, o dev server de que a missão depende — ou a
-// máquina inteira. Esperar aprovação (local, ou remota via Telegram ~150s POR tentativa)
+// máquina inteira. Esperar aprovação (que já chegou a custar ~150s POR tentativa)
 // por algo que JAMAIS deve rodar é desperdício puro: recusamos NA HORA, apontando a
 // alternativa cirúrgica. Retorna a mensagem (motivo pro modelo) quando é auto-destrutivo,
 // ou null quando é seguro (aí segue o fluxo normal, inclusive o gate de aprovação comum).
@@ -662,7 +1237,15 @@ function _vizinhos(absPath) {
   } catch (_) { return []; }
 }
 
+// Executor público: roda a ferramenta e passa TODA a saída pela máscara dos segredos conhecidos
+// do ts (token de sessão, chaves BYOK, senha SSH, auth de MCP e o token recebido em opts) antes de
+// ela virar contexto do modelo, log ou evidência. Se a máscara falhar, o resultado é descartado.
 async function execute(name, input, opts = {}) {
+  const raw = await _executeTool(name, input, opts);
+  try { return maskKnownSecrets(raw, [opts.token]); }
+  catch (_) { return { erro: 'Resultado descartado: a verificação de segredos na saída falhou.' }; }
+}
+async function _executeTool(name, input, opts = {}) {
   // BASE de trabalho: cwd da sessão do agente (opts.baseDir) → pasta confinada da
   // missão (opts.confineDir) → process.cwd(). É a raiz de todo caminho relativo.
   const baseDir = opts.baseDir || opts.confineDir || process.cwd();
@@ -692,6 +1275,9 @@ async function execute(name, input, opts = {}) {
         const comando = String(input.comando || '');
         { const scope = _commandScopeViolation(comando, opts.confineDir); if (scope) return { erro: scope }; }
         { const exfil = secretExfiltrationReason(comando); if (exfil) return { erro: exfil }; }
+        // credenciais do ts por shell: mesma recusa do ler_arquivo (defesa em profundidade — o
+        // gate do agent.js já pega antes)
+        { const tr = tsSecretReadReason(comando, { cwd: baseDir }); if (tr) return { erro: tr }; }
         // RECUSA INSTANTÂNEA (defesa em profundidade — o gate do agent.js já pega antes):
         // comando auto-destrutivo NUNCA roda e NUNCA espera aprovação.
         { const sd = selfDestructiveReason(comando, { cwd: baseDir }); if (sd) return { erro: sd }; }
@@ -765,7 +1351,16 @@ async function execute(name, input, opts = {}) {
       }
       case 'ler_arquivo': {
         const p = _abs(input.caminho, baseDir);
+        // Recusa os arquivos de credenciais do ts. O conteúdo devolvido NÃO passa por
+        // redactSecrets, de propósito: editar_arquivo precisa do texto exato (o "buscar" sai do
+        // que foi lido) e, com máscara, a edição falharia ou gravaria ••••REDACTED no arquivo.
+        // Segredo de projeto (.env, config com senha) chega inteiro ao modelo — decisão, não esquecimento.
+        // A exceção são os segredos do PRÓPRIO ts (maskKnownSecrets, no execute): se o .env tiver a
+        // mesma chave do providers.json, ela chega mascarada — e escrever_arquivo/editar_arquivo
+        // recusam gravar a máscara por cima do valor real.
+        // O escopo vem antes: ele recusa pelo texto, sem tocar no disco, o que está fora da missão.
         if (_outsideScope(p)) return _scopeError(p);
+        { const g = _guardTsSecretRead(p); if (g) return { erro: g }; }
         if (BIN_RE.test(p)) return { erro: 'Arquivo binário — ler_arquivo só lê texto. Use executar_comando com uma ferramenta adequada.' };
         // Não achou? Sugere nomes PARECIDOS na mesma pasta (o modelo chuta o nome do recurso).
         if (!fs.existsSync(p)) {
@@ -773,7 +1368,8 @@ async function execute(name, input, opts = {}) {
           return { erro: 'Arquivo não encontrado: ' + p + (v.length ? '. Nomes parecidos na mesma pasta: ' + v.join(', ') + ' — confira o nome EXATO (maiúsculas/plural contam).' : '. Confira o caminho (use listar_diretorio/buscar_arquivos).') };
         }
         try { if (fs.statSync(p).isDirectory()) return { erro: p + ' é uma PASTA, não um arquivo. Use listar_diretorio pra ver o conteúdo.' }; } catch (_) {}
-        const txt = fs.readFileSync(p, 'utf8');
+        const txt = _readTextNotTsSecret(p);
+        if (typeof txt !== 'string') return txt;
         const linhas = txt.split('\n'); const total = linhas.length; const MAXL = 400;
         const ini = parseInt(input.inicio) || 0;
         if (ini > 0) {
@@ -828,6 +1424,15 @@ async function execute(name, input, opts = {}) {
           }
         }
         if (_outsideScope(p)) return _scopeError(p);
+        // o rebase pode ter trocado o alvo: a pasta do ts é conferida de novo no caminho final
+        if (_rebased) { const g = _guardTsHome(p); if (g) return { erro: g }; }
+        // A leitura mascara os segredos conhecidos do ts: regravar o arquivo inteiro com o texto
+        // lido trocaria o valor real pela máscara (ex.: .env com a mesma chave do providers.json).
+        if (String(input.conteudo ?? '').includes(core.SECRET_MASK)) {
+          let atual = '';
+          try { if (fs.statSync(p).isFile()) atual = fs.readFileSync(p, 'utf8'); } catch (_) {}
+          if (atual && !atual.includes(core.SECRET_MASK)) return { erro: _MASK_WRITE_REFUSAL };
+        }
         const held = _acquireFileMutation(p); if (held.erro) return { erro: held.erro };
         try {
           fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -860,14 +1465,24 @@ async function execute(name, input, opts = {}) {
           }
         }
         if (_outsideScope(p)) return _scopeError(p);
+        { const g = _guardTsHome(p); if (g) return { erro: g }; } // de novo, no alvo final do rebase
+        // Sem "substituir" a edição APAGAVA o trecho buscado ('' por padrão). Apagar é pedido
+        // explícito: substituir vazio ("").
+        if (input.substituir === undefined || input.substituir === null) {
+          return { erro: 'Informe substituir (o texto novo). Para apagar o trecho buscado, passe substituir vazio ("").' };
+        }
         const held = _acquireFileMutation(p); if (held.erro) return { erro: held.erro };
         try {
         if (!fs.existsSync(p)) {
           const v = _vizinhos(p);
           return { erro: 'Arquivo não existe: ' + p + (v.length ? '. Nomes parecidos na mesma pasta: ' + v.join(', ') + ' — confira se não errou o nome.' : '') + ' Pra criar arquivo NOVO use escrever_arquivo.' };
         }
-        const orig = fs.readFileSync(p, 'utf8');
+        // Lê pelo descritor com a mesma checagem de identidade do ler_arquivo: um apelido de
+        // credencial do ts (hardlink, UNC por IP) não chega à mensagem de "Linha parecida" abaixo.
+        const orig = _readTextNotTsSecret(p);
+        if (typeof orig !== 'string') return orig;
         let buscar = String(input.buscar ?? ''), substituir = String(input.substituir ?? '');
+        if (substituir.includes(core.SECRET_MASK) && !orig.includes(core.SECRET_MASK)) return { erro: _MASK_WRITE_REFUSAL };
         if (substituir.includes('\uFFFD') && !orig.includes('\uFFFD')) return { erro: 'CODIFICAÇÃO BLOQUEADA: a edição introduziria o caractere de substituição �. Releia a fonte em UTF-8 e envie o texto correto.' };
         if (!buscar) return { erro: 'buscar vazio.' };
         // tolerância CRLF: o modelo manda \n mas arquivo Windows tem \r\n — normaliza o par
@@ -881,7 +1496,7 @@ async function execute(name, input, opts = {}) {
           const lines = orig.split(/\r?\n/);
           const idx = alvo ? lines.findIndex(l => l.includes(alvo.slice(0, 25))) : -1;
           return { erro: 'Trecho de "buscar" NÃO encontrado — tem que ser EXATO (mesmos espaços/indentação). '
-            + (idx >= 0 ? `Linha parecida (linha ${idx + 1}): ${lines[idx].slice(0, 160)} — releia com ler_arquivo e copie exato.` : 'Releia o arquivo com ler_arquivo e copie o trecho exato.') };
+            + (idx >= 0 ? `Linha parecida (linha ${idx + 1}): ${core.redactSecrets(lines[idx]).slice(0, 160)} — releia com ler_arquivo e copie exato.` : 'Releia o arquivo com ler_arquivo e copie o trecho exato.') };
         }
         if (count > 1 && !input.todas) return { erro: `Trecho AMBÍGUO: ${count} ocorrências. Inclua mais linhas de contexto em "buscar" pra ficar único, ou passe todas:true.` };
         const novo = input.todas ? orig.split(buscar).join(substituir) : orig.replace(buscar, substituir);
@@ -893,6 +1508,7 @@ async function execute(name, input, opts = {}) {
       case 'restaurar_arquivo': {
         const p = _abs(input.caminho, baseDir);
         if (_outsideScope(p)) return _scopeError(p);
+        { const g = _guardTsHome(p); if (g) return { erro: g }; }
         const held = _acquireFileMutation(p); if (held.erro) return { erro: held.erro };
         try {
         const dir = path.join(BK_DIR, _bkKey(p));
@@ -920,6 +1536,10 @@ async function execute(name, input, opts = {}) {
         // próximos caminhos relativos (e comandos) a partir daqui.
         const alvo = _abs(input.caminho || input.diretorio || '.', baseDir);
         if (_outsideScope(alvo)) return _scopeError(alvo);
+        // ~/.ts não vira pasta de trabalho: buscar_codigo indexaria as credenciais (o índice pula
+        // ".ts" só como SUBpasta) e caminhos relativos cairiam nelas. Skills e memória continuam
+        // legíveis pelo caminho completo.
+        if (_insideTsHome(alvo)) return { erro: 'RECUSADO: "' + alvo + '" é a área de configuração do ts (~/.ts) — ela não vira pasta de trabalho, porque guarda credenciais (token de sessão, chaves de IA, auth de MCP). Para ler uma skill ou a memória, use ler_arquivo com o caminho completo; para ver os nomes, listar_diretorio.' };
         let st; try { st = fs.statSync(alvo); } catch (_) { const v = _vizinhos(alvo); return { erro: 'Pasta não existe: ' + alvo + (v.length ? '. Nomes parecidos na pasta acima: ' + v.join(', ') : '') + '. Confira o caminho (use listar_diretorio/buscar_arquivos).' }; }
         if (!st.isDirectory()) return { erro: 'Não é uma pasta: ' + alvo };
         return { ok: true, cwd: alvo, _setCwd: alvo };
@@ -947,6 +1567,8 @@ async function execute(name, input, opts = {}) {
       case 'buscar_codigo': {
         const consulta = String(input.consulta || '').trim();
         if (!consulta) return { erro: 'consulta vazia' };
+        // dentro de ~/.ts o índice leria (e gravaria em .ts-indice.json) as credenciais do ts
+        if (_insideTsHome(baseDir)) return { erro: 'RECUSADO: a pasta de trabalho está dentro de ~/.ts (configuração e credenciais do ts) — buscar_codigo não indexa essa área. Mude para a pasta do projeto com mudar_diretorio.' };
         const ix = require('./indice');
         let idx = ix.load(baseDir);
         let construiu = false;
@@ -1063,6 +1685,7 @@ async function execute(name, input, opts = {}) {
       case 'ler_documento': {
         const target = _abs(input.caminho, baseDir);
         if (_outsideScope(target)) return _scopeError(target);
+        { const g = _guardTsSecretRead(target); if (g) return { erro: g }; }
         return await require('./office-readers').lerDocumento({ ...input, caminho: target });
       }
       case 'editar_documento': {
@@ -1070,6 +1693,7 @@ async function execute(name, input, opts = {}) {
         if (_outsideScope(target)) return _scopeError(target);
         const copy = input.caminho_copia ? _abs(input.caminho_copia, baseDir) : undefined;
         if (copy && _outsideScope(copy)) return _scopeError(copy);
+        for (const alvo of [target, copy]) { const g = alvo && _guardTsHome(alvo); if (g) return { erro: g }; }
         const held = _acquireFileMutation(target); if (held.erro) return { erro: held.erro };
         try {
           const result = await require('./office-editors').editarDocumento({ ...input, caminho: target, caminho_copia: copy });
@@ -1082,6 +1706,7 @@ async function execute(name, input, opts = {}) {
         if (_outsideScope(target)) return _scopeError(target);
         const copy = input.caminho_copia ? _abs(input.caminho_copia, baseDir) : undefined;
         if (copy && _outsideScope(copy)) return _scopeError(copy);
+        for (const alvo of [target, copy]) { const g = alvo && _guardTsHome(alvo); if (g) return { erro: g }; }
         const held = _acquireFileMutation(target); if (held.erro) return { erro: held.erro };
         try {
           const result = await require('./office-editors').editarPlanilha({ ...input, caminho: target, caminho_copia: copy });
@@ -1092,6 +1717,7 @@ async function execute(name, input, opts = {}) {
       case 'ler_planilha': {
         const target = _abs(input.caminho, baseDir);
         if (_outsideScope(target)) return _scopeError(target);
+        { const g = _guardTsSecretRead(target); if (g) return { erro: g }; }
         return await require('./office-readers').lerPlanilha({ ...input, caminho: target });
       }
       case 'status_microsoft365':
@@ -1182,6 +1808,7 @@ async function execute(name, input, opts = {}) {
       case 'ler_apresentacao': {
         const target = _abs(input.caminho, baseDir);
         if (_outsideScope(target)) return _scopeError(target);
+        { const g = _guardTsSecretRead(target); if (g) return { erro: g }; }
         return await require('./office-readers').lerApresentacao({ ...input, caminho: target });
       }
       case 'android_parear':
@@ -1197,6 +1824,7 @@ async function execute(name, input, opts = {}) {
       case 'android_capturar_tela': {
         const target = _abs(input.caminho, baseDir);
         if (_outsideScope(target)) return _scopeError(target);
+        { const g = _guardTsHome(target); if (g) return { erro: g }; }
         return await require('./device-tools').capturarTela({ ...input, caminho: target });
       }
       default: {
@@ -1212,5 +1840,7 @@ async function execute(name, input, opts = {}) {
   } catch (e) { return { erro: String((e && e.message) || e).slice(0, 400) }; }
 }
 
-module.exports = { DEFS, execute, isDestructive, selfDestructiveReason, secretExfiltrationReason, buildProjectMap,
-  _test: { shellGotcha: _shellGotcha, normalizeWindowsReadOnlyCommand: _normalizeWindowsReadOnlyCommand, commandScopeViolation: _commandScopeViolation, isReadOnlySearchNoMatch: _isReadOnlySearchNoMatch } };
+module.exports = { DEFS, execute, isDestructive, selfDestructiveReason, secretExfiltrationReason, tsSecretReadReason, buildProjectMap,
+  knownSecretValues, knownSecretsFor, maskKnownSecrets,
+  _test: { shellGotcha: _shellGotcha, normalizeWindowsReadOnlyCommand: _normalizeWindowsReadOnlyCommand, commandScopeViolation: _commandScopeViolation, isReadOnlySearchNoMatch: _isReadOnlySearchNoMatch, guardTsSecretRead: _guardTsSecretRead, remoteUnc: _remoteUnc,
+    guardTsHome: _guardTsHome, tsTextCitesSecret: _tsTextCitesSecret } };