auroq-os 2.6.9 → 2.7.0

package/.auroq-core/como-funciona.md

@@ -0,0 +1,162 @@
+# Como o Auroq OS funciona por dentro
+
+> Arquivo de consulta. Não carrega em toda conversa: leia quando o aluno perguntar "como funciona",
+> quando for explicar o sistema ou quando a tarefa precisar desse mapa. As regras de trabalho estão
+> no `AGENTS.md` da raiz da pasta e em `.claude/rules/`; em conflito, elas valem sobre este texto.
+> Este arquivo é do sistema: a atualização troca.
+
+## A ideia
+
+O Auroq OS transforma o Claude Code (ou o Codex) num centro de comando do negócio do aluno.
+
+- **Pensar com IA:** decisões, planos e estratégia, com a IA como parceira.
+- **Fazer com IA:** o aluno pede, a equipe de IA executa, o aluno confere e aprova.
+- **Lembrar com IA:** o que foi decidido e aprendido fica salvo na pasta e cresce com o uso.
+
+Fórmula: repertório + IA = resultado. O aluno domina o **o quê** (o que fazer e se ficou bom);
+a IA domina o **como**.
+
+## Quem é quem na equipe
+
+| Tipo | O que é | Exemplo |
+|------|---------|---------|
+| **Companion** | Chefe da equipe e parceiro do aluno. Situa, lembra, pensa junto e chama quem faz | `/auroq-companion` |
+| **Mentes** | Pensam e julgam: consultam, mentoram, avaliam | Clone, mente sintética, consultor |
+| **Workers** | Executam uma função (um cargo) | um worker de atendimento |
+| **Squads** | Vários agentes com etapas e conferência de qualidade | Squad de conteúdo, de anúncios |
+| **Ops** | O técnico: instala, atualiza, conserta, conecta | `/AuroqOS:agents:ops` |
+| **Forjas** | Criam agentes novos para o negócio do aluno | Squad Forge, Mind Forge, Worker Forge, Clone Forge, ETLmaker |
+
+Subtipos de mente: **Clone** (replica uma pessoa real), **Mente sintética** (junta vários
+especialistas num agente só) e **Consultor** (empacota o conhecimento de um assunto).
+
+Cada agente pode servir de **mentor** ("o que eu faço?"), **juiz** ("tá bom?") ou **executor** ("faz").
+Num squad os papéis ficam separados: quem coordena não executa, quem executa não aprova o próprio
+trabalho, quem julga não cria.
+
+**Como isso aparece para o aluno:** ele só fala com o Companion. O Companion escolhe e aciona o
+squad, a skill ou o agente certo sozinho, confere e entrega. O aluno não precisa saber o nome de ninguém.
+
+## Onde mora cada coisa
+
+```
+pasta-do-negocio/
+├── AGENTS.md               # regras de base (Claude, Codex, Grok) — do sistema
+├── .claude/
+│   ├── CLAUDE.md           # porta de entrada do Claude Code (importa o AGENTS.md)
+│   ├── rules/              # regras do sistema + custom-do-aluno.md (do aluno)
+│   ├── commands/           # atalhos dos agentes (/auroq-companion, /AuroqOS:agents:ops...)
+│   ├── output-styles/      # estilo de resposta Direto
+│   └── hooks/              # automações (Synapse, sincronização, histórico)
+├── .auroq-core/            # núcleo do sistema (constitution, configuração) — não mexer
+├── .synapse/               # lembretes curtos que o sistema injeta em cada conversa
+├── agents/companion/data/  # memória: onde paramos, decisões, padrões, pendências
+├── business/               # o negócio: cockpit, campanhas, processos, vault (fora do git)
+└── docs/knowledge/         # conhecimento do aluno
+    ├── expert-mind/        # quem o aluno é: propósito, identidade, valores, tom de voz, história
+    └── expert-business/    # o que ele faz: posicionamento, público, método, produtos
+```
+
+Os nomes `expert-mind/` e `expert-business/` ficaram assim por compatibilidade; o conteúdo é do aluno.
+A equipe da Arcane (Companion interno, Consultor, forjas, Pack) não fica no disco: chega ao vivo pelo
+MCP `arcane`.
+
+## Constitution (resumo)
+
+Texto completo em `.auroq-core/constitution.md`.
+
+| Artigo | Princípio |
+|--------|-----------|
+| I | O terminal é o centro de comando: o negócio passa pela pasta, ferramentas externas são braços |
+| II | Cada um faz o seu: o técnico (push forçado, MCP, infraestrutura, atualização) é do Ops |
+| III | Documentar é investir: o que não está escrito se perde |
+| IV | Não inventar: fato, número e prova precisam de fonte |
+| V | Qualidade com julgamento: o aluno aprova as entregas importantes |
+| VI | Evolução incremental: reusar antes de adaptar, adaptar antes de criar |
+
+## Jeito de trabalhar de todo agente
+
+- **Plano antes de execução** em trabalho grande: o plano é a coleira.
+- **Documento de trabalho atualizado** a cada etapa: sobrevive à compactação da conversa e serve
+  de passagem de bastão para qualquer agente.
+- **Sem viagem:** faz o pedido, não inventa melhoria; mudança de rumo só com o aluno.
+- **Sem bagunça:** tarefas com entrada e saída claras, documentos valem mais que conversa,
+  conferência antes de aceitar a entrega.
+
+Premissas: faça primeiro e documente depois; ninguém cuida do negócio como o dono; resolva a dor de
+agora; a certeza vem do uso; nada volta para o zero.
+
+## Ciclos
+
+**Dia a dia:** situar ("onde estou?") → priorizar ("o que dói mais?") → executar → documentar →
+refinar (melhorar agentes e processos). Cada volta deixa o sistema mais forte.
+
+**Conversa:** o Companion carrega onde paramos, mostra o que importa, o aluno escolhe o foco, a
+equipe trabalha, no fim de cada tarefa a memória é salva e, quando o aluno pede, o trabalho é salvo
+e entregue no GitHub.
+
+**Semana:** sem revisão há 7 dias ou mais, o Companion propõe uma revisão de 20 minutos (cockpit,
+trackers, pendências, padrões).
+
+**Projeto:** nasce no cockpit com tracker e fases → os agentes trabalham e atualizam o tracker →
+termina com uma retrospectiva de 3 perguntas e vai para o arquivo, abrindo vaga para o próximo.
+
+## Níveis de uso de IA
+
+| Nível | Como é |
+|-------|--------|
+| N0 | Sem IA, na força bruta |
+| N1 | IA crua: cada conversa começa do zero |
+| N2 | IA com repertório: skills, mentes e contexto que fica |
+| N3 | Sistema operacional de IA: equipe coordenada, memória e Companion |
+
+O Auroq OS leva o aluno ao N3.
+
+## Conhecimento, skills e agentes
+
+- **Base de conhecimento:** conhecimento bruto tratado (extraído, limpo, organizado). É o ingrediente.
+- **Skill:** IA + base de conhecimento + persona + regras. É o prato.
+- Caminho: conhecimento bruto → tratamento (o ETLmaker faz) → base pronta → skill → agente.
+  Conhecimento primeiro, execução depois.
+
+Três camadas de contexto que a equipe usa:
+
+| Pergunta | De onde vem |
+|----------|-------------|
+| Para quem trabalho? | `docs/knowledge/expert-mind/` |
+| O que sei fazer? | `docs/knowledge/expert-business/` e o conhecimento que o aluno tratou |
+| O que está rolando agora? | `business/campanhas/` e o cockpit |
+
+Tipos de skill: de **identidade** (do aluno, únicas), **técnicas** (copy, tráfego, lançamento) e de
+**projeto** (de uma campanha, temporárias).
+
+## Memória
+
+| Camada | Onde | Dura |
+|--------|------|------|
+| Conversa | o chat | até a compactação |
+| Operacional | `agents/companion/data/` | entre conversas |
+| Permanente | `docs/knowledge/` e `business/` | para sempre |
+
+Quando salvar: decisão tomada, projeto avançou, conhecimento criado, padrão percebido, tarefa
+concluída e conversa encerrando. Regra completa: `.claude/rules/memoria-inteligente.md`.
+
+## Projetos
+
+- Ideias soltas viram pendência; o que vai ser feito entra no **cockpit** (`business/cockpit.md`),
+  com no máximo 3 projetos ativos, cada um com a próxima ação definida.
+- Receitas que se repetem viram **processos** em `business/processos/`.
+- Cada projeto tem um **tracker** (`business/campanhas/{projeto}/tracker.md`): todo agente lê antes de
+  trabalhar e atualiza depois (`.claude/rules/project-tracker.md`).
+
+## Salvar é o botão do negócio
+
+Commit aqui não é coisa de programador: é o ponto de restauração do negócio. A mensagem conta o que
+aconteceu (`progresso:`, `decisao:`, `processo:`, `agente:`, `conhecimento:`, `campanha:`, `fix:`,
+`setup:`), não o que mudou nos arquivos. Entregar (push) manda a cópia para o GitHub privado do aluno.
+Ritual em `.claude/rules/puxar-e-entregar.md`.
+
+## Volante
+
+Conhecimento cresce → agentes melhoram → o negócio do aluno anda → o aluno aprende mais → o
+conhecimento cresce de novo. Cada uso acelera o próximo.

