auroq-os 2.6.9 → 2.7.0

package/bin/auroq-os.js

@@ -70,7 +70,7 @@ ${PURPLE}  ━━━━━━━━━━━━━━━━━━━━━━━
 ${PURPLE}${BOLD}       ▄▀█ █  █ █▀█ █▀█ █▀█${RESET}  ${DIM}OS v${PKG_VERSION}${RESET}
 ${PURPLE}${BOLD}       █▀█ █▄▄█ █▀▄ █▄█ ▀▀█${RESET}
 
-${DIM}       Sistema Operacional de IA para Experts${RESET}
+${DIM}       Sistema Operacional de IA para o seu negocio${RESET}
 ${DIM}       Pensar. Fazer. Lembrar. Com IA.${RESET}
 
 ${PURPLE}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
@@ -1433,6 +1433,20 @@ async function patchEnableAllProjectMcpServers(targetDir) {
         mudou = true;
       }
     }
+    // 2.7.0: o gancho da compactação nasceu com "timeout": 15000 (o Claude Code conta em segundos:
+    // ~4 h). O modelo agora diz 10; quem já tinha a pasta recebe o valor do modelo.
+    const tempoDoModelo = (modelo.hooks.PreCompact || []).flatMap(g => g?.hooks || [])
+      .find(h => /precompact-session-digest\.cjs/.test(String(h?.command || '')))?.timeout;
+    if (Number.isFinite(tempoDoModelo)) {
+      for (const g of Array.isArray(json.hooks.PreCompact) ? json.hooks.PreCompact : []) {
+        for (const h of Array.isArray(g?.hooks) ? g.hooks : []) {
+          if (/precompact-session-digest\.cjs/.test(String(h?.command || '')) && Number(h.timeout) > 60) {
+            h.timeout = tempoDoModelo;
+            mudou = true;
+          }
+        }
+      }
+    }
   }
   if (require('../lib/ahi/install.cjs').mergeHooks(json, targetDir, 'claude-code')) mudou = true;
   if (json.enableAllProjectMcpServers !== true) {
@@ -1473,6 +1487,33 @@ async function listarArquivos(dir, base = dir) {
   return saida;
 }
 
+// 2.7.0 — As regras de base moram no AGENTS.md (a manutencao sempre troca) e o CLAUDE.md as
+// importa. Ate a 2.6.10 o CLAUDE.md nunca era tocado depois da primeira instalacao: quem instalou
+// cedo ficou com a doutrina da v1.1.0 para sempre. Agora: identico a uma versao que publicamos ->
+// trocado pelo novo; mexido pelo aluno (ex.: nome do Companion na FASE 10) -> fica como esta e so
+// ganha, no fim, a linha que importa o AGENTS.md. Nada do aluno e apagado.
+const IMPORTA_AGENTS = '@../AGENTS.md';
+async function atualizarClaudeMd(src, dst) {
+  if (!(await fs.pathExists(dst))) {
+    await fs.copy(src, dst);
+    return 'novo';
+  }
+  const atual = await fs.readFile(dst);
+  const hAtual = hashNormalizado(atual);
+  if (hAtual === hashNormalizado(await fs.readFile(src))) return 'igual';
+  const oficiais = require('../lib/legacy-shims.json')['.claude/CLAUDE.md'] || [];
+  if (oficiais.includes(hAtual)) {
+    await fs.copy(src, dst, { overwrite: true });
+    return 'atualizado';
+  }
+  const texto = atual.toString('utf8');
+  if (texto.split(/\r?\n/).some(linha => linha.trim() === IMPORTA_AGENTS)) return 'do-aluno';
+  const nl = texto.includes('\r\n') ? '\r\n' : '\n';
+  const bloco = ['', '', '## Regras de base do Auroq OS (a atualizacao mantem em dia)', '', IMPORTA_AGENTS, ''].join(nl);
+  await fs.writeFile(dst, texto.replace(/\s+$/, '') + bloco);
+  return 'importou';
+}
+
 async function atualizarSynapse(sourceDir, targetDir) {
   const origem = path.join(sourceDir, '.auroq-core', 'core', 'synapse');
   const destino = path.join(targetDir, '.auroq-core', 'core', 'synapse');
@@ -1549,14 +1590,14 @@ function opcoesDeLoginDeTeste() {
 }
 
 // ─── INSTALACAO ──────────────────────────────────────────
-// Barra de status do Claude Code (2.6.8): a mesma do Euriler, no HOME do aluno. Nunca derruba a
+// Barra de status (2.6.8; Codex e Grok desde 2.6.10): a mesma do Euriler, no HOME do aluno. Nunca derruba a
 // instalacao: sem a barra o sistema funciona igual, entao qualquer falha vira aviso.
 function ligarBarraDeStatus() {
-  step('Ligando a barra de status do Claude Code...');
+  step('Ligando a barra de status (Claude Code, Codex e Grok)...');
   try {
     const r = require('../lib/barra').instalarBarra();
     const textos = {
-      'ligada': 'Barra de status ligada (vale em todo terminal do Claude Code)',
+      'ligada': 'Barra de status ligada no Claude Code (vale em todo terminal)',
       'atualizada': 'Barra de status em dia',
       'em-dia': 'Barra de status em dia',
       'barra-do-aluno': 'Voce ja tem uma barra de status propria no Claude Code; ficou como estava',
@@ -1565,6 +1606,13 @@ function ligarBarraDeStatus() {
     };
     if (textos[r.estado]) success(textos[r.estado]);
     else warn(`Barra de status nao ligada (${r.estado}${r.detalhe ? `: ${r.detalhe}` : ''})`);
+    // 2.6.10: a mesma barra no Grok (se instalado) e a barra nativa do Codex com os mesmos itens.
+    const outras = { ligada: 'ligada', atualizada: 'em dia', 'em-dia': 'em dia', 'barra-do-aluno': 'a sua ficou como estava', 'tirada-pelo-aluno': 'desligada por voce' };
+    for (const [nome, estado] of [['Codex', r.codex], ['Grok', r.grok]]) {
+      if (!estado || estado === 'sem-grok') continue;
+      if (outras[estado]) success(`Barra de status no ${nome}: ${outras[estado]}`);
+      else warn(`Barra de status no ${nome} nao ligada (${estado})`);
+    }
     return r;
   } catch (e) {
     warn(`Barra de status nao ligada (${String(e && e.message || e).split(/\r?\n/)[0].slice(0, 200)}). O resto funciona normal.`);
@@ -1738,6 +1786,7 @@ async function init({ pasta = null, maintenance = false, modoAgente = false, mig
     '.auroq-core/constitution.md',
     '.auroq-core/core-config.yaml',
     '.auroq-core/dna-operacional.md',
+    '.auroq-core/como-funciona.md', // 2.7.0 — doutrina que saiu do CLAUDE.md (consulta sob demanda)
     '.auroq-core/development/sistema-gestao-projetos.md',
     '.auroq-core/development/sistema-memoria.md',
 
@@ -1930,6 +1979,7 @@ async function init({ pasta = null, maintenance = false, modoAgente = false, mig
   }
 
   let copied = 0;
+  let claudeMd = null;
   for (const file of frameworkFiles) {
     // Pular companion.md generico se ja tem personalizado
     if (file === '.claude/commands/companion.md' && hasCustomCompanion) {
@@ -1942,7 +1992,9 @@ async function init({ pasta = null, maintenance = false, modoAgente = false, mig
       const dstExists = await fs.pathExists(dst);
       // Framework files: SEMPRE sobrescrever (atualizar)
       // Student files: so copiar se NAO existem (preservar dados)
-      if ((isStudentFile || file.startsWith('business/') || file.startsWith('docs/knowledge/') || file === '.claude/CLAUDE.md') && dstExists) {
+      if (file === '.claude/CLAUDE.md') {
+        claudeMd = await atualizarClaudeMd(src, dst);
+      } else if ((isStudentFile || file.startsWith('business/') || file.startsWith('docs/knowledge/')) && dstExists) {
         // Nao sobrescrever dados do aluno
       } else if (file === '.claude/settings.json' && dstExists) {
         // Mescla: o que e do framework vem do modelo; permissoes, statusLine, env e hooks do aluno ficam.
@@ -1957,6 +2009,8 @@ async function init({ pasta = null, maintenance = false, modoAgente = false, mig
     }
   }
   success(`${copied} arquivos instalados`);
+  if (claudeMd === 'atualizado') success('CLAUDE.md atualizado para as regras de trabalho novas');
+  if (claudeMd === 'importou') success('CLAUDE.md seu mantido, agora com as regras de base do AGENTS.md');
   if (removidos > 0) {
     success(`${removidos} regra(s) antiga(s) aposentada(s)`);
   }
@@ -2148,21 +2202,21 @@ ${DIM}  Suas customizacoes (sobrevivem a todo update):${RESET}
     ${CYAN}.claude/settings.local.json${RESET}        ${DIM}— suas configuracoes locais${RESET}
 
 ${DIM}  Agentes core disponiveis:${RESET}
-    ${PURPLE}/companion${RESET}              ${DIM}— Parceiro cognitivo${RESET}
-    ${PURPLE}/AuroqOS:agents:ops${RESET}     ${DIM}— Git, deploy, ambiente${RESET}
-    ${PURPLE}/organizer${RESET}              ${DIM}— Organizacao e backup${RESET}
+    ${PURPLE}/auroq-companion${RESET}        ${DIM}— Chefe da sua equipe: fale com ele, ele aciona o resto${RESET}
+    ${PURPLE}/AuroqOS:agents:ops${RESET}     ${DIM}— O tecnico: instala, atualiza, conserta e conecta${RESET}
+    ${PURPLE}/auroq-organizer${RESET}        ${DIM}— Organizacao e backup${RESET}
 
-${DIM}  Meta Squads (criadores de agentes):${RESET}
-    ${PURPLE}/squad-forge${RESET}            ${DIM}— Cria squads multi-agente${RESET}
-    ${PURPLE}/mind-forge${RESET}             ${DIM}— Cria mentes sinteticas${RESET}
-    ${PURPLE}/worker-forge${RESET}           ${DIM}— Cria workers${RESET}
-    ${PURPLE}/clone-forge${RESET}            ${DIM}— Clona mentes reais${RESET}
-    ${PURPLE}/etlmaker${RESET}               ${DIM}— Extrai e estrutura conhecimento${RESET}
+${DIM}  Meta Squads (criadores de agentes; o Companion chama quando precisa):${RESET}
+    ${PURPLE}/auroq-squad-forge${RESET}      ${DIM}— Cria squads multi-agente${RESET}
+    ${PURPLE}/auroq-mind-forge${RESET}       ${DIM}— Cria mentes sinteticas${RESET}
+    ${PURPLE}/auroq-worker-forge${RESET}     ${DIM}— Cria workers${RESET}
+    ${PURPLE}/auroq-clone-forge${RESET}      ${DIM}— Clona mentes reais${RESET}
+    ${PURPLE}/auroq-etlmaker${RESET}         ${DIM}— Extrai e estrutura conhecimento${RESET}
 
 ${DIM}  Claude Code e Codex sao runtimes oficiais. Escolha um por sessao; ambos usam os mesmos agentes e arquivos.${RESET}
 
 ${PURPLE}${BOLD}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
-${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para Experts${RESET}
+${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para o seu negocio${RESET}
 ${DIM}  "Tu aumentaste o meu poder como do boi selvagem." — Sl 92:10${RESET}
 `);
 }
@@ -2332,7 +2386,7 @@ ${DIM}  Ritual de todo dia, em toda maquina:${RESET}
 ${DIM}  Nunca levante da maquina com trabalho nao entregue — o sistema lembra, mas so voce entrega.${RESET}
 
 ${PURPLE}${BOLD}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
-${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para Experts${RESET}
+${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para o seu negocio${RESET}
 `);
 }
 

package/installer/install.ps1

@@ -589,7 +589,7 @@ function Invoke-AuroqLogin {
   # sucesso. Usado como pergunta de sim/nao, ele dizia "voce ja estava logado"
   # pra quem nunca logou, pulava o portao e deixava a conta sem acesso chegar ate
   # a criacao da pasta.
-  & (Get-AuroqNpx) -y auroq-os@2.6.9 check-access
+  & (Get-AuroqNpx) -y auroq-os@2.7.0 check-access
   if ($LASTEXITCODE -ne 0) {
     Write-AuroqLog 'login' 'recusado'
     Write-Host ''
@@ -677,7 +677,7 @@ function Invoke-AuroqInit {
   if ($env:AUROQ_INSTALL_DRY_RUN) { Write-AuroqOk 'Sistema - seria montado aqui'; return }
 
   Set-Location $script:AuroqPastaAlvo
-  & (Get-AuroqNpx) -y auroq-os@2.6.9 instalar
+  & (Get-AuroqNpx) -y auroq-os@2.7.0 instalar
   if ($LASTEXITCODE -ne 0) {
     Write-AuroqLog 'init' 'falhou'
     Write-AuroqErro 'A montagem do sistema parou no meio.' 'Rode o mesmo comando de novo. Se repetir, mande pro suporte o arquivo install.log da pasta .auroq.'

package/installer/install.sh

@@ -219,9 +219,9 @@ auroq_tem_terminal() {
 # recebem pedaco do script no lugar da resposta dele.
 auroq_npx_aluno() {
   if [ -t 0 ]; then
-    npx -y auroq-os@2.6.9 "$@"
+    npx -y auroq-os@2.7.0 "$@"
   else
-    npx -y auroq-os@2.6.9 "$@" < /dev/tty
+    npx -y auroq-os@2.7.0 "$@" < /dev/tty
   fi
 }
 

package/lib/barra/barra.cjs

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 'use strict';
-// Barra de status do Claude Code do aluno (2.6.8). Mora em ~/.auroq/barra/barra.cjs e e o
-// `statusLine.command` do ~/.claude/settings.json: vale em qualquer terminal e no app Auroq OS.
+// Barra de status do aluno (2.6.8; Grok desde 2.6.10). Mora em ~/.auroq/barra/barra.cjs e e o
+// `statusLine.command` do ~/.claude/settings.json e o `[ui.status_line]` do ~/.grok/config.toml:
+// vale em qualquer terminal e no app Auroq OS. O Codex usa a barra nativa dele (ver index.js).
 //
 //   node barra.cjs                 desenha a barra (o Claude Code manda o JSON da sessao na entrada)
+//   node barra.cjs grok            desenha a barra no Grok (mesmo JSON, com os nomes do Grok)
 //   node barra.cjs titulo "Texto"  grava o titulo da conversa (uma vez por sessao; a IA chama)
 //   node barra.cjs topico          pedaco da barra: o titulo desta sessao
 //   node barra.cjs data            pedaco da barra: "sex 16/10 11:39"
@@ -19,6 +21,7 @@ const PASTA = __dirname;
 const TITULOS = path.join(PASTA, 'titulos');
 const MOTOR = path.join(PASTA, 'ccstatusline', 'dist', 'ccstatusline.js');
 const LAYOUT = path.join(PASTA, 'ccstatusline.json');
+const LAYOUT_GROK = path.join(PASTA, 'ccstatusline-grok.json');
 const SESSAO_VALIDA = /^[A-Za-z0-9._-]{1,128}$/;
 const SETE_DIAS_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -46,16 +49,19 @@ function arquivoDoTitulo(sessao) {
 }
 
 function gravarTitulo(texto) {
-  const sessao = process.env.CLAUDE_CODE_SESSION_ID;
+  // Claude Code e Grok poem o id da sessao no terminal da IA. Um aberto dentro do outro herda os
+  // dois, entao grava nos dois: cada barra le o seu.
+  const sessoes = [process.env.CLAUDE_CODE_SESSION_ID, process.env.GROK_SESSION_ID].filter(s => s && SESSAO_VALIDA.test(s));
   const titulo = String(texto || '').replace(/[\r\n\t]+/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 60);
-  if (!titulo || !sessao || !SESSAO_VALIDA.test(sessao)) return;
+  if (!titulo || !sessoes.length) return;
   fs.mkdirSync(TITULOS, { recursive: true });
-  const alvo = arquivoDoTitulo(sessao);
-  // Uma vez por sessao: o primeiro titulo fica, como o do Euriler.
-  try {
-    fs.writeFileSync(alvo, `${titulo}\n`, { flag: 'wx' });
-  } catch (e) {
-    if (e.code !== 'EEXIST') throw e;
+  for (const sessao of sessoes) {
+    // Uma vez por sessao: o primeiro titulo fica, como o do Euriler.
+    try {
+      fs.writeFileSync(arquivoDoTitulo(sessao), `${titulo}\n`, { flag: 'wx' });
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+    }
   }
   limparTitulosVelhos();
 }
@@ -72,12 +78,34 @@ function limparTitulosVelhos() {
 
 function mostrarTitulo(entrada) {
   const sessao = sessaoDoJson(entrada);
-  if (!sessao) return '';
+  let titulo = '';
+  if (sessao) {
+    try {
+      titulo = fs.readFileSync(arquivoDoTitulo(sessao), 'utf8').split(/\r?\n/)[0] || '';
+    } catch {}
+  }
+  // Sem titulo gravado, o nome da sessao que o Grok (ou o /rename do Claude Code) da.
+  if (!titulo) {
+    try {
+      const nome = JSON.parse(entrada).session_name;
+      if (typeof nome === 'string') titulo = nome.replace(/[\u0000-\u001f\u007f]/g, '').trim();
+    } catch {}
+  }
+  return [...titulo].slice(0, 40).join('');
+}
+
+// O Grok segue a convencao do Claude Code, mas chama o contexto atual de `context_tokens`.
+function jsonDoGrok(entrada) {
   try {
-    const primeira = fs.readFileSync(arquivoDoTitulo(sessao), 'utf8').split(/\r?\n/)[0] || '';
-    return [...primeira].slice(0, 40).join('');
+    const dados = JSON.parse(entrada);
+    const janela = dados.context_window;
+    if (janela && typeof janela.context_tokens === 'number' && !janela.current_usage) {
+      janela.current_usage = { input_tokens: janela.context_tokens, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 };
+      if (typeof janela.total_input_tokens !== 'number') janela.total_input_tokens = janela.context_tokens;
+    }
+    return JSON.stringify(dados);
   } catch {
-    return '';
+    return entrada;
   }
 }
 
@@ -116,12 +144,12 @@ function repassarAoApp(entrada) {
   } catch {}
 }
 
-function desenhar(entrada) {
+function desenhar(entrada, { layout = LAYOUT, env = process.env } = {}) {
   return new Promise(resolve => {
-    if (!fs.existsSync(MOTOR)) return resolve();
+    if (!fs.existsSync(MOTOR) || !fs.existsSync(layout)) return resolve();
     let filho;
     try {
-      filho = spawn(process.execPath, [MOTOR, '--config', LAYOUT], { stdio: ['pipe', 'inherit', 'ignore'], windowsHide: true });
+      filho = spawn(process.execPath, [MOTOR, '--config', layout], { stdio: ['pipe', 'inherit', 'ignore'], windowsHide: true, env });
     } catch {
       return resolve();
     }
@@ -138,6 +166,12 @@ async function principal() {
   if (modo === 'data') return process.stdout.write(dataCurta());
   const entrada = await lerEntrada();
   if (modo === 'topico') return process.stdout.write(mostrarTitulo(entrada));
+  if (modo === 'grok') {
+    // O Grok passa a largura da linha em COLUMNS; o ccstatusline usa para alinhar a direita.
+    const env = { ...process.env };
+    if (/^\d+$/.test(env.COLUMNS || '') && !env.CCSTATUSLINE_WIDTH) env.CCSTATUSLINE_WIDTH = env.COLUMNS;
+    return desenhar(jsonDoGrok(entrada), { layout: LAYOUT_GROK, env });
+  }
   repassarAoApp(entrada);
   await desenhar(entrada);
 }
@@ -146,4 +180,4 @@ if (require.main === module) {
   principal().catch(() => {}).finally(() => { process.exitCode = 0; });
 }
 
-module.exports = { dataCurta, sessaoDoJson, mostrarTitulo, gravarTitulo, scriptDoApp };
+module.exports = { dataCurta, sessaoDoJson, mostrarTitulo, gravarTitulo, scriptDoApp, jsonDoGrok };

package/lib/barra/ccstatusline-grok.json

@@ -0,0 +1,98 @@
+{
+  "version": 4,
+  "lines": [
+    [
+      {
+        "id": "l1-model",
+        "type": "model",
+        "color": "brightCyan",
+        "bold": true,
+        "rawValue": true
+      },
+      {
+        "id": "l1-effort",
+        "type": "thinking-effort",
+        "color": "magenta"
+      },
+      {
+        "id": "l1-skill",
+        "type": "skills",
+        "color": "brightBlack",
+        "metadata": {
+          "hide": "empty"
+        }
+      },
+      {
+        "id": "l1-topic",
+        "type": "custom-command",
+        "color": "yellow",
+        "commandPath": "{{BARRA}} topico",
+        "timeout": 1000
+      },
+      {
+        "id": "l1-flex",
+        "type": "flex-separator"
+      },
+      {
+        "id": "l1-clock-ico",
+        "type": "custom-text",
+        "customText": "⏱",
+        "color": "brightYellow",
+        "merge": "no-padding"
+      },
+      {
+        "id": "l1-clock",
+        "type": "session-clock",
+        "color": "brightYellow",
+        "rawValue": true
+      }
+    ],
+    [
+      {
+        "id": "l2-cwd",
+        "type": "current-working-dir",
+        "color": "blue",
+        "metadata": {
+          "abbreviateHome": "true"
+        }
+      },
+      {
+        "id": "l2-branch",
+        "type": "git-branch",
+        "color": "green",
+        "metadata": {
+          "hide": "no-git"
+        }
+      },
+      {
+        "id": "l2-changes",
+        "type": "git-changes",
+        "color": "yellow",
+        "metadata": {
+          "hide": "zero"
+        }
+      }
+    ],
+    [
+      {
+        "id": "l3-ctx",
+        "type": "context-bar",
+        "color": "brightMagenta"
+      },
+      {
+        "id": "l3-flex",
+        "type": "flex-separator"
+      },
+      {
+        "id": "l4-date",
+        "type": "custom-command",
+        "color": "brightBlack",
+        "commandPath": "{{BARRA}} data",
+        "timeout": 1000
+      }
+    ]
+  ],
+  "flexMode": "full",
+  "colorLevel": 3,
+  "defaultPadding": " "
+}

package/lib/barra/index.js

@@ -1,7 +1,11 @@
 'use strict';
-// Barra de status do Claude Code do aluno (2.6.8): a mesma barra do Euriler (modelo, esforco,
-// titulo da conversa, pasta, branch, contexto, cache, uso de 5 h e da semana, data), em qualquer
-// terminal do Mac ou do Windows e dentro do app Auroq OS.
+// Barra de status do aluno (2.6.8; Codex e Grok desde 2.6.10): a mesma barra do Euriler (modelo,
+// esforco, titulo da conversa, pasta, branch, contexto, cache, uso de 5 h e da semana, data), em
+// qualquer terminal do Mac ou do Windows e dentro do app Auroq OS.
+//   - Claude Code: `statusLine` no ~/.claude/settings.json roda barra.cjs (ccstatusline).
+//   - Grok: `[ui.status_line]` no ~/.grok/config.toml roda `barra.cjs grok` (so se o Grok existe).
+//   - Codex: nao aceita comando na barra; liga a barra nativa com os mesmos itens no
+//     `[tui] status_line` do ~/.codex/config.toml (o app Auroq OS espelha esse arquivo nas contas).
 //
 // O que faz, sempre no HOME do aluno (nunca na pasta do negocio):
 //   - copia o ccstatusline travado (MIT, sem dependencias) para ~/.auroq/barra/ccstatusline;
@@ -19,6 +23,9 @@ const VERSAO_CCSTATUSLINE = '2.2.30';
 const AQUI = __dirname;
 
 const ehNossa = comando => /[\\/]\.auroq[\\/]barra[\\/]barra\.cjs/.test(comando);
+// Mesmos itens da barra do Euriler no Codex (~/.codex/config.toml dele, 24/09/2026).
+const CODEX_ITENS = ['model-with-reasoning', 'thread-title', 'current-dir', 'git-branch', 'branch-changes', 'context-used', 'five-hour-limit', 'weekly-limit'];
+const CODEX_LINHA = `status_line = [${CODEX_ITENS.map(i => `"${i}"`).join(', ')}]`;
 const ehDoApp = comando => /agent-hooks[\\/]+claude-statusline/.test(comando);
 const sha = texto => crypto.createHash('sha256').update(texto).digest('hex');
 
@@ -67,39 +74,106 @@ function copiarMotor(origem, destino) {
   return true;
 }
 
-function instalarBarra({
-  home = os.homedir(),
-  claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(home, '.claude'),
-  origem = null,
-} = {}) {
-  if (fs.existsSync(path.join(home, '.auroq', 'sem-barra'))) return { estado: 'desligada' };
+// ─── TOML sem biblioteca: so acha a secao pelo cabecalho e mexe nas linhas dela. O resto do
+// arquivo (comentarios, ordem, outras secoes) volta byte a byte como estava.
+const CABECALHO = /^\s*\[\s*([^\[\]]+?)\s*\]\s*(#.*)?$/;
+const CABECALHO_QUALQUER = /^\s*\[/;
 
-  const pasta = path.join(home, '.auroq', 'barra');
-  const script = path.join(pasta, 'barra.cjs').split(path.sep).join('/');
-  // Aspas servem ao cmd.exe e aos shells POSIX; caminho com aspas, $, crase ou quebra de linha fica de fora.
-  if (/["\r\n`$%]/.test(script)) return { estado: 'caminho-nao-suportado', detalhe: script };
-  const comando = `node "${script}"`;
+function lerToml(arquivo) {
+  const texto = fs.existsSync(arquivo) ? fs.readFileSync(arquivo, 'utf8') : '';
+  const quebra = texto.includes('\r\n') ? '\r\n' : '\n';
+  return { texto, quebra, linhas: texto === '' ? [] : texto.split(/\r?\n/) };
+}
 
-  fs.mkdirSync(pasta, { recursive: true });
-  const motorNovo = copiarMotor(origem || origemPadrao(), path.join(pasta, 'ccstatusline'));
-  gravarAtomico(path.join(pasta, 'barra.cjs'), fs.readFileSync(path.join(AQUI, 'barra.cjs')));
+function secao(linhas, nome) {
+  const inicio = linhas.findIndex(l => (l.match(CABECALHO) || [])[1] === nome);
+  if (inicio === -1) return null;
+  let fim = linhas.length;
+  for (let i = inicio + 1; i < linhas.length; i++) {
+    if (CABECALHO_QUALQUER.test(linhas[i])) { fim = i; break; }
+  }
+  return { inicio, fim };
+}
 
-  // Layout: o nosso, a menos que o aluno tenha mexido no que gravamos da ultima vez.
-  const registroPath = path.join(pasta, 'instalacao.json');
-  const registro = lerJson(registroPath) || {};
-  const layoutPath = path.join(pasta, 'ccstatusline.json');
-  const layout = fs.readFileSync(path.join(AQUI, 'ccstatusline.json'), 'utf8').split('{{BARRA}}').join(comando.replace(/"/g, '\\"'));
-  const layoutAtual = fs.existsSync(layoutPath) ? fs.readFileSync(layoutPath, 'utf8') : null;
-  const layoutDoAluno = layoutAtual !== null && registro.layoutSha && sha(layoutAtual) !== registro.layoutSha && sha(layoutAtual) !== sha(layout);
-  if (!layoutDoAluno && layoutAtual !== layout) gravarAtomico(layoutPath, layout);
+function chaveNaSecao(linhas, s, chave) {
+  const re = new RegExp(`^\\s*${chave}\\s*=`);
+  for (let i = s.inicio + 1; i < s.fim; i++) if (re.test(linhas[i])) return i;
+  return -1;
+}
+
+function gravarToml(arquivo, { linhas, quebra }) {
+  fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+  let texto = linhas.join(quebra);
+  if (!texto.endsWith(quebra)) texto += quebra;
+  gravarAtomico(arquivo, texto);
+}
 
+function acrescentarSecao(toml, novas) {
+  const linhas = [...toml.linhas];
+  while (linhas.length && linhas[linhas.length - 1].trim() === '') linhas.pop();
+  if (linhas.length) linhas.push('');
+  return { ...toml, linhas: [...linhas, ...novas] };
+}
+
+// Codex: barra nativa com os mesmos itens. So ocupa `[tui] status_line` quando ninguem pos.
+function ligarCodex({ codexDir, registro }) {
+  const arquivo = path.join(codexDir, 'config.toml');
+  const toml = lerToml(arquivo);
+  if (/^\s*tui\s*\.\s*status_line\s*=/m.test(toml.texto)) return 'barra-do-aluno';
+  const tui = secao(toml.linhas, 'tui');
+  if (tui) {
+    const i = chaveNaSecao(toml.linhas, tui, 'status_line');
+    if (i !== -1) return toml.linhas[i].replace(/\s+/g, '') === CODEX_LINHA.replace(/\s+/g, '') ? 'em-dia' : 'barra-do-aluno';
+    if (registro.codexLigadaEm) return 'tirada-pelo-aluno';
+    const novas = [CODEX_LINHA];
+    if (chaveNaSecao(toml.linhas, tui, 'status_line_use_colors') === -1) novas.push('status_line_use_colors = true');
+    const linhas = [...toml.linhas];
+    linhas.splice(tui.inicio + 1, 0, ...novas);
+    gravarToml(arquivo, { ...toml, linhas });
+    return 'ligada';
+  }
+  if (registro.codexLigadaEm) return 'tirada-pelo-aluno';
+  gravarToml(arquivo, acrescentarSecao(toml, ['[tui]', CODEX_LINHA, 'status_line_use_colors = true']));
+  return 'ligada';
+}
+
+// Grok: `[ui.status_line]` roda a mesma barra. So mexe se o Grok existe neste computador.
+function ligarGrok({ grokDir, registro, script }) {
+  if (!fs.existsSync(grokDir)) return 'sem-grok';
+  if (script.includes("'")) return 'caminho-nao-suportado';
+  const arquivo = path.join(grokDir, 'config.toml');
+  const toml = lerToml(arquivo);
+  // String literal do TOML (aspas simples): as aspas duplas do caminho passam sem escape.
+  const desejadas = ['[ui.status_line]', 'type = "command"', `command = 'node "${script}" grok'`, 'refresh_interval = 10'];
+  const atual = secao(toml.linhas, 'ui.status_line');
+  if (atual) {
+    const corpo = toml.linhas.slice(atual.inicio, atual.fim);
+    if (!corpo.some(l => /^\s*command\s*=/.test(l) && ehNossa(l))) return 'barra-do-aluno';
+    const sobra = corpo.slice(1).filter(l => l.trim() !== '' && !/^\s*(type|command|refresh_interval)\s*=/.test(l));
+    const novas = [...desejadas, ...sobra];
+    const limpas = corpo.filter(l => l.trim() !== '');
+    if (JSON.stringify(limpas) === JSON.stringify(novas)) return 'em-dia';
+    const linhas = [...toml.linhas];
+    const vazias = corpo.length - limpas.length;
+    linhas.splice(atual.inicio, corpo.length, ...novas, ...Array(vazias).fill(''));
+    gravarToml(arquivo, { ...toml, linhas });
+    return 'atualizada';
+  }
+  const ui = secao(toml.linhas, 'ui');
+  if (ui && chaveNaSecao(toml.linhas, ui, 'status_line') !== -1) return 'barra-do-aluno';
+  if (/^\s*ui\s*\.\s*status_line\s*[.=]/m.test(toml.texto)) return 'barra-do-aluno';
+  if (registro.grokLigadaEm) return 'tirada-pelo-aluno';
+  gravarToml(arquivo, acrescentarSecao(toml, desejadas));
+  return 'ligada';
+}
+
+// Claude Code: so a chave `statusLine` do ~/.claude/settings.json.
+function ligarClaude({ claudeDir, registro, comando }) {
   const settingsPath = path.join(claudeDir, 'settings.json');
   let settings = {};
   if (fs.existsSync(settingsPath)) {
     settings = lerJson(settingsPath);
-    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
-      return { estado: 'settings-ilegivel', detalhe: settingsPath };
-    }
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) return 'settings-ilegivel';
   }
   const atual = settings.statusLine && typeof settings.statusLine.command === 'string' ? settings.statusLine.command : '';
   let estado;
@@ -114,14 +188,66 @@ function instalarBarra({
     gravarAtomico(settingsPath, `${JSON.stringify({ ...settings, statusLine: { ...(estado === 'em-dia' ? settings.statusLine : {}), ...desejada } }, null, 2)}\n`);
     if (estado === 'em-dia') estado = 'atualizada';
   }
+  return estado;
+}
+
+function seguro(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    return `erro: ${String(e && e.message || e).split(/\r?\n/)[0].slice(0, 160)}`;
+  }
+}
+
+function instalarBarra({
+  home = os.homedir(),
+  claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(home, '.claude'),
+  codexDir = process.env.CODEX_HOME || path.join(home, '.codex'),
+  grokDir = process.env.GROK_HOME || path.join(home, '.grok'),
+  origem = null,
+} = {}) {
+  if (fs.existsSync(path.join(home, '.auroq', 'sem-barra'))) return { estado: 'desligada' };
+
+  const pasta = path.join(home, '.auroq', 'barra');
+  const script = path.join(pasta, 'barra.cjs').split(path.sep).join('/');
+  // Aspas servem ao cmd.exe e aos shells POSIX; caminho com aspas, $, crase ou quebra de linha fica de fora.
+  if (/["\r\n`$%]/.test(script)) return { estado: 'caminho-nao-suportado', detalhe: script };
+  const comando = `node "${script}"`;
+
+  fs.mkdirSync(pasta, { recursive: true });
+  const motorNovo = copiarMotor(origem || origemPadrao(), path.join(pasta, 'ccstatusline'));
+  gravarAtomico(path.join(pasta, 'barra.cjs'), fs.readFileSync(path.join(AQUI, 'barra.cjs')));
+
+  // Layout: o nosso, a menos que o aluno tenha mexido no que gravamos da ultima vez.
+  const registroPath = path.join(pasta, 'instalacao.json');
+  const registro = lerJson(registroPath) || {};
+  const gravarLayout = (nome, shaAnterior) => {
+    const destino = path.join(pasta, nome);
+    const novo = fs.readFileSync(path.join(AQUI, nome), 'utf8').split('{{BARRA}}').join(comando.replace(/"/g, '\\"'));
+    const atual = fs.existsSync(destino) ? fs.readFileSync(destino, 'utf8') : null;
+    const doAluno = Boolean(atual !== null && shaAnterior && sha(atual) !== shaAnterior && sha(atual) !== sha(novo));
+    if (!doAluno && atual !== novo) gravarAtomico(destino, novo);
+    return { doAluno, sha: doAluno ? shaAnterior : sha(novo) };
+  };
+  const layoutClaude = gravarLayout('ccstatusline.json', registro.layoutSha);
+  const layoutGrok = gravarLayout('ccstatusline-grok.json', registro.layoutGrokSha);
+  const layoutDoAluno = layoutClaude.doAluno;
+
+  const estado = ligarClaude({ claudeDir, registro, comando });
 
+  const codex = seguro(() => ligarCodex({ codexDir, registro }));
+  const grok = seguro(() => ligarGrok({ grokDir, registro, script }));
+  const agora = new Date().toISOString();
   const novoRegistro = {
     versaoCcstatusline: VERSAO_CCSTATUSLINE,
-    layoutSha: layoutDoAluno ? registro.layoutSha : sha(layout),
-    ligadaEm: registro.ligadaEm || (estado === 'ligada' ? new Date().toISOString() : undefined),
+    layoutSha: layoutClaude.sha,
+    layoutGrokSha: layoutGrok.sha,
+    ligadaEm: registro.ligadaEm || (estado === 'ligada' ? agora : undefined),
+    codexLigadaEm: registro.codexLigadaEm || (codex === 'ligada' ? agora : undefined),
+    grokLigadaEm: registro.grokLigadaEm || (grok === 'ligada' ? agora : undefined),
   };
   gravarAtomico(registroPath, `${JSON.stringify(novoRegistro, null, 2)}\n`);
-  return { estado, comando, motorNovo, layoutDoAluno: Boolean(layoutDoAluno) };
+  return { estado, comando, motorNovo, layoutDoAluno, codex, grok };
 }
 
-module.exports = { instalarBarra, ehNossa, ehDoApp, VERSAO_CCSTATUSLINE };
+module.exports = { instalarBarra, ehNossa, ehDoApp, VERSAO_CCSTATUSLINE, CODEX_ITENS };