auroq-os 1.0.0

package/.claude/hooks/synapse-engine.cjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// SYN-14: Boot time captured before ANY require — measures hook cold start
+const _BOOT_TIME = process.hrtime.bigint();
+'use strict';
+
+/**
+ * SYNAPSE Hook Entry Point — UserPromptSubmit
+ *
+ * Thin wrapper that reads JSON from stdin, delegates to SynapseEngine,
+ * and writes <synapse-rules> context to stdout.
+ *
+ * - Silent exit on missing .synapse/ directory
+ * - Silent exit on any error (never blocks the user prompt)
+ * - All errors logged to stderr with [synapse-hook] prefix
+ * - 5s safety timeout as defense-in-depth
+ *
+ * @module synapse-engine-hook
+ */
+
+const path = require('path');
+const { resolveHookRuntime, buildHookOutput } = require(
+  path.join(__dirname, '..', '..', '.auroq-core', 'core', 'synapse', 'runtime', 'hook-runtime.js'),
+);
+
+/** Safety timeout (ms) — defense-in-depth; Claude Code also manages hook timeout. */
+const HOOK_TIMEOUT_MS = 5000;
+
+/**
+ * Read all data from stdin as a JSON object.
+ * @returns {Promise<object>} Parsed JSON input
+ */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('error', (e) => reject(e));
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try { resolve(JSON.parse(data)); }
+      catch (e) { reject(e); }
+    });
+  });
+}
+
+/** Main hook execution pipeline. */
+async function main() {
+  const input = await readStdin();
+  const runtime = resolveHookRuntime(input);
+  if (!runtime) return;
+
+  const result = await runtime.engine.process(input.prompt, runtime.session);
+
+  // QW-1: Wire updateSession() — persist bracket transitions after each prompt
+  if (runtime.sessionId && runtime.sessionsDir) {
+    try {
+      const { updateSession } = require(
+        path.join(runtime.cwd, '.auroq-core', 'core', 'synapse', 'session', 'session-manager.js'),
+      );
+      updateSession(runtime.sessionId, runtime.sessionsDir, {
+        context: { last_bracket: result.bracket || 'FRESH' },
+      });
+    } catch (_err) {
+      // Fire-and-forget — never block the prompt
+    }
+  }
+
+  const output = JSON.stringify(buildHookOutput(result.xml));
+
+  // Write and flush stdout (callback may not exist in mocked environments)
+  const flushed = process.stdout.write(output);
+  if (!flushed) {
+    await new Promise((resolve) => process.stdout.once('drain', resolve));
+  }
+}
+
+/**
+ * Safely exit the process — no-op inside Jest workers to prevent worker crashes.
+ * @param {number} code - Exit code
+ */
+function safeExit(code) {
+  if (process.env.JEST_WORKER_ID) return;
+  process.exit(code);
+}
+
+/** Entry point runner — sets safety timeout and executes main(). */
+function run() {
+  const timer = setTimeout(() => safeExit(0), HOOK_TIMEOUT_MS);
+  timer.unref();
+  main()
+    .then(() => safeExit(0))
+    .catch((err) => {
+      console.error(`[synapse-hook] ${err.message}`);
+      safeExit(0);
+    });
+}
+
+if (require.main === module) run();
+
+module.exports = { readStdin, main, run, HOOK_TIMEOUT_MS };

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