package/.auroq-core/core/synapse/output/formatter.js

@@ -23,6 +23,18 @@ const { estimateTokens } = require('../utils/tokens');
  * Truncation removes from the END of this array first (SUMMARY, then
  * KEYWORD, then SQUAD, etc.) to preserve highest-priority sections.
  */
+/**
+ * Regras que mais escapam em conversa longa (2.7.0). O resto já está no AGENTS.md e nas rules;
+ * aqui fica só o que costuma sumir depois de muitas mensagens.
+ */
+const LEMBRETE_CONVERSA_LONGA = [
+  '[LEMBRETE: CONVERSA LONGA]',
+  '  1. Resposta que fez trabalho fecha com **Resumo:** e **Onde parou:**.',
+  '  2. Travas do AGENTS.md (dinheiro, mensagem ou post para outra pessoa, apagar, force push, senha): só com ordem do aluno para aquela ação.',
+  '  3. Tarefa concluída: salve onde parou e as decisões na memória (rule memoria-inteligente) antes de seguir.',
+  '  4. Companion aciona sozinho squads, skills e agentes, revisa e entrega; não manda o aluno chamar ninguém.',
+].join('\n');
+
 const SECTION_ORDER = [
   'CONTEXT_BRACKET',
   'CONSTITUTION',
@@ -400,7 +412,7 @@ function enforceTokenBudget(sections, sectionIds, tokenBudget) {
   }
 
   // Sections that should never be removed
-  const PROTECTED = new Set(['CONTEXT_BRACKET', 'CONSTITUTION', 'AGENT']);
+  const PROTECTED = new Set(['CONTEXT_BRACKET', 'CONSTITUTION', 'AGENT', 'CONVERSA_LONGA']);
 
   // Truncation priority: remove from end first
   const TRUNCATION_ORDER = [
@@ -531,9 +543,16 @@ function formatSynapseRules(results, bracket, contextPercent, session, devmode,
     }
   }
 
+  // Conversa longa (2.7.0): do MODERATE em diante, as regras que mais escapam quando a conversa
+  // enche voltam a cada mensagem. Acréscimo: nada do que já era injetado sai.
+  if (bracket && bracket !== 'FRESH') {
+    sections.push(LEMBRETE_CONVERSA_LONGA);
+    sectionIds.push('CONVERSA_LONGA');
+  }
+
   // Handoff warning (CRITICAL bracket)
   if (showHandoffWarning) {
-    sections.push('[HANDOFF WARNING]\n  Context is nearly exhausted. Consider starting a new session to preserve quality.');
+    sections.push('[HANDOFF WARNING]\n  A conversa está quase cheia. Termine o passo atual, salve a memória e sugira ao aluno abrir uma conversa nova (ou /compact).');
     sectionIds.push('HANDOFF_WARNING');
   }
 
@@ -563,4 +582,5 @@ module.exports = {
   estimateTokens,
   SECTION_ORDER,
   LAYER_TO_SECTION,
+  LEMBRETE_CONVERSA_LONGA,
 };

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

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

package/.claude/CLAUDE.md

@@ -1,9 +1,17 @@
 # Auroq OS
 
-Sistema operacional de IA para o negócio. Você manda e julga; a IA executa.
+Sistema operacional de IA para o negócio do aluno. Ele pede, confere e aprova; a IA executa.
 
-Ative um agente pelo comando (`/companion`, `$companion`, `@companion`). Todo conteúdo Arcane (Companion interno, Consultor, forjas, Pack) vem pelo MCP `arcane` — nunca procurar em `agents/`.
+As regras de base de toda conversa estão no `AGENTS.md` da raiz da pasta, o mesmo arquivo que o Codex
+e o Grok leem. Ele entra aqui pela linha abaixo:
 
-Sua memória e seus documentos ficam na sua máquina e no seu GitHub privado (senhas e `business/vault/` ficam fora). O histórico das sessões com os squads está previsto nos Termos de Uso: vem ligado para quem aceita os termos na plataforma (quem já tinha dito "não" continua sem gravar) e você desliga quando quiser em Minha Conta, "Guardar minhas conversas". Se a pasta do seu negócio tem dados de clientes, desligue. Além disso, a Arka registra qual conteúdo licenciado foi entregue, quando e pra qual conta — igual a uma nota de entrega.
+@../AGENTS.md
 
-Rules em `.claude/rules/`. Constitution em `.auroq-core/constitution.md`.
+## Só no Claude Code
+
+- As regras de `.claude/rules/` carregam sozinhas. `.claude/rules/custom-do-aluno.md` vale acima de todas.
+- O estilo de resposta é o Direto (`.claude/output-styles/direto.md`).
+- Agentes pelo comando: `/auroq-companion` (ou o nome que o aluno deu ao Companion, como
+  `/atlas-companion`), `/AuroqOS:agents:ops`, `/auroq-consultor` e as forjas `/auroq-squad-forge`,
+  `/auroq-mind-forge`, `/auroq-worker-forge`, `/auroq-clone-forge`, `/auroq-etlmaker`. O aluno não
+  precisa usar nenhum: falar o que quer basta.

package/.claude/commands/auroq-companion.md

@@ -1,6 +1,6 @@
 # companion
 
-Parceiro cognitivo pessoal. Situa, lembra, pensa junto, roteia.
+Parceiro cognitivo pessoal. Situa, lembra, pensa junto e aciona a equipe sozinho.
 
 Todo conteúdo deste agente vem pelo MCP `arcane` (catálogo `auroq-core`). Chame a tool `squad_ativar` com recurso_id `companion`. Enquanto o servidor responder, nunca procurar arquivo local deste agente.
 

package/.claude/hooks/precompact-session-digest.cjs

@@ -1,46 +1,182 @@
 #!/usr/bin/env node
 /**
- * Claude Code Hook: PreCompact Session Digest
+ * Gancho da compactação do Claude Code (2.7.0).
  *
- * This hook is registered with Claude Code to trigger before context compact.
- * It delegates to the unified hook runner in auroq-core.
+ * Quando a conversa enche, o Claude Code resume e "compacta" o histórico. O resumo perde detalhe e a
+ * IA costuma esquecer o que estava fazendo e as regras de fechamento. Este gancho roda em dois momentos:
  *
- * Installation:
- * - Claude Code automatically discovers hooks in .claude/hooks/
- * - Hook naming: {event}-{name}.js (e.g., precompact-session-digest.js)
+ * - PreCompact: lê o fim da conversa (arquivo `transcript_path` que o Claude Code entrega) e grava em
+ *   `.auroq/compactacao/ultima.md` os últimos pedidos do aluno, os arquivos mexidos e a última resposta.
+ *   Fica só no computador do aluno (`.auroq/` não vai para o GitHub) e passa pelo mesmo filtro de
+ *   senhas e chaves do registro de conversas.
+ * - SessionStart com origem "compact" (logo depois do resumo): devolve à IA um lembrete curto com esse
+ *   retrato e as regras que mais escapam em conversa longa.
  *
- * @see .auroq-core/hooks/unified/runners/precompact-runner.js
- * @see Story MIS-3 - Session Digest (PreCompact Hook)
+ * Nunca bloqueia a compactação nem a conversa: qualquer falha sai em silêncio com código 0.
+ * Até a 2.6.10 este arquivo carregava um executor de `.auroq-core/hooks/unified/` que não
+ * existe no pacote, e só exportava uma função que ninguém chamava: não salvava nada.
  */
 
 'use strict';
 
-const path = require('path');
+const fs = require('node:fs');
+const path = require('node:path');
 
-// Resolve path to the unified hook runner
-const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
-const runnerPath = path.join(
-  PROJECT_ROOT,
-  '.auroq-core',
-  'hooks',
-  'unified',
-  'runners',
-  'precompact-runner.js',
-);
+const RAIZ = path.resolve(__dirname, '..', '..');
+const PASTA = path.join(RAIZ, '.auroq', 'compactacao');
+const ARQUIVO = path.join(PASTA, 'ultima.md');
+const LER_DO_FIM = 4 * 1024 * 1024; // conversa grande: só o fim interessa
+const VALE_POR_MS = 2 * 60 * 60 * 1000; // retrato com mais de 2 h não volta para a conversa
+const MAX_PEDIDOS = 6;
+const MAX_ARQUIVOS = 15;
 
-// Load and execute the hook runner
+let limpar = s => String(s);
 try {
-  const { onPreCompact } = require(runnerPath);
+  const { scrub } = require('./ahi/security.cjs');
+  limpar = s => String(scrub(String(s)).value);
+} catch { /* sem o filtro do registro de conversas: o texto passa pelo corte abaixo */ }
 
-  // Export the hook handler for Claude Code
-  module.exports = async (context) => {
-    return await onPreCompact(context);
+function cortar(texto, max) {
+  const t = String(texto || '').replace(/\s+/g, ' ').trim();
+  return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+
+function lerEntrada() {
+  try {
+    const bruto = fs.readFileSync(0, 'utf8');
+    const dados = JSON.parse(bruto.replace(/^/, ''));
+    return dados && typeof dados === 'object' ? dados : {};
+  } catch { return {}; }
+}
+
+function fimDoArquivo(arquivo) {
+  const fd = fs.openSync(arquivo, 'r');
+  try {
+    const { size } = fs.fstatSync(fd);
+    const inicio = Math.max(0, size - LER_DO_FIM);
+    const buf = Buffer.alloc(size - inicio);
+    fs.readSync(fd, buf, 0, buf.length, inicio);
+    const linhas = buf.toString('utf8').split('\n');
+    if (inicio > 0) linhas.shift(); // primeira linha pode ter vindo cortada
+    return linhas;
+  } finally { fs.closeSync(fd); }
+}
+
+const textoDe = conteudo => (typeof conteudo === 'string'
+  ? conteudo
+  : (Array.isArray(conteudo) ? conteudo.filter(p => p && p.type === 'text').map(p => p.text || '').join('\n') : ''));
+
+// /tmp e /private/tmp (Mac), atalhos e letras de unidade: compara o caminho de verdade dos dois lados.
+// Arquivo que já não existe: resolve a pasta mais próxima que existe e junta o resto.
+function real(p) {
+  let base = path.resolve(p);
+  const resto = [];
+  for (;;) {
+    try { return path.join(fs.realpathSync.native(base), ...resto); } catch { /* sobe uma pasta */ }
+    const acima = path.dirname(base);
+    if (acima === base) return path.resolve(p);
+    resto.unshift(path.basename(base));
+    base = acima;
+  }
+}
+
+function relativo(arquivo) {
+  const abs = real(path.resolve(RAIZ, String(arquivo)));
+  const rel = path.relative(real(RAIZ), abs);
+  return (rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel : abs).split(path.sep).join('/');
+}
+
+function retrato(transcript) {
+  const pedidos = [];
+  const arquivos = [];
+  let ultimaResposta = '';
+  for (const linha of fimDoArquivo(transcript)) {
+    if (!linha.trim()) continue;
+    let ev;
+    try { ev = JSON.parse(linha); } catch { continue; }
+    const msg = ev && ev.message;
+    if (!msg || ev.isMeta || ev.isSidechain) continue;
+    if (ev.type === 'user' && msg.role === 'user') {
+      const texto = textoDe(msg.content).trim();
+      // Resultado de ferramenta, lembrete do sistema e comando com marcação não são pedido do aluno.
+      if (texto && !texto.startsWith('<')) pedidos.push(texto);
+    } else if (ev.type === 'assistant' && Array.isArray(msg.content)) {
+      for (const parte of msg.content) {
+        if (parte && parte.type === 'text' && String(parte.text || '').trim()) ultimaResposta = parte.text;
+        const alvo = parte && parte.type === 'tool_use' && parte.input && (parte.input.file_path || parte.input.notebook_path);
+        if (alvo && /^(Edit|MultiEdit|Write|NotebookEdit)$/.test(String(parte.name))) {
+          const rel = relativo(alvo);
+          const i = arquivos.indexOf(rel);
+          if (i >= 0) arquivos.splice(i, 1);
+          arquivos.push(rel);
+        }
+      }
+    }
+  }
+  return {
+    pedidos: pedidos.slice(-MAX_PEDIDOS).map(p => cortar(limpar(p), 400)),
+    arquivos: arquivos.slice(-MAX_ARQUIVOS).map(a => cortar(a, 200)), // caminho não passa no filtro: ele apaga nome longo
+    ultimaResposta: cortar(limpar(ultimaResposta), 700),
   };
-} catch (error) {
-  console.error('[PreCompact Hook] Failed to load hook runner:', error.message);
+}
+
+function antesDeCompactar(entrada) {
+  const transcript = entrada.transcript_path;
+  if (!transcript || !fs.existsSync(transcript)) return;
+  const r = retrato(transcript);
+  const quando = new Date().toISOString();
+  const md = [
+    '# Antes da última compactação',
+    '',
+    `- Quando: ${quando}`,
+    `- Conversa: ${cortar(entrada.session_id || '?', 80)} (${entrada.trigger === 'manual' ? 'compactação pedida' : 'compactação automática'})`,
+    '',
+    '## Últimos pedidos do aluno (do mais antigo ao mais novo)',
+    '',
+    ...(r.pedidos.length ? r.pedidos.map(p => `- ${p}`) : ['- (nenhum pedido em texto no fim da conversa)']),
+    '',
+    '## Arquivos mexidos',
+    '',
+    ...(r.arquivos.length ? r.arquivos.map(a => `- \`${a}\``) : ['- (nenhum)']),
+    '',
+    '## Última resposta da IA',
+    '',
+    r.ultimaResposta || '(sem texto)',
+    '',
+  ].join('\n');
+  fs.mkdirSync(PASTA, { recursive: true });
+  const tmp = `${ARQUIVO}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, md, { mode: 0o600 });
+  fs.renameSync(tmp, ARQUIVO);
+}
 
-  // Graceful degradation - export no-op function
-  module.exports = async () => {
-    console.log('[PreCompact Hook] Hook runner not available, skipping');
+function depoisDeCompactar() {
+  let st;
+  try { st = fs.statSync(ARQUIVO); } catch { return; }
+  if (Date.now() - st.mtimeMs > VALE_POR_MS) return;
+  const md = fs.readFileSync(ARQUIVO, 'utf8');
+  const secao = nome => {
+    const m = md.split(`## ${nome}`)[1];
+    return m ? m.split('\n## ')[0].trim() : '';
   };
+  const ultimoPedido = (secao('Últimos pedidos do aluno (do mais antigo ao mais novo)').split('\n').filter(l => l.startsWith('- ')).pop() || '').slice(2);
+  const arquivos = secao('Arquivos mexidos').split('\n').filter(l => l.startsWith('- `')).map(l => l.slice(2)).slice(-8);
+  const contexto = [
+    'A conversa acabou de ser compactada. O retrato de antes do resumo está em `.auroq/compactacao/ultima.md` (leia se precisar do detalhe).',
+    ultimoPedido ? `Último pedido do aluno: ${ultimoPedido}` : '',
+    arquivos.length ? `Arquivos mexidos: ${arquivos.join(', ')}` : '',
+    'Antes de seguir: se uma tarefa já terminou e a memória não foi salva (`agents/companion/data/contexto-dinamico.md` e `log-decisoes.md`), salve agora.',
+    'Continua valendo: fechar a resposta que fez trabalho com **Resumo:** e **Onde parou:**; as travas do AGENTS.md (dinheiro, mensagem ou post para outra pessoa, apagar, force push, senha) só com ordem do aluno para aquela ação.',
+  ].filter(Boolean).join('\n');
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: contexto } }));
+}
+
+function principal() {
+  const entrada = lerEntrada();
+  const evento = String(entrada.hook_event_name || '');
+  if (evento === 'PreCompact') antesDeCompactar(entrada);
+  else if (evento === 'SessionStart' && entrada.source === 'compact') depoisDeCompactar();
 }
