auroq-os 2.5.11 → 2.6.0

package/.auroq-core/core/synapse/engine.js

@@ -123,9 +123,8 @@ class PipelineMetrics {
    * Record that a layer encountered an error.
    *
    * @param {string} name - Layer name
-   * @param {Error} error - The error object
    */
-  errorLayer(name, error) {
+  errorLayer(name) {
     const existing = this.layers[name] || {};
     if (existing.start) {
       const endTime = process.hrtime.bigint();
@@ -135,7 +134,7 @@ class PipelineMetrics {
     this.layers[name] = {
       ...existing,
       status: 'error',
-      error: error && error.message ? error.message : String(error),
+      errorCode: 'SYNAPSE_LAYER_FAILED',
     };
   }
 
@@ -170,8 +169,27 @@ class PipelineMetrics {
 // SynapseEngine
 // ---------------------------------------------------------------------------
 
-/** Hard pipeline timeout in milliseconds. */
+/** Cooperative budget between layers; synchronous work cannot be interrupted. */
 const PIPELINE_TIMEOUT_MS = 100;
+// Keep substantial headroom below the outer hook's 5000 ms safety timeout.
+const MAX_PIPELINE_TIMEOUT_MS = 1000;
+const SYNAPSE_PIPELINE_TIMEOUT_ENV = 'AUROQ_SYNAPSE_PIPELINE_TIMEOUT_MS';
+
+/** Resolve a short pipeline budget. Invalid values preserve the safe default. */
+function resolvePipelineTimeoutMs(config = {}) {
+  const fromEnv = process.env[SYNAPSE_PIPELINE_TIMEOUT_ENV];
+  const value = fromEnv !== undefined && fromEnv !== ''
+    ? fromEnv
+    : config.synapse?.pipelineTimeoutMs;
+  if (value === undefined || value === null) return PIPELINE_TIMEOUT_MS;
+  const timeout = typeof value === 'number' || typeof value === 'string' ? Number(value) : NaN;
+  if (!Number.isInteger(timeout) || timeout <= 0 || timeout > MAX_PIPELINE_TIMEOUT_MS) {
+    // Do not echo invalid values: environment/config may contain private text.
+    console.warn('[synapse:engine] SYNAPSE_INVALID_PIPELINE_TIMEOUT');
+    return PIPELINE_TIMEOUT_MS;
+  }
+  return timeout;
+}
 
 /**
  * NOG-18: Default active layers (L0-L2 only).
@@ -250,8 +268,13 @@ class SynapseEngine {
   async process(prompt, session, processConfig) {
     const safeProcessConfig = (processConfig && typeof processConfig === 'object') ? processConfig : {};
     const mergedConfig = { ...this.config, ...safeProcessConfig };
+    mergedConfig.synapse = { ...(this.config.synapse || {}), ...(safeProcessConfig.synapse || {}) };
+    const pipelineTimeoutMs = resolvePipelineTimeoutMs(mergedConfig);
+    const pipelineNow = typeof safeProcessConfig.nowNs === 'function'
+      ? safeProcessConfig.nowNs
+      : process.hrtime.bigint;
     const metrics = new PipelineMetrics();
-    metrics.totalStart = process.hrtime.bigint();
+    metrics.totalStart = pipelineNow();
 
     // 1. Calculate bracket (or use fixed layers in non-legacy mode)
     const promptCount = (session && session.prompt_count) || 0;
@@ -266,7 +289,7 @@ class SynapseEngine {
 
       // Guard: no layer config (invalid bracket — should not happen)
       if (!layerConfig) {
-        metrics.totalEnd = process.hrtime.bigint();
+        metrics.totalEnd = pipelineNow();
         return { xml: '', metrics: metrics.getSummary() };
       }
       activeLayers = layerConfig.layers;
@@ -291,8 +314,8 @@ class SynapseEngine {
         continue;
       }
 
-      // Check hard pipeline timeout (convert hrtime to ms for comparison)
-      if (Number(process.hrtime.bigint() - metrics.totalStart) / 1e6 > PIPELINE_TIMEOUT_MS) {
+      // Cooperative check between layers; the host owns interruption of a stuck process.
+      if (Number(pipelineNow() - metrics.totalStart) / 1e6 >= pipelineTimeoutMs) {
         // Log remaining layers as skipped
         const remaining = this.layers.slice(this.layers.indexOf(layer));
         for (const r of remaining) {
@@ -314,14 +337,28 @@ class SynapseEngine {
         previousLayers,
       });
 
-      const result = layer._safeProcess(context);
+      let result;
+      try {
+        result = layer._safeProcess(context);
+      } catch (_error) {
+        metrics.errorLayer(layer.name);
+        continue;
+      }
 
       if (result && Array.isArray(result.rules)) {
         metrics.endLayer(layer.name, result.rules.length);
         results.push(result);
         previousLayers.push(result);
       } else if (result === null || result === undefined) {
-        metrics.skipLayer(layer.name, 'Returned null');
+        try {
+          if (typeof layer.getLastError === 'function' && layer.getLastError()) {
+            metrics.errorLayer(layer.name);
+          } else {
+            metrics.skipLayer(layer.name, 'Returned null');
+          }
+        } catch (_error) {
+          metrics.errorLayer(layer.name);
+        }
       } else {
         metrics.skipLayer(layer.name, 'Invalid result format');
       }
@@ -341,8 +378,9 @@ class SynapseEngine {
       }
     }
 
-    metrics.totalEnd = process.hrtime.bigint();
+    metrics.totalEnd = pipelineNow();
     const summary = metrics.getSummary();
+    summary.pipeline_timeout_ms = pipelineTimeoutMs;
 
     // Persist hook metrics (fire-and-forget)
     this._persistHookMetrics(summary, bracket, mergedConfig);
@@ -382,6 +420,7 @@ class SynapseEngine {
       const hookBootMs = hookBootTime ? Number(process.hrtime.bigint() - hookBootTime) / 1e6 : 0;
       const data = {
         totalDuration: summary.total_ms,
+        pipelineTimeoutMs: summary.pipeline_timeout_ms,
         hookBootMs,
         bracket,
         layersLoaded: summary.layers_loaded,
@@ -397,6 +436,7 @@ class SynapseEngine {
           duration: info.duration || 0,
           status: info.status || 'unknown',
           rules: info.rules || 0,
+          ...(info.errorCode ? { errorCode: info.errorCode } : {}),
         };
       }
       fs.writeFileSync(
@@ -413,4 +453,7 @@ module.exports = {
   SynapseEngine,
   PipelineMetrics,
   PIPELINE_TIMEOUT_MS,
+  MAX_PIPELINE_TIMEOUT_MS,
+  SYNAPSE_PIPELINE_TIMEOUT_ENV,
+  resolvePipelineTimeoutMs,
 };

package/.auroq-core/core/synapse/layers/layer-processor.js

@@ -34,6 +34,7 @@ class LayerProcessor {
     this.name = name;
     this.layer = layer;
     this.timeout = timeout;
+    this._lastError = null;
   }
 
   /**
@@ -65,6 +66,7 @@ class LayerProcessor {
    */
   _safeProcess(context) {
     const start = Date.now();
+    this._lastError = null;
     try {
       const result = this.process(context);
       const elapsed = Date.now() - start;
@@ -72,11 +74,18 @@ class LayerProcessor {
         console.warn(`[synapse:${this.name}] Warning: Layer exceeded timeout (${elapsed}ms > ${this.timeout}ms)`);
       }
       return result;
-    } catch (error) {
-      console.warn(`[synapse:${this.name}] Error: ${error.message}`);
+    } catch (_error) {
+      // Raw error messages/stacks can contain prompt or domain content.
+      this._lastError = new Error('SYNAPSE_LAYER_FAILED');
+      console.warn(`[synapse:${this.name}] SYNAPSE_LAYER_FAILED`);
       return null;
     }
   }
+
+  /** Return a content-free failure marker for the engine's metrics. */
+  getLastError() {
+    return this._lastError;
+  }
 }
 
 module.exports = LayerProcessor;

package/.auroq-core/core/synapse/runtime/hook-runtime.js

@@ -6,25 +6,29 @@ const fs = require('fs');
 const DEFAULT_STALE_TTL_HOURS = 168; // 7 days
 
 /**
- * Read stale session TTL from core-config.yaml.
- * Falls back to DEFAULT_STALE_TTL_HOURS (168h = 7 days).
+ * Read optional project configuration without disclosing parse failures.
  *
  * @param {string} cwd - Working directory
- * @returns {number} TTL in hours
+ * @returns {object} Configuration or an empty object
  */
-function getStaleSessionTTL(cwd) {
+function loadCoreConfig(cwd) {
   try {
-    const yaml = require('js-yaml');
     const configPath = path.join(cwd, '.auroq-core', 'core-config.yaml');
-    if (!fs.existsSync(configPath)) return DEFAULT_STALE_TTL_HOURS;
+    if (!fs.existsSync(configPath)) return {};
+    const yaml = require('js-yaml');
     const config = yaml.load(fs.readFileSync(configPath, 'utf8'));
-    const ttl = config && config.synapse && config.synapse.session && config.synapse.session.staleTTLHours;
-    return typeof ttl === 'number' && ttl > 0 ? ttl : DEFAULT_STALE_TTL_HOURS;
+    return config && typeof config === 'object' ? config : {};
   } catch (_err) {
-    return DEFAULT_STALE_TTL_HOURS;
+    // YAML errors can contain configuration values; never log their text.
+    return {};
   }
 }
 
+function getStaleSessionTTL(config) {
+  const ttl = config && config.synapse && config.synapse.session && config.synapse.session.staleTTLHours;
+  return typeof ttl === 'number' && ttl > 0 ? ttl : DEFAULT_STALE_TTL_HOURS;
+}
+
 /**
  * Resolve runtime dependencies for Synapse hook execution.
  *
@@ -46,7 +50,7 @@ function resolveHookRuntime(input) {
   if (!fs.existsSync(synapsePath)) return null;
 
   try {
-    const { loadSession, cleanStaleSessions } = require(
+    const { loadSession, createSession, cleanStaleSessions } = require(
       path.join(cwd, '.auroq-core', 'core', 'synapse', 'session', 'session-manager.js'),
     );
     const { SynapseEngine } = require(
@@ -54,13 +58,21 @@ function resolveHookRuntime(input) {
     );
 
     const sessionsDir = path.join(synapsePath, 'sessions');
-    const session = loadSession(sessionId, sessionsDir) || { prompt_count: 0 };
-    const engine = new SynapseEngine(synapsePath);
+    let session = sessionId ? loadSession(sessionId, sessionsDir) : null;
+    // loadSession validates the ID before we use it as a filename. Create only
+    // a missing session: an unreadable/corrupt existing file is kept intact.
+    if (!session && sessionId && !fs.existsSync(path.join(sessionsDir, `${sessionId}.json`))) {
+      session = createSession(sessionId, cwd, sessionsDir);
+    }
+    const shouldCleanStaleSessions = session?.prompt_count === 0;
+    session = session || { prompt_count: 0 };
+    const coreConfig = loadCoreConfig(cwd);
+    const engine = new SynapseEngine(synapsePath, { synapse: coreConfig.synapse || {} });
 
     // AC3: Run cleanup on first prompt only (fire-and-forget)
-    if (session.prompt_count === 0) {
+    if (shouldCleanStaleSessions) {
       try {
-        const ttlHours = getStaleSessionTTL(cwd);
+        const ttlHours = getStaleSessionTTL(coreConfig);
         const removed = cleanStaleSessions(sessionsDir, ttlHours);
         if (removed > 0 && process.env.DEBUG === '1') {
           console.error(`[hook-runtime] Cleaned ${removed} stale session(s) (TTL: ${ttlHours}h)`);
@@ -73,7 +85,7 @@ function resolveHookRuntime(input) {
     return { engine, session, sessionId, sessionsDir, cwd };
   } catch (error) {
     if (process.env.DEBUG === '1') {
-      console.error(`[hook-runtime] Failed to resolve runtime: ${error.message}`);
+      console.error('[hook-runtime] SYNAPSE_RUNTIME_FAILED');
     }
     return null;
   }

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

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

package/.claude/commands/AuroqOS/agents/ops.md

@@ -10,8 +10,13 @@ O Pack chega ao vivo pelo MCP. NUNCA peça zip nem instalacao do Pack.
 
 Ao ativar, mostre o selo de acesso que a tool devolver (as duas primeiras linhas) antes de qualquer outra coisa — é como o aluno vê que a licença dele foi conferida agora.
 
-Se a tool recusar (acesso vencido, cancelado, suspenso ou encerrado) ou falhar: confira se existe `agents/ops/OPS-LOCAL.md` no disco (é o Bootstrap completo que morava no computador do aluno antes da migração; o instalador guarda ele ali). Se existir, avise em UMA linha — "O servidor não liberou o conteúdo ao vivo; seguindo com o Bootstrap que já está no seu computador." — e siga por esse arquivo como fonte da verdade, mostrando a mensagem do servidor junto. Se não existir, mostre a mensagem exatamente como veio, com o contato do suporte da Arcane, e pare. Nunca improvisar de memória, nunca tentar de novo sozinho. O que já estava no computador do aluno antes da migração continua dele.
+Se a tool recusar (acesso vencido, cancelado, suspenso ou encerrado) ou falhar: confira se existe `agents/ops/OPS-LOCAL.md` no disco (é o Bootstrap completo que morava no computador do aluno antes da migração; o instalador guarda ele ali). Se existir, avise em UMA linha — "O servidor não liberou o conteúdo ao vivo; seguindo com o Bootstrap que já está no seu computador." — e siga por esse arquivo como fonte da verdade, mostrando a mensagem do servidor junto. Se não existir, mostre a mensagem exatamente como veio, com o contato do suporte da Arcane, e pare (única exceção abaixo). Nunca improvisar de memória, nunca tentar de novo sozinho. O que já estava no computador do aluno antes da migração continua dele.
 
-**Comandos antigos aposentados:** `*update-auroq`, `*update`, `*update-packarcane` e instalacao do Pack nao autorizam copiar arquivos antigos ou instalar ZIP. Para conteudo, usar o MCP. Para cuidar do motor, consultar `forja_bundle` com forge_id `ops` e fase `manutencao`. Se este negocio ainda nao tem MCP, explicar a mudanca e exigir SIM explicito antes da migracao; usar `npx -y auroq-os@latest manutencao` na raiz do negocio. O CLI preserva o que ja pertence ao aluno e pede consentimento quando falta MCP. Nunca seguir a antiga lista ATUALIZA nem extrair pacote em /tmp/auroq-update. Depois rodar `npx -y auroq-os@latest doctor`.
+**Exceção — atualizar ou consertar a conexão sem o MCP:** se a tool falhou ou recusou e o aluno pediu para atualizar o sistema ou consertar a conexão, rode você mesmo na raiz do negócio (Windows: `npx.cmd` no lugar de `npx`), sem mandar o aluno ao terminal:
+- atualizar: `npx -y auroq-os@latest manutencao --agente` (Claude Code: timeout 600000; Codex: espere a linha `AUROQ_RESULTADO`). `status=ok` → "Pronto, atualizei."; `motivo=login` → oriente o login na janela "Login Arcane" que abriu, nunca peça senha no chat, e peça que ele repita o pedido; `motivo=migracao` → peça o SIM e rode de novo com `--migrar-mcp`; outro erro → mostre a `mensagem` e sugira o Arcano;
+- consertar a conexão: `npx -y auroq-os@latest register-mcp`.
+Depois: "Feche e abra o Claude Code (ou o Codex) para terminar." Não rode `doctor` em seguida.
 
-CRITICAL: Do not treat this file as the Bootstrap. Use the MCP `arcane` tools; fall back to `agents/ops/OPS-LOCAL.md` only after the MCP refused or failed and that file exists.
+**Comandos antigos aposentados:** `*update-auroq`, `*update`, `*update-packarcane` e instalacao do Pack nao autorizam copiar arquivos antigos ou instalar ZIP. Para conteudo, usar o MCP. Para atualizar o sistema ("atualiza o sistema"), seguir `forja_bundle` com forge_id `ops` e fase `manutencao` — ou a exceção acima, se o MCP falhar. Nunca seguir a antiga lista ATUALIZA nem extrair pacote em /tmp/auroq-update.
+
+CRITICAL: Do not treat this file as the Bootstrap. Use the MCP `arcane` tools; fall back to `agents/ops/OPS-LOCAL.md` only after the MCP refused or failed and that file exists. Without the MCP, the only other local action is the update/connection exception above.

package/.claude/hooks/auroq-sync.cjs

@@ -51,6 +51,9 @@ function describeCommits(range, limit) {
 
 // ─── Aviso de versao nova (1x por dia) ───────────────────
 const VERSION_CHECK_EVERY_MS = 24 * 60 * 60 * 1000;
+// Consulta que falhou (sem internet, npm fora): tenta de novo em 1 h, nao em 24 h. Antes a
+// checagem era marcada ANTES de consultar e uma falha deixava o aluno 24 h sem aviso.
+const VERSION_RETRY_AFTER_FAIL_MS = 60 * 60 * 1000;
 
 function localVersion() {
   try {
@@ -80,11 +83,18 @@ function versionNotice() {
   const st = readState();
   const now = Date.now();
   if (st.lastVersionCheck && now - st.lastVersionCheck < VERSION_CHECK_EVERY_MS) return null;
-  st.lastVersionCheck = now; // marca ANTES da consulta — offline nao vira insistencia
-  writeState(st);
+  if (st.lastVersionFail && now - st.lastVersionFail < VERSION_RETRY_AFTER_FAIL_MS) return null;
   const latest = npmLatest();
-  if (!latest || cmpVer(latest, local) <= 0) return null;
-  return `[Auroq update] Saiu versao nova do sistema: v${local} instalada → v${latest} disponivel. Avise o expert em 1 linha e ofereca: "quer que eu atualize agora?" (o *manutencao do Ops aplica tudo e preserva os dados dele; antes de aplicar, ele mostra o que mudou).`;
+  if (!latest) {
+    st.lastVersionFail = now; // offline nao vira insistencia, mas tambem nao cala 24 h
+    writeState(st);
+    return null;
+  }
+  st.lastVersionCheck = now; // so marca as 24 h depois de o npm responder
+  st.lastVersionFail = 0;
+  writeState(st);
+  if (cmpVer(latest, local) <= 0) return null;
+  return `[Auroq update] Saiu versao nova do sistema: v${local} instalada → v${latest} disponivel. Na sua primeira resposta, avise o expert em 1 frase simples e pergunte: "Quer que eu atualize agora? Leva uns 5 minutos e voce nao precisa fazer nada." Se ele disser sim: a atualizacao e feita pelo Ops, sem o expert abrir terminal — chame a tool forja_bundle (MCP arcane) com forge_id "ops" e fase "manutencao" e siga aqueles passos a risca (e o mesmo que ele pedir ao Ops "atualiza o sistema"). Se ele disser nao, nao pergunte de novo nesta conversa.`;
 }
 
 function sessionStart() {

package/.claude/rules/mcp-usage.md

@@ -27,4 +27,4 @@ Outros agentes sao **consumidores** de MCP, nao administradores. Se precisar de
 3. Playwright nos cenarios tecnicos
 4. Ferramentas externas sem equivalente nativo
 
-Se a tool `arcane` recusar ou falhar: a pasta do agente existe em `agents/`? Sim → avisar em uma linha e seguir pelo disco. Não → mostrar a mensagem e parar. Nunca improvisar de memoria.
+Se a tool `arcane` recusar ou falhar: a pasta do agente existe em `agents/`? Sim → avisar em uma linha e seguir pelo disco. Não → mostrar a mensagem e parar. Nunca improvisar de memoria. Exceção: pedido de atualizar o sistema ou consertar a conexão — o Ops roda a manutenção local (ver o atalho do Ops).

package/AGENTS.md

@@ -7,7 +7,7 @@ Sistema operacional de IA. Runtimes oficiais desta versão: Claude Code e Codex.
 - Claude: `/companion`, `/ops`, `/consultor`, `/squad-forge`, …
 - Codex: `$companion`, `$ops`, `$consultor`, `$squad-forge`, … (skills em `.agents/skills/`)
 
-Todo conteúdo Arcane vem pelo MCP `arcane` (catálogos `auroq-core` e `arcane-pack`). Nunca procurar esse conteúdo em `agents/`. Se a tool falhar, mostre a mensagem e pare.
+Todo conteúdo Arcane vem pelo MCP `arcane` (catálogos `auroq-core` e `arcane-pack`). Nunca procurar esse conteúdo em `agents/`. Se a tool falhar, mostre a mensagem e pare (exceção: pedido de atualizar o sistema ou consertar a conexão — o `$ops` roda a manutenção local).
 
 **Execucao preparada pelo MCP:** Edicao, Carrossel, Trafego, Low Ticket e Bia recebem seus arquivos por `squad_passo` com o recurso_id do squad e passo `preparar-execucao`. O agente executa o script retornado na pasta do negocio e continua o trabalho. Anuncios funciona sem arquivos locais. Nao instalar nem atualizar Pack; nao pedir ZIP. Os arquivos locais servem apenas para executar o passo, nunca como fonte do metodo.
 

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 2.6.0 — 2026-09-21
+
+### O aluno atualiza o sistema pelo Ops, sem abrir terminal
+
+- O caminho oficial de atualizar e pedir ao Ops, no Claude Code ou no Codex: "atualiza o sistema" (ou responder "sim" quando o sistema avisa que saiu versao nova). O Ops roda `manutencao --agente` e responde "Pronto, atualizei" — dizendo se precisa fechar e abrir o aplicativo. Rodar no terminal virou so reserva.
+- `manutencao --agente` nunca faz pergunta que trave e termina sempre com uma linha que o Ops le: `AUROQ_RESULTADO status=ok versao=<x.y.z> reabrir=<sim|nao>` ou `AUROQ_RESULTADO status=erro motivo=<login|acesso|rede|pasta|migracao|falha> mensagem="..."`. Sem terminal de verdade (o Ops, CI), vale o mesmo mesmo sem `--agente`: nenhuma pergunta espera digitacao.
+- Negocio no sistema antigo (sem MCP) so migra com o SIM do aluno: o Ops pergunta no chat e repassa com `--migrar-mcp`. Sem o SIM, nada e alterado (`motivo=migracao`).
+- Login expirado sem terminal: abre uma janela "Login Arcane" pro aluno digitar e-mail e senha da plataforma e espera ate 5 minutos (Windows: `cmd` com `npx.cmd`, sem depender da politica do PowerShell; Mac: Terminal). Nao abriu ou o tempo acabou: `motivo=login` com o comando exato. Senha nunca passa pelo chat.
+- `~/.arcane/credentials.json` nao e mais apagado quando a sessao falha: e o mesmo arquivo do conteudo ao vivo, e apaga-lo derrubava o MCP do aluno. Renovacao que falha rele o arquivo (o cliente MCP pode ter girado o token ao mesmo tempo) e tenta de novo uma vez; sessao recusada pelo servidor deixa de passar em silencio. Campos que so o cliente MCP usa ficam no arquivo.
+- A manutencao nao apaga mais as permissoes do aluno: `.claude/settings.json` e mesclado — o que o sistema controla (hooks do sistema, estilo, idioma) vem da versao nova; permissoes (inclusive o modo sem pedir permissao), `statusLine`, `env`, outras chaves e hooks proprios do aluno ficam, sem hook duplicado.
+- A versao nova so e carimbada no fim, depois de tudo dar certo — e o registro do conteudo ao vivo so recebe a versao nova junto com esse carimbo: uma manutencao interrompida no meio nao finge mais que a pasta esta em dia, nem para o servidor.
+- O registro do conteudo ao vivo (`.mcp.json` e `.codex/config.toml`) passa a levar `AUROQ_OS_VERSION` (versao do motor da pasta), junto com o que ja existia no `env`. O cliente 0.7.0 manda essa versao ao servidor, que avisa quem ficou para tras. `doctor` e `register-mcp` mantem o valor em dia sem acusar pendencia. O que e do aluno no `env` fica; o que o sistema administra (proxy, certificado, variaveis do Windows) continua vindo da maquina de agora — proxy que sumiu sai do registro, e o "conserta a conexao" volta a consertar.
+- O que espera decisao do aluno deixa de virar "atualizacao falhou": pedir o SIM da migracao e pedir o login registram desfecho proprio na telemetria, e erro inesperado ao conferir o acesso sai como `motivo=falha` com a mensagem real — nunca mais manda procurar uma janela de login que nao existe.
+- `check-access` volta a responder na hora quando nao ha terminal (com o comando exato do login): a janela "Login Arcane" e so da manutencao, que a pede de proposito.
+- O pin do cliente passa a morar no campo `arcaneMcpPin` do package.json (fonte unica, lida tambem pelo servidor no npm) e vai a `arcane-mcp@0.7.0`. A publicacao continua travada ate o 0.7.0 existir no npm.
+- Aviso de versao ao abrir o Claude Code: uma consulta que falha nao cala mais o aviso por 24 h (tenta de novo em 1 h), e o texto oferece atualizar pelo Ops.
+- Na falta do conteudo ao vivo, o atalho do Ops ainda consegue atualizar o sistema ou consertar a conexao localmente e manda fechar e abrir o aplicativo.
+- Inclui tudo do 2.5.12. Instaladores do repositorio preparados para 2.6.0 (regra do 2.5.12): as copias publicas so sao promovidas depois de publicar o arcane-mcp 0.7.0 e o 2.6.0 e passar os gates nativos.
+
+## 2.5.12 — 2026-09-21
+
+- SYNAPSE persiste a sessao desde o primeiro prompt, limita o orcamento total entre camadas e distingue falhas sem expor mensagens/conteudo privado. Mantem manifest, eventos dos hosts e camadas opcionais desligadas.
+- Pacote real passa por inventario SHA-256 apos a casca, arquivos obrigatorios/proibidos e referencias locais do runtime. O empacotamento restaura o checkout, inclusive em falhas. Integridade de conteudo nao equivale a assinatura de autoria.
+- Atualiza js-yaml para 4.3.2, corrigindo avisos de consumo excessivo de CPU no parser usado pelo motor.
+- Manutencao reconhece as versoes oficiais anteriores do SYNAPSE e preserva arquivos personalizados e dados do negocio. Mantem arcane-mcp@0.6.1.
+- Instaladores preparados para esta versao; copias publicas so sao promovidas depois dos gates nativos macOS/Windows Node 22/24 e da verificacao no npm. Maquinas existentes atualizam pelo fluxo de manutencao.
+
 ## 2.5.11 — 2026-09-21
 
 ### O diagnostico passa a dizer o que achou (EMB-050)

package/README.md

@@ -29,7 +29,7 @@ irm https://arka.education/install.ps1 | iex
 Depois, **feche e abra** o Claude Code ou o Codex — senao ele nao enxerga o que
 acabou de ser instalado.
 
-O caminho manual antigo foi aposentado. Use a instalacao guiada acima. Em negocio existente, peca ao Ops "manutencao do motor". Os agentes e squads chegam pelo MCP, sem instalacao ou atualizacao de Pack.
+O caminho manual antigo foi aposentado. Use a instalacao guiada acima. Em negocio existente, peca ao Ops "atualiza o sistema" (no Claude Code ou no Codex). Os agentes e squads chegam pelo MCP, sem instalacao ou atualizacao de Pack.
 
 
 > **Grok:** nao precisa de `sync:codex`. Ele descobre `.claude/commands/`,
@@ -44,7 +44,7 @@ O caminho manual antigo foi aposentado. Use a instalacao guiada acima. Em negoci
 
 | Comando | O que faz |
 |---------|-----------|
-| `auroq-os manutencao` | Manutencao do motor no negocio existente; conteudo vem pelo MCP |
+| `auroq-os manutencao` | Manutencao do motor no negocio existente; conteudo vem pelo MCP. **Caminho normal: pedir ao Ops "atualiza o sistema"** — ele roda `manutencao --agente` (sem perguntas; ultima linha `AUROQ_RESULTADO ...`). Rodar no terminal e so reserva |
 | `auroq-os clone` | Continua o SEU negocio em outra maquina (ou na maquina de um colaborador) — baixa tudo do GitHub, ja instalado |
 | `auroq-os fix-gitignore` | Garante as protecoes de segredo no .gitignore (vault, .env, midia) e destraqueia segredos versionados |
 | `auroq-os login` | Forca novo login (substitui credencial atual) |
@@ -98,23 +98,31 @@ e o servidor, e diz exatamente o que fazer.
 
 ## Atualizar o sistema
 
-De tempos em tempos sai versao nova do **motor** (novos comandos, correcoes do instalador).
-Voce nao precisa vigiar nada: ao abrir o Claude Code no seu projeto, o sistema avisa
-sozinho quando existe versao nova (confere no maximo 1x por dia).
+De tempos em tempos sai versao nova do **motor** ou da **conexao** (novos comandos,
+correcoes). Voce nao precisa vigiar nada: quando existe versao nova, o proprio sistema
+avisa — ao usar um squad ou agente do conteudo ao vivo e ao abrir o Claude Code no seu
+projeto — e pergunta se voce quer atualizar.
 
-Pra atualizar, e uma frase — dentro do Claude Code, com o Ops ativo (`/AuroqOS:agents:ops`):
+Pra atualizar, e uma frase — dentro do Claude Code ou do Codex, com o Ops ativo
+(`/AuroqOS:agents:ops` ou `$ops`), ou respondendo "sim" ao aviso:
 
 ```
 atualiza o sistema
 ```
 
-O Ops confere seu acesso, mostra o que mudou, salva um ponto de restauracao (commit),
-aplica a versao nova e roda o diagnostico no final. **Seus dados nunca sao tocados**:
-memoria do Companion, documentos, cockpit, campanhas, squads que voce criou e
-personalizacoes ficam exatamente como estavam. O que se atualiza e so o framework.
+Voce nao abre terminal nem digita comando: o Ops salva um ponto de restauracao (commit)
+se houver trabalho seu pendente, roda a manutencao e diz se precisa fechar e abrir o
+aplicativo. Se o login da plataforma tiver expirado, abre uma janela "Login Arcane" pra
+voce digitar o e-mail e a senha (nunca no chat). **Seus dados nunca sao tocados**:
+memoria do Companion, documentos, cockpit, campanhas, squads que voce criou,
+personalizacoes e as suas permissoes do Claude Code ficam exatamente como estavam.
+O que se atualiza e so o framework.
+
+Reserva, so se o Ops nao abrir: na pasta do negocio, `npx -y auroq-os@latest manutencao`
+(Windows: `npx.cmd`).
 
 O historico do que mudou em cada versao fica no arquivo `CHANGELOG.md`, dentro do
-proprio pacote — o Ops resume pra voce antes de aplicar.
+proprio pacote.
 
 ## Historico de uso (AHI)
 
@@ -174,8 +182,8 @@ Direitos de consulta/exclusao continuam disponiveis com autenticacao mesmo sem
 licenca de captura. Para apagar o historico da conta inteira, o escopo explicito
 exigido e `excluir --account --confirm-delete`.
 
-A atualizacao do coletor exige `npx auroq-os@latest manutencao` no projeto e reabrir
-o host. O aviso de nova versao ao iniciar o Claude Code nao instala essa correcao.
+A atualizacao do coletor exige a manutencao no projeto (peca ao Ops "atualiza o sistema")
+e reabrir o host. O aviso de nova versao ao iniciar o Claude Code nao instala essa correcao.
 A publicacao do pacote tambem nao comprova que cada aluno ja atualizou.
 
 ## Estrutura
@@ -228,14 +236,17 @@ agents/             → Seu exercito (companion, workers, minds, squads)
 *Auroq OS — by Euriler Jube / Arka*
 
 
-## Observabilidade do motor (candidato 2.5.2)
+## Observabilidade e integridade do motor
 
-Apos publicacao, `npx -y auroq-os@2.5.11 doctor` mostra a fila local segura e os comandos pinados de
-manutencao/diagnostico. `npx -y auroq-os@2.5.11 manutencao` preserva o caminho existente
+Apos publicacao, `npx -y auroq-os@2.6.0 doctor` mostra a fila local segura e os comandos pinados de
+manutencao/diagnostico. `npx -y auroq-os@2.6.0 manutencao` preserva o caminho existente
 de consentimento legado, studentFiles, customizacoes e dados do negocio. Nao ha
-migracao forcada. O registro MCP aponta para `arcane-mcp@0.6.1`, publicado no npm em
-21/09/2026; `npm run release:verify` recusa publicar com um pin que o npm nao resolva.
-Os instaladores oficiais seguem em 2.5.10; promover pra 2.5.11 e ato explicito, depois da publicacao e da verificacao do tarball.
+migracao forcada. O registro MCP aponta para `arcane-mcp@0.7.0` — o pin mora no campo
+`arcaneMcpPin` do package.json (fonte unica; o servidor le o mesmo campo no npm). O 0.7.0
+ainda precisa ser publicado: `npm run release:verify` recusa publicar com um pin que o npm
+nao resolva. Os instaladores do repositorio ficam preparados para 2.6.0; as copias publicas so recebem
+a versao apos os gates nativos e a verificacao do tarball publicado.
+O pacote inclui `lib/runtime-integrity.json`: inventario SHA-256 gerado depois da montagem da casca, verificavel com `npm run integrity:verify` dentro do pacote extraido. Ele comprova consistencia do conteudo; nao e uma assinatura de autoria.
 
 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
@@ -254,8 +265,7 @@ instalacao/manutencao/doctor/login/register-mcp. Bootstrap conversacional e o tr
 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.
+a whitelist antes de distribuir/promover os clientes; a promocao dos instaladores sincronizados depende da publicacao e verificacao da versao fixada. 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