terminal-smart-cli 0.97.29 → 0.97.31

package/lib/tools.js

@@ -6,6 +6,7 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 const compactor = require('./compactor');
+const fileLock = require('./file-lock');
 
 // ── SNAPSHOT antes de sobrescrever ──────────────────────────────────────────
 // Toda escrita/edição faz uma cópia do original em ~/.ts/backups/<hash>/<nome>.<ts>.bak
@@ -38,6 +39,23 @@ function _snapshot(absPath) {
 // pra compatibilidade (tools.isDestructive segue funcionando pra quem já importava).
 const { isDestructive } = require('./core');
 
+// Conteúdo de e-mail/site/arquivo pode tentar convencer o modelo a mandar
+// segredos para fora. O prompt ajuda, mas a defesa precisa existir também no
+// executor: se um comando combina transporte de rede com fonte sensível, ele
+// nunca é executado, inclusive quando foi formado por uma injeção indireta.
+function secretExfiltrationReason(cmd) {
+  const text = String(cmd || '');
+  const transports = /\b(?:curl|wget|invoke-webrequest|invoke-restmethod|iwr|irm)\b/i.test(text)
+    || /\b(?:fetch|axios|requests\.(?:get|post|put)|http\.request|https\.request)\b/i.test(text);
+  if (!transports) return null;
+  const sensitiveFile = /(?:^|[\s"'=:@])(?:~[\\/])?(?:\.env(?:\.[a-z0-9_-]+)?|\.ssh[\\/](?:id_[a-z0-9_-]+|authorized_keys|config)|(?:id_rsa|id_ed25519|credentials(?:\.json)?|service[-_]?account[^\s"']*\.json))\b/i.test(text);
+  const sensitiveRuntime = /\b(?:process\.env|os\.environ|\$env:|get-childitem\s+env:)\b/i.test(text);
+  if (sensitiveFile || sensitiveRuntime) {
+    return 'BLOQUEADO: possível exfiltração de segredo. Um comando de rede não pode ler/enviar .env, chaves SSH, credenciais ou variáveis de ambiente. Nunca transmita segredos; use apenas dados públicos explicitamente necessários.';
+  }
+  return null;
+}
+
 // Definições no formato OpenAI function-calling — schemas SIMPLES de propósito
 // (Gemini via CDC rejeita propertyNames/additionalProperties; só type/properties/required).
 const DEFS = [
@@ -382,11 +400,55 @@ function _guardTsHome(p) {
 // 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).
+// Apenas conversões de leitura, de UMA operação e sem encadeamento. Não tentamos
+// "adivinhar" comandos mutantes: nesses casos, a recusa explicada é mais segura.
+function _psLiteral(value) { return String(value || '').replace(/'/g, "''"); }
+function _normalizeWindowsReadOnlyCommand(cmd, platform = process.platform) {
+  if (platform !== 'win32') return null;
+  const s = String(cmd || '').trim();
+  if (!s || /[\r\n;&|><`]/.test(s) || /^\s*(?:powershell|pwsh)(?:\.exe)?\b/i.test(s)) return null;
+  const drivePath = (raw) => {
+    const found = String(raw || '').trim().match(/^\/([a-zA-Z])\/(.+)$/);
+    return found ? `${found[1].toUpperCase()}:\\${found[2].replace(/\//g, '\\')}` : String(raw || '').trim();
+  };
+  let m = s.match(/^grep\s+(-n\s+)?(?:--\s+)?(?:"([^"]+)"|'([^']+)'|(\S+))\s+([^\s]+)$/i);
+  if (m) {
+    const pattern = m[2] || m[3] || m[4];
+    const file = drivePath(m[5]);
+    return {
+      command: `powershell -NoProfile -Command "Select-String -LiteralPath '${_psLiteral(file)}' -Pattern '${_psLiteral(pattern)}' | ForEach-Object { '{0}:{1}' -f $_.LineNumber,$_.Line }"`,
+      note: 'grep convertido para Select-String (somente leitura).',
+    };
+  }
+  m = s.match(/^(tail|head)\s+-n\s+(\d{1,5})\s+([^\s]+)$/i);
+  if (m) {
+    const count = Math.min(10000, Math.max(1, Number(m[2])));
+    const file = drivePath(m[3]);
+    const part = m[1].toLowerCase() === 'tail' ? `-Tail ${count}` : `-TotalCount ${count}`;
+    return {
+      command: `powershell -NoProfile -Command "Get-Content -LiteralPath '${_psLiteral(file)}' ${part}"`,
+      note: `${m[1].toLowerCase()} convertido para Get-Content (somente leitura).`,
+    };
+  }
+  if (/^ls(?:\s+-[a-z]+)?$/i.test(s)) return { command: 'dir /a', note: 'ls convertido para dir /a (somente leitura).' };
+  if (/^pwd$/i.test(s)) return { command: 'cd', note: 'pwd convertido para cd (somente leitura).' };
+  return null;
+}
+
 // Gotchas de shell no Windows que falham de um jeito CONFUSO (o agente perdia vários
 // passos tentando de novo). Devolve a mensagem com o CONSERTO pronto, ou null.
 function _shellGotcha(cmd) {
   const s = String(cmd || '');
   const multi = /[\r\n]/.test(s);
+  // executar_comando usa cmd.exe. Modelos alternam facilmente entre os dois
+  // dialetos e `Select-String`/`Get-Content` soltos viram "não reconhecido",
+  // desperdiçando uma rodada antes de o recovery engine conseguir explicar.
+  // Recusar antes da execução preserva a etapa e entrega a forma correta.
+  if (process.platform === 'win32'
+      && !/^\s*(?:powershell|pwsh)(?:\.exe)?\b/i.test(s)
+      && /(?:^|[&|]\s*|\s)(?:Select-String|Get-(?:Content|ChildItem|Item|FileHash|NetTCPConnection)|Test-Path|Set-(?:Content|Location)|Add-Content|Remove-Item|Copy-Item|Move-Item|New-Item)(?:\s|$)/i.test(s)) {
+    return 'Este shell é cmd.exe, mas o comando é do PowerShell. Chame explicitamente: powershell -NoProfile -Command "<comando>". Não repita o cmdlet solto.';
+  }
   // python -c / node -e multilinha ou com import() dinâmico: quebra no eval / morre calado
   if (/\bpython3?\s+-c\b/.test(s) && multi)
     return 'python -c MULTILINHA falha em silêncio no Windows. Escreva um arquivo .py com escrever_arquivo e rode "python arquivo.py".';
@@ -410,6 +472,39 @@ function _shellGotcha(cmd) {
   return null;
 }
 
+// `path.resolve` protege contra "..", mas não contra `raiz/link -> /fora`.
+// Para não ler/escrever através de junction/symlink, comparamos também o caminho
+// REAL do alvo (ou do ancestral existente quando o arquivo ainda será criado).
+function _pathStartsWith(child, parent) {
+  const norm = (p) => process.platform === 'win32' ? String(p).toLowerCase() : String(p);
+  const c = norm(child), r = norm(parent);
+  return c === r || c.startsWith(r + path.sep);
+}
+function _nearestExistingReal(p) {
+  let cur = path.resolve(p);
+  for (;;) {
+    try { return fs.realpathSync.native ? fs.realpathSync.native(cur) : fs.realpathSync(cur); } catch (_) {}
+    const parent = path.dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+function _scopeContains(confineDir, candidate) {
+  const root = path.resolve(confineDir);
+  const abs = path.resolve(candidate);
+  if (!_pathStartsWith(abs, root)) return false;
+  const rootReal = _nearestExistingReal(root);
+  const targetReal = _nearestExistingReal(abs);
+  // Se não conseguimos resolver (raiz removida no meio da operação), falha
+  // fechada: é mais seguro recusar que abrir caminho fora da missão.
+  return !!rootReal && !!targetReal && _pathStartsWith(targetReal, rootReal);
+}
+function _acquireFileMutation(target) {
+  const lock = fileLock.acquire(target);
+  if (lock) return { lock };
+  return { erro: 'ARQUIVO_OCUPADO: outro processo do Terminal Smart está alterando este arquivo. Aguarde e tente uma vez; nunca force a remoção do lock.' };
+}
+
 function _commandScopeViolation(cmd, confineDir) {
   if (!confineDir) return null;
   const text = String(cmd || '');
@@ -422,9 +517,14 @@ function _commandScopeViolation(cmd, confineDir) {
   const candidates = [];
   for (const m of text.matchAll(/[A-Za-z]:[\\/][^ \t\r\n"'|;&<>]*/g)) candidates.push(m[0]);
   for (const m of text.matchAll(/(?:^|[\s"'=])((?:\/(?!\/))[^ \t\r\n"'|;&<>]*)/g)) candidates.push(m[1]);
+  // Alvos relativos (ex.: `echo x > link/arquivo`) também podem atravessar
+  // um symlink. Capturamos apenas tokens com separador, ignorando flags/URLs.
+  for (const m of text.matchAll(/(?:^|[\s"'=<>])((?:\.?[\\/])?[A-Za-z0-9_.@-]+(?:[\\/][A-Za-z0-9_.@-]+)+)/g)) {
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(m[1])) candidates.push(m[1]);
+  }
   for (const raw of candidates) {
-    const abs = path.resolve(raw);
-    if (abs !== root && !abs.startsWith(root + path.sep)) {
+    const abs = path.resolve(root, raw);
+    if (!_scopeContains(root, abs)) {
       return `CAPABILITY_DENIED: comando mutante referencia "${raw}", fora da raiz autorizada "${root}".`;
     }
   }
@@ -553,9 +653,7 @@ async function execute(name, input, opts = {}) {
   }
   const _outsideScope = (p) => {
     if (!opts.confineDir) return false;
-    const root = path.resolve(opts.confineDir);
-    const abs = path.resolve(p);
-    return abs !== root && !abs.startsWith(root + path.sep);
+    return !_scopeContains(opts.confineDir, p);
   };
   const _scopeError = (p) => ({ erro: `CAPABILITY_DENIED: "${path.resolve(p)}" está fora da raiz autorizada "${path.resolve(opts.confineDir)}".` });
   try {
@@ -563,6 +661,7 @@ async function execute(name, input, opts = {}) {
       case 'executar_comando': {
         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 }; }
         // 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 }; }
@@ -570,14 +669,16 @@ async function execute(name, input, opts = {}) {
         // Barrar ANTES de rodar (com o conserto na mão) economiza o ciclo erro→tentativa→erro
         // que o agente repetia: python -c multilinha morria em silêncio, node -e com import()
         // quebrava no eval, e `timeout /t` (cmd) virava o timeout do coreutils sob git-bash.
-        { const g = _shellGotcha(comando); if (g) return { erro: g }; }
+        const normalized = _normalizeWindowsReadOnlyCommand(comando);
+        const comandoExecutado = normalized ? normalized.command : comando;
+        { const g = _shellGotcha(comandoExecutado); if (g) return { erro: g }; }
         // Comandos de INSTALL/BUILD (apt/npm/pip/make/gcc/docker build…) levam muito mais que 60s —
         // sem isso o apt-get de vários pacotes MORRIA no timeout padrão (nada instalava, em silêncio).
         // Eles ganham 10min de default (até 30min se o agente pedir timeout_s); resto segue 60s.
-        const _slow = /(^|[\s;|&(])(apt|apt-get|aptitude|dpkg|yum|dnf|zypper|pacman|snap|brew|pip|pip3|npm|yarn|pnpm|gem|cargo|go\s+(get|build|install)|make|cmake|meson|ninja|gcc|g\+\+|clang|mvn|gradle|\.\/gradlew|dotnet|composer|bundle|flutter\s+(build|pub)|docker\s+(build|pull|compose)|configure|\.\/configure|\.\/build)([\s;|&)]|$)/i.test(comando);
+        const _slow = /(^|[\s;|&(])(apt|apt-get|aptitude|dpkg|yum|dnf|zypper|pacman|snap|brew|pip|pip3|npm|yarn|pnpm|gem|cargo|go\s+(get|build|install)|make|cmake|meson|ninja|gcc|g\+\+|clang|mvn|gradle|\.\/gradlew|dotnet|composer|bundle|flutter\s+(build|pub)|docker\s+(build|pull|compose)|configure|\.\/configure|\.\/build)([\s;|&)]|$)/i.test(comandoExecutado);
         const _dflt = _slow ? 600 : 60;
         const timeout = Math.min(1800, Math.max(5, Number(input.timeout_s) || _dflt)) * 1000;
-        const cmd = process.platform === 'win32' ? `chcp 65001>nul & ${comando}` : comando;
+        const cmd = process.platform === 'win32' ? `chcp 65001>nul & ${comandoExecutado}` : comandoExecutado;
         return await new Promise((res) => {
           require('child_process').exec(cmd, { timeout, shell: true, windowsHide: true, maxBuffer: 4 * 1024 * 1024, cwd: fs.existsSync(baseDir) ? baseDir : undefined }, (e, out, err) => {
             const c = compactor.compact(comando, out || '', { codigo: e?.code ?? 0 });
@@ -585,6 +686,7 @@ async function execute(name, input, opts = {}) {
             const _rd = require('./core').redactSecrets;
             const r = { stdout: _rd(c.out), stderr: _rd(compactor.stripAnsi(err || '').slice(0, 1500)), codigo: e?.code ?? 0 };
             if (c.note) r.aviso = c.note;
+            if (normalized) r.normalizado = normalized.note;
             if (!r.stdout.trim() && !r.stderr.trim() && r.codigo === 0 && /python3? -c/.test(comando) && comando.includes('\n'))
               r.aviso = 'stdout VAZIO: no Windows, python -c multi-linha falha em silêncio. ESCREVA um .py com escrever_arquivo e rode "python arquivo.py".';
             res(r);
@@ -683,16 +785,20 @@ async function execute(name, input, opts = {}) {
             _rebased = p;
           }
         }
-        fs.mkdirSync(path.dirname(p), { recursive: true });
-        const existed = fs.existsSync(p);
-        // O caminho do backup era DESCARTADO aqui. Agora volta no resultado (_backup) pra
-        // o loop registrar no checkpoint da sessão e permitir o "desfaz tudo".
-        const _bk = existed ? _snapshot(p) : null; // backup antes de sobrescrever
-        fs.writeFileSync(p, String(input.conteudo ?? ''), 'utf8');
-        const r = { ok: true, caminho: p, bytes: Buffer.byteLength(String(input.conteudo ?? '')), sobrescreveu: existed };
-        r._backup = _bk || ''; r._acao = existed ? 'alterado' : 'criado';
-        if (_rebased) r.aviso = 'Caminho fora do diretório de trabalho foi RE-BASEADO para dentro dele. Use ESTE caminho a partir de agora: ' + p;
-        return r;
+        if (_outsideScope(p)) return _scopeError(p);
+        const held = _acquireFileMutation(p); if (held.erro) return { erro: held.erro };
+        try {
+          fs.mkdirSync(path.dirname(p), { recursive: true });
+          const existed = fs.existsSync(p);
+          // O caminho do backup era DESCARTADO aqui. Agora volta no resultado (_backup) pra
+          // o loop registrar no checkpoint da sessão e permitir o "desfaz tudo".
+          const _bk = existed ? _snapshot(p) : null; // backup antes de sobrescrever
+          fs.writeFileSync(p, String(input.conteudo ?? ''), 'utf8');
+          const r = { ok: true, caminho: p, bytes: Buffer.byteLength(String(input.conteudo ?? '')), sobrescreveu: existed };
+          r._backup = _bk || ''; r._acao = existed ? 'alterado' : 'criado';
+          if (_rebased) r.aviso = 'Caminho fora do diretório de trabalho foi RE-BASEADO para dentro dele. Use ESTE caminho a partir de agora: ' + p;
+          return r;
+        } finally { held.lock.release(); }
       }
       case 'editar_arquivo': {
         // Edição por ÂNCORA (ideia do hashline do OMYP): troca SÓ o trecho buscado, sem
@@ -708,6 +814,9 @@ async function execute(name, input, opts = {}) {
             p = path.join(base, i >= 0 ? parts.slice(i).join(path.sep) : parts[parts.length - 1]);
           }
         }
+        if (_outsideScope(p)) return _scopeError(p);
+        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.' };
@@ -733,10 +842,13 @@ async function execute(name, input, opts = {}) {
         const _bk2 = _snapshot(p); // backup antes de editar (reversível via restaurar_arquivo)
         fs.writeFileSync(p, novo, 'utf8');
         return { ok: true, caminho: p, ocorrencias: input.todas ? count : 1, bytes_antes: Buffer.byteLength(orig), bytes_depois: Buffer.byteLength(novo), _backup: _bk2 || '', _acao: 'alterado' };
+        } finally { held.lock.release(); }
       }
       case 'restaurar_arquivo': {
         const p = _abs(input.caminho, baseDir);
         if (_outsideScope(p)) return _scopeError(p);
+        const held = _acquireFileMutation(p); if (held.erro) return { erro: held.erro };
+        try {
         const dir = path.join(BK_DIR, _bkKey(p));
         let baks = [];
         try { baks = fs.readdirSync(dir).filter(f => f.endsWith('.bak')).sort(); } catch (_) {}
@@ -745,6 +857,7 @@ async function execute(name, input, opts = {}) {
         _snapshot(p); // guarda o estado ATUAL antes de reverter (permite "refazer")
         fs.copyFileSync(ultimo, p);
         return { ok: true, caminho: p, restaurado: true, de_backup: path.basename(ultimo) };
+        } finally { held.lock.release(); }
       }
       case 'listar_diretorio': {
         const p = _abs(input.caminho || '.', baseDir);
@@ -909,18 +1022,24 @@ 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);
-        const result = await require('./office-editors').editarDocumento({ ...input, caminho: target, caminho_copia: copy });
-        if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
-        return result;
+        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 });
+          if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
+          return result;
+        } finally { held.lock.release(); }
       }
       case 'editar_planilha': {
         const target = _abs(input.caminho, baseDir);
         if (_outsideScope(target)) return _scopeError(target);
         const copy = input.caminho_copia ? _abs(input.caminho_copia, baseDir) : undefined;
         if (copy && _outsideScope(copy)) return _scopeError(copy);
-        const result = await require('./office-editors').editarPlanilha({ ...input, caminho: target, caminho_copia: copy });
-        if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
-        return result;
+        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 });
+          if (result.ok) { result._backup = result.backup || ''; result._acao = result.editou_original ? 'alterado' : 'criado'; }
+          return result;
+        } finally { held.lock.release(); }
       }
       case 'ler_planilha': {
         const target = _abs(input.caminho, baseDir);
@@ -1045,4 +1164,5 @@ async function execute(name, input, opts = {}) {
   } catch (e) { return { erro: String((e && e.message) || e).slice(0, 400) }; }
 }
 
-module.exports = { DEFS, execute, isDestructive, selfDestructiveReason, buildProjectMap, _test: { shellGotcha: _shellGotcha } };
+module.exports = { DEFS, execute, isDestructive, selfDestructiveReason, secretExfiltrationReason, buildProjectMap,
+  _test: { shellGotcha: _shellGotcha, normalizeWindowsReadOnlyCommand: _normalizeWindowsReadOnlyCommand } };

package/lib/ui.js

@@ -129,6 +129,11 @@ const _TOOL_PT = {
   navegador: 'Navegando na web', explorar: 'Explorando o projeto', lembrar: 'Salvando na memória',
   skill_gerenciar: 'Ajustando uma habilidade', compactar_contexto: 'Resumindo o histórico',
   pedir_ajuda_humano: 'Pedindo sua ajuda', ler_planilha: 'Lendo a planilha',
+  ler_planilha_office_web: 'Lendo a planilha', editar_planilha_office_web: 'Editando a planilha',
+  ler_documento_office_web: 'Lendo o documento', editar_documento_office_web: 'Editando o documento',
+  ler_apresentacao_office_web: 'Lendo a apresentação', editar_apresentacao_office_web: 'Editando a apresentação',
+  google_mail_list: 'Verificando e-mails', google_mail_search: 'Procurando e-mails', google_mail_draft: 'Criando rascunho de e-mail',
+  microsoft_mail_list: 'Verificando e-mails', microsoft_mail_search: 'Procurando e-mails', microsoft_mail_draft: 'Criando rascunho de e-mail',
 };
 const _TOOL_EN = {
   executar_comando: 'Running command', executar_remoto: 'Running on the server',
@@ -139,6 +144,11 @@ const _TOOL_EN = {
   navegador: 'Browsing the web', explorar: 'Exploring the project', lembrar: 'Saving to memory',
   skill_gerenciar: 'Tuning a skill', compactar_contexto: 'Summarizing history',
   pedir_ajuda_humano: 'Asking for your help', ler_planilha: 'Reading the spreadsheet',
+  ler_planilha_office_web: 'Reading the spreadsheet', editar_planilha_office_web: 'Editing the spreadsheet',
+  ler_documento_office_web: 'Reading the document', editar_documento_office_web: 'Editing the document',
+  ler_apresentacao_office_web: 'Reading the presentation', editar_apresentacao_office_web: 'Editing the presentation',
+  google_mail_list: 'Checking email', google_mail_search: 'Searching email', google_mail_draft: 'Creating an email draft',
+  microsoft_mail_list: 'Checking email', microsoft_mail_search: 'Searching email', microsoft_mail_draft: 'Creating an email draft',
 };
 function friendlyTool(name, en) {
   const map = en ? _TOOL_EN : _TOOL_PT;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.97.29",
+  "version": "0.97.31",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"
   },
   "scripts": {
-    "test": "node test/core.test.js && node test/audit-packs.test.js && node test/intelligence-core.test.js && node test/cloud-slug.test.js && node test/eval-model.test.js && node test/project-cache.test.js && node test/memory-bus.test.js && node test/capabilities.test.js && node test/mcp-e2e.test.js && node test/erros.test.js && node test/evolution-telemetry.test.js && node test/capability-pack.test.js && node test/video-generation.test.js && node test/image-job.test.js && node test/byok.test.js && node test/conhecimento.test.js && node test/policy.test.js && node test/temas.test.js && node test/skill-index.test.js && node test/doctor.test.js && node test/google-workspace-tools.test.js && node test/office-editors.test.js"
+    "test": "node test/core.test.js && node test/windows-shell-normalization.test.js && node test/gateways.test.js && node test/agent-recovery-guard.test.js && node test/agent-plan-model-contract.test.js && node test/agent-mission-limits.test.js && node test/agent-external-approval.test.js && node test/agent-prompt-injection.test.js && node test/file-concurrency.test.js && node test/mission-observability.test.js && node test/audit-packs.test.js && node test/intelligence-core.test.js && node test/cloud-slug.test.js && node test/eval-model.test.js && node test/project-cache.test.js && node test/memory-bus.test.js && node test/capabilities.test.js && node test/mcp-e2e.test.js && node test/erros.test.js && node test/evolution-telemetry.test.js && node test/owner-audit.test.js && node test/capability-pack.test.js && node test/video-generation.test.js && node test/image-job.test.js && node test/byok.test.js && node test/conhecimento.test.js && node test/policy.test.js && node test/temas.test.js && node test/skill-index.test.js && node test/doctor.test.js && node test/google-workspace-tools.test.js && node test/office-editors.test.js"
   },
   "files": [
     "bin",