vault-go 0.22.0 → 0.22.2

package/README.md

@@ -1,126 +1,57 @@
-## Login no navegador
-
-`bunx --bun vault-go@latest` abre o autenticador do AI Vault Memory no navegador. E-mail, senha e MFA são informados apenas no portal. Ao concluir, o terminal recebe um código de uso único por `127.0.0.1` e o troca com PKCE; tokens não aparecem na URL nem no console. O listener fecha ao concluir ou após cinco minutos.
-
-Para trocar a conta: `bunx --bun vault-go@latest login --force`. Para chave de API explícita: `bunx --bun vault-go@latest login --force --api-key`. Se a abertura automática falhar, use o endereço exibido no mesmo computador. Requer uma sessão local com navegador para o retorno loopback.
-
 # vault-go
 
-[Idiomas AST e awareness local do Grok](docs/ast-and-awareness.md): catálogo de disponibilidade real das grammars, configuração opt-in, filtros e limites do writer mensal.
+MCP server and installer for **[Vault Memory](https://vault.resolveup.com.br)** — search, capture, and use account memory across AI clients.
 
-Servidor MCP em Bun para pesquisar, contextualizar e registrar memória na
-plataforma Vault. A persistência fica no PostgreSQL do serviço Rust executado
-no EasyPanel; o painel local mantém um cache privado das consultas recentes.
+Memories live in your Vault Memory cloud account. This package installs the local MCP server, signs you in, registers clients, and runs an optional local worker that turns captured events into memories.
 
-## Pré-requisito
+```sh
+npm install -g vault-go@latest
+vault-go setup
+```
 
-Instale o [Bun](https://bun.sh/) e confirme:
+Or without a global install:
 
 ```sh
-bun --version
+bunx --bun vault-go@latest
 ```
 
-## Instalação MCP
+Requires [Bun](https://bun.sh/) (`bun --version`) and Node.js 20+.
 
-### Opção remota somente leitura
+## Sign in
 
-Para pesquisa e contexto, é possível usar diretamente o endpoint Streamable
-HTTP da plataforma, sem instalar runtime ou banco local. Crie em **Segurança >
-Chaves de API** uma chave apenas com `memory:read` e configure:
+`vault-go setup` and `vault-go login` open the Vault Memory sign-in page in your browser. Email, password, and MFA stay in the portal. The CLI receives a one-time code on `127.0.0.1` and exchanges it with PKCE. Tokens never appear in the URL or terminal. The listener closes when login finishes or after five minutes.
 
 ```sh
-export VAULT_GO_TOKEN='<chave-memory-read>'
-codex mcp add vault-go \
-  --url https://vaultmemoryai.com/api/mcp \
-  --bearer-token-env-var VAULT_GO_TOKEN
+vault-go login --force              # switch account
+vault-go login --force --api-key    # paste a scoped API key instead
 ```
 
-Configuração genérica para clientes com transporte HTTP:
+If the browser does not open, use the loopback URL printed in the same session.
 
-```json
-{
-  "mcpServers": {
-    "vault-go": {
-      "type": "http",
-      "url": "https://vaultmemoryai.com/api/mcp",
-      "headers": {
-        "Authorization": "Bearer ${VAULT_GO_TOKEN}"
-      }
-    }
-  }
-}
-```
+Credentials are stored in `~/.memvault/auth.json` (`0600`). The directory is `0700`. Passwords and MFA codes are not saved.
 
-O endpoint remoto expõe somente projetos, busca, contexto, recentes, feed,
-linha do tempo, entrada/saída de ferramentas, contexto de arquivos, estatísticas, estado vetorial e consultas
-às bases de conhecimento. Para captura automática, criação/reconstrução de
-bases, escrita, importação ou exclusão, use o cliente Bun completo abaixo.
+## Install MCP
 
-### Opção Bun completa
+### Full local server (capture + write)
 
-Execute em um terminal:
+The setup wizard:
 
-```sh
-bunx --bun vault-go@latest
-```
+1. Reuses an existing session in `~/.memvault`, or opens Vault Memory sign-in.
+2. Detects installed clients and registers the MCP server.
+3. Leaves other client config in place.
+4. Installs the local dashboard on port `38850` (starts at login on macOS).
 
-A instalação abre com uma animação ASCII do Vault Go e mostra um indicador
-enquanto verifica os motores disponíveis. Em terminais pequenos, a abertura usa
-uma versão compacta. Para desativar, execute `vault-go setup --no-animation` ou
-defina `VAULT_GO_NO_ANIMATION=1`. `NO_COLOR`, `TERM=dumb`, CI e saídas sem terminal
-também usam a apresentação estática, sem códigos ANSI ou espera. O modo MCP
-`serve` não exibe a animação.
-
-O assistente:
-
-1. valida uma sessão existente em `~/.memvault`;
-2. se necessário, abre o login do AI Vault Memory no navegador (chave de API somente com `--api-key`)
-   `vg_live_...`;
-3. detecta os clientes instalados;
-4. permite escolher onde registrar o MCP;
-5. preserva as outras configurações dos clientes;
-6. instala e abre o painel local na porta 38850 (início automático no macOS).
-
-Clientes suportados:
-
-- Codex e ChatGPT Desktop local;
-- Claude Code e Claude Desktop;
-- Grok (config.toml nativo e hooks em `~/.grok/hooks`);
-- Agy / Antigravity CLI e IDE;
-- Gemini CLI;
-- Cursor e Windsurf;
-- VS Code com GitHub Copilot;
-- GitHub Copilot CLI;
-- Roo Code;
-- OpenCode.
-
-O Crystal do Vault Desktop usa este mesmo servidor MCP. Ative **Crystal → MCP →
-Ativar no Vault MCP** no Desktop atualizado e reconecte o cliente MCP. As ferramentas
-`vault_go_crystal_list`, `read`, `search`, `write`, `delete`, `sync` e `status` ficam
-disponíveis junto às ferramentas de memória. O Desktop deve permanecer aberto no
-mesmo computador; a conexão local é configurada automaticamente, sem copiar um
-segredo ou cadastrar um segundo servidor. Desativar a integração revoga essa conexão.
-
-Comandos explícitos:
+Supported clients: Codex, ChatGPT Desktop, Claude Code, Claude Desktop, Grok, Agy / Antigravity, Gemini CLI, Cursor, Windsurf, VS Code + GitHub Copilot, Copilot CLI, Roo Code, OpenCode, and Vault Desktop (Crystal).
 
 ```sh
-bunx --bun vault-go@latest setup
-bunx --bun vault-go@latest setup --clients codex,claude,copilot
-bunx --bun vault-go@latest setup --engine openrouter
-bunx --bun vault-go@latest setup --engine claude --model sonnet
-bunx --bun vault-go@latest login --force
-bunx --bun vault-go@latest serve
-bunx --bun vault-go@latest engine list
-bunx --bun vault-go@latest engine use openrouter
-bunx --bun vault-go@latest engine use codex --model terra
-bunx --bun vault-go@latest engine key openrouter
+vault-go setup
+vault-go setup --clients codex,claude,copilot
+vault-go setup --engine openrouter
+vault-go setup --engine claude --model sonnet
+vault-go serve
 ```
 
-As credenciais são gravadas em `~/.memvault/auth.json` com permissão `0600`;
-o diretório usa `0700`. Senhas e códigos MFA não são persistidos. Reinicie os
-clientes que estavam abertos depois da primeira instalação.
-
-Configuração MCP genérica:
+Generic MCP config:
 
 ```json
 {
@@ -133,262 +64,137 @@ Configuração MCP genérica:
 }
 ```
 
-Por padrão, todos os clientes reutilizam `~/.memvault/config.json` e
-`~/.memvault/auth.json`, criados pelo assistente. Também é possível apontar
-outro diretório:
+Override the home directory with `VAULT_GO_HOME`. Restart clients that were already open after the first install.
+
+### Read-only remote MCP
+
+For search and context without a local runtime, create an API key with `memory:read` under **Security → API keys**, then:
+
+```sh
+export VAULT_GO_TOKEN='<memory-read-key>'
+codex mcp add vault-go \
+  --url https://vaultmemoryai.com/api/mcp \
+  --bearer-token-env-var VAULT_GO_TOKEN
+```
 
 ```json
 {
   "mcpServers": {
     "vault-go": {
-      "command": "bunx",
-      "args": ["--bun", "vault-go@latest", "serve"],
-      "env": {
-        "VAULT_GO_HOME": "/caminho/privado/.memvault"
+      "type": "http",
+      "url": "https://vaultmemoryai.com/api/mcp",
+      "headers": {
+        "Authorization": "Bearer ${VAULT_GO_TOKEN}"
       }
     }
   }
 }
 ```
 
-Para ambientes efêmeros, `VAULT_GO_TOKEN` aceita um access token de sessão ou
-uma chave `vg_live_...` criada na tela **Segurança > Chaves de API**. Use
-somente os escopos necessários: `memory:read` para pesquisa/contexto,
-`memory:write` para eventos e lembranças e `memory:delete` para exclusão.
-`VAULT_GO_API_URL` troca o endpoint. O login normal permite renovação
-automática; a chave de API é indicada para automações com prazo e escopo
-limitados.
-
-## Ferramentas MCP
-
-- `vault_go_status`: conexão e autenticação sem expor credenciais.
-- `vault_go_cloud_health`: disponibilidade da plataforma.
-- `vault_go_projects` e `vault_go_project_create`: projetos da conta.
-- `vault_go_session_start` e `vault_go_session_end`: ciclo de sessão.
-- `vault_go_event`: eventos de prompt, ferramenta e resultado.
-- `vault_go_remember`: observações, decisões, descobertas e resumos.
-- `vault_go_search`: busca textual com ranking e trechos.
-- `vault_go_search_index`: índice compacto com filtros, trechos e custo estimado.
-- `vault_go_observations`: carrega em lote somente os IDs selecionados.
-- `vault_go_timeline`: contexto anterior e posterior a uma memória.
-- `vault_go_context`: contexto progressivo com limite de caracteres.
-- `vault_go_file_context`: histórico ligado aos arquivos lidos ou modificados.
-- `vault_go_stats`: contagens isoladas da conta.
-- `vault_go_jobs`: fila PostgreSQL da conta, sem payload sensível.
-- `vault_go_job_retry` e `vault_go_job_cancel`: controle idempotente do processamento.
-- `vault_go_export` e `vault_go_import`: transporte JSON tenant-scoped, atômico e idempotente.
-- `vault_go_embedding_status` e `vault_go_embedding_backfill`: busca híbrida e fila vetorial, sem expor chaves.
-- `vault_go_feed`: pagina memórias recentes por projeto, tipo e origem.
-- `vault_go_knowledge_bases` e `vault_go_knowledge_base`: lista e abre bases focadas.
-- `vault_go_knowledge_build` e `vault_go_knowledge_rebuild`: cria ou atualiza uma base a partir de filtros.
-- `vault_go_knowledge_query`: recupera contexto fundamentado e citações dentro da base.
-- `vault_go_knowledge_delete`: remove a base e preserva as memórias originais.
-- `vault_go_forget`: exclusão explícita de uma memória.
-- `vault_go_engines`: lista motores de contexto (Vault AI, Claude, OpenRouter, Gemini, ChatGPT/Codex) sem revelar chaves.
-- `vault_go_engine_select`: escolhe o motor local (`vault-ai-resume`, `claude-subscription`, `openai-subscription`, `openrouter`, `gemini`).
-- `vault_go_generate_context`: gera título, fatos e conceitos com o motor escolhido; não persiste memória sozinho.
-
-O seletor oferece Codex (Terra, Luna ou Sol pela assinatura ChatGPT), Claude (CLI da assinatura), OpenRouter (chave), Gemini (chave) ou o Vault AI Resume da conta, quando disponível no servidor. Grave chaves com `vault-go engine key openrouter|gemini` ou no painel local; as ferramentas MCP não aceitam segredos.
-
-Na instalação, o Vault Go registra hooks no Claude Code, no Codex, no Grok, no Agy e no Gemini CLI. Eles carregam contexto e capturam os eventos oferecidos pelo cliente; o serviço local (`http://localhost:38850`) gera memórias com o motor escolhido, persistindo no Vault. No OpenCode 1.x, um plugin acrescenta contexto ao sistema antes das chamadas do modelo; esse adaptador não adiciona captura automática.
-
-Também há [captura persistente opt-in de transcripts Claude/Codex e contexto entre projetos](docs/transcripts-and-context.md), com comandos CLI e MCP, checkpoints privados e consentimento por workspace/conta. Ativar esses recursos preserva o motor/modelo escolhido.
-
-O recurso `vault-go://status` fornece o resumo sanitizado em JSON.
-
-Para reduzir o uso de contexto, prefira a recuperação em três camadas:
-
-1. Pesquise com `vault_go_search_index`, usando projeto, origem, conceitos,
-   arquivos e intervalo de datas quando conhecidos.
-2. Abra `vault_go_timeline` somente para os resultados que precisam de
-   contexto cronológico.
-3. Envie os IDs escolhidos a `vault_go_observations` para carregar o conteúdo
-   completo em um único lote tenant-scoped.
-
-As bases, filtros, vínculos e feed ficam exclusivamente no PostgreSQL da
-plataforma. A consulta retorna evidências e `synthesisAvailable: false`; o
-cliente MCP faz a síntese, evitando respostas inventadas e chaves ocultas no
-servidor. A síntese do servidor só será habilitada quando um provedor semântico
-for configurado explicitamente.
-
-## Fluxo integrado
+Remote MCP exposes projects, search, context, recents, feed, timeline, tool I/O, file context, stats, embeddings, and knowledge-base queries. Automatic capture, knowledge-base writes, import, and delete require the local Bun server.
+
+`VAULT_GO_TOKEN` accepts a session token or a `vg_live_...` key. Use only the scopes you need: `memory:read`, `memory:write`, `memory:delete`. `VAULT_GO_API_URL` changes the API host. Browser login refreshes automatically; API keys are for scoped automation.
+
+### Vault Desktop (Crystal)
+
+On an updated Vault Desktop, enable **Crystal → MCP → Enable in Vault MCP** and reconnect the MCP client. Crystal note tools (`vault_go_crystal_list`, `read`, `search`, `write`, `delete`, `sync`, `status`) appear next to memory tools. Desktop must stay open on the same machine. No second server or copied secret is required. Disabling the integration revokes that connection.
+
+## How it works
 
 ```text
-Cliente MCP -> vault-go (Bun) -> API autenticada (Bun)
-                              -> engine interno (Rust)
-                              -> PostgreSQL no EasyPanel
+AI client  →  vault-go (local MCP)
+                  ↓
+           Vault Memory API (authenticated)
+                  ↓
+           Memory engine  →  your account store
 ```
 
-O engine não possui rota pública. A API valida o JWT do usuário, substitui-o
-por uma credencial interna e informa ao engine a conta autenticada. Todas as
-consultas aplicam esse identificador, impedindo leitura entre contas.
+The engine has no public route. The API authenticates you, then scopes every query to that account. Clients cannot read another account’s memories.
+
+Setup also installs session hooks on Claude Code, Codex, Grok, Agy, and Gemini CLI. Those hooks load project context and capture supported events. The local worker at `http://localhost:38850` generates memories with the selected engine and writes them to Vault Memory. OpenCode 1.x gets a context-only plugin; it does not capture automatically.
 
-## Segurança
+Prefer three-step retrieval to keep context small:
 
-- Não retorna access token nem refresh token em ferramentas ou recursos.
-- Aceita HTTPS; HTTP somente em localhost.
-- Renova o access token usando o refresh token local com permissão privada.
-- Limita tamanhos, listas e janelas nos schemas das ferramentas.
-- Reserva `stdout` exclusivamente para o protocolo MCP.
-- O painel guarda cache de projetos/memórias e metadados de chamadas MCP em arquivos privados locais.
+1. `vault_go_search_index` with project, type, concepts, files, or dates.
+2. `vault_go_timeline` only around the hits that need nearby context.
+3. `vault_go_observations` for the selected IDs.
 
-Instale o MCP apenas em clientes confiáveis: o cliente conectado pode pedir
-busca, gravação e exclusão de memórias dentro da conta autenticada.
+## Context engines
 
-## Desenvolvimento
+List and select engines without putting API keys in MCP tools:
 
 ```sh
-npm install
-bun run typecheck
-bun test src
-bun run build
-npm run pack:check
+vault-go engine list
+vault-go engine use openrouter
+vault-go engine use codex --model terra
+vault-go engine key openrouter
 ```
 
-## Publicação automática
+| Engine | How it authenticates |
+| --- | --- |
+| Vault AI Resume | Vault account entitlement |
+| Claude | `claude auth login` (subscription CLI) |
+| Codex / ChatGPT | `codex login` — models `terra`, `luna`, `sol` (CLI 0.155.1+) |
+| OpenRouter | key stored with `vault-go engine key openrouter` |
+| Gemini | key stored with `vault-go engine key gemini` |
 
-Pushes em `main` passam por CI. Commits convencionais acionam release
-semântica, publicação no npm, tag e GitHub Release:
+MCP tools never accept secrets. Store keys with the CLI or the local dashboard. Provider usage limits apply. Managed Vault AI generation still depends on server configuration and quota.
 
-- `fix:` gera patch;
-- `feat:` gera minor;
-- `feat!:` ou `BREAKING CHANGE:` gera major.
+## MCP tools
 
-O segredo `NPM_TOKEN` existe apenas no GitHub Actions e nunca deve ser salvo no
-repositório ou em logs.
+Account and health: `vault_go_status`, `vault_go_cloud_health`, `vault_go_preferences`, `vault_go_preferences_update`.
 
+Projects and sessions: `vault_go_projects`, `vault_go_project_create`, `vault_go_session_start`, `vault_go_session_end`, `vault_go_session_start_context`.
 
-## Painel local · localhost:38850
+Capture and recall: `vault_go_event`, `vault_go_remember`, `vault_go_forget`, `vault_go_search`, `vault_go_search_index`, `vault_go_observations`, `vault_go_timeline`, `vault_go_context`, `vault_go_file_context`, `vault_go_feed`, `vault_go_memory`, `vault_go_tool_uses`, `vault_go_stats`.
 
-```sh
-bunx --bun vault-go@latest setup --lang pt
-bunx --bun vault-go@latest local install
-bunx --bun vault-go@latest local open
-bunx --bun vault-go@latest local status
-bunx --bun vault-go@latest local stop
-bunx --bun vault-go@latest local uninstall
-```
+Knowledge bases: `vault_go_knowledge_bases`, `vault_go_knowledge_base`, `vault_go_knowledge_build`, `vault_go_knowledge_rebuild`, `vault_go_knowledge_query`, `vault_go_knowledge_delete`, `vault_go_prime_corpus`, `vault_go_query_corpus`, `vault_go_reprime_corpus`.
+
+Jobs and backup: `vault_go_jobs`, `vault_go_job`, `vault_go_job_retry`, `vault_go_job_cancel`, `vault_go_processing_status`, `vault_go_observer_status`, `vault_go_export`, `vault_go_import`, `vault_go_backup_create`, `vault_go_backup_restore`, `vault_go_embedding_status`, `vault_go_embedding_backfill`.
+
+Engines and updates: `vault_go_engines`, `vault_go_engine_select`, `vault_go_generate_context`, `vault_go_update_status`, `vault_go_update_check`, `vault_go_update_install`, `vault_go_update_configure`.
 
-O assistente e a página de retorno do login suportam `--lang pt|en|es`.
-O painel detecta o idioma do navegador e oferece seletor PT/EN/ES, busca
-local, atividade MCP recente, projetos e memórias consultados na nuvem.
-Atualiza a interface a cada 5 segundos enquanto visível e consulta a nuvem
-a cada 15 segundos. Sem conexão, conserva o último cache da mesma conta.
-
-Abra http://localhost:38850 e clique em **Conectar ao Vault** para entrar pelo navegador. A senha permanece no portal; o painel libera a sessão somente após confirmar o retorno OAuth com PKCE. A tela oferece próximos passos para configurar clientes e registrar a primeira memória. A logo e as cores são as mesmas do portal.
-
-O serviço escuta exclusivamente em 127.0.0.1:38850. `local open` verifica
-uma prova criptográfica do serviço e abre uma sessão privada no navegador;
-o segredo local é removido do fragmento imediatamente e trocado por cookie
-HttpOnly/SameSite=Strict. Não há CORS nem acesso direto da nuvem ao localhost.
-O portal `/app/local` abre o painel da máquina atual.
-
-No macOS, `local install` registra um LaunchAgent do usuário. Em Linux e
-Windows, inicia o serviço nesta sessão; após reiniciar, use `local start`.
-O runtime fica em `~/.memvault/local-runtime`, independente do cache bunx.
-`local stop` para o processo; `local uninstall` remove o início automático e
-preserva autenticação, cache e atividade. A atualização automática mantém o
-serviço e os hooks atualizados; clientes MCP abertos precisam reconectar.
-Após validar a nova versão do serviço, a atualização também repara os hooks do
-Gemini e o plugin do OpenCode quando esses clientes já têm o MCP Vault configurado.
-Plugins de terceiros são preservados. Reinicie clientes abertos para carregar
-novos hooks ou o módulo atualizado do plugin.
-
-A atividade registra método, rota, duração e resultado das chamadas feitas
-pelo MCP Vault, sem argumentos, consultas ou credenciais. Não captura toda a
-atividade da máquina nem importa automaticamente o banco do claude-mem em
-37701. A sincronização deste painel é de leitura da nuvem; as ferramentas
-MCP continuam responsáveis pelas gravações na API.
-
-### Sessões, dispositivos e proteção local
-
-**Sair** encerra a sessão desta página e cancela suas prévias de contexto.
-**Desconectar dispositivo** pede confirmação, revoga as credenciais do agente
-na nuvem e remove a autenticação e o cache local após sucesso. Os arquivos
-pessoais permanecem intactos. Para reconectar, entre novamente pelo navegador.
-O portal mostra último contato, permissões e permite revogar cada agente.
-
-O cache e a credencial de monitoramento usam AES-256-GCM. No macOS, a chave
-fica no Keychain; nos demais sistemas, em arquivo privado `0600`. Os tokens
-MCP existentes continuam em arquivo privado. O painel informa essas diferenças:
-cache cifrado não significa que todas as memórias sejam criptografadas ponta a
-ponta. O cofre de arquivos e o canal do terminal têm seus próprios protocolos.
-
-### Motor de contexto
-
-Escolha **Vault AI Resume**, **Claude Subscription** ou **OpenAI Subscription**
-no painel local. A disponibilidade é verificada antes da geração. Claude usa
-`claude auth login`; OpenAI usa `codex login` com uma conta ChatGPT. O agente
-não pede nem copia credenciais desses provedores. O modelo gerenciado depende
-de configuração e quota no servidor Vault.
-
-A prévia manual exige texto informado pelo usuário, usa diretório temporário,
-limites de entrada/saída e timeout, e permite cancelamento. CLIs recebem apenas
-o texto informado, com ferramentas/configurações locais desativadas conforme
-os recursos suportados. O resultado é uma prévia privada da sessão, disponível
-para copiar; não é salvo automaticamente como memória. Os planos e limites do
-provedor escolhido se aplicam. Cancelar não garante estorno de uso já iniciado.
-
-
-## Contexto automático e processamento
-
-Os hooks SessionStart leem o contexto do projeto no início, retomada e compactação
-conforme os eventos oferecidos pelo cliente. O hook anterior à leitura de arquivos
-é síncrono para conseguir inserir o contexto. `vault_go_session_start_context`
-executa o mesmo leitor, respeitando `contextItems` e `contextMaxChars` da conta.
-
-Claude, Codex e Gemini mostram uma confirmação quando o contexto é carregado,
-sem exibir conteúdo da memória nessa confirmação. Worktrees Git reutilizam o
-projeto do repositório principal; se ele ainda não estiver cadastrado, um projeto
-existente do próprio worktree continua legível. Submódulos mantêm seu projeto.
-
-O Gemini usa `SessionStart`, `BeforeAgent`, `AfterTool` e `AfterAgent`, conforme
-seu [contrato de hooks](https://geminicli.com/docs/hooks/reference/). Não há
-injeção de histórico de arquivo em `BeforeTool`, pois esse evento não oferece
-esse contrato. O plugin OpenCode usa `experimental.chat.system.transform`
-do [contrato 1.x](https://github.com/anomalyco/opencode/blob/v1.18.31/packages/plugin/src/index.ts),
-com prazo de três segundos e continuação normal em caso de falha. Consultas
-simultâneas da mesma sessão são compartilhadas; respostas de uma credencial
-substituída não são injetadas. Clientes sem esses adaptadores acessam memória
-pelas ferramentas MCP, sem promessa de contexto automático.
-
-A captura respeita `automaticCapture`, `captureMode` e a opção de incluir resultados
-de ferramentas. Uma falha ao consultar preferências desativa aquela captura.
-Eventos privados não são enviados; campos sensíveis e marcadores privados são
-removidos antes do processamento. A redação é heurística, não uma garantia de
-reconhecimento de qualquer formato de segredo.
-
-O worker processa uma fila privada persistente com o motor selecionado. A geração
-bem-sucedida é conservada para repetir somente a gravação quando a rede falha;
-a importação usa uma chave idempotente. A troca de conta não transfere jobs entre
-contas. Jobs antigos são adotados apenas após confirmar que o projeto pertence
-à conta autenticada. `summaryMode=off` preserva o conteúdo capturado sem chamar
-modelo. `vault_go_processing_status` mostra pendências e falhas sem seu conteúdo.
+Graph and local code: `vault_go_graph`, `vault_go_graph_link`, `vault_go_graph_link_delete`, `vault_go_graph_presets`, `vault_go_graph_preset_save`, `vault_go_smart_outline`, `vault_go_smart_unfold`, `vault_go_smart_search`, `vault_go_smart_languages`.
+
+Workflows: `vault_go_workflow`, `vault_go_modes`, `vault_go_mode`, plus named prompts such as `vault_go_babysit`. Loading a mode gives the agent instructions; it does not start a background job.
+
+Optional local integrations (explicit consent): Telegram alerts, custom mode taxonomies, Claude/Codex transcript watchers, multi-project context chains, and Grok awareness logs. See `vault_go_capabilities` for what is configured on this machine.
+
+The `vault-go://status` resource is a sanitized JSON summary.
+
+## Local dashboard
 
 ```sh
-vault-go engine use codex --model terra
-vault-go engine model luna
-vault-go engine model sol
+vault-go local install
+vault-go local open
+vault-go local status
+vault-go local stop
+vault-go local uninstall
 ```
 
-No MCP, use `vault_go_engine_select` com `engine: "openai-subscription"` e
-`model: "terra"`, `"luna"` ou `"sol"`. Requer `codex login` com ChatGPT e a CLI
-0.155.1 ou superior no PATH usado pelo serviço. Instalações antigas que aparecem
-antes no PATH são detectadas antes da geração. O modelo padrão do Codex é Terra.
-Os limites de uso da assinatura se aplicam. O processamento gerenciado Vault AI
-continua dependendo de configuração e quota no servidor.
+Open [http://localhost:38850](http://localhost:38850) and choose **Connect to Vault**. The service listens only on `127.0.0.1:38850`. `local open` proves the local process cryptographically, then uses an HttpOnly / SameSite=Strict cookie. There is no CORS and no inbound path from the cloud to localhost.
 
-## Atualização automática
+The dashboard follows the browser language (pt / en / es) and can switch locale. It shows local search, recent MCP activity, and cloud projects/memories for the signed-in account. While visible it refreshes the UI every 5 seconds and the cloud every 15 seconds. Offline, it keeps the last cache for that account.
 
-O worker verifica diariamente a versão estável no registro npm oficial. Prepara
-uma instalação de versão exata em `~/.memvault/releases`, sem executar scripts
-do pacote, valida a estrutura e executa um teste de inicialização. Ativa a versão
-quando o worker e a fila estão ociosos. Uma falha na inicialização restaura o runtime
-anterior. A autenticação, as preferências e a fila são preservadas.
+On macOS, `local install` registers a user LaunchAgent. On Linux and Windows it starts for this session; use `local start` after reboot. Runtime files live in `~/.memvault/local-runtime`. Uninstall removes autostart and keeps auth, cache, and activity.
 
-Requer npm instalado e acesso ao registro oficial. A verificação começa um minuto
-após iniciar o worker; uma tentativa pendente é reconsiderada a cada hora. Os
-clientes MCP em execução precisam reconectar para carregar novas ferramentas.
+**Sign out** ends this browser session and cancels its context previews. **Disconnect device** revokes the cloud device credential and, after success, removes local auth and cache. Personal files are left in place. Reconnect through the browser.
+
+## Capture and processing
+
+SessionStart hooks load project context on start, resume, and compact when the client offers those events. File-read hooks are synchronous so context can be injected. `vault_go_session_start_context` is the same reader, using the account `contextItems` and `contextMaxChars` budget.
+
+Claude, Codex, and Gemini confirm that context loaded without printing memory contents. Git worktrees reuse the canonical repository project. Submodules keep their own project.
+
+Capture honors `automaticCapture`, `captureMode`, and whether tool results are included. A preference lookup failure disables that capture. Private events are not sent. Sensitive fields and private markers are stripped before processing (heuristic redaction, not a guarantee for every secret format).
+
+The worker drains a private queue with the selected engine. Successful generation is cached so a network retry does not call the model again. Import uses an idempotency key. Account switches do not move jobs between accounts. `summaryMode=off` stores captured text without calling a model. `vault_go_processing_status` reports counts, not contents.
+
+Opt-in Claude/Codex transcript watchers and project context chains are configured with MCP/CLI and stay bound to the current account.
+
+## Automatic updates
+
+The worker checks the official npm registry daily for a stable `vault-go` release, stages an exact version under `~/.memvault/releases` without running package install scripts, validates it, and activates when idle. A failed start rolls back. Auth, preferences, and the queue are kept. Open MCP clients must reconnect to load new tools.
 
 ```sh
 vault-go update status
@@ -398,78 +204,31 @@ vault-go update off
 vault-go update on
 ```
 
-As mesmas operações estão no MCP: `vault_go_update_status`, `vault_go_update_check`,
-`vault_go_update_install` e `vault_go_update_configure`. Instalação manual pode
-reiniciar o serviço; a atualização automática espera o processamento terminar.
-
-## Auditoria do claude-mem e ferramentas adicionais
-
-A comparação usa o código do claude-mem 13.25.2, commit
-`adce0fdfaf1cd46646bbd0b22ae74cbd460ed787`. A matriz acessível em
-`vault_go_capabilities` e no recurso `vault-go://capabilities` distingue funções
-implementadas e suas dependências. `deploymentVerified` resulta de consultas aos
-contratos da API/engine conectados, com cache privado de cinco minutos por conta;
-não presume autenticação dos provedores nem entrega de notificações. O recurso
-MCP lê somente o cache; a ferramenta verifica por padrão.
-
-Além das ferramentas acima, o MCP inclui:
-
-- `vault_go_workflow`: guia de recuperação progressiva.
-- `vault_go_tool_uses`: dados originais redigidos de ferramentas, por ID do evento,
-  memória vinculada ou chave externa; depende da captura histórica disponível.
-- `vault_go_memory`: abre uma memória por UUID.
-- `vault_go_preferences` / `vault_go_preferences_update`: captura e orçamento de contexto.
-- `vault_go_observer_status` / `vault_go_processing_status`: processamento remoto e local.
-- `vault_go_graph`, `vault_go_graph_link`, `vault_go_graph_link_delete`,
-  `vault_go_graph_presets` e `vault_go_graph_preset_save`: leitura e manutenção do grafo.
-- `vault_go_smart_outline`, `vault_go_smart_unfold` e `vault_go_smart_search`:
-  exploração AST local. Search aceita padrões estruturais como `console.log($ARG)`;
-  `filePattern` é glob. As ferramentas informam linguagens suportadas e truncamento,
-  limitam leitura ao workspace e bloqueiam caminhos privados e escapes por symlink.
-
-A busca aceita `query` opcional, `offset` e `orderBy`. A timeline também pode
-localizar a âncora por consulta. `vault_go_job` consulta um job individual.
-`vault_go_prime_corpus`, `vault_go_query_corpus` e `vault_go_reprime_corpus`
-respondem com o modelo escolhido, citações e histórico local cifrado de até 12 turnos.
-
-`vault_go_backup_create` salva todas as páginas de um snapshot consistente em
-arquivo privado, com SHA-256 e cobertura declarada. `vault_go_backup_restore`
-valida hash e proprietário antes de alterar preferências ou dados. Snapshots têm
-TTL de uma hora e limite explícito de 100 mil registros; exceder limites retorna
-erro, sem apresentar um backup truncado como completo. O formato é próprio do
-Vault; não equivale ao SQLite upstream nem a uma réplica offline.
-
-Telegram, CCS Align e taxonomias herdadas têm integrações locais próprias; veja
-[integrações de modos](docs/mode-integrations.md). Watchers de Claude/Codex e
-contexto entre projetos são configuráveis com consentimento; veja
-[transcripts e contexto](docs/transcripts-and-context.md). O [scan completo](docs/claude-mem-upstream-scan.md)
-registra os contratos upstream; a matriz MCP descreve a implementação atual.
-
-
-## Modos e skills padrão no MCP
-
-O pacote inclui 20 workflows originais adaptados ao Vault. Liste com
-`vault_go_modes` e carregue com `vault_go_mode`, por exemplo:
+## Security
 
-```json
-{"name":"babysit","task":"Acompanhe os checks e revisões do PR solicitado."}
-```
+- Tools and resources never return access or refresh tokens.
+- HTTPS only, except HTTP on localhost.
+- Access tokens refresh from a private local refresh token.
+- Tool schemas bound sizes, lists, and windows.
+- `stdout` is reserved for the MCP protocol.
+- The dashboard cache uses AES-256-GCM (macOS Keychain, elsewhere a `0600` file). Encrypted cache is not the same as end-to-end encryption of every memory.
 
-Clientes com suporte a prompts também recebem `vault_go_babysit`,
-`vault_go_mem_search`, `vault_go_make_plan` e os demais nomes do catálogo.
-O recurso `vault-go://modes` expõe requisitos e limitações de cada workflow.
-Carregar um modo entrega instruções ao agente; não inicia execução independente.
+Install this MCP only on clients you trust: a connected client can search, write, and delete memories in the signed-in account.
+
+## Development
+
+```sh
+npm install
+bun run typecheck
+bun test src
+bun run build
+npm run pack:check
+```
 
-Incluídos: babysit, mem-search, how-it-works, make-plan, do, smart-explore,
-knowledge-agent, standup, timeline-report, weekly-digests, learn-codebase,
-pathfinder, design-is, what-the, version-bump, oh-my-issues, cloud-sync,
-mode-creator, ccs-align e wowerpoint.
+Pushes to `main` run CI. Conventional commits publish to npm (`fix` → patch, `feat` → minor, `BREAKING CHANGE` → major). `NPM_TOKEN` lives only in GitHub Actions.
 
-Babysit exige acesso do cliente ao GitHub por `gh` ou conector e acompanha o PR
-enquanto a solicitação está ativa. `mode-creator` instala taxonomias herdadas e
-`ccs-align` mantém cache, exclusões e relatório de regras por viewer. Wowerpoint
-ainda depende de um renderer de apresentação do cliente, e cmem.ai continua sendo
-um serviço distinto. Ações externas seguem a autorização da tarefa; carregar um
-prompt não envia mensagens, publica versões ou faz merge.
+## Links
 
-A validação e as diferenças de arquitetura estão na [revisão de implantação](docs/parity-deployment-review.md).
+- Product: [https://vault.resolveup.com.br](https://vault.resolveup.com.br)
+- Source: [https://github.com/resolveup-cloud/vault-go](https://github.com/resolveup-cloud/vault-go)
+- npm: [https://www.npmjs.com/package/vault-go](https://www.npmjs.com/package/vault-go)

package/dist/smart-code.js

@@ -2,6 +2,7 @@ import { Lang, parse, registerDynamicLanguage } from '@ast-grep/napi';
 import { createRequire } from 'node:module';
 import { readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
 const BUILTIN_LANGUAGES = [
     { name: 'JavaScript', parser: Lang.JavaScript, extensions: ['.js', '.jsx', '.mjs', '.cjs'] },
     { name: 'TypeScript', parser: Lang.TypeScript, extensions: ['.ts', '.mts', '.cts'] },
@@ -29,16 +30,19 @@ const DYNAMIC_LANGUAGES = [
     { name: 'Sql', parser: 'sql', extensions: ['.sql'], packageName: '@ast-grep/lang-sql' },
     { name: 'Markdown', parser: 'markdown', extensions: ['.md', '.mdx'], packageName: '@ast-grep/lang-markdown' },
     { name: 'Zig', parser: 'zig', extensions: ['.zig'], packageName: '@tree-sitter-grammars/tree-sitter-zig', binding: '@tree-sitter-grammars+tree-sitter-zig' },
-    { name: 'Scss', parser: 'scss', extensions: ['.scss'], packageName: 'tree-sitter-scss', binding: 'tree-sitter-scss' },
+    { name: 'Scss', parser: 'scss', extensions: ['.scss'], packageName: 'tree-sitter-scss', binding: 'tree-sitter-scss', bundled: true },
 ];
 // Register the complete allowlisted set once. No path from a workspace/config is loaded as executable grammar code.
 const grammarRequire = createRequire(import.meta.url);
+const bundledGrammarRoot = fileURLToPath(new URL('../grammars/', import.meta.url));
 const unavailable = new Set();
 const registrations = {};
 for (const language of DYNAMIC_LANGUAGES) {
     try {
         const grammar = language.binding ? {
-            libraryPath: join(dirname(grammarRequire.resolve(`${language.packageName}/package.json`)), 'prebuilds', `${process.platform}-${process.arch}`, `${language.binding}.node`),
+            libraryPath: language.bundled
+                ? join(bundledGrammarRoot, language.parser, 'prebuilds', `${process.platform}-${process.arch}`, `${language.binding}.node`)
+                : join(dirname(grammarRequire.resolve(`${language.packageName}/package.json`)), 'prebuilds', `${process.platform}-${process.arch}`, `${language.binding}.node`),
             extensions: language.extensions.map(ext => ext.slice(1)), languageSymbol: `tree_sitter_${language.parser}`, expandoChar: '_',
         } : grammarRequire(language.packageName);
         statSync(grammar.libraryPath);

package/grammars/scss/NOTICE

@@ -0,0 +1,3 @@
+Prebuilt Tree-sitter SCSS grammars redistributed from tree-sitter-scss@1.0.0 (MIT).
+Source: https://www.npmjs.com/package/tree-sitter-scss
+Vault Go loads these platform prebuilds at runtime and does not compile tree-sitter-css.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vault-go",
-  "version": "0.22.0",
-  "description": "Servidor MCP universal com autenticação e instalação multi-cliente para a plataforma Vault.",
+  "version": "0.22.2",
+  "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {
     "vault-go": "dist/index.js",
@@ -78,7 +78,6 @@
     "dist/server.d.ts",
     "assets/",
     "README.md",
-    "docs/mode-integrations.md",
     "LICENSE",
     "dist/mcp-result.js",
     "dist/mcp-result.d.ts",
@@ -114,7 +113,6 @@
     "dist/transcript-tools.d.ts",
     "dist/context-chain.js",
     "dist/context-chain.d.ts",
-    "docs/transcripts-and-context.md",
     "dist/capture-privacy.js",
     "dist/capture-privacy.d.ts",
     "dist/deployment-verification.js",
@@ -123,8 +121,7 @@
     "dist/grok-awareness.d.ts",
     "dist/awareness-tools.js",
     "dist/awareness-tools.d.ts",
-    "docs/ast-and-awareness.md",
-    "docs/parity-deployment-review.md"
+    "grammars/"
   ],
   "scripts": {
     "clean": "bun -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
@@ -156,6 +153,7 @@
     "model-context-protocol",
     "memory",
     "vault",
+    "vault-memory",
     "memvault",
     "knowledge",
     "codex",
@@ -190,7 +188,6 @@
     "@ast-grep/napi": "0.45.3",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@tree-sitter-grammars/tree-sitter-zig": "1.1.2",
-    "tree-sitter-scss": "1.0.0",
     "zod": "3.25.76"
   },
   "devDependencies": {

package/docs/ast-and-awareness.md

@@ -1,72 +0,0 @@
-# AST completo e awareness local do Grok
-
-## Idiomas AST
-
-`vault_go_smart_languages` publica o catálogo e a disponibilidade real na plataforma. `smart_outline`, `smart_unfold` e `smart_search` usam grammars Tree-sitter carregadas pelo ast-grep; indisponibilidade nunca vira parsing por regex. Os limites anteriores de workspace, arquivos privados, bytes, quantidade de arquivos/símbolos e tamanho da saída continuam valendo.
-
-| Idioma | Extensões |
-| --- | --- |
-| JavaScript | `.js`, `.jsx`, `.mjs`, `.cjs` |
-| TypeScript | `.ts`, `.mts`, `.cts` |
-| TSX | `.tsx` |
-| HTML | `.html`, `.htm` |
-| CSS | `.css` |
-| Python | `.py`, `.pyw` |
-| Go | `.go` |
-| Rust | `.rs` |
-| Ruby | `.rb` |
-| Java | `.java` |
-| C | `.c`, `.h` |
-| C++ | `.cpp`, `.cc`, `.cxx`, `.hpp`, `.hh` |
-| Kotlin | `.kt`, `.kts` |
-| Swift | `.swift` |
-| PHP | `.php` |
-| Lua | `.lua` |
-| Scala | `.scala`, `.sc` |
-| Bash | `.sh`, `.bash`, `.zsh` |
-| Haskell | `.hs` |
-| TOML | `.toml` |
-| YAML | `.yml`, `.yaml` |
-| SQL | `.sql` |
-| Markdown | `.md`, `.mdx` |
-| Zig | `.zig` |
-| SCSS | `.scss` |
-
-Isso cobre os 24 idiomas do `LANG_MAP` upstream, além do HTML que o Vault já suportava. `.mdx` usa a grammar Markdown e `.zsh` usa Bash, como no upstream; não promete validar extensões próprias de MDX/Zsh.
-
-JS/TS/TSX/HTML/CSS usam as grammars de `@ast-grep/napi`. Dezoito outras usam pacotes oficiais `@ast-grep/lang-*`, fixados no `package.json`/lock. Zig e SCSS usam os símbolos C `tree_sitter_zig` e `tree_sitter_scss` exportados pelos prebuilds dos pacotes `@tree-sitter-grammars/tree-sitter-zig@1.1.2` e `tree-sitter-scss@1.0.0`. Carregar esses símbolos diretamente permite usar o mesmo AST/matcher do ast-grep, sem compilar ou executar scripts de instalação.
-
-Os prebuilds são dependências do MCP instalado. O worker local e a fila não importam o parser nem essas dependências. `npm ci --ignore-scripts` é suportado nos sistemas com prebuild compatível. O pacote SCSS não publica prebuild Linux ARM64; ali o catálogo informa indisponibilidade e operações diretas falham explicitamente. Outros alvos também dependem da presença e compatibilidade do prebuild: não há download ou compilação automática durante o uso. Todos os 25 foram verificados nesta implementação em macOS ARM64.
-
-Os nomes/símbolos, corpos e posições vêm de nós e campos da árvore. Markdown usa a árvore de seções para desdobrar uma seção completa. Buscas com metavariáveis foram verificadas também em Python, Go, Zig e SCSS, incluindo a distinção entre chamadas reais e textos em comentários/strings.
-
-O registro segue a [API oficial do ast-grep](https://ast-grep.github.io/guide/api-usage/js-api): todas as grammars são registradas juntas uma vez por processo. Os [pacotes oficiais de grammars](https://github.com/ast-grep/langs) fornecem os parsers pré-compilados. Nenhuma biblioteca escolhida por caminho de workspace/configuração é carregada como código executável.
-
-## Awareness do Grok
-
-Awareness é escrita local de uma linha factual em `agents/<UUID>/memory/log/YYYY-MM.md`, consumida pelo agente Grok. Não é uma integração Telegram.
-
-1. Use `vault_go_grok_awareness_configure` com `enabled=true`, `consent=true`, `agentDataRoot` absoluto existente, `agentIds` permitidos e ao menos um filtro em `triggerTypes` ou `triggerConcepts`.
-2. Use `vault_go_grok_awareness_push` com `agentId` permitido e `memoryIds` UUID para enviar memórias já existentes na conta autenticada.
-3. Consulte `vault_go_grok_awareness_status` ou desative com `enabled=false`.
-
-Nada é ativado por padrão. Não há escolha automática de diretório ou agentes piloto. O consentimento fica em `grok-awareness.json`, privado e específico da conta. Troca de conta revoga o consentimento local. A leitura MCP confere também a credencial antes/depois da API, impedindo publicar um resultado recebido durante troca de conta.
-
-Hooks que recebem `agent_id`/`agentId` preservam esse agente na fila. Após persistir a memória no Vault, a fila envia o fato apenas ao agente correspondente e permitido; não faz broadcast. O pipeline atual grava essas memórias como `discovery`, portanto a automação usa esse tipo e os conceitos gerados. O push por IDs preserva o `memoryType` armazenado e atende aos demais tipos, como `decision` ou `bugfix`. Sem identidade de agente, a fila não escreve awareness.
-
-Cada linha usa a forma `- YYYY-MM-DD [awareness] tipo — título: subtítulo. primeiro fato`, com whitespace colapsado e até 500 caracteres. Flags/blocos privados são rejeitados; credenciais usam a mesma redação da captura. A deduplicação compara o corpo, ignorando a data, dentro do log mensal. O mês usa UTC. `profile.md` não é alterado.
-
-O writer limita lotes a 100 observações e arquivos mensais a 1 MiB, valida a raiz e todos os diretórios descendentes, recusa symlinks/hardlinks de logs e usa lock entre processos e substituição atômica com arquivos 0600. Conteúdo anterior é preservado. Um log cheio ou destino inacessível produz `awareness_write_failed`, sem conteúdo sensível no status. Falha depois da persistência mantém o job para retry; o resultado do modelo já gerado é reutilizado e a importação mantém sua chave idempotente. Desativar awareness permite concluir esses jobs sem nova escrita local. Outros processos que escrevam o mesmo log precisam coordenar acesso para garantir ausência de sobrescrita concorrente.
-
-## Fontes e validação
-
-Contrato upstream consultado no SHA `adce0fdfaf1cd46646bbd0b22ae74cbd460ed787`:
-
-- `src/services/smart-file-read/parser.ts`: `LANG_MAP`, grammars e queries de símbolos.
-- `src/services/integrations/GrokBotAwarenessPusher.ts`: filtros, linha limitada, destino mensal, allowlist e deduplicação.
-- `src/services/worker/agents/ResponseProcessor.ts`: envio vinculado a `pendingAgentId`, após persistência.
-- `tests/integrations/grok-bot-awareness-pusher.test.ts`: casos do writer upstream.
-
-Fixtures do Vault verificam outlines/desdobramento de todos os idiomas, busca estrutural, consentimento/filtros, privacidade, conta, concorrência, rotação, caminho malicioso, retomada sem regeneração, MCP e carregamento do worker staged sem `node_modules`. Nenhum log de agente ou configuração da instalação real foi modificado. A revisão multimodelo foi substituída por revisão manual, pois o gateway LiteLLM não está configurado neste ambiente.
-
-Validação em 2026-09-20 sobre a base `8f08e19341eed95164ee9a77cf178486adeddb0f`: instalação limpa `npm ci --ignore-scripts`, `bun run build`, 178 testes / 1323 assertions (`bun test src`), `git diff --check` e pacote npm passaram. `npm audit --omit=dev` retornou zero vulnerabilidades. A validação posterior à instalação limpa confirmou que as grammars funcionam sem postinstall; o subprocesso staged confirmou que fila/awareness não precisam dessas dependências no worker.

package/docs/mode-integrations.md

@@ -1,74 +0,0 @@
-# Integrações de modos
-
-O Vault Go implementa três superfícies locais independentes: alertas Telegram,
-CCS Align e taxonomias customizadas. O registro MCP fica em
-`registerModeIntegrations`, separado do servidor principal.
-
-## Telegram
-
-O token do bot nunca é aceito como argumento MCP. Defina
-`VAULT_GO_TELEGRAM_BOT_TOKEN` no ambiente privado do serviço e invoque
-`vault_go_telegram_configure` com o chat e os tipos ou conceitos aprovados.
-A configuração é cifrada pelo armazenamento privado local; status, resources e
-erros não retornam o token. Configurar não envia mensagem. O único envio de teste
-ocorre por uma chamada explícita a `vault_go_telegram_test`.
-
-Depois da persistência de uma observação, o worker envia apenas quando alertas
-estão habilitados e o tipo ou um conceito corresponde aos gatilhos. A mensagem é
-limitada a tipo, título, projeto e ID; narrativa e fatos não são enviados. Uma
-falha do Telegram não repete nem invalida uma memória já persistida.
-
-Ferramentas: `vault_go_telegram_status`, `vault_go_telegram_configure`,
-`vault_go_telegram_disable` e `vault_go_telegram_test`.
-
-## CCS Align
-
-Cada viewer possui `middle.jsonl`, `exclude-marks.json`, `cursor.json` e
-`rules-report.md` sob o diretório privado do Vault. Atualizações usam arquivo
-temporário e rename, deduplicam por UUID e conteúdo e limitam quantidade e
-tamanho. Excluir filtra o cache compilado; não apaga a memória cloud. Restaurar
-remove a marca e requer um novo ciclo para reler a fonte autoritativa.
-
-O ciclo comprova health e consulta `search_index → timeline → observations`.
-O rules check recebe listas limitadas de regras como dados, detecta
-`SHADOW_HOUSE`, `DENY_ALLOW`, `DRIFT` e `CLOCK_HEADER` e acrescenta uma seção ao
-relatório. Ele nunca altera house, project ou seat rules.
-
-Ferramentas: `vault_go_ccs_align_health`, `vault_go_ccs_align_cycle`,
-`vault_go_ccs_align_exclude`, `vault_go_ccs_align_restore` e
-`vault_go_ccs_align_rules_check`.
-
-O writer de awareness do Grok Bot é outra função upstream: ele grava linhas em
-logs mensais de um agente Grok. CCS Align não escreve nesses logs e esta mudança
-não implementa esse writer.
-
-## Taxonomias customizadas
-
-`vault_go_custom_mode_save` valida identificadores, taxonomias e prompts antes
-de gravar. A resolução rejeita pais desconhecidos e ciclos; arrays presentes
-substituem os do pai e prompts são mesclados. O catálogo e a preferência ativa
-ficam cifrados. `vault_go_custom_mode_select` aplica o modo à injeção de contexto
-e à geração local futura. Memórias existentes não são reclassificadas.
-
-Ferramentas adicionais: `vault_go_custom_modes`, `vault_go_custom_mode_get` e
-`vault_go_custom_mode_delete`. O modo base `code` não pode ser sobrescrito ou
-apagado, e um modo com filhos não pode ser removido.
-
-## Auditoria dos workflows
-
-Os 20 nomes em `vault-go://modes` correspondem aos 20 skills publicados no
-snapshot upstream 13.25.2. Um skill é um roteiro executado pelo agente cliente;
-carregá-lo não iniciar um agente em background não é, por si só, uma lacuna.
-Babysit, planejamento, execução, relatórios e os demais roteiros funcionam quando
-o cliente oferece as ferramentas indicadas. Diferenças reais permanecem para
-knowledge-agent (sem sessão conversacional persistente), wowerpoint (sem renderer
-PPTX/PDF embutido) e cloud-sync (cmem.ai não é o Vault cloud).
-
-Após integrar estes módulos, a matriz global deve separar a antiga linha conjunta:
-
-- Telegram: disponível com configuração explícita e gatilhos locais.
-- CCS Align: disponível na variante Vault descrita acima.
-- Modos customizados: disponíveis; atualizar a linha de privacy/capture modes.
-- Grok awareness push: ainda não implementado e distinto de Telegram/CCS Align.
-- Transcript watchers: avaliar separadamente com o trabalho específico de watchers.
-- Workflows: não marcar como parciais apenas porque o agente cliente executa as instruções.

package/docs/parity-deployment-review.md

@@ -1,60 +0,0 @@
-# Revisão e implantação da paridade
-
-Data: 20 de setembro de 2026. Referência: claude-mem 13.25.2, adce0fdf.
-
-## Implementado
-
-Busca sem query obrigatória, offset e ordem por data; timeline com âncora por
-consulta; leitura individual de jobs. Backup v2 paginado e consistente por
-snapshot materializado, privado no cliente, com hash e validação de proprietário
-antes da restauração. O formato cobre preferências e dados de memória; o manifesto
-explicita limites e omissões, sem declarar exportações truncadas como completas.
-
-Conversas com corpora usam o modelo escolhido, fontes numeradas e histórico local
-cifrado por conta/base. Respostas HTTP do corpus têm teto de 8 MiB; o JSON de
-fontes enviado ao modelo tem teto de 16 mil caracteres. Codex Terra/Luna/Sol e
-Claude Haiku foram executados de verdade com fontes sintéticas e citações válidas.
-O schema estrito exige todos os campos e aceita classificação nula.
-
-Telegram, CCS Align, taxonomias herdadas, watchers de Claude/Codex e encadeamento
-de projetos têm ferramentas próprias no MCP. Captura adicional e envio de
-alertas exigem configuração explícita. Caches e destinos de notificações ficam
-vinculados à conta. O Crystal usa o mesmo servidor Vault Go.
-
-AST real cobre os 24 idiomas upstream e HTML; o catálogo informa disponibilidade
-por plataforma. SCSS não tem prebuild Linux ARM64. Awareness do Grok usa logs
-mensais locais, com consentimento e allowlist de agentes.
-
-## Evidências
-
-- Engine 649f5f7 e API fdcc24b enviados a main e implantados no Docker Swarm.
-- Serviços saudáveis; health/readiness, autenticação e contratos testados na API canônica.
-- `deploymentVerified: true`: health, searchIndex, toolUses, feed, knowledgeBases,
-  observerStatus, backup e job aprovados em 20/09/2026. A verificação é dinâmica,
-  privada por conta e válida por cinco minutos; não equivale a verificar
-  credenciais externas, qualidade dos modelos ou entrega Telegram.
-- Backup real: 4.008 registros, 81 páginas, 14.070.751 bytes. Arquivo privado
-  mantido em `~/.memvault/backups/`; conteúdo não foi publicado.
-- Testes de snapshot cobrem alterações/remoções/criações entre páginas, expiração,
-  limites, isolamento entre contas e restauração idempotente.
-- Testes do cliente cobrem mudança de conta durante operações, resposta HTTP
-  excessiva, substituição de lock, redaction, credenciais, MCP e fila de modelos.
-- Auditoria de dependências de produção: zero vulnerabilidades.
-- Crystal: 122 testes, typecheck, gates de qualidade e E2E Electron com 2.359 notas;
-  as sete operações foram exercitadas pelo MCP Vault e servidor Crystal reais.
-
-## Revisão
-
-APROVADO COM RESSALVAS. A revisão multimodelo foi substituída por revisão manual:
-ANTHROPIC_BASE_URL e ANTHROPIC_AUTH_TOKEN não estavam definidos, impedindo conferir
-os aliases dos três revisores no gateway. Não se presumiu que aliases eram órfãos.
-A revisão manual e uma segunda leitura independente encontraram e corrigiram
-fencing de conta, recuperação de locks, restauração de preferências e limites de
-leitura. As correções têm testes de regressão.
-
-Ressalvas: o servidor gerenciado está `configured:false` até receber uma credencial
-válida; provedores locais selecionados continuam disponíveis com sua autenticação.
-Backup v2 não é o formato SQLite upstream nem uma réplica offline/cmem.ai Pro.
-Restauração é idempotente por página; não é uma única transação entre preferências
-do gateway e todos os dados do engine. Os workflows/skills executam no cliente e
-respeitam as ferramentas e autorizações disponíveis nesse cliente.

package/docs/transcripts-and-context.md

@@ -1,75 +0,0 @@
-# Transcripts persistentes e contexto entre projetos
-
-Vault Go pode capturar transcripts JSONL de Claude Code e Codex enquanto o serviço local está em execução. É uma opção local, desligada por padrão e vinculada à conta Vault. A preferência da conta `automaticCapture` também precisa estar ativada. A geração continua usando o motor/modelo já escolhido; ativar watchers não altera Claude Haiku, Codex ou chaves de providers.
-
-## Ativação
-
-```sh
-vault-go transcripts enable --client claude --workspace /caminho/projeto --consent
-vault-go transcripts enable --client codex --workspace /caminho/projeto --consent
-vault-go local start
-vault-go transcripts status
-```
-
-As raízes padrão são `~/.claude/projects` e `~/.codex/sessions`. Para outro perfil, use `--root /caminho/transcripts`. O workspace e a raiz precisam existir e ser caminhos absolutos. Registre cada workspace separadamente; no máximo 20 pares cliente/workspace. Subdiretórios de um repositório usam sua raiz Git.
-
-Sem `--from-start`, arquivos existentes começam no fim na primeira descoberta. Eventos que chegarem antes dessa primeira leitura podem ser pulados. Arquivos novos, criados depois da ativação, são lidos desde o início. Use `--from-start` na primeira configuração apenas quando quiser importar o histórico. Uma importação histórica pode se sobrepor à captura anterior por hooks sem identificadores comuns; a opção é explícita por esse motivo. Uma troca de conta exige novo consentimento.
-
-```sh
-vault-go transcripts enable --client codex --workspace /projeto --root /export/rollouts --consent --from-start
-vault-go transcripts poll
-vault-go transcripts disable --client codex --workspace /projeto
-```
-
-`poll` executa um lote sem iniciar serviços nem modificar preferências. `disable` devolve imediatamente aos hooks nativos a captura daquele cliente/workspace. Enquanto o watcher estiver habilitado, os hooks nativos continuam injetando contexto, mas deixam a escrita para o transcript, evitando captura dupla na operação normal. Desligar o serviço local mantém o checkpoint para retomada. Para voltar à captura exclusiva por hooks, desative o watcher.
-
-O setup aceita `--watch-transcripts claude|codex --workspace /projeto --consent`, opcionalmente `--transcript-root /raiz` e `--from-start`. Não ativa watchers implicitamente.
-
-## Recuperação e privacidade
-
-- `transcript-watchers.json` guarda o consentimento; `transcript-checkpoints.json` guarda offsets em bytes, identidade dos arquivos e o estado mínimo de chamadas pendentes. Arquivos usam permissão 0600 e gravação atômica. Entradas pendentes são redigidas e limitadas; esse checkpoint não é criptografado.
-- O checkpoint avança depois do evento cloud e da fila durável de geração. Falhas de rede voltam ao mesmo identificador idempotente. Uma perda de confirmação pode repetir o envio HTTP, mas usa a mesma chave na API e na fila/importação. Não há promessa de execução exatamente uma vez do modelo após replay histórico.
-- Um lock por processo impede dois consumidores simultâneos. Reinício, inode novo, truncamento e alteração do prefixo são detectados. Linhas parciais esperam a próxima leitura; UTF-8 usa offsets em bytes. JSON inválido e linhas acima de 256 KB são descartados.
-- Apenas registros cujo `cwd` corresponde ao workspace consentido são enviados. Symlinks encontrados na árvore são ignorados. Trocar conta, credenciais ou consentimento durante uma operação interrompe o lote. Um refresh de credencial pode abortar um lote; a próxima leitura retoma com os mesmos IDs.
-- `<private>` / `<vault-private>` e flags privadas bloqueiam o turno inteiro, incluindo ferramentas e resposta, até o próximo prompt público. Senhas, tokens, chaves e blocos de contexto são redigidos com a política dos hooks. `includeToolResults=false` continua omitindo resultados na API. Ao começar no fim de um arquivo existente, a leitura espera um novo prompt público antes de capturar ferramentas/respostas.
-- Claude: `user`, `assistant`, blocos `text`, `tool_use`, `tool_result`. Codex: `session_meta`, `turn_context`, `response_item.message`, chamadas `function_call` e `custom_tool_call` e seus resultados. `event_msg` duplicados são ignorados; `task_complete.last_agent_message` é fallback para resposta final ausente. Comentários intermediários do Codex não viram resumo. Formatos desconhecidos são ignorados.
-- Chamadas sem resultado ficam pendentes até o resultado chegar. No máximo 16 chamadas pendentes por arquivo, com entrada redigida limitada a 16 KB; excedentes antigos são descartados. Um novo prompt limpa chamadas sem resultado do turno anterior.
-
-Cada lote processa até 200 registros, 32 arquivos e 2 MB; cada arquivo é lido em blocos de até 256 KB. A descoberta visita até 4096 entradas e 1000 arquivos, priorizando diretórios e arquivos recentes. O checkpoint mantém até 1000 arquivos e aproximadamente 4 MB. Árvores que excedam os limites podem deixar arquivos históricos fora da descoberta; selecione uma raiz mais estreita para esses casos. A descoberta não promete uma varredura exaustiva de arquivos arbitrariamente grandes. A fila de geração mantém seus limites próprios.
-
-O worker faz polling a cada cinco segundos. `local serve`, instalação e atualizações usam o mesmo lifecycle; o serviço só se declara ocioso quando nenhuma captura está em execução e espera a captura atual ao fechar. Updates copiam os módulos novos para o runtime, preservando consentimento e checkpoints fora dele. SDK MCP e Zod ficam isolados em `transcript-tools.js`; o worker/hook staged não depende de `node_modules`.
-
-## Cadeia de contexto
-
-```sh
-vault-go context-chain set --workspace /app --roots /biblioteca,/infra --consent
-vault-go context-chain set --workspace /worktree --worktree-parent --consent
-vault-go context-chain status
-vault-go context-chain clear --workspace /app
-```
-
-SessionStart e `vault_go_session_start_context` passam a consultar o projeto primário e os vínculos configurados para aquele workspace. São no máximo cinco projetos, sempre descobertos na lista autenticada da conta e comparados por caminho exato. Projetos inexistentes ou marcados privados são omitidos; a leitura nunca cria projetos. O pai de worktree é resolvido pelo `.git`/`commondir`, sem executar comandos Git, e requer consentimento explícito.
-
-`contextItems` e `contextMaxChars` são orçamentos totais compartilhados entre os projetos, incluindo os pequenos cabeçalhos que identificam cada projeto. Os limites de caracteres e itens não são multiplicados por projeto. Vínculos vivem em `context-chains.json`, com permissão privada e escopo da conta. PreToolUse permanece restrito ao projeto/arquivo em uso.
-
-Isto fornece contexto multi-project em cadeia explícita. Não reproduz o renderer visual/token analytics do claude-mem nem escreve `AGENTS.md` automaticamente. O filtro semântico de memórias e isolamento do tenant continuam pertencendo à API Vault autenticada.
-
-## Ferramentas MCP
-
-| Ferramenta | Operação |
-| --- | --- |
-| `vault_go_transcripts_status` | Consentimento, alvos, última leitura e erro sanitizado |
-| `vault_go_transcripts_configure` | Ativar/desativar; exige `consent=true` para ativar |
-| `vault_go_transcripts_poll` | Processar um lote dos alvos já habilitados |
-| `vault_go_context_chain` | Consultar vínculos da conta |
-| `vault_go_context_chain_configure` | Definir/remover raízes e pai de worktree consentidos |
-
-## Evidência de implementação
-
-A descoberta upstream usou `/tmp/claude-mem-parity-20260919`, especialmente `src/services/transcripts/{processor,config,types}.ts`, `tests/transcripts/processor-codex-context.test.ts`, `tests/transcripts/watcher-start-at-end.test.ts` e o relatório `/tmp/claude-mem-parity-scan.md`. A arquitetura de watcher/runtime foi portada funcionalmente para a fila e a API Vault, sem executar scripts upstream.
-
-Foi consultada somente a estrutura de três arquivos locais por host (tipos e nomes de campos conhecidos, sem conteúdo dos prompts) para confirmar `custom_tool_call/output`, fases `commentary` e metadados Claude/Codex. Fixtures sintéticas em `src/transcript-watchers.test.ts` reproduzem esses formatos, com HTTP local, subprocesso CLI e runtime staged isolado. `src/context-chain.test.ts` verifica consentimento, isolamento, privacidade, limites totais, worktree e integração do hook.
-
-A revisão multimodelo foi substituída por revisão manual porque as variáveis de acesso ao gateway LiteLLM não estão disponíveis neste ambiente; nenhum alias foi chamado ou classificado como órfão sem consulta. A revisão manual conferiu fronteiras de conta/consentimento, parser, checkpoints, exclusão mútua, limites, integração e pacote. Nenhum watcher foi ativado na conta real e o worker instalado não foi alterado por estes testes.
-
-Validação em 2026-09-20, sobre a base `8f08e19341eed95164ee9a77cf178486adeddb0f`: `bun run build` e `bun test src` passaram (169 testes, 1229 assertions). `npm pack --dry-run --json` contém os 12 arquivos `.js`/`.d.ts` novos e esta documentação, sem arquivos de teste. `git diff --check` passou. Veredito manual: aprovado com os limites operacionais declarados acima.