@@ -0,0 +1,79 @@
+# Agent Authority — Auroq OS
+
+## Delegation Matrix
+
+### Ops — Operacoes Exclusivas
+
+| Operacao | Exclusivo? | Outros Agentes |
+|----------|-----------|--------------|
+| `git push` / `git push --force` | SIM | BLOQUEADO |
+| `gh pr create` / `gh pr merge` | SIM | BLOQUEADO |
+| MCP add/remove/configure | SIM | BLOQUEADO |
+| Environment bootstrap | SIM | BLOQUEADO |
+| Commit inteligente (ritual completo) | SIM | Outros agentes delegam |
+
+### Companion — Cerebro do Sistema
+
+| Operacao | Exclusivo? |
+|----------|-----------|
+| Situacao diaria (boot + briefing) | SIM |
+| Sistema de memoria (contexto, decisoes, padroes) | SIM |
+| Sistema de projetos (cockpit, trackers, escalacao) | SIM |
+| Weekly review | SIM |
+| Roteamento para agente adequado | SIM |
+| Criacao de projetos | SIM |
+
+### Forge — Criacao de Agentes
+
+| Operacao | Exclusivo? |
+|----------|-----------|
+| Criar workers | SIM (basico) — Forges premium quando instalados |
+| Criar minds | SIM (basico) — Forges premium quando instalados |
+| Criar squads | SIM (basico) — Forges premium quando instalados |
+
+### Workers — Execucao
+
+| Permitido | Bloqueado |
+|---------|---------|
+| `git add`, `git commit`, `git status` | `git push` (delegar pra Ops) |
+| `git branch`, `git checkout` (local) | `gh pr create/merge` (delegar pra Ops) |
+| Execucao de tasks operacionais | Criar novos agentes (delegar pra Forge) |
+| Atualizacao de documentos de trabalho | Decisoes estrategicas (delegar pro Expert) |
+
+### Squads — Processos Complexos
+
+| Permitido | Bloqueado |
+|---------|---------|
+| Executar pipeline completo com quality gates | `git push` (delegar pra Ops) |
+| Criar documentos de output | Criar novos agentes (delegar pra Forge) |
+| Atualizar KBs e skills | Decisoes fora do escopo do squad |
+
+## Cross-Agent Delegation
+
+### Git Push Flow
+```
+QUALQUER agente → Ops (*commit / *push)
+```
+
+### Novo Agente Flow
+```
+Expert pede → Forge cria → Expert valida
+```
+
+### Projeto Novo Flow
+```
+Expert pede → Companion cria (*novo-projeto) → Expert valida
+```
+
+### Memoria Flow
+```
+QUALQUER agente detecta trigger → salva (ou pergunta) conforme rule memoria-inteligente
+Companion consolida no weekly review
+```
+
+## Escalation Rules
+
+1. Agente nao consegue completar task → Informar expert com contexto
+2. Quality gate falha → Retornar pro executor com feedback especifico
+3. Violacao constitucional detectada → BLOCK, corrigir antes de prosseguir
+4. Conflito de boundary → Constitution Art. II resolve (cada um faz o seu)

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

@@ -0,0 +1,97 @@
+# Agent Handoff Protocol — Context Compaction
+
+## Purpose
+
+Prevent context window accumulation when switching between Auroq OS agents (`@agent` commands). Each agent switch compacts the previous agent's full persona into a structured handoff artifact (~379 tokens) instead of retaining the full definition (~3-5K tokens).
+
+## When This Applies
+
+This protocol activates whenever:
+1. A user invokes a new agent via `@agent-name` or `/AuroqOS:agents:agent-name`
+2. The current session already has a different agent active
+
+## Handoff Protocol
+
+### On Agent Switch (outgoing agent)
+
+Before loading the new agent, mentally generate a handoff artifact with:
+
+```yaml
+handoff:
+  from_agent: "{current_agent_id}"
+  to_agent: "{new_agent_id}"
+  story_context:
+    story_id: "{active story ID}"
+    story_path: "{active story path}"
+    story_status: "{current status}"
+    current_task: "{last task being worked on}"
+    branch: "{current git branch}"
+  decisions:
+    - "{key decision 1}"
+    - "{key decision 2}"
+  files_modified:
+    - "{file 1}"
+    - "{file 2}"
+  blockers:
+    - "{any active blockers}"
+  next_action: "{what the incoming agent should do}"
+```
+
+### On Agent Switch (incoming agent)
+
+The incoming agent receives:
+1. Its own **full agent profile** (persona, commands, dependencies)
+2. The **handoff artifact** from the previous agent (compact summary)
+3. **NOT** the previous agent's full persona/instructions/tool definitions
+
+### Compaction Limits
+
+| Limit | Value |
+|-------|-------|
+| Max handoff artifact size | 500 tokens |
+| Max retained agent summaries | 3 (oldest discarded on 4th switch) |
+| Max decisions in artifact | 5 |
+| Max files_modified entries | 10 |
+| Max blockers | 3 |
+
+### What to Preserve (ALWAYS include)
+
+- Active story ID and path
+- Current task being worked on
+- Git branch name
+- Key architectural decisions made
+- Files created or modified
+- Active blockers
+
+### What to Discard (NEVER carry forward)
+
+- Previous agent's full persona definition
+- Previous agent's command list
+- Previous agent's dependency list
+- Previous agent's tool configurations
+- Previous agent's CodeRabbit integration details
+- Previous agent's greeting templates
+
+## Storage
+
+Handoff artifacts are stored at `.auroq/handoffs/` (runtime, gitignored). Format: `handoff-{from}-to-{to}-{timestamp}.yaml`.
+
+## Template Reference
+
+Full template: `.auroq-core/development/templates/agent-handoff-tmpl.yaml`
+
+## Example
+
+Session flow: `@sm` creates story → `@dev` implements → `@qa` reviews
+
+After `@sm` → `@dev` switch:
+- `@sm` full persona (~3K tokens) is **discarded**
+- Handoff artifact (~379 tokens) is **retained**: story ID, decisions, files, next action
+- `@dev` full persona (~5K tokens) is **loaded**
+- **Total context: ~5.4K** instead of ~8K (33% reduction per switch)
+
+After `@dev` → `@qa` switch:
+- `@dev` full persona is **discarded**
+- `@dev` handoff artifact is **retained** alongside `@sm` handoff
+- `@qa` full persona is **loaded**
+- **Total context: ~5.2K** instead of ~12K (57% reduction after 2 switches)

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