+
+try { principal(); } catch { /* nunca atrapalha a conversa */ }
+process.exitCode = 0;

package/.claude/output-styles/direto.md

@@ -8,12 +8,17 @@ keep-coding-instructions: true
 
 Comece pelo resultado. Pergunta simples recebe resposta simples; entrega ou
 analise costuma caber em um paragrafo de 3 a 5 frases com: o que aconteceu, o
-contexto minimo, o que muda para o expert e a decisao necessaria.
+contexto minimo, o que muda para o aluno e a decisao necessaria.
 
-- Use **Na sua mao:** somente quando houver uma decisao ou acao real do expert.
+- Use **Na sua mao:** somente quando houver uma decisao ou acao real do aluno.
 - Use **Risco:** somente para risco material que muda a decisao.
+- Decisao so quando nenhuma ferramenta resolve, assim: **Decide: A ou B?** A → o que acontece. B → o que acontece.
 - Preserve ressalva importante, teste que falhou, erro corrigido e atalho tomado.
 - Explique primeiro o efeito em linguagem comum; detalhe tecnico so quando ajuda a decidir.
 - Sem preambulo, repeticao, validacao vazia, emoji ou tabela quando uma frase resolve.
-- Nao termine oferecendo aprofundamento. Se o expert pedir "aprofunda X", entregue apenas o detalhe daquele ponto.
+- Nao termine oferecendo aprofundamento. Se o aluno pedir "aprofunda X", entregue apenas o detalhe daquele ponto.
 - O tamanho acompanha o pedido. Concisao corta enfeite, nunca fato que muda a decisao.
