terminal-smart-cli 0.98.0 → 0.99.0

package/lib/i18n.js

@@ -14,6 +14,14 @@ const STR = {
         ['ts qr', 'QR pra continuar a conversa no celular'],
         ['ts nova', 'zera o contexto da conversa'],
       ] },
+      { title: 'Hub (celular pareado)', items: [
+        ['ts hub iniciar', 'inicia o hub: conexão de saída com o relay (deixe rodando)'],
+        ['ts hub parear', 'QR de uso único para parear o celular; você confirma aqui no PC'],
+        ['ts hub aparelhos', 'lista os aparelhos pareados'],
+        ['ts hub revogar <id>', 'revoga um aparelho e corta a sessão dele na hora'],
+        ['ts hub status', 'estado do hub (relay, aparelhos, Parar tudo)'],
+        ['ts hub exportar-telas', 'grava as telas do tmux (janelas permitidas, com máscara de segredos) para o hub ler'],
+      ] },
       { title: 'Galeria de Skills (comunidade)', items: [
         ['ts skills', 'lista as skills da comunidade (mais instaladas)'],
         ['ts skills ver <slug>', 'lê a skill INTEIRA antes de instalar'],
@@ -39,12 +47,12 @@ const STR = {
       { title: 'Agente LOCAL (mãos nesta máquina)', items: [
         ['ts agente "tarefa"', 'executa DE VERDADE aqui: comandos, arquivos, diagnóstico'],
         ['ts agente "..." --ferramentas a,b', 'ESCOPO ESTRITO: somente as ferramentas autorizadas entram na missão'],
-        ['ts agente "..." --yes', 'autônomo (destrutivo pede aprovação no Telegram)'],
+        ['ts agente "..." --yes', 'autônomo (o que exige aprovação é recusado — não há quem aprove no terminal)'],
         ['ts diagnosticar "erro"', 'INVESTIGA a causa raiz: hipótese→sonda→veredito (só-leitura)'],
         ['ts diagnosticar "..." --remoto "ssh user@host"', 'investiga uma máquina remota'],
         ['ts diagnosticar "..." --registrar', 'salva a investigação como nota em .ts-conhecimento (inclusive o que foi REFUTADO)'],
-        ['ts sentinela add "nome" --cmd "..."', 'VIGIA determinístico (regra do if, ZERO token); --escalar diagnostica se falhar; --autofix conserta (com aprovação no Telegram)'],
-        ['ts sentinela instalar', 'agenda os checks no SO (cron/Task Scheduler) e avisa no Telegram'],
+        ['ts sentinela add "nome" --cmd "..."', 'VIGIA determinístico (regra do if, ZERO token); --escalar diagnostica se falhar; --autofix propõe o conserto e só aplica com sua aprovação no terminal'],
+        ['ts sentinela instalar', 'agenda os checks no SO (cron/Task Scheduler)'],
         ['ts agente --continuar "..."', 'retoma o trabalho anterior desta pasta'],
         ['ts agente "..." --yolo', 'FULL-AUTO: aprova TUDO na sessão, inclusive destrutivos (o gate anti-catástrofe ~/.ts/máquina segue ativo)'],
         ['ts agente "..." --navegador', 'EXPERIMENTAL: dá um Chrome real ao agente (abrir/ler/clicar/print+visão)'],
@@ -63,8 +71,10 @@ const STR = {
         ['ts politica testar "rm -rf build"', 'mostra o veredito e DE QUAL regra veio'],
         ['ts checkpoints', 'o que o agente mudou em cada sessão'],
         ['ts desfazer --sessao [id]', 'DESFAZ TUDO o que o agente fez na sessão (pula o que você editou depois)'],
-        ['ts conectar', 'usa SUA chave de IA (NVIDIA/Google/Cerebras/Groq/Ollama) em vez dos créditos'],
-        ['ts conectar nuvem', 'volta a usar os créditos do TS'],
+        ['ts conectar', 'conecta SUA chave de IA (NVIDIA/Google/Cerebras/Groq/OpenRouter) ou o Ollama local — o agente roda via sua chave'],
+        ['ts ia conectar chatgpt|claude', 'login oficial do Codex/Claude Code NESTE PC — chat e agente rodam via sua assinatura'],
+        ['ts ia status · ts ia usar chatgpt|claude', 'mostra/escolhe a IA da sua conta neste PC (automatico volta para a sua chave)'],
+        ['ts conectar nuvem', 'desativa a chave própria (volta à IA da conta: sua assinatura ou os créditos legados que restarem)'],
       ] },
       { title: 'Agentes na nuvem (orquestração)', items: [
         ['ts run "objetivo"', 'planeja → você aprova → executa'],
@@ -74,7 +84,7 @@ const STR = {
       ] },
       { title: 'Conta', items: [
         ['ts login · ts logout', 'conecta / desconecta este terminal'],
-        ['ts uso', 'créditos e consumo do mês'],
+        ['ts uso', 'plano, IA em uso e créditos legados (se houver)'],
         ['ts quem', 'conta conectada'],
         ['ts conta exportar', 'baixa seus dados sem senhas, tokens ou chaves privadas'],
         ['ts conta abrir', 'abre Minha Conta para privacidade e exclusão segura'],
@@ -87,7 +97,7 @@ const STR = {
         ['ts idioma pt|en', 'idioma (padrão pt-BR)'],
       ] },
     ],
-    help_footer: 'Cada uso debita dos seus Smart Credits — acompanhe com `ts uso`.',
+    help_footer: 'A IA roda via sua chave (`ts conectar`), via sua assinatura (`ts ia conectar`) ou via Ollama local — veja qual está em uso com `ts uso`.',
     repl_hello: 'converse naturalmente — eu identifico se é pergunta, ação ou objetivo · /ajuda · sair',
     onboard_title: 'Primeira vez? É só conversar — sem comando nenhum.',
     onboard_lines: [
@@ -99,7 +109,7 @@ const STR = {
     route_agent: 'isso pede ações nesta máquina — agindo como agente (digite /chat antes da frase pra só conversar)',
     route_run: 'objetivo grande — planejando com a equipe de agentes (você aprova antes de gastar)',
     repl_account: (u, p) => `conta ${u} · plano ${p}`,
-    repl_credits: (c) => `${c} créditos`,
+    repl_credits: (c) => `${c} créditos legados`,
     repl_help: [
       ['digite qualquer coisa', 'conversa em linguagem natural'],
       ['/agente "tarefa"', 'executa DE VERDADE nesta máquina (comandos, arquivos)'],
@@ -110,7 +120,7 @@ const STR = {
       ['/custo', 'quanto está gastando (ou de quem é a conta)'],
       ['/tema [nome]', 'troca a paleta do terminal'],
       ['/limpar', 'limpa a tela (o contexto continua)'],
-      ['/uso', 'créditos do mês'],
+      ['/uso', 'plano e IA em uso'],
       ['/nova', 'zera o contexto'],
       ['sair', 'encerra'],
     ],
@@ -143,11 +153,17 @@ const STR = {
     run_paused: (r) => `Pausada (${r}). Retome pela web ou app.`,
     runs_title: 'Últimas orquestrações',
     runs_empty: 'Nenhuma orquestração ainda. Comece com: ts run "objetivo"',
-    uso_title: 'Uso do mês',
+    uso_title: 'Uso e IA da conta',
     uso_plan: 'Plano',
+    uso_ai: 'IA em uso',
+    uso_ai_none: 'nenhuma IA própria conectada — use `ts conectar <provedor>` ou `ts ia conectar chatgpt|claude`',
+    uso_ai_unknown: 'não consegui confirmar a IA da conta agora (sem resposta do servidor) — veja depois com `ts uso` ou `ts ia status`',
+    uso_ai_sub_disconnected: (label, prov) => `modo ${label} selecionado, mas a CLI da conta não está pronta neste PC — o chat e o agente não rodam assim; faça o login com \`ts ia conectar ${prov}\` ou volte com \`ts ia usar automatico\``,
+    uso_ai_sub_not_selected: (prov) => `conta logada neste PC, mas não selecionada — use \`ts ia usar ${prov}\``,
+    byok_no_balance: (prov) => `Sua chave própria do ${prov} recusou a chamada por saldo ou limite no provedor. Nada foi cobrado pelo Terminal Smart. Adicione saldo no provedor, troque de provedor com \`ts conectar <provedor>\` (ou Ollama local) ou use sua assinatura com \`ts ia conectar chatgpt|claude\`.`,
     uso_remaining: 'restantes',
     uso_unlimited: 'ilimitado',
-    uso_credits: 'créditos',
+    uso_credits: 'créditos legados',
     uso_last: 'Últimos usos',
     quem_title: 'Conta conectada',
     quem_user: 'Usuário',
@@ -158,18 +174,21 @@ const STR = {
     lang_invalid: 'Idioma não suportado. Use: ts idioma pt  ou  ts idioma en',
     err_conn: 'Não consegui falar com o servidor. Verifique sua internet e tente de novo.',
     err_generic: 'Algo deu errado',
-    no_credits: 'Seu limite de IA acabou. O Free renova diariamente; planos pagos renovam por ciclo. Continue agora em terminalsmart.com.br/planos',
+    no_credits: 'A IA do Terminal Smart não está disponível para esta execução (sem créditos legados). Use a sua: `ts conectar <provedor>` (sua chave ou Ollama local) ou `ts ia conectar chatgpt|claude` (sua assinatura).',
     ask_empty: 'Diga o que você precisa. Ex.:  ts "como liberar a porta 443 no ufw?"',
     chat_hint: 'digite sua mensagem · "sair" encerra · "/nova" zera o contexto',
     chat_prompt: 'Você › ',
-    chat_bye: 'Até logo! A conversa continua salva na web (/ia).',
+    chat_bye: 'Até logo! O histórico desta pasta fica salvo só neste PC (`ts nova` limpa).',
     agent_need: 'Descreva a tarefa. Ex.:  ts agente "libere espaço em disco analisando as pastas maiores"',
     agent_thinking: 'agente pensando',
     agent_blocked: 'bloqueado pelo harness',
     agent_approve: (cmd) => `O agente quer rodar um comando DESTRUTIVO:\n\n    ${cmd}\n\n  Permitir? (s/N) `,
-    agent_footer: (st, cr, s) => `${st} passo(s) · ${cr} créditos · ${s}`,
-    agent_footer_byok: (st, prov, s) => `${st} passo(s) · sua chave (${prov}) · ${s}`,
-    agent_remote_wait: (ttl) => `comando destrutivo — pedido de aprovação enviado no seu Telegram (responda em até ${Math.round(ttl / 60)} min; sem resposta = negado)`,
+    agent_footer: (st, cr, s) => `${st} passo(s) · ${cr} créditos legados · ${s}`,
+    agent_footer_byok: (st, prov, s) => `${st} passo(s) · via sua chave (${prov}) · ${s}`,
+    agent_footer_via: (st, via, s) => `${st} passo(s) · ${via} · ${s}`,
+    via_key: (prov) => `via sua chave (${prov})`,
+    via_subscription: 'via sua assinatura',
+    via_ollama: 'via Ollama local',
     meta_need: 'Descreva o objetivo. Ex.:  ts meta "monte um site de portfólio completo nesta pasta" --budget 300',
     meta_title: 'MISSÃO',
     meta_exists: (g) => `Já existe uma missão em andamento neste diretório ("${g.slice(0, 60)}…"). Rode "ts meta" sem objetivo pra RETOMAR, ou use --novo pra recomeçar do zero.`,
@@ -203,6 +222,14 @@ const STR = {
         ['ts qr', 'QR to continue the conversation on your phone'],
         ['ts nova', 'reset the conversation context'],
       ] },
+      { title: 'Hub (paired phone)', items: [
+        ['ts hub iniciar', 'start the hub: outbound connection to the relay (keep it running)'],
+        ['ts hub parear', 'one-time QR to pair your phone; you confirm here on the PC'],
+        ['ts hub aparelhos', 'list paired devices'],
+        ['ts hub revogar <id>', 'revoke a device and cut its session right away'],
+        ['ts hub status', 'hub status (relay, devices, Stop all)'],
+        ['ts hub exportar-telas', 'write tmux screens (allowed windows, secrets masked) for the hub to read'],
+      ] },
       { title: 'Skills gallery (community)', items: [
         ['ts skills', 'list community skills (most installed)'],
         ['ts skills ver <slug>', 'read the WHOLE skill before installing'],
@@ -220,12 +247,12 @@ const STR = {
       { title: 'LOCAL agent (hands on this machine)', items: [
         ['ts agente "task"', 'actually does it here: commands, files, diagnosis'],
         ['ts agente "..." --tools a,b', 'STRICT SCOPE: only authorized tools enter the mission'],
-        ['ts agente "..." --yes', 'autonomous (destructive asks on Telegram)'],
+        ['ts agente "..." --yes', 'autonomous (anything that needs approval is refused — nobody at the terminal to approve)'],
         ['ts agente --continuar "..."', 'resume this folder\'s previous work'],
         ['ts agente "..." --yolo', 'FULL-AUTO: approves EVERYTHING this session, destructive included (~/.ts & machine anti-catastrophe still on)'],
         ['ts agente "..." --navegador', 'EXPERIMENTAL: gives the agent a real Chrome (open/read/click/print+vision)'],
         ['ts sentinela add "name" --cmd "..."', 'DETERMINISTIC watch (if-rule, ZERO tokens); escalates to AI only on failure'],
-        ['ts sentinela instalar', 'schedule checks on the OS (cron/Task Scheduler), alert on Telegram'],
+        ['ts sentinela instalar', 'schedule checks on the OS (cron/Task Scheduler)'],
         ['ts meta "big goal"', 'MISSION: checklist + rounds until done (overnight)'],
         ['ts meta --status', 'mission state for this directory'],
         ['ts eval suite.json', 'grade the agent on a case suite (AI judge + score)'],
@@ -235,8 +262,10 @@ const STR = {
         ['ts politica testar "rm -rf build"', 'shows the verdict and WHICH rule produced it'],
         ['ts checkpoints', 'what the agent changed in each session'],
         ['ts desfazer --sessao [id]', 'UNDO everything the agent did in that session (skips what you edited after)'],
-        ['ts conectar', 'use YOUR own AI key (NVIDIA/Google/Cerebras/Groq/Ollama) instead of credits'],
-        ['ts conectar nuvem', 'switch back to TS credits'],
+        ['ts conectar', 'connect YOUR AI key (NVIDIA/Google/Cerebras/Groq/OpenRouter) or local Ollama — the agent runs via your key'],
+        ['ts ia conectar chatgpt|claude', 'official Codex/Claude Code login ON THIS PC — chat and agent run via your subscription'],
+        ['ts ia status · ts ia usar chatgpt|claude', 'show/choose your account AI on this PC (automatico goes back to your key)'],
+        ['ts conectar nuvem', 'turn off your own key (back to the account AI: your subscription or any remaining legacy credits)'],
       ] },
       { title: 'Cloud agents (orchestration)', items: [
         ['ts run "goal"', 'plan → you approve → execute'],
@@ -246,7 +275,7 @@ const STR = {
       ] },
       { title: 'Account', items: [
         ['ts login · ts logout', 'connect / disconnect this terminal'],
-        ['ts uso', 'monthly credits and usage'],
+        ['ts uso', 'plan, AI in use and legacy credits (if any)'],
         ['ts quem', 'connected account'],
         ['ts account export', 'download your data without passwords, tokens or private keys'],
         ['ts account open', 'open Account for privacy controls and safe deletion'],
@@ -258,7 +287,7 @@ const STR = {
         ['ts idioma pt|en', 'language (default pt-BR)'],
       ] },
     ],
-    help_footer: 'Every use debits your Smart Credits — track it with `ts uso`.',
+    help_footer: 'AI runs via your key (`ts conectar`), via your subscription (`ts ia conectar`) or via local Ollama — see which one is in use with `ts uso`.',
     repl_hello: 'chat naturally — I detect question, action or big goal · /help · exit',
     onboard_title: 'First time? Just talk — no commands needed.',
     onboard_lines: [
@@ -270,7 +299,7 @@ const STR = {
     route_agent: 'this needs actions on this machine — acting as agent (prefix /chat to just talk)',
     route_run: 'big goal — planning with the agent team (you approve before spending)',
     repl_account: (u, p) => `account ${u} · plan ${p}`,
-    repl_credits: (c) => `${c} credits`,
+    repl_credits: (c) => `${c} legacy credits`,
     repl_help: [
       ['type anything', 'natural language chat'],
       ['/agente "task"', 'actually does it on this machine (commands, files)'],
@@ -281,7 +310,7 @@ const STR = {
       ['/custo', 'what it is costing (and whose bill it is)'],
       ['/tema [name]', 'switch the terminal palette'],
       ['/limpar', 'clear the screen (context stays)'],
-      ['/uso', 'monthly credits'],
+      ['/uso', 'plan and AI in use'],
       ['/nova', 'reset context'],
       ['exit', 'quit'],
     ],
@@ -314,11 +343,17 @@ const STR = {
     run_paused: (r) => `Paused (${r}). Resume on the web or app.`,
     runs_title: 'Recent orchestrations',
     runs_empty: 'No orchestrations yet. Start with: ts run "goal"',
-    uso_title: 'Monthly usage',
+    uso_title: 'Usage and account AI',
     uso_plan: 'Plan',
+    uso_ai: 'AI in use',
+    uso_ai_none: 'no AI of your own connected — use `ts conectar <provider>` or `ts ia conectar chatgpt|claude`',
+    uso_ai_unknown: 'could not confirm the account AI right now (no answer from the server) — check later with `ts uso` or `ts ia status`',
+    uso_ai_sub_disconnected: (label, prov) => `${label} mode selected, but the account CLI is not ready on this PC — chat and agent will not run like this; log in with \`ts ia conectar ${prov}\` or switch back with \`ts ia usar automatico\``,
+    uso_ai_sub_not_selected: (prov) => `account logged in on this PC but not selected — use \`ts ia usar ${prov}\``,
+    byok_no_balance: (prov) => `Your own ${prov} key was refused for balance or limits at the provider. Nothing was charged by Terminal Smart. Add balance at the provider, switch providers with \`ts conectar <provider>\` (or local Ollama) or use your subscription with \`ts ia conectar chatgpt|claude\`.`,
     uso_remaining: 'remaining',
     uso_unlimited: 'unlimited',
-    uso_credits: 'credits',
+    uso_credits: 'legacy credits',
     uso_last: 'Recent usage',
     quem_title: 'Connected account',
     quem_user: 'User',
@@ -329,18 +364,21 @@ const STR = {
     lang_invalid: 'Unsupported language. Use: ts idioma pt  or  ts idioma en',
     err_conn: 'Could not reach the server. Check your connection and retry.',
     err_generic: 'Something went wrong',
-    no_credits: 'Your AI limit is over. Free renews daily; paid plans renew each cycle. Continue now at terminalsmart.com.br/planos',
+    no_credits: 'Terminal Smart AI is not available for this run (no legacy credits). Use your own: `ts conectar <provider>` (your key or local Ollama) or `ts ia conectar chatgpt|claude` (your subscription).',
     ask_empty: 'Tell me what you need. E.g.:  ts "how do I open port 443 on ufw?"',
     chat_hint: 'type your message · "exit" quits · "/new" resets context',
     chat_prompt: 'You › ',
-    chat_bye: 'See you! The conversation stays saved on the web (/ia).',
+    chat_bye: 'See you! This folder\'s history stays only on this PC (`ts nova` clears it).',
     agent_need: 'Describe the task. E.g.:  ts agente "free disk space by analyzing the largest folders"',
     agent_thinking: 'agent thinking',
     agent_blocked: 'blocked by harness',
     agent_approve: (cmd) => `The agent wants to run a DESTRUCTIVE command:\n\n    ${cmd}\n\n  Allow? (y/N) `,
-    agent_footer: (st, cr, s) => `${st} step(s) · ${cr} credits · ${s}`,
-    agent_footer_byok: (st, prov, s) => `${st} step(s) · your key (${prov}) · ${s}`,
-    agent_remote_wait: (ttl) => `destructive command — approval request sent to your Telegram (answer within ${Math.round(ttl / 60)} min; no answer = denied)`,
+    agent_footer: (st, cr, s) => `${st} step(s) · ${cr} legacy credits · ${s}`,
+    agent_footer_byok: (st, prov, s) => `${st} step(s) · via your key (${prov}) · ${s}`,
+    agent_footer_via: (st, via, s) => `${st} step(s) · ${via} · ${s}`,
+    via_key: (prov) => `via your key (${prov})`,
+    via_subscription: 'via your subscription',
+    via_ollama: 'via local Ollama',
     meta_need: 'Describe the goal. E.g.:  ts meta "build a complete portfolio site in this folder" --budget 300',
     meta_title: 'MISSION',
     meta_exists: (g) => `A mission is already in progress in this directory ("${g.slice(0, 60)}…"). Run "ts meta" without a goal to RESUME, or use --novo to start over.`,

package/lib/ia-local.js

@@ -0,0 +1,388 @@
+// lib/ia-local.js — a IA da CONTA do usuário rodando NO PC dele.
+//
+// "Conta" aqui é a CLI oficial já logada nesta máquina: Claude Code (`claude`) ou Codex
+// (`codex`, a CLI do ChatGPT). Nada passa pelo servidor do Terminal Smart: o prompt vai
+// pelo stdin do processo local e a resposta volta pelo stdout.
+//
+// Execução só-texto e sem escrita, nas duas CLIs:
+//   - pasta temporária VAZIA como cwd (apagada no fim) — nada do projeto fica ao alcance;
+//   - prompt pelo stdin, nunca no argv (não aparece na lista de processos nem passa por shell);
+//   - execFile/spawn com ARRAY de argumentos, sem shell; no Windows o atalho `.cmd` do npm é
+//     lido e o script JS dele roda direto no Node (atalho desconhecido = recusa, sem shell);
+//   - ambiente mínimo (só o que a CLI precisa para achar a conta e a rede), sem token do TS
+//     nem chaves de API do usuário;
+//   - tempo máximo com encerramento da árvore de processos;
+//   - Claude: sem ferramentas (`--tools ""`), sem MCP, sem settings/hooks do usuário, sem
+//     sessão salva; Codex: sandbox só-leitura, efêmero, sem config/rules do usuário e com as
+//     ferramentas de shell/navegador/apps desligadas.
+'use strict';
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const childProcess = require('child_process');
+
+const MODOS = ['automatico', 'chatgpt', 'claude', 'paralelo'];
+const PROVEDORES = {
+  chatgpt: { bin: 'codex', nome: 'ChatGPT/Codex', envBin: 'TS_CODEX_BIN' },
+  claude: { bin: 'claude', nome: 'Claude', envBin: 'TS_CLAUDE_BIN' },
+};
+const PROMPT_MAX = 200000;
+const PRAZO_PADRAO = 180000;
+const PRAZO_STATUS = 8000;
+const SAIDA_MAX = 8 * 1024 * 1024;
+
+// Funcionalidades do Codex que dariam ferramentas ao modelo. A sandbox só-leitura já impede
+// escrita; desligar estas tira também a execução de comandos, o navegador e os apps.
+const CODEX_SEM_FERRAMENTAS = ['shell_tool', 'unified_exec', 'apps', 'plugins', 'browser_use',
+  'computer_use', 'in_app_browser', 'multi_agent', 'image_generation'];
+
+// Variáveis que a CLI realmente precisa (achar a casa/conta, o sistema e a rede). O resto do
+// ambiente — token do TS, chaves de API, segredos de outros programas — fica de fora.
+const AMBIENTE_PERMITIDO = new Set([
+  'PATH', 'PATHEXT', 'SYSTEMROOT', 'WINDIR', 'COMSPEC', 'SYSTEMDRIVE', 'OS',
+  'PROCESSOR_ARCHITECTURE', 'NUMBER_OF_PROCESSORS', 'COMPUTERNAME',
+  'HOME', 'USERPROFILE', 'HOMEDRIVE', 'HOMEPATH', 'APPDATA', 'LOCALAPPDATA', 'PROGRAMDATA',
+  'PROGRAMFILES', 'PROGRAMFILES(X86)', 'COMMONPROGRAMFILES',
+  'USER', 'USERNAME', 'USERDOMAIN', 'LOGNAME', 'SHELL',
+  'TEMP', 'TMP', 'TMPDIR', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TZ',
+  'XDG_CONFIG_HOME', 'XDG_DATA_HOME', 'XDG_CACHE_HOME', 'XDG_STATE_HOME', 'XDG_RUNTIME_DIR',
+  'DBUS_SESSION_BUS_ADDRESS',
+  'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'ALL_PROXY',
+  'NODE_EXTRA_CA_CERTS', 'SSL_CERT_FILE', 'SSL_CERT_DIR',
+  'CODEX_HOME', 'CLAUDE_CONFIG_DIR', 'CLAUDE_CODE_OAUTH_TOKEN', 'CLAUDE_CODE_GIT_BASH_PATH',
+]);
+
+function nomeDe(prov) { return (PROVEDORES[prov] || {}).nome || String(prov); }
+function modoValido(modo) { return MODOS.includes(String(modo || '').toLowerCase()); }
+function rotuloModo(modo) {
+  return modo === 'chatgpt' ? 'ChatGPT/Codex' : modo === 'claude' ? 'Claude' : modo === 'paralelo' ? 'ChatGPT/Codex + Claude' : 'automático';
+}
+function comoLogar(prov) {
+  return prov === 'chatgpt'
+    ? 'Rode `ts ia conectar chatgpt` (abre o `codex login` oficial).'
+    : 'Rode `claude` e use /login (ou `ts ia conectar claude` para ver o passo a passo).';
+}
+function comoInstalar(prov) {
+  return prov === 'chatgpt'
+    ? 'Instale a CLI oficial do Codex (`npm install -g @openai/codex`) e faça o login com `codex login`.'
+    : 'Instale o Claude Code oficial (https://claude.com/claude-code) e faça o login com `claude` → /login.';
+}
+
+function erroIa(codigo, mensagem) { const e = new Error(mensagem); e.code = codigo; return e; }
+
+function ambienteMinimo(base = process.env) {
+  const out = {};
+  for (const [k, v] of Object.entries(base || {})) {
+    if (v != null && AMBIENTE_PERMITIDO.has(k.toUpperCase())) out[k] = String(v);
+  }
+  out.NO_COLOR = '1';
+  out.FORCE_COLOR = '0';
+  return out;
+}
+
+// Atalho `.cmd` que o npm gera no Windows: a última linha chama `node "%dp0%\...\x.js" %*`.
+// Lendo o caminho do script, rodamos `node script.js args` direto — sem cmd.exe no meio.
+function scriptDoAtalhoNpm(arquivo) {
+  let texto = '';
+  try { texto = fs.readFileSync(arquivo, 'utf8'); } catch (_) { return null; }
+  const m = texto.match(/"%~?dp0%?\\([^"%]+\.(?:c|m)?js)"/i);
+  if (!m) return null;
+  const script = path.resolve(path.dirname(arquivo), m[1].replace(/\\/g, path.sep));
+  return fs.existsSync(script) ? script : null;
+}
+
+// Como rodar um arquivo executável SEM shell. Retorna { cmd, prefixo, caminho } ou { erro }.
+function comoExecutar(arquivo, plataforma = process.platform) {
+  const ext = path.extname(arquivo).toLowerCase();
+  if (['.js', '.cjs', '.mjs'].includes(ext)) return { cmd: process.execPath, prefixo: [arquivo], caminho: arquivo };
+  if (plataforma === 'win32' && ['.cmd', '.bat'].includes(ext)) {
+    const script = scriptDoAtalhoNpm(arquivo);
+    if (script) return { cmd: process.execPath, prefixo: [script], caminho: arquivo };
+    return { caminho: arquivo, erro: `não dá para executar com segurança o atalho "${path.basename(arquivo)}" sem passar pelo cmd.exe. Aponte TS_CODEX_BIN/TS_CLAUDE_BIN para o executável (.exe) ou para o script .js da CLI.` };
+  }
+  return { cmd: arquivo, prefixo: [], caminho: arquivo };
+}
+
+function criar(opcoes = {}) {
+  const {
+    bins = {},
+    spawnImpl = childProcess.spawn,
+    env = process.env,
+    homedir = os.homedir(),
+    tmpdir = os.tmpdir(),
+    plataforma = process.platform,
+  } = opcoes;
+
+  function ehArquivo(p) { try { return fs.statSync(p).isFile(); } catch (_) { return false; } }
+  function executavelPosix(p) { try { fs.accessSync(p, fs.constants.X_OK); return true; } catch (_) { return false; } }
+
+  function procurarNoPath(nome) {
+    const sep = plataforma === 'win32' ? ';' : ':';
+    const dirs = String(env.PATH || env.Path || '').split(sep).map(d => d.trim().replace(/^"|"$/g, '')).filter(Boolean);
+    // instalações oficiais que nem sempre estão no PATH do terminal atual
+    dirs.push(path.join(homedir, '.local', 'bin'), path.join(homedir, '.claude', 'local'));
+    if (plataforma === 'win32' && env.APPDATA) dirs.push(path.join(env.APPDATA, 'npm'));
+    if (plataforma !== 'win32') dirs.push('/usr/local/bin', '/opt/homebrew/bin');
+    // no Windows o atalho sem extensão do npm é um script sh: só .exe/.cmd/.bat servem
+    const exts = plataforma === 'win32' ? ['.exe', '.cmd', '.bat'] : [''];
+    for (const ext of exts) {
+      for (const d of dirs) {
+        const p = path.join(d, nome + ext);
+        if (ehArquivo(p) && (plataforma === 'win32' || executavelPosix(p))) return p;
+      }
+    }
+    return null;
+  }
+
+  function resolverExecutavel(prov) {
+    const info = PROVEDORES[prov];
+    if (!info) return null;
+    const custom = bins[prov] || env[info.envBin];
+    const alvo = custom ? path.resolve(String(custom)) : procurarNoPath(info.bin);
+    if (!alvo || !ehArquivo(alvo)) return null;
+    return comoExecutar(alvo, plataforma);
+  }
+
+  function arquivoCredencial(prov) {
+    if (prov === 'chatgpt') return path.join(env.CODEX_HOME || path.join(homedir, '.codex'), 'auth.json');
+    return path.join(env.CLAUDE_CONFIG_DIR || path.join(homedir, '.claude'), '.credentials.json');
+  }
+
+  function encerrar(proc) {
+    if (!proc) return;
+    if (plataforma === 'win32' && proc.pid) {
+      // o script do npm abre o binário nativo como filho: mata a árvore inteira
+      try { childProcess.execFile('taskkill', ['/pid', String(proc.pid), '/T', '/F'], { windowsHide: true }, () => {}); } catch (_) {}
+    }
+    try { proc.kill('SIGKILL'); } catch (_) {}
+  }
+
+  // Roda a CLI e junta a saída. stdin = texto (fechado logo depois) ou null (fechado vazio).
+  function rodar(exe, args, { stdin = null, cwd, timeoutMs = PRAZO_PADRAO } = {}) {
+    return new Promise((resolve, reject) => {
+      let proc;
+      try {
+        proc = spawnImpl(exe.cmd, [...exe.prefixo, ...args], {
+          cwd, env: ambienteMinimo(env), stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, shell: false,
+        });
+      } catch (e) { reject(erroIa('falha_execucao', `não consegui iniciar ${path.basename(exe.caminho)}: ${e.message}`)); return; }
+      let stdout = '', stderr = '', fim = false, tamanho = 0;
+      const timer = setTimeout(() => {
+        if (fim) return; fim = true; encerrar(proc);
+        reject(erroIa('timeout', `a IA local não respondeu em ${Math.round(timeoutMs / 1000)} s e foi encerrada.`));
+      }, timeoutMs);
+      if (timer.unref) timer.unref();
+      const juntar = (alvo) => (chunk) => {
+        tamanho += chunk.length;
+        if (tamanho > SAIDA_MAX) { if (!fim) { fim = true; clearTimeout(timer); encerrar(proc); reject(erroIa('saida_grande', 'a IA local devolveu uma saída grande demais e foi encerrada.')); } return; }
+        if (alvo === 'out') stdout += chunk; else stderr += chunk;
+      };
+      if (proc.stdout) { proc.stdout.setEncoding('utf8'); proc.stdout.on('data', juntar('out')); }
+      if (proc.stderr) { proc.stderr.setEncoding('utf8'); proc.stderr.on('data', juntar('err')); }
+      proc.once('error', (e) => {
+        if (fim) return; fim = true; clearTimeout(timer);
+        reject(erroIa(e && e.code === 'ENOENT' ? 'nao_instalada' : 'falha_execucao', `não consegui iniciar ${path.basename(exe.caminho)}: ${e.message}`));
+      });
+      proc.once('close', (code) => {
+        if (fim) return; fim = true; clearTimeout(timer);
+        resolve({ code, stdout, stderr });
+      });
+      if (proc.stdin) {
+        proc.stdin.on('error', () => {}); // EPIPE quando a CLI fecha antes de ler tudo
+        proc.stdin.end(stdin == null ? '' : String(stdin), 'utf8');
+      }
+    });
+  }
+
+  async function statusDe(prov, { rapido = false, prazoMs = PRAZO_STATUS } = {}) {
+    const exe = resolverExecutavel(prov);
+    if (!exe) return { instalada: false, logada: false, caminho: null };
+    if (exe.erro) return { instalada: true, logada: null, caminho: exe.caminho, detalhe: exe.erro };
+    if (ehArquivo(arquivoCredencial(prov))) return { instalada: true, logada: true, caminho: exe.caminho };
+    if (rapido) return { instalada: true, logada: null, caminho: exe.caminho };
+    // Sem o arquivo (ex.: macOS guarda no Keychain): pergunta à própria CLI, com prazo curto.
+    const args = prov === 'chatgpt' ? ['login', 'status'] : ['auth', 'status', '--json'];
+    let pasta = null;
+    try {
+      pasta = fs.mkdtempSync(path.join(tmpdir, 'ts-ia-local-'));
+      const r = await rodar(exe, args, { cwd: pasta, timeoutMs: prazoMs });
+      const saida = (r.stdout + '\n' + r.stderr).trim();
+      let logada;
+      if (prov === 'claude') {
+        let j = null; try { j = JSON.parse(r.stdout); } catch (_) {}
+        logada = j && typeof j.loggedIn === 'boolean' ? j.loggedIn : (r.code === 0 && !/not logged in|não está logad/i.test(saida));
+      } else {
+        logada = r.code === 0 && !/not logged in|não está logad/i.test(saida);
+      }
+      return { instalada: true, logada, caminho: exe.caminho };
+    } catch (e) {
+      return { instalada: true, logada: null, caminho: exe.caminho, detalhe: e.message };
+    } finally {
+      if (pasta) try { fs.rmSync(pasta, { recursive: true, force: true }); } catch (_) {}
+    }
+  }
+
+  // { chatgpt:{instalada, logada, caminho}, claude:{...} } — logada null = não deu para confirmar.
+  async function status(opts = {}) {
+    const [chatgpt, claude] = await Promise.all([statusDe('chatgpt', opts), statusDe('claude', opts)]);
+    return { chatgpt, claude };
+  }
+
+  // A CLI exigida pelo modo está pronta? Login "não confirmado" (null) conta como pronta:
+  // a execução real dá o erro claro, se for o caso.
+  function pronto(modo, st) {
+    const ok = (p) => !!(st && st[p] && st[p].instalada && st[p].logada !== false && !st[p].detalhe);
+    if (modo === 'chatgpt' || modo === 'claude') return ok(modo);
+    if (modo === 'paralelo') return ok('chatgpt') && ok('claude');
+    return false;
+  }
+  // Qual CLI falta para o modo (texto para o usuário).
+  function faltando(modo, st) {
+    const precisa = modo === 'paralelo' ? ['chatgpt', 'claude'] : [modo];
+    const faltam = precisa.filter(p => !pronto(p, st));
+    return faltam.map(p => {
+      const s = (st && st[p]) || {};
+      return `${nomeDe(p)} ${!s.instalada ? 'não está instalado neste PC' : s.detalhe ? `não pode ser executado (${s.detalhe})` : 'não está logado neste PC'}`;
+    }).join(' e ');
+  }
+
+  function argsCodex() {
+    return ['exec', '--json', '--ephemeral', '--ignore-user-config', '--ignore-rules',
+      '--sandbox', 'read-only', '--skip-git-repo-check', '--color', 'never',
+      ...CODEX_SEM_FERRAMENTAS.flatMap(f => ['--disable', f]),
+      '-'];
+  }
+  function argsClaude(sistema) {
+    return ['-p', '--output-format', 'json', '--tools', '', '--permission-mode', 'dontAsk',
+      '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}', '--setting-sources', '',
+      '--no-session-persistence', '--disable-slash-commands',
+      ...(sistema ? ['--system-prompt', String(sistema)] : [])];
+  }
+
+  function erroClaro(prov, detalheBruto) {
+    const nome = nomeDe(prov);
+    const detalhe = String(detalheBruto || '').replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').trim();
+    if (prov === 'chatgpt' && /token_revoked|refresh token (?:was )?(?:revoked|invalidated)|session has ended|log out and sign in again/i.test(detalhe)) {
+      return erroIa('sessao_expirada', `A sessão do ${nome} expirou ou foi revogada neste PC. Rode \`codex login\` (ou \`ts ia conectar chatgpt\`) para entrar de novo.`);
+    }
+    if (/not logged in|please (?:run )?[`'"]?(?:\/?login|codex login|claude login)|login required|invalid api key|authentication[_ ]error|unauthorized|\b401\b|no credentials|oauth token (?:has )?expired/i.test(detalhe)) {
+      return erroIa('nao_logada', `${nome} não está logado neste PC. ${comoLogar(prov)}`);
+    }
+    if (/unknown option|unexpected argument|unrecognized (?:option|argument)|error: unknown/i.test(detalhe)) {
+      return erroIa('desatualizada', `A versão instalada do ${nome} não aceita as opções seguras que o Terminal Smart usa. Atualize com \`${prov === 'chatgpt' ? 'codex update' : 'claude update'}\` e tente de novo.`);
+    }
+    if (/usage limit|rate limit|quota|\b429\b|limit reached/i.test(detalhe)) {
+      return erroIa('limite', `O plano da sua conta ${nome} atingiu o limite de uso agora. Espere a janela do plano renovar ou use outra IA (\`ts ia usar ...\` ou \`ts conectar <provedor>\`).`);
+    }
+    let resumo = detalhe.split(/\r?\n/).filter(Boolean).slice(-4).join(' ').slice(-400);
+    try { resumo = require('./core').redactSecrets(resumo); } catch (_) {}
+    return erroIa('falha_ia_local', `${nome} falhou neste PC${resumo ? ': ' + resumo : ' sem mensagem.'}`);
+  }
+
+  function interpretar(prov, r, inicio) {
+    const uso = { input_tokens: 0, cached_input_tokens: 0, output_tokens: 0 };
+    let texto = '', modelo = 'padrão da sua conta';
+    if (prov === 'chatgpt') {
+      const eventos = String(r.stdout || '').split(/\r?\n/).map(l => { try { return JSON.parse(l); } catch (_) { return null; } }).filter(Boolean);
+      const falha = eventos.find(e => e.type === 'error' || e.type === 'turn.failed');
+      const msgs = eventos.filter(e => e.type === 'item.completed' && e.item && e.item.type === 'agent_message').map(e => e.item.text).filter(Boolean);
+      const fimTurno = [...eventos].reverse().find(e => e.type === 'turn.completed');
+      if (fimTurno && fimTurno.usage) {
+        uso.input_tokens = Number(fimTurno.usage.input_tokens || 0);
+        uso.cached_input_tokens = Number(fimTurno.usage.cached_input_tokens || 0);
+        uso.output_tokens = Number(fimTurno.usage.output_tokens || 0);
+      }
+      texto = msgs.join('\n\n').trim();
+      if (!texto && (falha || r.code !== 0)) {
+        const det = falha ? (falha.message || (falha.error && falha.error.message) || JSON.stringify(falha)) : '';
+        throw erroClaro(prov, [det, r.stderr, r.stdout].filter(Boolean).join('\n'));
+      }
+    } else {
+      let j = null;
+      try { j = JSON.parse(String(r.stdout || '').trim()); } catch (_) {}
+      if (!j) {
+        if (r.code !== 0) throw erroClaro(prov, r.stderr || r.stdout);
+        texto = String(r.stdout || '').trim();
+      } else {
+        if (j.is_error || (j.subtype && j.subtype !== 'success')) throw erroClaro(prov, [j.result, j.error, r.stderr].filter(Boolean).join('\n') || j.subtype);
+        texto = String(j.result || '').trim();
+        modelo = Object.keys(j.modelUsage || {})[0] || j.model || modelo;
+        if (j.usage) {
+          uso.input_tokens = Number(j.usage.input_tokens || 0);
+          uso.cached_input_tokens = Number(j.usage.cache_read_input_tokens || 0);
+          uso.output_tokens = Number(j.usage.output_tokens || 0);
+        }
+      }
+    }
+    if (!texto) throw erroIa('sem_resposta', `${nomeDe(prov)} encerrou sem resposta.`);
+    return { provedor: prov, texto, uso, modelo, duracaoMs: Math.max(0, Date.now() - inicio) };
+  }
+
+  // Executa UM prompt na CLI do provedor. sistema: instrução de sistema (Claude recebe como
+  // --system-prompt; no Codex vai no começo do prompt). Devolve { texto, uso, modelo, provedor }.
+  async function executar(prov, prompt, { sistema = null, timeoutMs = PRAZO_PADRAO } = {}) {
+    if (!PROVEDORES[prov]) throw erroIa('provedor_invalido', 'Provedor de IA local inválido: use chatgpt ou claude.');
+    const exe = resolverExecutavel(prov);
+    if (!exe) throw erroIa('nao_instalada', `${nomeDe(prov)} não está instalado neste PC. ${comoInstalar(prov)}`);
+    if (exe.erro) throw erroIa('execucao_insegura', `${nomeDe(prov)}: ${exe.erro}`);
+    let texto = String(prompt || '');
+    if (prov === 'chatgpt' && sistema) texto = String(sistema) + '\n\n---\n\n' + texto;
+    texto = texto.slice(0, PROMPT_MAX);
+    const prazo = Math.max(5000, Number(timeoutMs) || PRAZO_PADRAO);
+    const inicio = Date.now();
+    const pasta = fs.mkdtempSync(path.join(tmpdir, 'ts-ia-local-'));
+    try {
+      let r = await rodar(exe, prov === 'chatgpt' ? argsCodex() : argsClaude(sistema), { stdin: texto, cwd: pasta, timeoutMs: prazo });
+      // Versão do Codex que não conhece alguma das funcionalidades desligadas: NÃO repete sem
+      // elas (seria rodar com menos travas sem o usuário saber); pede para atualizar.
+      if (prov === 'chatgpt' && r.code !== 0 && /feature/i.test(r.stderr) && /unknown|invalid|unrecognized|not (?:a )?(?:known|valid)/i.test(r.stderr)) {
+        throw erroIa('desatualizada', `A versão instalada do ${nomeDe(prov)} não aceita as opções seguras que o Terminal Smart usa. Atualize o Codex e tente de novo.`);
+      }
+      return interpretar(prov, r, inicio);
+    } finally {
+      try { fs.rmSync(pasta, { recursive: true, force: true }); } catch (_) {}
+    }
+  }
+
+  // Modo da conta → { modo, resultados:[...], parcial }. paralelo roda as duas ao mesmo tempo.
+  async function responder(modo, prompt, opts = {}) {
+    if (modo === 'chatgpt' || modo === 'claude') return { modo, resultados: [await executar(modo, prompt, opts)], parcial: false };
+    if (modo === 'paralelo') {
+      const settled = await Promise.allSettled([executar('chatgpt', prompt, opts), executar('claude', prompt, opts)]);
+      const resultados = settled.filter(s => s.status === 'fulfilled').map(s => s.value);
+      if (!resultados.length) {
+        const motivos = settled.map(s => s.reason && s.reason.message).filter(Boolean).join(' | ');
+        throw erroIa('sem_resposta', 'Nenhuma das IAs da sua conta respondeu neste PC' + (motivos ? ': ' + motivos : '.'));
+      }
+      return { modo, resultados, parcial: resultados.length !== 2 };
+    }
+    throw erroIa('modo_invalido', 'Modo de IA local inválido: use chatgpt, claude ou paralelo.');
+  }
+
+  // Login OFICIAL no PC, com o terminal do usuário (stdio herdado). Só o Codex tem um comando
+  // de login direto e estável; o Claude é orientado a usar /login dentro do `claude`.
+  function abrirLogin(prov) {
+    return new Promise((resolve, reject) => {
+      const exe = resolverExecutavel(prov);
+      if (!exe) { reject(erroIa('nao_instalada', `${nomeDe(prov)} não está instalado neste PC. ${comoInstalar(prov)}`)); return; }
+      if (exe.erro) { reject(erroIa('execucao_insegura', `${nomeDe(prov)}: ${exe.erro}`)); return; }
+      if (prov !== 'chatgpt') { reject(erroIa('sem_login_direto', comoLogar(prov))); return; }
+      let proc;
+      try { proc = spawnImpl(exe.cmd, [...exe.prefixo, 'login'], { stdio: 'inherit', env, shell: false }); }
+      catch (e) { reject(e); return; }
+      proc.once('error', reject);
+      proc.once('close', code => resolve(code));
+    });
+  }
+
+  return {
+    status, statusDe, pronto, faltando, executar, responder, abrirLogin, resolverExecutavel,
+    _test: { argsCodex, argsClaude, erroClaro, interpretar, arquivoCredencial, procurarNoPath, rodar },
+  };
+}
+
+const padrao = criar();
+module.exports = Object.assign({}, padrao, {
+  criar, MODOS, PROVEDORES, nomeDe, modoValido, rotuloModo, comoLogar, comoInstalar,
+  _util: { ambienteMinimo, comoExecutar, scriptDoAtalhoNpm, CODEX_SEM_FERRAMENTAS },
+});