@@ -0,0 +1,86 @@
+# Commit Inteligente — Ritual de Incrementacao
+
+> No Auroq OS, commit nao e sobre deployar codigo. E sobre **salvar o checkpoint do negocio**.
+> Cada commit e um ponto de evolucao incremental do sistema.
+
+## Quando Commitar
+
+- Final de sessao de trabalho significativa
+- Antes de trocar de assunto/projeto
+- Antes de fechar o computador
+- Quando completou uma etapa de projeto
+- Quando tomou decisoes importantes
+
+## Ritual do Commit (Ops executa)
+
+### 1. Revisar o que mudou
+```
+git status + git diff
+```
+Entender: o que progrediu desde o ultimo commit?
+
+### 2. Verificar projetos ativos
+- SE trabalhou num projeto do cockpit → tracker esta atualizado?
+- SE tracker nao foi atualizado → atualizar ANTES do commit (log, status, blockers)
+
+### 3. Verificar contexto
+- SE houve decisoes importantes → estao no `agents/companion/data/log-decisoes.md`?
+- SE o estado do negocio mudou → `agents/companion/data/contexto-dinamico.md` reflete?
+- SE algo foi aprendido → esta documentado em algum lugar?
+
+### 4. Commitar com mensagem significativa
+A mensagem conta O QUE ACONTECEU no negocio, nao o que mudou nos arquivos:
+
+**Formato:**
+```
+{tipo}: {o que aconteceu}
+
+{detalhes se necessario}
+```
+
+**Tipos:**
+- `progresso:` — avancou em projeto/tarefa
+- `decisao:` — tomou decisao estrategica
+- `processo:` — documentou/criou/melhorou processo
+- `agente:` — criou/melhorou agente/squad/worker
+- `conhecimento:` — adicionou/tratou conhecimento na biblioteca
+- `campanha:` — acao de campanha (criativo, disparo, ajuste)
+- `fix:` — corrigiu problema
+- `setup:` — configuracao/infra
+
+**Exemplos:**
+```
+progresso: NDF Workshop fase 1 concluida — LP, flows e criativos prontos
+decisao: definiu preco do ingresso em R$47 (teste contra R$97 no proximo ciclo)
+processo: documentou SOP de shift entre ciclos de lancamento
+agente: criou worker TechOps com vault e SOPs operacionais
+conhecimento: ETL completo de criativos de anuncio (9 vols, 6450 linhas)
+campanha: lancou lote 2 de criativos — 9 pecas, 3 hooks novos
+```
+
+### 5. Push
+- Backup na nuvem (GitHub)
+- Historico incremental do negocio
+- Qualquer maquina, qualquer momento: `git clone` e o negocio ta la
+
+## O que o Commit NAO e
+
+- NAO e sobre codigo limpo ou testes passando
+- NAO precisa de conventional commits estilo dev (feat/fix/chore)
+- NAO e obrigatorio ter tudo perfeito — e checkpoint, nao release
+- NAO e so pra deploy — e pra PERSISTIR evolucao
+
+## Commit como Seguro
+
+> "Commit e o botao salvar do sistema."
+
+Se o computador quebrar, se o autocompact apagar tudo, se trocar de maquina — o ultimo commit e o ponto de restauracao. Quanto mais frequente, menos se perde.
+
+## Protocolo do Ops
+
+Quando o expert pede `*commit` ou `*push`, o Ops executa o ritual completo:
+1. Revisa mudancas
+2. Pergunta se trackers e contexto estao atualizados
+3. Sugere mensagem de commit baseada no que aconteceu
+4. Expert aprova
+5. Commit + push

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