+- Resposta que fez trabalho termina com duas linhas curtas, em linguagem simples: **Resumo:** do
+  que se trata a conversa e o que ja ficou feito; **Onde parou:** o que ja funciona, o que segue
+  rodando e o que espera pelo aluno (ou "fechado, nada pendente"). Pergunta simples respondida em
+  uma frase dispensa.

package/.claude/rules/agent-authority.md

@@ -6,30 +6,30 @@
 environment bootstrap · `*update`. Nenhum outro agente executa isso — delegar pro Ops.
 
 **Salvar, entregar e puxar NAO sao exclusivos.** O Ops e o dono do ritual, mas qualquer
-agente ativo o executa quando o expert pede, sem troca de agente (`rules/puxar-e-entregar.md`).
+agente ativo o executa quando o aluno pede, sem troca de agente (`rules/puxar-e-entregar.md`).
 
 ## Quem faz o que
 
 | Agente | Escopo proprio |
 |--------|----------------|
 | **Companion** | Situacao diaria, memoria (contexto, decisoes, padroes), projetos e trackers, weekly review, roteamento, criacao de projetos |
-| **Organizer** | Diagnostico de organizacao, mover/renomear pra organizar, limpeza de duplicados e temporarios, backup espelhado, nomenclatura (mudanca em disco sempre com aprovacao do expert) |
+| **Organizer** | Diagnostico de organizacao, mover/renomear pra organizar, limpeza de duplicados e temporarios, backup espelhado, nomenclatura (mudanca em disco sempre com aprovacao do aluno) |
 | **Workers** | Executar tasks operacionais e atualizar documentos de trabalho |
 | **Squads** | Rodar pipeline completo com quality gates, produzir outputs, atualizar KBs e skills |
 
 Workers e squads nao criam agentes (isso e dos Meta Squads) nem tomam decisao
