auroq-os 2.5.1 → 2.5.4

package/.auroq-core/core-config.yaml

@@ -1,7 +1,7 @@
 project:
   name: "Auroq OS"
   type: greenfield
-  version: 2.5.1
+  version: 2.5.4
   installedAt: '2026-03-16'
 
 ide:

package/.claude/hooks/ahi-capture.cjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * Coletor AHI. Camada ao lado do Synapse: nunca substitui synapse-engine.cjs.
+ * Falha = exit 0. Sem stdout. Sem MCP Arcane neste negocio = no-op.
+ */
+process.on('uncaughtException', () => process.exit(0));
+process.on('unhandledRejection', () => process.exit(0));
+const kill = setTimeout(() => process.exit(0), 2500);
+function done() {
+  try { clearTimeout(kill); } catch { /* ignore */ }
+  process.exit(0);
+}
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  input += chunk;
+  if (input.length > 512 * 1024) input = input.slice(0, 512 * 1024);
+});
+process.stdin.on('end', () => {
+  try { capture(); } catch { /* never break Claude */ }
+  done();
+});
+
+function redact(text) {
+  return String(text || '')
+    .replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, '[REDACTED]')
+    .replace(/\bBearer\s+[A-Za-z0-9\-._~+/]+=*/gi, '[REDACTED]')
+    .replace(/\bsk-(?:live|test|proj)?[-_]?[A-Za-z0-9]{16,}\b/g, '[REDACTED]')
+    .replace(/\bghp_[A-Za-z0-9]{20,}\b/g, '[REDACTED]')
+    .slice(0, 8000);
+}
+
+function capture() {
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const cwd = process.cwd();
+  let mcp = false;
+  try {
+    const json = JSON.parse(fs.readFileSync(path.join(cwd, '.mcp.json'), 'utf8'));
+    mcp = Boolean(json && json.mcpServers && json.mcpServers.arcane);
+  } catch { /* sem MCP */ }
+  if (!mcp) return;
+  let event = {};
+  try { event = JSON.parse(input || '{}'); } catch { return; }
+  const name = event.hook_event_name || event.hookEventName;
+  if (!name) return;
+  const dir = path.join(cwd, '.auroq', 'ahi');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const row = {
+    at: new Date().toISOString(),
+    hook: String(name),
+    session_id: event.session_id || event.sessionId || null,
+    tool: event.tool_name || null,
+    text: redact(event.prompt || event.last_assistant_message || event.last_message || event.content || ''),
+  };
+  fs.appendFileSync(path.join(dir, 'events.jsonl'), `${JSON.stringify(row)}\n`, { mode: 0o600 });
+}

package/.claude/settings.local.json

@@ -3,6 +3,9 @@
     "allow": [],
     "deny": []
   },