@@ -0,0 +1,53 @@
+# DNA Operacional — Rules
+
+> Regras de comportamento que todo agente ativo no Auroq OS segue automaticamente.
+
+## Documentacao Continua
+
+SEMPRE que estiver trabalhando numa tarefa com mais de 3 etapas:
+
+1. **Criar ou atualizar documento de trabalho** no inicio da tarefa
+2. **Atualizar a cada etapa significativa**: progresso, decisoes, problemas, estado
+3. **Salvar estado ANTES de operacoes longas** (previne perda por autocompact)
+4. **Consolidar ao final**: resultado, aprendizados, proximos passos
+
+O documento de trabalho fica em:
+- `business/campanhas/{campanha}/` para trabalho de campanha
+- `business/processos/` para SOPs
+- Dentro do squad ou no local mais logico para o contexto
+
+## Anti-Viagem
+
+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**
+4. Nao adicionar features, melhorias ou conteudo nao solicitado
+5. Nao gerar dados, numeros ou fatos sem fonte verificada
+
+## Handoff entre Agentes
+
+SEMPRE que trocar de agente:
+
+1. Documento de trabalho deve estar atualizado com estado atual
+2. Gerar handoff artifact compacto (~379 tokens): de quem, pra quem, decisoes, proxima acao
+3. Armazenar em `.auroq/handoffs/`
+4. Novo agente le documento + handoff antes de comecar
+
+## Anti-Entropia
+
+SEMPRE:
+
+1. Tasks com inputs e outputs definidos quando possivel
+2. Se for squad: coordenador nao executa, executor nao se auto-valida
+3. Output importante vira documento .md (nao fica so na conversa)
+4. Quality gates em pontos criticos
+5. Ao terminar trabalho: registrar aprendizados que melhoram o sistema
+
+## Session Management
+
+1. Antes de autocompact iminente: salvar estado no documento de trabalho
+2. Apos autocompact: reativar agente (rele arquivos + resumo da sessao)
+3. Antes de trocar de sessao: commit (commit = botao salvar)
+4. Em novo chat: ativar agente → apontar pro documento de trabalho → continuar

package/.claude/rules/evolucao-incremental.md

@@ -0,0 +1,43 @@
+# Evolucao Incremental — Rules
+
+> Constitution Art. VI: Nunca do zero. REUSE > ADAPT > CREATE.
+
+## Hierarquia de Verificacao
+
+Antes de criar QUALQUER artefato (documento, agente, processo, template):
+
+### Gate 1: REUSE — Ja existe?
+- Buscar no Exocortex (docs/knowledge/)
+- Buscar nos squads instalados (agents/)
+- Buscar nos processos documentados (business/processos/)
+- Buscar nos templates de campanha (business/campanhas/_template/)
+
+SE encontrou algo que resolve → USAR direto. Nao recriar.
+
+### Gate 2: ADAPT — Existe algo parecido?
+- Buscar por artefato similar que pode ser adaptado
+- Template que pode ser preenchido
+- KB de dominio adjacente que pode ser reutilizada
+- Processo de outra campanha que pode ser copiado
+
+SE encontrou algo parecido → ADAPTAR. Nao criar do zero.
+
+### Gate 3: CREATE — Nao existe nada?
+- So agora criar do zero
+- Ao criar: documentar para futuro reuso
+- Usar templates padrao quando disponiveis
+
+## Aplicacoes Praticas
+
+| Situacao | REUSE | ADAPT | CREATE |
+|----------|-------|-------|--------|
+| Nova campanha | Copiar _template/ | Ajustar campanha anterior | So se for modelo novo |
+| Novo processo | Verificar se ja tem SOP | Adaptar SOP similar | Documentar apos fazer |
+| Novo agente | Verificar se ja existe squad/worker | Adaptar agente existente | Criar via Forge |
+| Novo documento | Verificar biblioteca-pmi/ | Adaptar doc existente | Criar e adicionar a biblioteca |
+
+## Regra de Ouro
+
+**Cada artefato criado deve ser reusavel.** Se criou um processo, documente como SOP. Se criou um template, coloque em _template/. Se criou um documento, adicione a biblioteca.
+
+O sistema fica mais rico a cada uso — nao mais poluido.

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