-estrategica (isso e do expert).
+estrategica (isso e do aluno).
 
 ## Meta Squads — criacao de agentes
 
 `/squad-forge` squads multi-agente · `/mind-forge` mentes sinteticas e consultores ·
 `/worker-forge` workers · `/clone-forge` clones de mentes reais · `/etlmaker` KBs.
 
-Fluxo: expert pede → Meta Squad adequado cria → expert valida.
+Fluxo: aluno pede → Meta Squad adequado cria → aluno valida.
 
 ## Escalation
 
-1. Agente nao consegue completar a task → informar o expert com contexto
+1. Agente nao consegue completar a task → informar o aluno com contexto
 2. Quality gate falha → volta pro executor com feedback especifico
 3. Violacao constitucional → BLOCK, corrigir antes de prosseguir
 4. Conflito de fronteira → Constitution Art. II resolve (cada um faz o seu)

package/.claude/rules/dna-operacional.md

@@ -22,7 +22,7 @@ SEMPRE que for executar:
 
 1. Verificar se existe plano/briefing aprovado para o trabalho
 2. Executar DENTRO do escopo planejado
-3. Se perceber necessidade de mudar escopo: **PARAR e perguntar ao expert**
+3. Se perceber necessidade de mudar escopo: **PARAR e perguntar ao aluno**
 4. Nao adicionar features, melhorias ou conteudo nao solicitado
 5. Nao gerar dados, numeros ou fatos sem fonte verificada
 