+  "env": {
+    "MCP_TIMEOUT": "120000"
+  },
   "hooks": {
     "UserPromptSubmit": [
       {
@@ -14,6 +17,16 @@
             "timeout": 10000
           }
         ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs",
+            "timeout": 3000
+          }
+        ]
       }
     ],
     "PreCompact": [

package/CHANGELOG.md

@@ -1,5 +1,26 @@
+## 2.5.4 — 2026-09-14
+
+- Historico do trabalho Arcane: se o negocio tem MCP `arcane`, o hook `ahi-capture.cjs` registra a sessao. Sem clique, sem pause. Falha do coletor nao quebra o Claude (exit 0, sem stdout). Nao substitui o Synapse.
+- `auroq-os historico` mostra ligado/desligado. Manutencao acrescenta o hook que faltar em `.claude/settings.local.json`.
+
+## 2.5.2 — 2026-09-11
+
+- **"UserPromptSubmit hook error ... hookEventName" a cada mensagem (EMB-040).** Quem instalou ate a 2.4.9 ficou com o Synapse antigo para sempre: a pasta era copiada sem sobrescrever e a correcao da 2.4.10 nunca chegava — o Claude Code recusava o pacote de regras em toda mensagem, enquanto a manutencao carimbava a versao nova. A manutencao agora troca todo arquivo do Synapse que seja uma versao oficial antiga (hashes das 90 versoes publicadas em `lib/synapse-hashes.json`) e guarda em `.auroq-core/preservado/synapse/` qualquer arquivo diferente de todas elas antes da troca. Integridade e `doctor` apontam o Synapse antigo em vez de dizer que esta tudo em dia.
+- **MCP arcane com CONNECT_TIMEOUT no Claude Code (EMB-041).** O Claude Code desiste do conteudo ao vivo aos 30s; o npx a frio no Windows leva 44-77s. Instalar, manutencao, register-mcp e clone gravam `env.MCP_TIMEOUT = 120000` em `.claude/settings.local.json` (o Codex ja tinha 120s); o `doctor` cobra esse tempo.
+- `.claude/settings.local.json` ilegivel deixa de virar `{}` (o aluno perdia os hooks): o original fica guardado ao lado e o arquivo volta a partir do modelo.
+- Instaladores fixam 2.5.2. Correcao feita a partir da 2.5.1 publicada; o candidato de telemetria segue separado.
+
 ## 2.5.1 — 2026-09-04
 
+## 2.5.3 — candidato local, nao publicado
+
+- Bootstrap dependency-light e outbox privada compartilhada com o MCP; retries autenticados com IDs estaveis e eventos sem dono exclusivamente locais.
+- Spool de etapas dos instaladores antes de Node, importado depois sem inferir identidade.
+- Pin MCP 0.6.0 e orientacoes de doctor/manutencao; studentFiles e consentimento legado preservados.
+- Instaladores oficiais fixam o motor publicado 2.5.2 (hotfix EMB-040/EMB-041); este candidato ainda nao foi publicado. Transporte/doctor novos dependem de publicacao/adocao.
+- Locks e publicacao atomicos, claim do spool e TTL pre-Node; runtime Windows faz fail-closed por ACL/no-follow indisponiveis.
+- Validacao Linux; Windows/macOS pendentes de execucao nativa.
+
 - Motor registra arcane-mcp 0.5.0: diagnostico de tentativas, erros, ambiente e reenvio apos falha de rede. Conteudo de conversas e arquivos nao e coletado. Instaladores fixam esta versao validada.
 
 ## 2.5.0 — 2026-09-04

package/README.md

@@ -164,3 +164,41 @@ agents/             → Seu exercito (companion, workers, minds, squads)
 ---
 
 *Auroq OS — by Euriler Jube / Arka*
+
+
+## Observabilidade do motor (candidato 2.5.2)
+
+Apos publicacao, `npx -y auroq-os@2.5.3 doctor` mostrara a fila local segura e os comandos pinados de
+manutencao/diagnostico. `npx -y auroq-os@2.5.3 manutencao` preserva o caminho existente
+de consentimento legado, studentFiles, customizacoes e dados do negocio. Nao ha
+migracao forcada. O registro MCP passa a apontar para `arcane-mcp@0.6.0`.
+Estes candidatos precisam ser publicados pelo coordenador apos review; consultar
+novamente colisao no registry antes de publicar. A promocao esta bloqueada por
+autenticacao npm (401 nas duas vias verificadas pelo coordenador). Os instaladores
+oficiais continuam em `auroq-os@2.5.2`, publicado; o spool nativo local pode ser servido
+com esse pin. Transporte/doctor novos dependem de publicacao e adocao dos candidatos.
+
+O CLI inicia captura antes das dependencias pesadas e registra resultado ao sair.
+Eventos com identidade ja existente podem seguir pela rota autenticada na proxima
+inicializacao. Shell e PowerShell gravam somente etapas/codigos em spool privado
+`~/.arcane/installer-outbox`, sem ler credenciais nem conteudo pessoal; 200 slots por
+formato limitam o disco antes de haver Node. Saturado, deixa de capturar. Quando Node
+executa nosso CLI, ele importa/expurga o spool com TTL de sete dias, preserva proveniencia
+local e jamais atribui esses eventos ao login posterior. Cada execucao do instalador
+expurga sete dias e slots interrompidos sob lock; nao precisa esperar Node. Nao existe daemon. O runtime Windows falha fechado (`OUTBOX_UNAVAILABLE`), sem
+ler/enviar/importar fila enquanto nao houver garantia nativa de ACL/no-follow.
+O PowerShell verifica DACL nativa e conserva seus eventos locais. O spool nao substitui o install.log legado,
+que nao e lido nem enviado pela telemetria nova.
+
+Captura cobre inicio e etapas Git/motor/acesso/pasta/montagem do instalador; no CLI,
+instalacao/manutencao/doctor/login/register-mcp. Bootstrap conversacional e o trabalho
+final do squad nao sao inferidos como sucesso por sair do CLI ou preparar arquivos.
+Antes de o script chegar ou em computador que nunca executa nosso codigo, nao ha sinal.
+A rota events continua autenticada, limitada e idempotente. A plataforma deve receber
+a whitelist antes de distribuir/promover os clientes; os instaladores sincronizados
+mantem o pin 2.5.1 publicado ate a promocao npm ser possivel. Nao precisa migration adicional.
+
+O canal de adocao e o instalador oficial, o README/changelog, o doctor e o aviso de
+comando aposentado quando a versao nova e executada. Isso nao atualiza silenciosamente
+quem continua com o pacote antigo. Testado nesta VPS em Linux; sintaxe Bash e verificacoes
+estaticas ASCII/compatibilidade PS passaram, mas Windows PS5.1 e macOS nao foram executados.

package/bin/auroq-os.js

@@ -12,6 +12,30 @@
 
 'use strict';
 
+async function observedMain() {
+ const telemetry = {...await import('../lib/telemetry.mjs')};
+ const credentials = require('../lib/credentials');
+ const owner = credentials.load()?.user?.id || null;
+ const stage = ({instalar:'install',manutencao:'update',doctor:'doctor',diagnostico:'doctor',login:'login','register-mcp':'bootstrap'})[process.argv[2]] || 'runtime';
+ const record = (outcome, error_code) => telemetry.enqueue(owner,{endpoint:'lifecycle',stage,outcome,error_code});
+ telemetry.setHost('auroq-os');telemetry.importInstallerSpool();record('started');
+ let importing = true;
+ process.once('exit',code=>record(code===0?'ok':'error',code===0?null:importing?'BOOTSTRAP_IMPORT':stage==='update'?'UPDATE_FAILED':'INSTALL_FAILED'));
+ process.once('uncaughtException',()=>{console.error('[auroq-os] RUNTIME_FAILURE');process.exit(1);});
+ process.once('unhandledRejection',()=>{console.error('[auroq-os] RUNTIME_FAILURE');process.exit(1);});
+ const cred = credentials.load();await telemetry.flush(cred?.user?.id,cred?.access_token);
+ try {
+telemetry.runtimeReady=()=>{importing=false;};
+runRuntime(telemetry);
+ } catch {
+  console.error('[auroq-os] '+(importing?'BOOTSTRAP_IMPORT':'RUNTIME_FAILURE')+'. Rode: npx -y auroq-os@2.5.3 doctor');
+  process.exitCode=1;
+ }
+}
+if(process.env.AUROQ_EXPORTA_INTERNOS==='1')runRuntime({runtimeReady(){}});
+else observedMain().catch(()=>{console.error('[auroq-os] BOOTSTRAP_IMPORT');process.exitCode=1;});
+
+function runRuntime(telemetry) {
 const path = require('path');
 const fs = require('fs-extra');
 const { execSync, execFileSync } = require('child_process');
@@ -164,6 +188,7 @@ const HEALTH_CHECKS = [
   ['.claude/output-styles/direto.md', 'Output style Direto'],
   ['.claude/rules/operacao-autonoma.md', 'Rule de operacao autonoma'],
   ['.claude/hooks/synapse-engine.cjs', 'Synapse Hook'],
+  ['.claude/hooks/ahi-capture.cjs', 'AHI Hook'],
   ['.claude/hooks/auroq-sync.cjs', 'Sync Hook'],
   ['.claude/rules/puxar-e-entregar.md', 'Rule puxar-e-entregar'],
   ['.claude/rules/mcp-usage.md', 'Rule MCP (carve-out Arcane)'],
@@ -246,6 +271,11 @@ async function runHealthChecks(targetDir) {
       missing.push(`${label} (${file})`);
     }
   }
+  if (await synapseDesatualizado(targetDir)) {
+    // Aviso, nao trava: um clone de negocio antigo traz o arquivo velho pelo git e so a
+    // manutencao nesta maquina (ou na outra, depois entregue) troca.
+    warn('Synapse antigo nesta pasta (erro "hookEventName" a cada mensagem). Peca ao Ops: manutencao do motor.');
+  }
   if (passed === HEALTH_CHECKS.length) {
     success(`${passed}/${HEALTH_CHECKS.length} verificacoes OK`);
   } else {
@@ -280,6 +310,14 @@ async function runDoctor(targetDir) {
     error(`Arquivos do sistema: faltam ${faltando}`);
     problemas.push('Peca manutencao do motor ao Ops dentro do Claude Code pra repor o que falta.');
   }
+  if (!(await synapseRegistrado(targetDir))) {
+    error('O hook do Synapse nao esta registrado: as regras do sistema nao chegam ao modelo');
+    problemas.push('Rode: npx auroq-os@latest register-mcp na pasta (repoe o registro sem tirar nada seu). Depois feche e abra o Claude Code.');
+  }
+  if (await synapseDesatualizado(targetDir)) {
+    error('Synapse antigo: o Claude Code recusa as regras a cada mensagem ("hookEventName")');
+    problemas.push('Peca manutencao do motor ao Ops dentro do Claude Code (ou rode npx auroq-os@latest manutencao na pasta) pra trocar o Synapse antigo.');
+  }
 
   // 2. O motor — e, principalmente, se quem abre pelo icone vai enxergar ele.
   //    Esta e a falha silenciosa do §5.4: no terminal funciona, no app nao, e
@@ -327,6 +365,15 @@ async function runDoctor(targetDir) {
   }
   if (pin) {
     success(`MCP arcane registrado no Claude Code (${pin})`);
+    let espera = NaN;
+    try {
+      const local = JSON.parse((await fs.readFile(path.join(targetDir, '.claude', 'settings.local.json'), 'utf8')).replace(/^\uFEFF/, ''));
+      espera = Number(local?.env?.MCP_TIMEOUT);
+    } catch { /* sem arquivo ou ilegivel = sem tempo de espera */ }
+    if (!(espera >= CLAUDE_MCP_TIMEOUT_MS)) {
+      error('O Claude Code esta com a espera padrao de 30s pelo conteudo ao vivo — no Windows a abertura pode cair (CONNECT_TIMEOUT)');
+      problemas.push('Rode: npx auroq-os@latest register-mcp (da ao Claude Code 2 minutos de espera). Depois feche e abra o Claude Code.');
+    }
   } else {
     error('MCP arcane nao registrado em .mcp.json');
     problemas.push('Rode: npx auroq-os register-mcp (reescreve o registro). Depois feche e abra o Claude Code.');
@@ -459,8 +506,12 @@ async function runDoctor(targetDir) {
 // (rede domestica + antivirus) a aluna viu timeout em todas as que fez. Por isso:
 // (1) o registro do Codex pede mais tempo, (2) instalacao/atualizacao ja baixam o
 // pacote, (3) o doctor mede o arranque de verdade em vez de so olhar o registro.
-const ARCANE_MCP_PIN = 'arcane-mcp@0.5.0';
+const ARCANE_MCP_PIN = 'arcane-mcp@0.6.0';
 const CODEX_MCP_STARTUP_SEC = 120;
+// O Claude Code tambem desistia aos 30s (MCP_TIMEOUT) e o aluno via CONNECT_TIMEOUT com o
+// servidor no ar e nenhum pedido chegando nele (11/09, EMB-041). Ele le o tempo do `env` das
+// configuracoes da pasta: provado no 2.1.267, servidor de 40s cai aos 30s sem isto e conecta com isto.
+const CLAUDE_MCP_TIMEOUT_MS = 120000;
 const CODEX_ENV_MINIMO = ['PATH', 'PATHEXT', 'USERNAME', 'USERDOMAIN', 'USERPROFILE', 'TEMP', 'TMP',
   'HOME', 'LOGNAME', 'SHELL', 'TERM', 'USER'];
 
@@ -508,7 +559,7 @@ function blocoCodexArcane(pin, opcoes) {
 }
 
 // Baixa o pacote do conteudo ao vivo com o MESMO nome que o registro usa (o cache do
-// npx e por nome+versao: `arcane-mcp` e `arcane-mcp@0.5.0` sao caches diferentes).
+// npx e por nome+versao: `arcane-mcp` e `arcane-mcp@0.6.0` sao caches diferentes).
 // `npx` no Windows e um .cmd: sem shell o Node recusa (EINVAL) e com `shell: true` o Node 24
 // imprime um DeprecationWarning na tela do aluno (DEP0190). Chamar o cmd.exe direto, sem shell.
 function comandoNpx(args) {
@@ -768,6 +819,16 @@ function rodarNoCodex(pasta) {
 }
 
 async function writeArcaneMcpConfig(targetDir) {
+  // Todo caminho que registra o MCP (instalar, manutencao, register-mcp, clone) passa aqui,
+  // entao e aqui que o Claude Code ganha o tempo de espera. Falhar em gravar isso (arquivo
+  // somente leitura, dono root) nao pode derrubar o registro nem o resto da manutencao.
+  let esperaOk = false;
+  try {
+    await patchEnableAllProjectMcpServers(targetDir);
+    esperaOk = true;
+  } catch (e) {
+    warn(`Nao consegui gravar .claude/settings.local.json (${e.code || e.message}): o Claude Code segue esperando so 30s pelo conteudo ao vivo. Confira a permissao desse arquivo e rode register-mcp de novo.`);
+  }
   const pin = ARCANE_MCP_PIN;
   const mcpPath = path.join(targetDir, '.mcp.json');
   let json = { mcpServers: {} };
@@ -791,22 +852,181 @@ async function writeArcaneMcpConfig(targetDir) {
     const next = (toml.trimEnd() ? `${toml.trimEnd()}\n\n` : '') + block;
     await fs.writeFile(tomlPath, next);
   }
+  return { esperaOk };
 }
 
+async function modeloSettingsLocal() {
+  try {
+    return await fs.readJSON(path.resolve(__dirname, '..', '.claude', 'settings.local.json'));
+  } catch {
+    return {};
+  }
+}
+
+// Copia dos bytes do aluno antes de reescrever o arquivo dele. Vai pra `.auroq/` (fora do
+// git): um settings.local.json pode ter token no `env` e nao pode subir pro GitHub.
+async function guardarSettingsLocal(targetDir, bruto, motivo) {
+  const quando = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
+  const guarda = path.join(targetDir, '.auroq', 'preservado', `settings.local.json.${motivo}-${quando}`);
+  await fs.ensureDir(path.dirname(guarda));
+  await fs.writeFile(guarda, bruto);
+  const giPath = path.join(targetDir, '.gitignore');
+  const gi = (await fs.pathExists(giPath)) ? await fs.readFile(giPath, 'utf8') : '';
+  if (!gi.split('\n').map(l => l.trim()).includes('.auroq/')) {
+    await fs.writeFile(giPath, `${gi.replace(/\s*$/, gi.trim() ? '\n' : '')}.auroq/\n`);
+  }
+  return path.relative(targetDir, guarda).split(path.sep).join('/');
+}
+
+const ehObjeto = v => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+
+// `.claude/settings.local.json` e do aluno: so acrescenta o que falta, nunca tira nada.
+// E o unico lugar que registra os hooks do Synapse e do PreCompact; se o arquivo nasce
+// sem eles (clone numa maquina nova, ou criado pelo proprio Claude Code), as regras
+// deixam de chegar ao modelo em silencio. Por isso os hooks do modelo que faltarem entram.
 async function patchEnableAllProjectMcpServers(targetDir) {
   const settingsPath = path.join(targetDir, '.claude', 'settings.local.json');
-  let json = {};
+  const modelo = await modeloSettingsLocal();
+  let json;
+  let mudou = false;
   if (await fs.pathExists(settingsPath)) {
+    const bruto = await fs.readFile(settingsPath);
     try {
-      json = await fs.readJSON(settingsPath);
+      json = JSON.parse(bruto.toString('utf8').replace(/^\uFEFF/, ''));
+      if (!ehObjeto(json)) throw new Error('nao e um objeto');
     } catch {
-      json = {};
+      // Antes virava {} e o aluno perdia os hooks e o que mais tivesse ali.
+      const guarda = await guardarSettingsLocal(targetDir, bruto, 'ilegivel');
+      warn(`.claude/settings.local.json estava ilegivel: guardei o original em ${guarda} e refiz a partir do modelo`);
+      json = JSON.parse(JSON.stringify(modelo));
+      mudou = true;
+    }
+    if (json.env !== undefined && !ehObjeto(json.env)) {
+      const guarda = await guardarSettingsLocal(targetDir, bruto, 'env-invalido');
+      warn(`O "env" de .claude/settings.local.json nao era uma lista de variaveis: guardei o original em ${guarda}`);
+      delete json.env;
+      mudou = true;
     }
+  } else {
+    json = JSON.parse(JSON.stringify(modelo));
+    mudou = true;
+  }
+  if (ehObjeto(modelo.hooks)) {
+    // Hook ja registrado (aqui ou no settings.json, com qualquer forma de caminho) nao
+    // entra de novo: rodar o Synapse duas vezes duplicaria as regras.
+    let doProjeto = {};
+    try {
+      doProjeto = JSON.parse((await fs.readFile(path.join(targetDir, '.claude', 'settings.json'), 'utf8')).replace(/^/, ''));
+    } catch { /* sem settings.json legivel */ }
+    const scripts = (grupos) => (Array.isArray(grupos) ? grupos : [])
+      .flatMap(g => (Array.isArray(g?.hooks) ? g.hooks : []))
+      .map(h => (String(h?.command || '').match(/[\w.-]+\.c?js\b/) || [''])[0]);
+    if (!ehObjeto(json.hooks)) json.hooks = {};
+    for (const [evento, grupos] of Object.entries(modelo.hooks)) {
+      const atuais = Array.isArray(json.hooks[evento]) ? json.hooks[evento] : [];
+      const presentes = new Set([...scripts(atuais), ...scripts(doProjeto?.hooks?.[evento])].filter(Boolean));
+      const faltando = (grupos || []).filter(g => scripts([g]).some(s => s && !presentes.has(s)));
+      if (faltando.length) {
+        json.hooks[evento] = [...atuais, ...faltando];
+        mudou = true;
+      }
+    }
+  }
+  if (json.enableAllProjectMcpServers !== true) {
+    json.enableAllProjectMcpServers = true;
+    mudou = true;
   }
-  if (json.enableAllProjectMcpServers === true) return;
-  json.enableAllProjectMcpServers = true;
+  const env = ehObjeto(json.env) ? json.env : {};
+  const atual = Number(env.MCP_TIMEOUT);
+  if (!(Number.isFinite(atual) && atual >= CLAUDE_MCP_TIMEOUT_MS)) {
+    json.env = { ...env, MCP_TIMEOUT: String(CLAUDE_MCP_TIMEOUT_MS) };
+    mudou = true;
+  }
+  if (!mudou) return false;
   await fs.ensureDir(path.dirname(settingsPath));
   await fs.writeJSON(settingsPath, json, { spaces: 2 });
+  return true;
+}
+
+// ─── Synapse: o motor que reforca as regras do sistema a cada mensagem ───
+// Ate a 2.5.1 esta pasta era copiada com overwrite:false. Quem instalou ate a 2.4.9 ficou
+// para sempre com o hook-runtime.js sem `hookEventName`: o Claude Code recusava o pacote
+// inteiro ("UserPromptSubmit hook error" a cada mensagem) e nenhuma regra chegava ao modelo,
+// enquanto a manutencao carimbava a versao nova (EMB-040). Agora: arquivo identico a uma
+// versao que publicamos e trocado; arquivo que ninguem publicou (mexido a mao) e guardado
+// em .auroq-core/preservado/synapse/ antes da troca.
+function hashNormalizado(buf) {
+  return require('crypto').createHash('sha256').update(buf.toString('utf8').replace(/\r\n/g, '\n')).digest('hex');
+}
+
+async function listarArquivos(dir, base = dir) {
+  const saida = [];
+  for (const nome of await fs.readdir(dir)) {
+    const abs = path.join(dir, nome);
+    const st = await fs.lstat(abs);
+    if (st.isDirectory()) saida.push(...(await listarArquivos(abs, base)));
+    else if (st.isFile()) saida.push(path.relative(base, abs).split(path.sep).join('/'));
+  }
+  return saida;
+}
+
+async function atualizarSynapse(sourceDir, targetDir) {
+  const origem = path.join(sourceDir, '.auroq-core', 'core', 'synapse');
+  const destino = path.join(targetDir, '.auroq-core', 'core', 'synapse');
+  if (!(await fs.pathExists(origem))) return null;
+  const oficiais = require('../lib/synapse-hashes.json');
+  const r = { novos: 0, atualizados: 0, iguais: 0, preservados: [], falhas: [] };
+  for (const rel of await listarArquivos(origem)) {
+    const src = path.join(origem, ...rel.split('/'));
+    const dst = path.join(destino, ...rel.split('/'));
+    try {
+      if (!(await fs.pathExists(dst))) {
+        await fs.copy(src, dst);
+        r.novos++;
+        continue;
+      }
+      const atual = await fs.readFile(dst);
+      const hAtual = hashNormalizado(atual);
+      if (hAtual === hashNormalizado(await fs.readFile(src))) {
+        r.iguais++;
+        continue;
+      }
+      if (!(oficiais[rel] || []).includes(hAtual)) {
+        const guarda = path.join(targetDir, '.auroq-core', 'preservado', 'synapse', `${rel}.${hAtual.slice(0, 12)}`);
+        if (!(await fs.pathExists(guarda))) {
+          await fs.ensureDir(path.dirname(guarda));
+          await fs.writeFile(guarda, atual);
+        }
+        r.preservados.push(rel);
+      }
+      await fs.copy(src, dst, { overwrite: true });
+      r.atualizados++;
+    } catch (e) {
+      r.falhas.push(`${rel} (${e.code || e.message})`);
+    }
+  }
+  return r;
+}
+
+async function synapseRegistrado(targetDir) {
+  for (const nome of ['settings.local.json', 'settings.json']) {
+    try {
+      const json = JSON.parse((await fs.readFile(path.join(targetDir, '.claude', nome), 'utf8')).replace(/^/, ''));
+      const grupos = Array.isArray(json?.hooks?.UserPromptSubmit) ? json.hooks.UserPromptSubmit : [];
+      if (grupos.some(g => (g?.hooks || []).some(h => String(h?.command || '').includes('synapse-engine.cjs')))) return true;
+    } catch { /* arquivo ausente ou ilegivel */ }
+  }
+  return false;
+}
+
+// O hook-runtime sem `hookEventName` e a assinatura do Synapse antigo (EMB-040).
+async function synapseDesatualizado(targetDir) {
+  const arq = path.join(targetDir, '.auroq-core', 'core', 'synapse', 'runtime', 'hook-runtime.js');
+  try {
+    return !(await fs.readFile(arq, 'utf8')).includes('hookEventName');
+  } catch {
+    return false;
+  }
 }
 
 // ─── INSTALACAO ──────────────────────────────────────────
@@ -992,6 +1212,7 @@ async function init({ pasta = null, maintenance = false } = {}) {
 
     // Hooks
     '.claude/hooks/synapse-engine.cjs',
+    '.claude/hooks/ahi-capture.cjs',
     '.claude/hooks/precompact-session-digest.cjs',
     '.claude/hooks/auroq-sync.cjs',
 
@@ -1196,25 +1417,26 @@ async function init({ pasta = null, maintenance = false } = {}) {
     await fs.copy(seedRoot, targetDir, { overwrite: false });
     success('Semente do aluno instalada (memoria, docs, cockpit — nunca sobrescreve)');
   }
-  await patchEnableAllProjectMcpServers(targetDir);
-  await writeArcaneMcpConfig(targetDir);
-  step('Preparando o conteudo ao vivo (baixa uma vez; no Windows prepara tambem pro Codex; pode levar 1-3 min)...');
-  if (aquecerArcaneMcp()) success('Conteudo ao vivo pronto pra abrir rapido');
-  else warn('Nao consegui baixar o conteudo ao vivo agora — a primeira abertura vai demorar mais');
-
-  // ─── Fase 4: Copiar Synapse Engine
+  // ─── Fase 4: Synapse Engine (troca versao oficial antiga; guarda o que foi mexido a mao).
+  // Antes do registro do MCP: se algo ali falhar, a correcao do hook (EMB-040) ja entrou.
   step('Instalando Synapse Engine...');
 
-  const synapseSrc = path.join(sourceDir, '.auroq-core', 'core', 'synapse');
-  const synapseDst = path.join(targetDir, '.auroq-core', 'core', 'synapse');
-  if (await fs.pathExists(synapseSrc)) {
-    await fs.copy(synapseSrc, synapseDst, { overwrite: false });
-    const synapseFiles = await fs.readdir(synapseSrc, { recursive: true });
-    success(`Synapse Engine instalado (${synapseFiles.length} arquivos)`);
-  } else {
+  const sinapse = await atualizarSynapse(sourceDir, targetDir);
+  if (!sinapse) {
     warn('Synapse Engine nao encontrado na fonte — pulando');
+  } else {
+    success(`Synapse Engine em dia (${sinapse.novos} novo(s), ${sinapse.atualizados} atualizado(s))`);
+    if (sinapse.preservados.length) {
+      warn(`Arquivo(s) do Synapse diferente(s) de qualquer versao oficial guardado(s) em .auroq-core/preservado/synapse antes da troca: ${sinapse.preservados.join(', ')}`);
+    }
+    if (sinapse.falhas.length) warn(`Nao consegui atualizar: ${sinapse.falhas.join(', ')}`);
   }
 
+  await writeArcaneMcpConfig(targetDir);
+  step('Preparando o conteudo ao vivo (baixa uma vez; no Windows prepara tambem pro Codex; pode levar 1-3 min)...');
+  if (aquecerArcaneMcp()) success('Conteudo ao vivo pronto pra abrir rapido');
+  else warn('Nao consegui baixar o conteudo ao vivo agora — a primeira abertura vai demorar mais');
+
   // ─── Fase 4b: Copiar Meta Squads e scripts (diretorios inteiros)
   step('Instalando Meta Squads e scripts...');
 
@@ -1510,6 +1732,11 @@ ${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para Experts${RES
 `);
 }
 
+telemetry.runtimeReady();
+if (['doctor','diagnostico'].includes(process.argv[2])) {
+ console.log('Observabilidade local:',JSON.stringify(telemetry.diagnostics()));
+ console.log('Manutencao: npx -y auroq-os@2.5.3 manutencao; MCP: npx -y arcane-mcp@0.6.0 doctor');
+}
 // ─── CLI ─────────────────────────────────────────────────
 const command = process.argv[2];
 
@@ -1517,6 +1744,7 @@ if (['init', 'install', 'update'].includes(command)) {
   error('Comando aposentado. Nada foi instalado ou alterado.');
   error('Primeira instalacao: https://arcane.arka.education/auroq');
   error('No negocio existente, peca ao Ops: manutencao do motor. Conteudo chega pelo MCP.');
+  error('Diagnostico: npx -y auroq-os@2.5.3 doctor. Manutencao: npx -y auroq-os@2.5.3 manutencao.');
   process.exitCode = 1;
 } else if (command === 'instalar' || command === 'manutencao') {
   // `--pasta <nome>`: o instalador manda o CLI criar e entrar na pasta do negocio,
@@ -1591,9 +1819,9 @@ if (['init', 'install', 'update'].includes(command)) {
       error('Rode este comando na raiz do seu negocio.');
       process.exit(1);
     }
-    await patchEnableAllProjectMcpServers(targetDir);
-    await writeArcaneMcpConfig(targetDir);
+    const { esperaOk } = await writeArcaneMcpConfig(targetDir);
     success('Conteudo ao vivo registrado (.mcp.json e .codex/config.toml).');
+    if (esperaOk) success(`Claude Code espera o conteudo ao vivo por ate ${CLAUDE_MCP_TIMEOUT_MS / 1000}s (.claude/settings.local.json)`);
     log(`${DIM}Baixando o conteudo ao vivo uma vez (pode levar 1-2 min)...${RESET}`);
     if (aquecerArcaneMcp()) success('Conteudo ao vivo pronto pra abrir rapido');
     else warn('Nao consegui baixar o conteudo ao vivo agora — a primeira abertura vai demorar mais');
@@ -1603,6 +1831,15 @@ if (['init', 'install', 'update'].includes(command)) {
     error(`Falha ao registrar o MCP: ${err.message}`);
     process.exit(1);
   });
+} else if (command === 'historico') {
+  import('../lib/ahi/historico.mjs').then((mod) => {
+    const result = mod.run(process.argv.slice(3));
+    console.log(JSON.stringify(result));
+    process.exit(result.ok ? 0 : 1);
+  }).catch((err) => {
+    error(`Falha no historico: ${err.message}`);
+    process.exit(1);
+  });
 } else if (command === 'sync-codex') {
   // Regenera as skills do Codex CLI a partir dos comandos atuais do projeto.
   try {
@@ -1627,6 +1864,7 @@ if (['init', 'install', 'update'].includes(command)) {
   log(`  ${CYAN}doctor${RESET}   Diagnostico: arquivos, Node, MCP arcane, login e servidor`);
   log(`  ${CYAN}register-mcp${RESET}  Reescrever o registro do conteudo ao vivo (MCP arcane) no projeto`);
   log(`  ${CYAN}sync-codex${RESET}  Gerar e verificar as skills locais do Codex CLI ($nome)`);
+  log(`  ${CYAN}historico${RESET}  Estado da captura do trabalho (ligada com o MCP Arcane)`);
   log(`  ${CYAN}conectar-1password${RESET}  Conectar o 1Password CLI (token lido do Ctrl+C, nunca digitado)`);
   log('');
   log(`${DIM}Primeira instalacao: https://arcane.arka.education/auroq${RESET}`);
@@ -1634,3 +1872,5 @@ if (['init', 'install', 'update'].includes(command)) {
 }
 
 if (process.env.AUROQ_EXPORTA_INTERNOS === '1') module.exports = { blocoCodexArcane, envCodexArcane, lerBlocoArcane, lerEnvDoBloco, limparArcaneDoGlobal, envComoCodex };
+
+}

package/installer/README.md

@@ -100,3 +100,23 @@ em vez do original, o teste quebra e diz qual é o certo.
 Existe pra quem não pode depender de um `cd` ter funcionado. O instalador do Mac
 entra na pasta antes de chamar o `init`, então não precisa da opção — mas ela é a
 rede de segurança de qualquer outro chamador.
+
+
+### Spool de observabilidade (npm 2.5.1 publicado; promocao pendente)
+
+O script registra metadados fechados em `~/.arcane/installer-outbox` antes de Node.
+Shell usa Perl nativo do Mac, umask 077 e lock com dono publicado atomicamente.
+PowerShell verifica ACL privada e usa handle exclusivo liberado pelo kernel em crash.
+Nao coleta identidade nem conteudo pessoal. O CLI importa como LOCAL, com TTL de sete
+dias, e o doctor mostra os codigos; nao envia retroativamente ao primeiro login.
+O proprio instalador expurga TTL e slots interrompidos a cada execucao, sem Node.
+Limites: 200 slots por formato, sem captura antes
+do download do proprio script, sem garantia de reconexao/adocao. Fonte oficial segue
+neste diretorio; `plataforma-arcane/npm run sync:installer` sincroniza as duas copias.
+
+Pins oficiais permanecem `auroq-os@2.5.2`, atualmente publicado. A publicacao do candidato
+por 401 nas duas vias testadas pelo coordenador; nao alterar autenticacao aqui.
+Candidatos motor 2.5.2/cliente 0.6.0 nao publicados. O spool local pode ser servido
+com o pin antigo; novo transporte/doctor depende de npm e adocao. Runtime Windows
+faz fail-closed ate dispor de ACL/no-follow seguros; spool PowerShell permanece local.
+Execucao Linux de Bash/Perl nao valida macOS nem Windows/PowerShell 5.1.