@@ -0,0 +1,38 @@
+# MCP Usage — Auroq OS
+
+## Prioridade de Ferramentas
+
+SEMPRE preferir ferramentas nativas do Claude Code sobre MCP:
+
+| Task | USAR | NAO USAR |
+|------|------|----------|
+| Ler arquivos | `Read` tool | MCP servers |
+| Escrever arquivos | `Write` / `Edit` tools | MCP servers |
+| Rodar comandos | `Bash` tool | MCP servers |
+| Buscar arquivos | `Glob` tool | MCP servers |
+| Buscar conteudo | `Grep` tool | MCP servers |
+
+## MCP Governance
+
+Gestao de MCP servers (add/remove/configure) e **EXCLUSIVA do Ops**.
+
+Outros agentes sao **consumidores** de MCP, nao administradores. Se precisar de gestao MCP, delegar pro Ops.
+
+## Quando usar MCP
+
+1. Browser automation (Playwright) — testes, screenshots, interacao web
+2. WhatsApp (quando configurado) — mensagens, contatos
+3. Notion (quando configurado) — docs externos
+4. Ferramentas externas sem equivalente nativo
+
+## Quando NAO usar MCP
+
+- Operacoes com arquivos locais (usar ferramentas nativas)
+- Comandos de shell (usar Bash)
+- Qualquer coisa que uma ferramenta nativa resolve
+
+## Rationale
+
+- Ferramentas nativas executam no sistema LOCAL
+- MCP servers podem ter latencia, falhas de conexao, custos
+- Ferramentas nativas sao mais rapidas e confiaveis pra operacoes locais

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

@@ -0,0 +1,65 @@
+# Memoria Inteligente — Rule Global
+
+> Todo agente no Auroq OS segue este protocolo de memoria. Nao e opcional.
+
+## 6 Triggers — 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:
+```
+## [DATA] — [TITULO]
+**Contexto:** [situacao]
+**Decisao:** [o que decidiu]
+**Racional:** [por que]
+**Impacto:** [o que muda]
+```
+
+### 2. Projeto Progrediu
+SE completou tarefa de projeto ou avancou fase:
+→ Atualizar tracker do projeto (conforme project-tracker protocol)
+→ Adicionar entrada no LOG do tracker
+
+### 3. Conhecimento Criado
+SE produziu documento, framework, analise, ou processo novo que tem valor permanente:
+→ Perguntar: "Salvo na biblioteca? Onde faz mais sentido?"
+→ Salvar em `docs/knowledge/` (subpasta adequada) ou `business/processos/`
+
+### 4. Padrao Detectado
+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:
+→ Ops verifica no ritual de commit: contexto e trackers atualizados?
+→ Atualizar `agents/companion/data/contexto-dinamico.md` com onde paramos
+
+### 6. Autocompact Iminente
+SE sessao longa e contexto pode ser compactado:
+→ SALVAR ESTADO IMEDIATAMENTE no documento de trabalho
+→ Atualizar contexto-dinamico se nao fez ainda
+
+## Onde Cada Coisa Vai
+
+| Tipo de informacao | Destino |
+|-------------------|---------|
+| Decisao estrategica | `agents/companion/data/log-decisoes.md` |
+| Progresso de projeto | `business/campanhas/{projeto}/tracker.md` |
+| Onde estamos agora | `agents/companion/data/contexto-dinamico.md` |
+| Ideia ou pendencia | `agents/companion/data/demandas-backlog.md` |
+| Padrao recorrente | `agents/companion/data/padroes-observados.md` |
+| Conhecimento permanente | `docs/knowledge/{subpasta}/` |
+| Processo documentado | `business/processos/` |
+| Estado de trabalho (pre-autocompact) | Documento de trabalho do projeto |
+
+## Regra de Ouro
+
+**Na duvida, salva.** E mais barato salvar informacao que nao vai usar do que perder informacao que precisava.
+
+## O que NAO salvar
+
+- Conversa trivial sem decisao ou aprendizado
+- Informacao que ja existe em outro lugar (nao duplicar)
+- Dados temporarios que perdem valor em 24h
+- Output intermediario que vai ser refinado (salvar so o final)

package/.claude/rules/project-tracker.md