package/.claude/rules/memoria-inteligente.md

@@ -2,12 +2,23 @@
 
 > Todo agente no Auroq OS segue este protocolo de memoria. Nao e opcional.
 
-## 5 Triggers — Quando Salvar
+## Regra principal: fim de tarefa, memoria salva
+
+No fim de CADA tarefa concluida, o agente ativo (Companion ou qualquer outro) salva sem esperar
+pedido, antes da resposta final:
+→ `agents/companion/data/contexto-dinamico.md`: onde paramos (o que ficou pronto, o que segue, o que espera o aluno)
+→ `agents/companion/data/log-decisoes.md`: as decisoes tomadas na tarefa (formato abaixo)
+→ tracker do projeto, se a tarefa e de um projeto do cockpit
+→ Avisar em uma linha o que anotou ("Anotei: ..."). Se o aluno pedir para nao guardar algo, nao guarde.
+
+Os gatilhos abaixo completam essa regra no meio do trabalho.
+
+## 7 Gatilhos — Quando Salvar
 
 ### 1. Decisao Tomada
-SE o expert decidiu algo significativo (estrategia, preco, foco, prioridade, cancelamento):
-→ Perguntar: "Registro essa decisao no log?"
-→ SE sim: salvar em `agents/companion/data/log-decisoes.md` no formato:
+SE o aluno decidiu algo significativo (estrategia, preco, foco, prioridade, cancelamento):
+→ Registrar em `agents/companion/data/log-decisoes.md` (no maximo no fim da tarefa) e avisar em uma linha
+→ Formato:
 ```
 ## [DATA] — [TITULO]
 **Contexto:** [situacao]
@@ -23,7 +34,7 @@ SE completou tarefa de projeto ou avancou fase:
 
 ### 3. Conhecimento Criado
 SE produziu documento, framework, analise, ou processo novo que tem valor permanente:
-→ Perguntar: "Salvo na biblioteca? Onde faz mais sentido?"
+→ Perguntar: "Guardo no seu conhecimento? Onde faz mais sentido?"
 → Salvar em `docs/knowledge/` (subpasta adequada) ou `business/processos/`
 
 ### 4. Padrao Detectado
@@ -31,10 +42,20 @@ SE o Companion percebe comportamento recorrente (so Companion faz isso):
 → Registrar silenciosamente em `agents/companion/data/padroes-observados.md`
 
 ### 5. Sessao Encerrando
-SE expert indica que vai fechar ou pede commit final:
+SE o aluno indica que vai fechar ou pede commit final:
 → Ops verifica no ritual de commit: contexto e trackers atualizados?
 → Atualizar `agents/companion/data/contexto-dinamico.md` com onde paramos
 
+### 6. Tarefa Concluida
+SE terminou uma tarefa (entregou o que foi pedido, mesmo que pequena):
+→ Aplicar a regra principal acima: contexto-dinamico + log de decisoes + tracker, e avisar em uma linha
+
+### 7. Correcao Recebida
+SE o aluno corrigiu um jeito seu de trabalhar ("nao faz assim", "ja falei", "errou de novo"):
+→ Conferir se a regra ja existe em `.claude/rules/custom-do-aluno.md`; se existe, nao repetir
+→ Se nao existe: escrever em "Suas regras" uma linha imperativa com o porque, sem contar o caso
+→ Avisar em uma linha: "Anotei nas suas regras: ..."
+
 > Salvar estado antes de compactacao de contexto e responsabilidade do
 > `dna-operacional.md` (Session Management) — nao repetir aqui.
 
@@ -50,10 +71,11 @@ SE expert indica que vai fechar ou pede commit final:
 | Conhecimento permanente | `docs/knowledge/{subpasta}/` |
 | Processo documentado | `business/processos/` |
 | Estado de trabalho (pre-autocompact) | Documento de trabalho do projeto |
+| Correcao do aluno (vira regra) | `.claude/rules/custom-do-aluno.md` |
 
 ## Regra de Ouro
 
-**Na duvida, salva.** E mais barato salvar informacao que nao vai usar do que perder informacao que precisava.
+**Tarefa concluida = memoria salva.** Fora isso, **na duvida, salva.** E mais barato salvar informacao que nao vai usar do que perder informacao que precisava.
 
 ## O que NAO salvar
 

package/.claude/rules/natural-language-first.md

@@ -2,13 +2,13 @@
 
 ## Principio
 
-Todo agente no Auroq OS opera por linguagem natural. O expert descreve o que quer com as palavras dele e o agente entende, classifica e executa. O expert NUNCA precisa saber nomes de comandos, sintaxe ou atalhos.
+Todo agente no Auroq OS opera por linguagem natural. O aluno descreve o que quer com as palavras dele e o agente entende, classifica e executa. O aluno NUNCA precisa saber nomes de comandos, sintaxe ou atalhos.
 
 Ele fala ("guarda esse documento", "instala esses squads que recebi", "ta uma bagunca aqui"), o agente mapeia pro modo certo internamente e executa — sem pedir pra reformular.
 
 ## Greetings
 
-O greeting diz quem o agente e e o que ele PODE FAZER, nunca como o expert deve DIGITAR.
+O greeting diz quem o agente e e o que ele PODE FAZER, nunca como o aluno deve DIGITAR.
 Estrutura obrigatoria:
 
 1. Banner com nome do agente
@@ -27,7 +27,7 @@ Estrutura obrigatoria:
 ## Comandos (`*comando`)
 
 - Existem como atalho pra quem ja conhece o sistema.
-- NUNCA sao mencionados proativamente (excecao: `*help`, quando o expert pede).
+- NUNCA sao mencionados proativamente (excecao: `*help`, quando o aluno pede).
 - NUNCA sao exigidos. Tudo que um comando faz, a linguagem natural tambem faz.
 
 ## Applies To