auroq-os 2.6.10 → 2.8.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.10
+  version: 2.8.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/auroq-sync.cjs

@@ -4,7 +4,8 @@
  * Auroq OS — Sync Hook
  *
  *   --session-start  (SessionStart)      checa o GitHub ao abrir; PUXA se for seguro; relata o que chegou
- *   --remind         (UserPromptSubmit)  lembra, com moderacao, de trabalho nao entregue
+ *   --remind         (UserPromptSubmit)  lembra, com moderacao, de trabalho nao entregue, e traz da
+ *                                        memoria do negocio (app Auroq OS) o que tem a ver com o pedido
  *
  * Regras de ouro:
  * - Nunca bloqueia a sessao (sempre exit 0) e fica em silencio quando nao ha o que dizer.
@@ -97,8 +98,23 @@ function versionNotice() {
   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.`;
 }
 
+// ─── Bilhete da memória (app Auroq OS, Fase 1 da memória do aluno) ───────────
+// O app refaz `agents/companion/data/nucleo.md` sozinho depois das conversas (teto de 3.000
+// caracteres). Toda conversa nova comeca com ele, no lugar de ler os arquivos inteiros da memoria.
+const NUCLEO = path.join('agents', 'companion', 'data', 'nucleo.md');
+const NUCLEO_MAX = 3000;
+
+function nucleoNotice() {
+  let texto;
+  try { texto = fs.readFileSync(path.join(CWD, NUCLEO), 'utf8'); } catch { return null; }
+  texto = texto.replace(/^\uFEFF/, '').replace(/\r\n/g, '\n').trim();
+  if (!texto) return null;
+  if (texto.length > NUCLEO_MAX) texto = `${texto.slice(0, NUCLEO_MAX - 1)}…`;
+  return `[Memoria do sistema] Bilhete da memoria deste negocio (${NUCLEO}, refeito sozinho pelo app Auroq OS a partir das conversas anteriores; vale para todo agente, squad e skill desta pasta, nao so o Companion). Use para saber quem e o aluno, onde voces pararam, o que ja foi decidido e o que esta pendente; nao leia para o aluno sem ele pedir. Detalhes em agents/companion/data/.\n${texto}`;
+}
+
 function sessionStart() {
-  const vNotice = versionNotice();
+  const vNotice = [nucleoNotice(), versionNotice()].filter(Boolean).join('\n') || null;
   if (!isRepo() || !hasRemote()) { emit('SessionStart', vNotice); return; }
   const up = upstream();
   if (!up) { emit('SessionStart', vNotice); return; }
@@ -139,8 +155,54 @@ function sessionStart() {
   emit('SessionStart', lines.join('\n'));
 }
 
-function remind() {
-  if (!isRepo()) return;
+// ─── Busca na memória a cada pedido (app Auroq OS, Fase 2 da memória do aluno) ─────
+// O app mantém um índice da memória do negócio; `auroq memoria busca --gancho` devolve até 3 trechos
+// (1.500 caracteres) que passam no filtro de relevância, ou nada. Pedido trivial não busca. Sem o app
+// (comando ausente, app fechado, demorou), segue em silêncio: a conversa nunca espera por isso.
+const MEMORIA = path.join('agents', 'companion', 'data');
+const TEMPO_DA_BUSCA_MS = 3500;
+const TRIVIAL = /^(?:oi|ola|olá|ok|blz|beleza|obrigad[oa]|valeu|sim|n[aã]o|pode|segue|continua|bom dia|boa tarde|boa noite|top|show|perfeito|certo|isso|entendi|bora|go)\b/i;
+
+function acharAuroq() {
+  const nomes = process.platform === 'win32' ? ['auroq.exe'] : ['auroq'];
+  const pastas = String(process.env.PATH || '').split(path.delimiter).filter(Boolean);
+  if (process.platform === 'darwin') pastas.push('/Applications/Auroq OS.app/Contents/Resources/bin');
+  for (const pasta of pastas) {
+    for (const nome of nomes) {
+      const alvo = path.join(pasta, nome);
+      try { if (fs.statSync(alvo).isFile()) return alvo; } catch { /* segue */ }
+    }
+  }
+  return null;
+}
+
+function pedidoDoAluno(entrada) {
+  try {
+    const dado = JSON.parse(entrada || '{}');
+    return typeof dado.prompt === 'string' ? dado.prompt : '';
+  } catch {
+    return '';
+  }
+}
+
+function buscaNaMemoria(pedido) {
+  const texto = String(pedido || '').replace(/\s+/g, ' ').trim();
+  if (texto.length < 8 || (texto.length < 30 && TRIVIAL.test(texto))) return null;
+  if (!fs.existsSync(path.join(CWD, MEMORIA))) return null;
+  const programa = acharAuroq();
+  if (!programa) return null;
+  try {
+    const saida = execFileSync(programa, ['memoria', 'busca', texto.slice(0, 600), '--gancho'], {
+      cwd: CWD, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: TEMPO_DA_BUSCA_MS, windowsHide: true,
+    }).trim();
+    return /^\[Memoria do (sistema|Companion)\]/.test(saida) ? saida.slice(0, 2500) : null;
+  } catch {
+    return null;
+  }
+}
+
+function lembrete() {
+  if (!isRepo()) return null;
   const dirty = dirtyFiles();
   const up = upstream();
   const ahead = up ? countRange(`${up}..HEAD`) : 0;
@@ -148,30 +210,37 @@ function remind() {
   const now = Date.now();
   if (dirty.length === 0 && ahead === 0) {
     if (st.dirtySince) { st.dirtySince = 0; writeState(st); }
-    return;
+    return null;
   }
-  if (!st.dirtySince) { st.dirtySince = now; writeState(st); return; }
-  if (now - st.dirtySince < REMIND_AFTER_MS) return;
-  if (st.lastRemind && now - st.lastRemind < REMIND_EVERY_MS) return;
+  if (!st.dirtySince) { st.dirtySince = now; writeState(st); return null; }
+  if (now - st.dirtySince < REMIND_AFTER_MS) return null;
+  if (st.lastRemind && now - st.lastRemind < REMIND_EVERY_MS) return null;
   st.lastRemind = now;
   writeState(st);
   const mins = Math.round((now - st.dirtySince) / 60000);
-  emit('UserPromptSubmit', `[Auroq lembrete] Ha trabalho nao entregue ha ~${mins} min (${dirty.length} arquivo(s) alterado(s)${ahead ? `, ${ahead} commit(s) sem push` : ''}). NAO interrompa o raciocinio atual. Ao fechar o bloco em andamento, ofereca em UMA linha: "quer que eu salve e entregue pro GitHub?". Nunca entregue sem o expert pedir.`);
+  return (`[Auroq lembrete] Ha trabalho nao entregue ha ~${mins} min (${dirty.length} arquivo(s) alterado(s)${ahead ? `, ${ahead} commit(s) sem push` : ''}). NAO interrompa o raciocinio atual. Ao fechar o bloco em andamento, ofereca em UMA linha: "quer que eu salve e entregue pro GitHub?". Nunca entregue sem o expert pedir.`);
+}
+
+function remind(entrada) {
+  const partes = [buscaNaMemoria(pedidoDoAluno(entrada)), lembrete()].filter(Boolean);
+  emit('UserPromptSubmit', partes.join('\n\n') || null);
 }
 
 let ran = false;
+let entrada = '';
 function main() {
   if (ran) return;
   ran = true;
-  try { if (MODE === '--remind') remind(); else sessionStart(); }
+  try { if (MODE === '--remind') remind(entrada); else sessionStart(); }
   catch (e) { console.error(`[auroq-sync] ${e.message}`); }
   process.exit(0);
 }
 
 // Consome o JSON que o Claude Code envia no stdin (nao depende dele) e roda no fim;
 // fallback por timer garante execucao mesmo se o stdin nao fechar.
+// O pedido do aluno (UserPromptSubmit) vem nesse JSON e é o que a busca da memória usa.
 process.stdin.resume();
-process.stdin.on('data', () => {});
+process.stdin.on('data', (pedaco) => { if (entrada.length < 200000) entrada += pedaco; });
 process.stdin.on('end', main);
 process.stdin.on('error', main);
 setTimeout(main, 400).unref();

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.