@@ -0,0 +1,49 @@
+# Project Tracker Protocol — Regra para Todos os Agentes
+
+## Quando Esta Regra se Aplica
+
+Esta regra se aplica sempre que um agente trabalha em algo relacionado a um projeto listado no cockpit (`business/cockpit.md`).
+
+## Protocolo Obrigatorio
+
+### ANTES de trabalhar
+
+1. **Ler o tracker do projeto** (path no cockpit) — entender onde estamos, quais tarefas sao suas, o que esta bloqueado
+2. **Verificar dependencias** — se sua tarefa depende de outra que nao esta Done, nao comece (registre como blocker)
+3. **Identificar sua tarefa** — saber exatamente o que precisa fazer antes de comecar
+
+### DURANTE o trabalho
+
+4. **Focar no escopo** — fazer o que o tracker define, nao mais, nao menos
+5. **Se encontrar blocker novo** — registrar imediatamente no tracker (secao BLOCKERS)
+
+### DEPOIS de trabalhar
+
+6. **Atualizar o tracker** — marcar tarefas como Done + data, atualizar status
+7. **Adicionar entrada no LOG** — uma linha: data — agente: o que fez
+8. **Se desbloqueou outra tarefa** — isso fica visivel automaticamente pela mudanca de status da dependencia
+9. **Se completou a ultima tarefa da fase** — atualizar a fase para Done e indicar proxima fase
+
+### SE nao existe tracker
+
+- Se o projeto esta no cockpit mas nao tem tracker: avisar o Euriler ("Projeto X nao tem tracker. Quer que eu crie?")
+- Se o trabalho nao esta relacionado a nenhum projeto do cockpit: trabalhar normalmente sem tracker
+
+## O que NAO fazer
+
+- NAO criar tracker sem o projeto estar no cockpit
+- NAO alterar tarefas de outros agentes (so atualizar as suas)
+- NAO remover entradas do log (log e append-only)
+- NAO mudar o objetivo ou fases do projeto (so o Euriler/Jarvis fazem isso)
+
+## Formato do LOG
+
+```
+- DD/MM — @nome-agente: descricao curta do que foi feito
+```
+
+Exemplo:
+```
+- 16/03 — @tech-ops: Configurou UTMs na LP final
+- 15/03 — @design: Entregou criativos lote 2 (9 pecas)
+```

package/.claude/rules/tool-response-filtering.md

@@ -0,0 +1,57 @@
+---
+paths:
+  - .auroq-core/data/tool-registry.yaml
+  - .mcp.json
+---
+# Tool Response Filtering — Dynamic Token Reduction
+
+When processing responses from MCP tools or large web fetches, apply the filter
+configuration defined in `.auroq-core/data/tool-registry.yaml` for the tool that
+produced the response. This reduces context token consumption without losing
+task-relevant information.
+
+## Filter Types
+
+### content
+Extract the main informational content and discard noise (navigation, ads,
+boilerplate, repetitive headers/footers). Limit the extracted output to
+approximately `max_tokens` tokens, truncating at a natural paragraph or
+sentence boundary. If `extract` fields are specified, prioritize those
+fields from the response object.
+
+**Apply to:** WebFetch HTML responses, EXA search results, Context7 docs.
+
+### schema
+From a JSON object or array of objects, select ONLY the fields listed in
+`fields`. Discard all other keys. If `max_tokens` is set, truncate the
+serialized result at that token limit.
+
+**Apply to:** Playwright page data, API responses with known schemas.
+
+### field
+From an array of objects (tabular data), project ONLY the columns listed
+in `fields` and limit the result to `max_rows` rows. This is analogous to
+`SELECT field1, field2 FROM data LIMIT max_rows`.
+
+**Apply to:** Apify scraper results, database query results, CSV-like data.
+
+## How to Apply
+
+1. After receiving a tool response, identify the tool name.
+2. Look up the tool in `tool-registry.yaml` → check for a `filter` key.
+3. If a filter exists, apply the corresponding type rules above.
+4. If NO filter exists for the tool, use the full response as-is.
+5. Present the filtered result in your reasoning — do NOT repeat the raw
+   unfiltered payload.
+
+## Fallback
+
+If the filter would remove ALL content (empty result), fall back to the
+full unfiltered response. Never produce an empty result from filtering.
+
+## Performance Note
+
+This is a zero-overhead optimization. The filter is applied during your
+reasoning step — no external scripts are invoked. The utility scripts at
+`.auroq-core/utils/filters/` are available for batch post-processing of
+saved responses but are NOT required during normal tool use.

package/.claude/settings.json

@@ -0,0 +1 @@
+{ "language": "portuguese" }