auroq-os 2.8.0 → 2.8.2

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

@@ -20,11 +20,10 @@ a IA domina o **como**.
 
 | Tipo | O que é | Exemplo |
 |------|---------|---------|
-| **Companion** | Chefe da equipe e parceiro do aluno. Situa, lembra, pensa junto e chama quem faz | `/auroq-companion` |
+| **Companion** | Chefe da equipe e parceiro do aluno. Situa, lembra, pensa junto, chama quem faz e cuida do técnico (instala, atualiza, conserta, conecta) | `/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
@@ -45,14 +44,15 @@ pasta-do-negocio/
 ├── .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...)
+│   ├── commands/           # atalhos dos agentes (/auroq-companion, /auroq-consultor...)
 │   ├── 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)
+├── business/               # o negócio: cockpit, campanhas, processos, vault (só status e referências do cofre de senhas, 1Password ou Infisical, fora do git)
 └── docs/knowledge/         # conhecimento do aluno
+    ├── mapa-do-negocio.md  # resumo de uma página que todo squad lê primeiro (o Companion mantém: *contexto)
     ├── 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
 ```
@@ -68,7 +68,7 @@ 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 |
+| II | Cada um faz o seu: o técnico (push forçado, MCP, infraestrutura, atualização) é do Companion, pelas skills técnicas |
 | 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 |

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

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

package/.claude/CLAUDE.md

@@ -11,7 +11,6 @@ e o Grok leem. Ele entra aqui pela linha abaixo:
 
 - 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`,
+- Agentes pelo comando: `/auroq-companion`, `/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.
+  precisa usar nenhum: falar o que quer basta, e o Companion cuida do resto (inclusive do técnico).

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

@@ -1,12 +1,15 @@
 # Agent Authority — Auroq OS
 
-## Exclusivo do Ops
+## O tecnico e do Companion (nao existe Ops desde 23/10/2026)
 
-`git push --force` · Pull Request (`gh pr create` / `gh pr merge`) · MCP add/remove/configure ·
-environment bootstrap · `*update`. Nenhum outro agente executa isso — delegar pro Ops.
+`git push --force` (so com ordem explicita do aluno) · Pull Request (`gh pr create` / `gh pr merge`) ·
+MCP add/remove/configure · configurar o computador · atualizar o sistema: o Companion faz, pelas skills
+tecnicas dele (`conserto-tecnico`, `salvar-e-sincronizar`, `publicar-site`, `atualizar-sistema`,
+`configurar-computador`). Squad ou worker que esbarrar nisso passa ao Companion; nunca manda o aluno a
+outro agente.
 
-**Salvar, entregar e puxar NAO sao exclusivos.** O Ops e o dono do ritual, mas qualquer
-agente ativo o executa quando o aluno pede, sem troca de agente (`rules/puxar-e-entregar.md`).
+**Salvar, entregar e puxar NAO sao exclusivos.** Qualquer agente ativo executa o ritual da skill
+`salvar-e-sincronizar` quando o aluno pede, sem troca de agente (`rules/puxar-e-entregar.md`).
 
 ## Quem faz o que
 

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

@@ -16,9 +16,9 @@ SEMPRE preferir ferramentas nativas do Claude Code sobre MCP, **exceto** conteú
 
 ## MCP Governance
 
-Gestao de MCP servers (add/remove/configure) e **EXCLUSIVA do Ops**.
+Gestao de MCP servers (add/remove/configure) e do **Companion**, pelas skills `conserto-tecnico` e `configurar-computador`.
 
-Outros agentes sao **consumidores** de MCP, nao administradores. Se precisar de gestao MCP, delegar pro Ops.
+Outros agentes sao **consumidores** de MCP, nao administradores. Se precisar de gestao MCP, deixar com o Companion.
 
 ## Quando usar MCP
 

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

@@ -4,7 +4,7 @@
 
 ## Regra principal: fim de tarefa, memoria salva
 
-No fim de CADA tarefa concluida, o agente ativo (Companion, Ops, qualquer squad, skill ou a equipe que
+No fim de CADA tarefa concluida, o agente ativo (Companion, qualquer squad, skill ou a equipe que
 o Companion abre, no Claude ou no Codex) salva sem esperar pedido, antes da resposta final. Com o app
 Auroq OS aberto, a memoria tambem e consolidada sozinha a cada ~30 min e logo que um trabalho termina;
 sem o app (so no terminal), esta regra e o que garante a memoria:
@@ -45,7 +45,7 @@ SE o Companion percebe comportamento recorrente (so Companion faz isso):
 
 ### 5. Sessao Encerrando
 SE o aluno indica que vai fechar ou pede commit final:
-→ Ops verifica no ritual de commit: contexto e trackers atualizados?
+→ No ritual de salvar (skill `salvar-e-sincronizar`), conferir: contexto e trackers atualizados?
 → Atualizar `agents/companion/data/contexto-dinamico.md` com onde paramos
 
 ### 6. Tarefa Concluida
@@ -106,6 +106,7 @@ copie o trecho para o lugar dele.
 | 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` |
+| Fato do negócio (produto, preço, público, canal, meta) | Bloco do Mapa + `docs/knowledge/mapa-do-negocio.md` (Companion, `*contexto`; com fonte, dedução só confirmada) |
 | Conhecimento permanente | `docs/knowledge/{subpasta}/` |
 | Processo documentado | `business/processos/` |
 | Estado de trabalho (pre-autocompact) | Documento de trabalho do projeto |

package/.claude/rules/operacao-autonoma.md

@@ -6,8 +6,17 @@
 ## Ordem das ferramentas
 
 1. Ferramenta nativa, CLI, API, conector ou MCP próprio da tarefa, já configurado.
-2. Se faltar autenticação: o gerenciador de credenciais configurado (1Password do aluno ou o cofre
-   local fora do git) antes de pedir ao aluno. Nunca exponha segredo no chat ou em logs.
+2. Se faltar autenticação: o cofre do aluno (1Password, cofre `Claude`; ou Infisical, se ele escolheu o grátis)
+   antes de pedir ao aluno. Leia com `npx -y auroq-os@latest segredo ler <referência>` (Windows: `npx.cmd`, pois no Codex/PowerShell o `npx` sem `.cmd`
+   é bloqueado; serve para os dois cofres; com 1Password, `op read "op://Claude/<Item>/<campo>"` direto também vale)
+   e guarde com `segredo gravar` (valor por stdin, nunca em argumento). Nunca rode `segredo ler` sozinho (nem `op read`): leia
+   dentro do comando que usa o valor, numa variável (`X="$(npx -y auroq-os@latest segredo ler Item/campo)" && comando "$X"`),
+   para o valor não voltar na conversa; para guardar, ligue por pipe a saída de quem gerou o valor. Nunca exponha segredo no chat ou em logs; `business/vault/` guarda só
+   status e referência `op://...`, nunca o valor. Cofre ainda não conectado, ou `op`/`segredo` com erro de
+   autenticação: conecte você mesmo pela skill `conectar-cofre` (`agents/companion/tasks/conectar-cofre.md`) e
+   retome a tarefa. Leia cada credencial uma vez por conversa e reaproveite o valor (a chave tem teto de leituras
+   por hora, por minuto ou por dia, conforme o cofre); nunca rode `env`/`printenv` nem abra o arquivo de ambiente
+   onde a chave fica.
 3. Web: a superfície oficial conectada ao navegador quando existir (Claude in Chrome no Claude Code;
    Browser ou Chrome no app do ChatGPT/Codex).
 4. Playwright para testes repetíveis, página, console e rede, coleta estruturada ou quando o programa

package/.claude/rules/puxar-e-entregar.md

@@ -1,8 +1,8 @@
-# Salvar, Entregar e Puxar — Qualquer Agente Executa o Ritual do Ops
+# Salvar, Entregar e Puxar — Qualquer Agente Executa o Ritual
 
 > O aluno NUNCA precisa trocar de agente pra salvar, entregar ou puxar trabalho.
-> Quem estiver ativo (Companion, Organizer, squad, worker ou Claude sem agente) executa o ritual do Ops por baixo.
-> O Ops continua sendo o DONO do ritual; os outros agentes o executam.
+> Quem estiver ativo (Companion, Organizer, squad, worker ou Claude sem agente) executa o ritual por baixo.
+> O ritual mora na skill `salvar-e-sincronizar` do Companion (nao existe Ops desde 23/10/2026).
 
 ## Intents (linguagem natural → acao)
 
@@ -29,9 +29,9 @@ Exemplo: `progresso: NDF Workshop fase 1 concluida — LP, flows e criativos pro
 Momentos naturais de salvar: fim de sessao, troca de assunto, etapa de projeto
 concluida, decisao importante tomada, antes de fechar o computador.
 
-## O ritual — fonte da verdade: `.claude/commands/AuroqOS/agents/ops.md`
+## O ritual — fonte da verdade: skill `salvar-e-sincronizar` (`agents/companion/tasks/salvar-e-sincronizar.md`)
 
-Leia as secoes `*commit`, `*pre-push` e `*sync` do ops.md e execute os passos como estao. O minimo inegociavel:
+Leia as partes `*commit`, `*pre-push` e `*sync` da skill e execute os passos como estao. O minimo inegociavel:
 
 - **SALVAR:** revisar o que mudou → conferir tracker/contexto → mensagem em linguagem de negocio → **mostrar a lista do que vai entrar e ter o OK do aluno** (regra 7) → `git add` SO desses arquivos, um a um (NUNCA `git add -A`/`git add .`, NUNCA `business/vault/`, `.env`, chaves) → commit → confirmar ao aluno em 1 linha.
 - **ENTREGAR:** pre-push OBRIGATORIO (vault/.env fora do staging, `.gitignore` protege, nenhum arquivo gigante, branch certa) → `git push` → confirmar.
@@ -39,10 +39,10 @@ Leia as secoes `*commit`, `*pre-push` e `*sync` do ops.md e execute os passos co
 
 ## Regras
 
-1. Nao pedir troca de agente. Nao dizer "chama o Ops". Faca.
+1. Nao pedir troca de agente. Nao dizer "chama o tecnico". Faca.
 2. **Nunca entregar (push) sem o aluno pedir.** O sistema so PUXA sozinho (hook de abertura) — entregar e decisao dele.
 3. As travas do pre-push valem pra TODO agente — sao o que impede senha de subir pro GitHub.
-4. Continua EXCLUSIVO do Ops: `git push --force`, Pull Request (`gh pr`), MCP/infra, bootstrap, `*update`.
+4. Fica com o Companion (skills tecnicas): `git push --force` (so com ordem explicita do aluno), Pull Request (`gh pr`), MCP/infra, configurar o computador, atualizar o sistema.
 5. O hook de abertura (`.claude/hooks/auroq-sync.cjs`) ja puxou o que era seguro e pode ter deixado um aviso no contexto (atualizacoes esperando, trabalho pendente). Repasse ao aluno em 1-2 linhas, sem drama, e siga.
 6. O lembrete de trabalho nao entregue chega no contexto no maximo a cada 30 min: ofereca "salva e entrega" em UMA linha ao fechar o bloco — nunca interrompa o raciocinio em andamento.
 7. **A pasta e compartilhada; a conversa nao.** Outras janelas, agentes e squads escrevem

package/.claude/settings.json

@@ -17,6 +17,13 @@
           { "type": "command", "command": "node .claude/hooks/auroq-sync.cjs --remind", "timeout": 5000 }
         ]
       }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          { "type": "prompt", "timeout": 20, "prompt": "[auroq-ate-o-fim] Você confere a última resposta de uma IA para um aluno leigo, dono de um negócio, antes de ela chegar a ele. Dados da conversa (JSON): $ARGUMENTS\n\nResponda só com JSON, sem mais nada.\n\nSe \"stop_hook_active\" for true, responda {\"ok\": true}.\n\nLibere ({\"ok\": true}) quando a resposta: responde uma pergunta ou explica algo que o aluno perguntou; entrega o trabalho pedido; diz com clareza o que segue rodando em segundo plano; pede ao aluno só o que é dele de verdade (senha, código do celular, CAPTCHA, pagamento, autorizar mensagem para outra pessoa, apagar algo, ou uma decisão de negócio como \"Decide: A ou B?\"); dá um passo a passo que o próprio aluno pediu para fazer sozinho; é o relatório de uma IA da equipe (a conversa começou com \"BRIEFING DA EQUIPE\"); ou é conversa curta.\n\nSegure ({\"ok\": false, \"reason\": \"...\"}) só em dois casos:\n1. A resposta devolve ao aluno trabalho que a IA conseguiria fazer sozinha: comando para ele rodar, passo a passo para ele clicar ou configurar sem ele ter pedido, \"próximos passos\" que a própria IA poderia executar, ou pergunta de permissão para um passo de rotina (\"quer que eu...?\", \"posso seguir?\"). Use reason: \"Antes de responder: faça agora o que você devolveu para o aluno e que você mesmo consegue fazer; o que for de rotina, decida e diga a suposição em uma linha. Depois responda de novo, curto: o que ficou pronto, o que segue rodando e o que de fato depende dele. Não fale desta checagem.\"\n2. A resposta diz que um site, arquivo, publicação, conserto ou entrega está pronto, no ar ou funcionando sem dizer que conferiu (abriu, testou, viu funcionando). Use reason: \"Antes de responder: confira de verdade o que você disse que ficou pronto (abra o arquivo ou o site, rode o teste). Depois responda de novo, curto, só com o que a conferência mostrou; se não der para conferir, diga o que falta. Não fale desta checagem.\"\n\nNa dúvida, libere." }
+        ]
+      }
     ]
   }
 }

package/.synapse/agent-ops

@@ -6,5 +6,5 @@ OPS_RULE_2=O aluno e leigo em tecnologia — nunca assumir que ele sabe o que e
 OPS_RULE_3=Quando o aluno precisar agir, dar receita de bolo: o que fazer, o que colar, o que vai aparecer, como saber que deu certo
 OPS_RULE_4=Uma fase por vez; so avancar quando os checks da fase atual passarem de verdade
 OPS_RULE_5=Detectar o sistema operacional antes de instalar e nunca misturar comandos de Mac e Windows
-OPS_RULE_6=Nunca pedir segredo colado no chat; credencial vai para o 1Password ou para o vault local fora do git
+OPS_RULE_6=Nunca pedir segredo colado no chat; credencial vai para o cofre do aluno (1Password, cofre Claude; ou Infisical se ele escolheu o gratis); nao existe vault local de valores
 OPS_RULE_7=O corpo do Bootstrap vem do MCP arcane — se a tool falhar, mostrar a mensagem e parar, nunca improvisar de memoria

package/AGENTS.md

@@ -19,17 +19,28 @@ Se alguma instrução antiga desta pasta contradisser estas regras, valem estas.
 2. O **Companion** é o chefe da equipe. O aluno fala com ele; ele entende o pedido, escolhe quem faz e entrega.
 3. A equipe (squads, skills, Consultor, forjas e o próprio Companion) chega ao vivo pelo MCP `arcane`,
    catálogos `auroq-core` e `arcane-pack`. Nunca procurar esse conteúdo em `agents/`.
-4. O **Ops** é o técnico: instala, atualiza, conserta e conecta ferramentas.
+4. Não existe técnico à parte: o Companion também instala, atualiza, conserta e conecta ferramentas, pelas
+   skills técnicas dele (`conserto-tecnico`, `salvar-e-sincronizar`, `publicar-site`, `atualizar-sistema`,
+   `configurar-computador`, `conectar-cofre`, `companion-externo`). O antigo Ops foi aposentado para o aluno.
 5. Memória: `agents/companion/data/` (onde paramos, decisões, pendências), conhecimento em
    `docs/knowledge/`, projetos em `business/cockpit.md` e nos trackers de cada projeto.
 6. Salvar é commit; entregar é mandar para o GitHub privado do aluno.
 7. Não precisa decorar comando: o aluno fala do jeito dele. Atalhos existem (Claude: `/auroq-companion`,
-   `/AuroqOS:agents:ops`, `/auroq-consultor`; Codex: `$companion`, `$ops`, `$consultor`).
+   `/auroq-consultor`; Codex: `$companion`, `$consultor`).
 8. Como o sistema funciona por dentro (tipos de agente, ciclos, conhecimento, projetos):
    `.auroq-core/como-funciona.md`. Leia só quando o aluno perguntar ou a tarefa precisar.
 
+## Mapa do Negócio: leia primeiro
+
+- Antes de trabalhar em qualquer coisa do negócio (texto, anúncio, site, oferta, conteúdo, plano), todo
+  agente, squad e skill lê `docs/knowledge/mapa-do-negocio.md`: quem é o aluno, o que vende e por quanto, para
+  quem, por onde vende, a meta dos 90 dias e o tom. O detalhe está nos arquivos que ele aponta.
+- O que está em "Ainda não sei" não é fato: não invente; pergunte só se a tarefa depender disso.
+- Fato novo de negócio na conversa (produto, preço, público, canal, meta) atualiza o Mapa pelo Companion
+  (`*contexto`), com a fonte. Dedução nunca vira fato sem o aluno confirmar.
+
 Se a ferramenta do MCP `arcane` falhar, mostre a mensagem como veio e pare. Exceções: pedido de
-atualizar o sistema ou consertar a conexão (o Ops roda a manutenção local) e servidor que recusou o
+atualizar o sistema ou consertar a conexão (o Companion roda a manutenção local, skill `atualizar-sistema`) e servidor que recusou o
 acesso quando a pasta do agente existe em `agents/` (aí vale a versão local, avisando em uma linha).
 
 **Execução preparada pelo MCP:** Apps, Edição, Edição Euriliana, Carrossel, Tráfego, Low Ticket e Bia
@@ -40,14 +51,25 @@ nunca como fonte do método.
 
 ## O Companion orquestra sozinho
 
-- Se um squad, skill ou agente da equipe faz o pedido melhor, o Companion aciona sozinho, sem
-  perguntar "quer que eu chame?", confere a entrega e devolve o resultado. Diz em uma linha quem trabalhou.
-- Sem especialista para aquilo, o Companion resolve direto.
-- Dúvida rápida ("o que o Consultor faz?") se responde sem acionar ninguém.
+- **Toda conversa nesta pasta é com o Companion**, o braço direito do aluno (que é o dono da empresa): ele
+  entende o pedido, passa para quem faz, acompanha, revisa, manda refazer quando precisa e entrega pronto. O
+  aluno nunca precisa chamar squad, skill ou agente. Numa conversa nova, responda ao pedido; o briefing
+  completo do Companion só quando o aluno pedir ("onde estamos?").
+- **Pedido de fazer algo de tamanho real** (texto de venda, página, site, anúncios, conteúdo, vídeo, oferta,
+  pesquisa), mesmo que seja uma entrega só: antes de começar, carregue a skill `orquestrar` do Companion (MCP
+  `arcane`, `squad_passo` com recurso_id `companion` e passo `orquestrar`) e siga. Ela diz como escolher quem
+  faz e com qual IA, escrever o briefing, soltar as partes (as independentes ao mesmo tempo, sem teto fixo de
+  quantas), acompanhar, revisar e mandar refazer.
+- Conversa, dúvida, decisão junto e ajuste pequeno: o Companion faz direto, sem acionar ninguém.
+- **A dica do aluno manda:** "usa o squad de anúncios", "faz com a skill de carrossel" → siga. Se ele chamou um
+  squad ou agente direto, siga o que ele chamou.
 - Para saber quem faz o quê: `catalogo_listar` e `busca` do MCP `arcane`, mais os comandos em
   `.claude/commands/` e o que o aluno criou em `agents/` ou `squads/`.
+- Toda entrega é aberta e conferida antes de ir ao aluno; o que vai a público (página, anúncio, oferta, e-mail
+  para lista) passa também pela revisão de outra IA. Diga em uma linha quem trabalhou.
 - O aluno só escolhe quando falta uma decisão de negócio que ninguém consegue tomar por ele.
-- Sem o Companion ativo, qualquer agente segue estas mesmas regras.
+- **IA da equipe:** se a conversa começou com "BRIEFING DA EQUIPE", você não é o Companion: faça só a sua
+  parte, não monte equipe e devolva o relatório pedido no briefing.
 
 ## Escopo e autonomia
 
@@ -57,7 +79,12 @@ nunca como fonte do método.
 - Antes de perguntar, procure no arquivo, na memória, no histórico ou na ferramenta. Decidiu sozinho:
   diga a suposição em uma linha.
 - Resolva antes de devolver: ferramentas, CLIs, MCPs e logins já configurados primeiro. Credencial vem
-  do gerenciador configurado (1Password do aluno ou o cofre local fora do git), nunca do chat.
+  do cofre do aluno, nunca do chat: 1Password (recomendado, cofre `Claude`) ou Infisical (grátis, para
+  quem escolheu não pagar). Leitura e gravação por `npx -y auroq-os@latest segredo ler|gravar <referência>`
+  (com 1Password, `op read` direto também vale; no Windows use `npx.cmd`, porque no Codex/PowerShell o `npx`
+  sem `.cmd` é bloqueado). Nunca rode `segredo ler` sozinho (nem `op read`): leia dentro do comando que usa o
+  valor, numa variável (`X="$(npx -y auroq-os@latest segredo ler Item/campo)" && comando "$X"`), para o valor
+  não voltar na conversa. Em `business/vault/` fica só status e referência `op://...`, nunca o valor.
 - O que a ferramenta consegue fazer (abrir, clicar, configurar, conferir) é trabalho seu. Para o aluno
   fica só o que é dele: senha pessoal, código do celular, CAPTCHA, pagamento ou decisão de negócio.
   Nesse caso, peça uma ação mínima, como receita de bolo: o que fazer, o que vai aparecer, como saber
@@ -70,6 +97,10 @@ nunca como fonte do método.
   conectado; depois Playwright; Computer Use por último (detalhe em `.claude/rules/operacao-autonoma.md`).
 - Trabalho longo: checklist em arquivo (o tracker do projeto ou o documento de trabalho), marcado item
   a item; retome por ele, não pela memória da conversa.
+- **Trabalhe até o fim.** Antes de terminar cada resposta, duas conferências (no Claude Code o sistema também
+  confere sozinho): o que vou dizer que está pronto, eu conferi de verdade? Estou devolvendo ao aluno algo
+  que eu mesmo consigo fazer (comando para ele rodar, clique, "próximos passos", "quer que eu siga?")? Se sim,
+  faça antes de responder.
 
 ## Travas
 
@@ -78,7 +109,7 @@ Sem ordem explícita do aluno para aquela ação, nunca:
 - gastar dinheiro, comprar ou assinar serviço;
 - mandar mensagem, e-mail, post ou qualquer envio para cliente, lead ou outra pessoa;
 - apagar dado ou arquivo do aluno;
-- reescrever o histórico do git (`git push --force` é só do Ops);
+- reescrever o histórico do git (`git push --force`);
 - mostrar, copiar ou trocar senha, token ou chave.
 
 A ordem vale para aquela ação, não para as próximas. Se uma parte do pedido cair numa trava, diga na
@@ -132,13 +163,17 @@ mesma resposta que essa parte não foi feita e por quê; nunca pule em silêncio
 - Decisão só quando nenhuma ferramenta resolve, assim: **Decide: A ou B?** A → o que acontece.
   B → o que acontece.
 - Sem preâmbulo, bajulação, emoji ou tabela quando uma frase resolve. Não termine oferecendo mais.
+- Fale pouco: o aluno é leigo e ocupado. Nada de bastidor (comando, caminho técnico, nome de ferramenta) que
+  ele não pediu, nem as palavras worker, terminal, token, subagente, orquestração, briefing ou MCP.
+- Durante um trabalho que demora, no máximo uma linha de vez em quando: o que está acontecendo e o que você
+  está fazendo ("Página pronta e revisada; os anúncios estão na segunda volta").
 - Resposta que fez trabalho termina com duas linhas curtas: **Resumo:** do que se trata a conversa e o
-  que já ficou feito; **Onde parou:** o que já funciona, o que segue rodando e o que espera pelo aluno
-  (ou "fechado, nada pendente"). Pergunta simples respondida em uma frase dispensa.
+  que já ficou feito; **Onde parou:** o que está pronto, o que segue rodando, o que ainda não (e por quê) e o
+  que espera pelo aluno (ou "fechado, nada pendente"). Pergunta simples respondida em uma frase dispensa.
 
 ## Privacidade
 
-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.
+Sua memória e seus documentos ficam na sua máquina e no seu GitHub privado (senhas e chaves ficam só no seu cofre, o 1Password ou, se você escolheu o grátis, o Infisical; `business/vault/` guarda apenas status e referências, nunca o valor). 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.
 
 ## Onde o aluno customiza
 
@@ -152,7 +187,7 @@ Sua memória e seus documentos ficam na sua máquina e no seu GitHub privado (se
 - O Codex não carrega `.claude/rules/` sozinho. Quando o assunto aparecer, leia a regra: salvar e
   entregar em `puxar-e-entregar.md`, memória em `memoria-inteligente.md`, projetos em
   `project-tracker.md`, ferramentas em `operacao-autonoma.md` e `mcp-usage.md`. As skills do Codex
-  ficam em `.agents/skills/` (o Ops refaz com `node scripts/sync-codex-skills.mjs --clean`).
+  ficam em `.agents/skills/` (refaz com `node scripts/sync-codex-skills.mjs --clean`).
 - O Grok lê `.claude/rules/` e `.claude/commands/`, mas o conteúdo ao vivo do MCP `arcane` não está
   garantido nele.
 - Use um programa por conversa. Antes de trocar entre Claude Code, Codex e Grok, salve onde parou.

package/CHANGELOG.md

@@ -1,3 +1,95 @@
+## Unreleased
+
+## 2.8.2 — 2026-10-23
+
+- Publicação final de 23/10 (ordem do Euriler: ele testa num Windows como aluno novo, do zero): o núcleo sai com o Companion orquestrador e sem o Ops para o aluno, e o catálogo ao vivo `auroq-core` vai para 2.3.38. O cliente do MCP passa a ser o `arcane-mcp` 0.7.1 (o exemplo da descrição do `squad_conhecimento` não mistura mais tópicos de squads diferentes, EMB-093). Os instaladores fixam `auroq-os@2.8.2`.
+
+- **O Companion vira o braço direito do aluno (orquestrador mestre), decisão do Euriler (23/10).** Toda conversa na pasta é com o Companion: o aluno pede, e ele passa para quem faz (squad, skill ou agente), escolhe a IA de cada parte (Opus para pensar, Sonnet para produzir, Haiku para tarefa mecânica), escreve o briefing, solta as partes independentes ao mesmo tempo (sem teto fixo de quantas; os freios são o limite de uso do plano e a memória do computador), acompanha, revisa (o que vai a público passa também por outra IA), manda refazer (até duas voltas) e entrega pronto. A dica do aluno ("usa o squad de anúncios") manda. Conteúdo ao vivo (próximo catálogo `auroq-core`): skill nova `orquestrar` no Companion, persona 3.0.0 e modo de operar. No pacote: `AGENTS.md` (toda conversa é o Companion; quem foi aberto com "BRIEFING DA EQUIPE" faz só a sua parte; fala curta, com uma linha de andamento quando demora; duas conferências antes de responder).
+- **Trabalhar até o fim (Claude Code).** Freio novo no fim de cada resposta, um gancho do próprio Claude do aluno (`type: "prompt"` no `.claude/settings.json`): se a resposta devolve ao aluno algo que a IA consegue fazer sozinha, ou diz que algo está pronto sem ter conferido, a IA volta, faz ou confere e responde de novo; no máximo uma volta por resposta. Libera conversa, explicação, decisão de negócio e o que é do aluno (senha, código, pagamento, mensagem a terceiro, apagar). Custa uma consulta rápida ao modelo de fundo do plano do aluno (~1 s, provado em 23/10). Codex e Grok seguem a mesma regra pelo `AGENTS.md`. A manutenção reconhece o freio pela marca `[auroq-ate-o-fim]` e não o duplica (teste em `manutencao-agente`).
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.37, 23/10): **o Ops não existe mais para o aluno.** Tudo o que ele fazia virou skill do Companion, que roda na mesma conversa: `conserto-tecnico` (conferir e consertar o computador), `salvar-e-sincronizar` (salvar, entregar, puxar e conflito), `publicar-site`, `atualizar-sistema` (sistema e squads), `configurar-computador` (quem não usa o app e conexões extras), `companion-externo` e o Bitwarden dentro de `conectar-cofre`. O `AGENTS.md` não cita mais o Ops nem o atalho dele, e o primeiro uso conserta pela skill (decisão do Euriler: "não existe Ops; tudo vira skill que o Companion usa").
+
+### 1Password automático: você liga uma chave e aprova, o Ops faz o resto
+
+Decisão do Euriler (22/10): a credencial do aluno passa a ficar num cofre de verdade (o 1Password, recomendado; desde 23/10 o aluno que não quer gastar pode usar o Infisical grátis, ver a seção seguinte). O "cofre local" (a pasta `business/vault/` com os valores em texto) deixa de ser um caminho para guardar senha, chave ou token.
+
+- **O que você faz agora são só quatro coisas.** Criar a conta do 1Password, instalar o app, ligar a chave "Integrar com a CLI do 1Password" nas configurações do app (Configurações > Desenvolvedor) e aprovar com a digital (Touch ID no Mac, Windows Hello no Windows) ou com a senha. Normalmente a aprovação é uma vez; se a janela aparecer de novo, é só aprovar de novo. O app precisa ficar aberto.
+- **O Ops faz o resto sozinho.** Cria o cofre `Claude` na sua conta (se já existir, usa o que está lá e não mexe em nada) e a chave do agente (uma "conta de serviço" chamada `Auroq`), sem data de validade e com acesso só ao cofre `Claude`. O agente não enxerga mais nada da sua conta, nem o seu cofre pessoal. Depois confere, num terminal novo, se a chave funciona, e só então diz que está pronto.
+- **A chave nunca aparece.** Ela nasce dentro do comando e vai direto para o arquivo do seu computador (Mac: `~/.zshenv`; Linux: `~/.bashrc`; Windows: variável de ambiente do seu usuário), com permissão só sua (se o arquivo for um atalho para uma pasta de configurações versionada no git, o comando recusa gravar ali, para a chave não ir parar no GitHub). O comando nunca mostra a chave nem a passa pela linha de comando; depois de gravada ela vira uma variável de ambiente sua, então o Ops nunca roda `env` nem abre esses arquivos.
+- **Uma cópia no seu cofre pessoal.** O item "Auroq OS - token da conta de servico" fica guardado no seu cofre pessoal, que o agente não enxerga. Num segundo computador seu, o comando acha essa cópia e reaproveita a mesma chave em vez de criar outra (o 1Password aceita ~100 contas de serviço por conta). Se a cópia não puder ser guardada, a conexão vale do mesmo jeito e o Ops avisa.
+- **O cofre local saiu como rota de credencial.** `business/vault/` continua existindo só para o status e para as referências `op://...`, nunca com o valor. A oferta "seguir com cofre local (menos seguro)" saiu do Ops, do `AGENTS.md` e dos guias.
+- **Quem não tem 1Password é guiado a criar.** O Ops explica o caminho: teste grátis de 14 dias, sem cartão; depois, o plano Individual custa ~US$ 2,99 por mês (promoção do 1º ano, cobrança anual) a ~US$ 3,99 por mês (anual, preço regular) ou ~US$ 4,99 no mensal, e o Families ~US$ 4,49 a ~US$ 5,99 por mês. Os preços mudam: confira na tela. O Ops nunca digita dados de pagamento nem cria a conta por você.
+- **Mais de uma conta no app?** O comando não adivinha: lista as contas e pede para você escolher em qual vai ficar o cofre (`--conta "<e-mail>"`). Se a única conta do app for de empresa (Teams ou Business), ele também pergunta antes de criar o cofre nela. Em conta de empresa (Teams ou Business) só o dono ou o administrador cria conta de serviço, por padrão; sem permissão, o comando para antes de criar qualquer coisa e explica.
+- **O Companion liga o cofre sozinho (skill `conectar-1password`, hoje `conectar-cofre`).** Pipeline de 8 etapas, cada uma com o critério de "pronto": conta e plano → app instalado e chave "Integrar com a CLI" ligada → ferramenta `op` → aprovação com a digital → cofre `Claude` → chave do agente → teste em terminal novo → pronto (só depois do teste). Ele aciona no primeiro uso (conferência técnica), quando uma tarefa precisa de uma credencial e não acha a chave, e quando o `op` dá erro de autenticação; também responde ao `*cofre`. Fica retomável: o comando grava, em `~/.arcane/1password-etapas.json` (só neste computador, fora do GitHub, sem segredo e sem e-mail), até onde chegou; `--estado` mostra a etapa sem falar com o 1Password e sem gastar a cota, e rodar o comando de novo reconfere tudo e continua de onde parou, sem criar nada em duplicidade. O Ops e o Companion leem a cota com cuidado: cada credencial uma vez por conversa, com `op read`, e nunca rodam `env`/`printenv` nem abrem o arquivo onde a chave fica.
+- **Mais cuidado com a sua conta.** Falha passageira (limite de uso, falta de internet, resposta estranha de um proxy) nunca é tratada como "chave morta": o comando para sem criar outra conta de serviço e sem arquivar a cópia boa, e diz para tentar de novo em alguns minutos. Antes de criar qualquer coisa ele confere que consegue guardar a chave: se o arquivo de configurações do seu terminal for um atalho ou estiver guardado no git (como repositórios de "dotfiles"), ou já tiver uma linha sua para essa chave, ele não grava (a chave iria para o GitHub, ou apagaria o que é seu) e avisa. Só uma execução por vez, e uma cópia da chave só é reaproveitada se for da mesma conta e só enxergar o cofre `Claude`.
+- **Modo manual só como plano B.** O jeito antigo (você cria a conta de serviço no site do 1Password e copia o token) continua existindo atrás de `--manual`, escondido, para quem não puder usar o automático. Não faz parte do caminho principal.
+- **Limite de uso.** Nos planos Individual e Families, a chave aceita ~1.000 leituras e ~100 escritas por hora, e a conta inteira ~1.000 chamadas por dia (confira na tela do 1Password). O Ops lê o que precisa uma vez por conversa e reaproveita o valor, em vez de ler de novo.
+- **Trocar a chave.** `--rotacionar` cria uma chave nova mesmo com a atual funcionando. A antiga só deixa de valer quando você a revoga em 1password.com > Developer > Service accounts (o 1Password não tem comando para apagar conta de serviço). Se o endereço de login da conta mudar, a chave precisa ser trocada assim.
+
+### Para o suporte
+
+- **Comando:** `npx -y auroq-os@latest conectar-1password --agente` (Windows: `npx.cmd`; dê 10 minutos de tempo-limite à ferramenta). Sem `--agente` (aluno no terminal), se a chave do app ainda não estiver ligada, o comando espera até 5 min, olhando a cada 3 s, e segue sozinho.
+- **Flags:** `--agente` (usado pelo Ops e pelo app: não espera, não pergunta e termina com uma linha só); `--conta "<e-mail>"` (escolhe a conta do app quando há mais de uma; aceita e-mail, endereço de login ou ID); `--rotacionar`; `--esperar N` (segundos; 0 não espera); `--manual` (plano B).
+- **Linha lida pelo Ops (só com `--agente`):** `AUROQ_RESULTADO 1password=<ok|aguardando|erro> codigo=<codigo> [aviso=cofres-extras] [contas="a|b"] mensagem="..."`, no mesmo padrão da `manutencao --agente`. Código de saída: 0 para `ok` e para `aguardando` (falta uma ação do aluno, não é falha; assim a telemetria não registra falso `INSTALL_FAILED`) e 1 para `erro`.
+- **Códigos `ok`:** `criada`, `reaproveitada` (achou a cópia no cofre pessoal), `ja-conectado` (pode vir com `aviso=cofres-extras`: a chave antiga enxerga mais cofres que o `Claude`; rode com `--rotacionar`).
+- **Estado e retomada:** `--estado` (com `--agente`) imprime `AUROQ_ESTADO 1password=<pronto|em-andamento|nao-iniciado> proxima=<etapa> feitas=... token=<configurado|ausente> ultimo=<codigo> conferido=nao` (`conferido=nao`: não falou com o 1Password). O arquivo de estado fica em `~/.arcane/1password-etapas.json`; a trava de instância única, em `~/.arcane/1password.lock`.
+- **Códigos `aguardando`:** `ligar-integracao` (a chave "Integrar com a CLI do 1Password" está desligada; o app aberto e desbloqueado é pré-requisito, e o erro `No accounts configured` também cai aqui), `escolher-conta` (mais de uma conta no app; as contas vêm no campo `contas`), `aprovar-no-app` (o aluno não aprovou a janela da digital), `confirmar-conta` (a conta do app parece de empresa: só segue com `--conta`) e `outra-execucao` (já tem uma conexão rodando neste computador; vale por até 15 minutos).
+- **Códigos `erro`:** `sem-op` e `op-antigo` (o `op` não instalou ou é anterior à 2.30.0; ele atualiza sozinho quando consegue), `rede`, `conta-nao-encontrada` (o `--conta` não existe no app), `sem-cofre`, `cofre-duplicado` (a conta tem dois cofres `Claude`; o `op` deixa duplicar e o comando para sem criar nada), `sem-permissao` (conta de empresa em que o aluno não é dono nem administrador), `falha-criar`, `nao-gravou` (não conseguiu salvar a chave no computador), `token-recusado` (a chave foi salva, mas o teste falhou; a chave não se perde, rode de novo), `cofres-extras` (a chave nova enxerga mais que o `Claude`), `app-tem-prioridade` (o `op` respondeu pelo app e não pela chave), `conta-ambigua` (duas contas com o mesmo e-mail: use o endereço de login em `--conta`) e `token-indisponivel` (limite de uso, falta de internet ou demora do 1Password na hora de conferir a chave que já existe: o comando para SEM criar outra conta de serviço; tente de novo em alguns minutos), `arquivo-ambiente` (o arquivo de configurações do terminal é um atalho, está no git ou já tem uma linha do aluno para a chave: nada foi criado) e `falha` (exceção inesperada). Erros que o aluno ou o plano dele resolvem (`sem-op`, `op-antigo`, `rede`, `conta-nao-encontrada`, `conta-ambigua`, `cofre-duplicado`, `sem-permissao`, `token-indisponivel`, `arquivo-ambiente`) saem com 1 mas a telemetria os registra como etapa do fluxo, não como instalação quebrada.
+- **Sinais conhecidos:** `(429) Too Many Requests` é limite de uso estourado; no macOS 27, se o `op` disser `No accounts configured` com o app aberto, libere o terminal em Privacidade e Segurança > Arquivos e Pastas ("Data shared by 1Password") e abra o terminal de novo. Windows: a documentação do 1Password só cita o PowerShell como terminal suportado; Git Bash e WSL ficam para conferir no teste manual.
+- **Nunca peça o token ao aluno** nem o aceite colado na conversa: o comando automático não precisa dele.
+
+### Plano B grátis: Infisical, para quem não quer gastar nem 1 real
+
+Decisão do Euriler (23/10): além do 1Password (pago, recomendado), o aluno que diz "não quero gastar nem 1 real, mas quero resolver" tem o **Infisical**, um cofre de código aberto com plano grátis na nuvem. Não é tão bom quanto o 1Password (não preenche senha no navegador; só guarda as chaves que o agente usa), mas resolve. O cofre local, com os valores em texto, continua proibido.
+
+- **A escolha vem no começo.** Quando o aluno precisa de um cofre e ainda não tem nenhum, o Companion pergunta: "Quer o 1Password (uns 3 dólares por mês, confira o preço na tela, preenche senha no navegador, recomendado) ou o grátis (Infisical, só guarda as chaves do agente)?". Sem resposta clara, ele oferece o 1Password e diz que o grátis existe. O comando novo `conectar-cofre` faz essa escolha; o `conectar-1password` continua com as mesmas flags e respostas (só passa a marcar o cofre ativo em `~/.arcane/cofre.json`).
+- **O que o aluno faz no grátis são duas coisas.** Criar a conta grátis no Infisical (app.infisical.com/signup) e entrar na conta na página que abre sozinha no navegador. Ele **não** clica em "Start a free trial" (o teste do plano pago pede cartão e pode virar cobrança se não for cancelado). O resto é do Companion.
+- **O Companion faz o resto, em 7 etapas, cada uma com o seu "pronto".** Conta → ferramenta `infisical` → entrar no navegador → projeto `Auroq` → chave do agente → teste em terminal novo → pronto (só depois do teste). Ele instala a ferramenta sem pedir senha de administrador e sem mexer no PATH (baixa a versão 0.44.8 da página oficial de versões, confere o código de verificação SHA-256 e guarda no computador do aluno; se não der, tenta Homebrew no Mac e winget no Windows), cria o projeto `Auroq`, cria a chave do agente **só desse projeto** (uma "identidade de máquina" do projeto, com papel `member`: lê e grava segredos, sem validade) e guarda a chave no computador, no mesmo lugar da chave do 1Password. Por último confere num terminal novo: grava, lê e apaga um segredo de teste usando só a chave do agente. O segredo de teste tem nome novo a cada teste (`AUROQ_TESTE_<12 caracteres 0-9 e A-F>`), então nunca pisa num segredo do aluno e dois computadores testando juntos não se atrapalham; depois de gravar ele é sempre apagado, mesmo se a leitura falhar, e se nem o apagar der certo a tela diz o nome para o aluno apagar no painel (a migração para o 1Password ignora esse nome).
+- **A sessão do aluno só existe na configuração.** O login do navegador vale alguns dias (o padrão do Infisical é 10; na nuvem o prazo exato não foi confirmado) e a ferramenta não o renova, então o agente não depende dele: trabalha só com a chave do agente, que não vence e entra sozinha a cada uso. O login do aluno é encerrado no fim de **toda** execução que o usou, com sucesso ou com erro (a tela avisa "O Auroq saiu da sua sessão do Infisical"), para o acesso de administrador da organização não ficar parado alguns dias no computador. Se o encerramento falhar, a tela avisa e traz o caminho do programa que o Auroq instalou para o aluno sair na mão (`<caminho> logout --profile auroq`); isso não muda o resultado da conexão. Só não é encerrado quando o login ainda não terminou (o aluno ainda não aprovou). Consequência: depois de um erro posterior ao login (por exemplo `falha-identidade` ou `rede`), a rodada seguinte abre o navegador de novo para entrar ou aprovar; e os erros que só se resolvem trocando de organização ou de conta (`sem-organizacao`, `projeto-sem-acesso`, `sem-permissao`) dizem "Encerrei a sessão" e a próxima rodada reabre o navegador.
+- **A chave nunca aparece.** Nem na tela, nem na conversa, nem em linha de comando, nem nos arquivos do projeto ou da configuração do Auroq: ela nasce dentro do comando e é gravada direto no arquivo de ambiente do seu usuário (Mac/Linux, permissão só dele, com as mesmas recusas da rota A para atalho, arquivo no git e linha própria do aluno) ou nas variáveis do usuário (Windows). Qualquer programa do aluno consegue usá-la. Se não der para gravar, a chave que acabou de ser criada é revogada na hora, para não sobrar nada solto; se nem a revogação der certo, o resultado traz `aviso=chave-orfa` e a descrição da chave a apagar no painel.
+- **Uma chave por computador.** Quem usa dois computadores tem uma chave em cada (descrição "Auroq OS - <nome do computador> [código de 10 caracteres] - <data>"). O código vem de um identificador que o sistema já tem (não do nome, que pode repetir ou mudar) e só ele identifica o computador: trocar a chave (`--rotacionar`) revoga só as antigas daquele computador, nunca as dos outros, mesmo com dois computadores de mesmo nome. Além das que têm o código do computador na descrição, a troca também revoga a chave que este computador usa agora, reconhecida pelos 4 primeiros caracteres que o Infisical lista (vale para computador novo com a pasta copiada, em que o código da descrição é de antes). A troca lista as chaves antigas antes de criar a nova, só revoga depois que o teste da nova passa e, se a revogação falhar, termina `ok` com `aviso=revogacao-pendente` ("a chave antiga AINDA vale"): a rodada seguinte, sem `--rotacionar`, termina a troca. Se não achar nenhuma chave antiga para revogar (e havia chaves vivas), termina `ok` com `aviso=chave-antiga-nao-identificada`: nenhuma foi revogada, a que vazou (se for uma antiga) continua valendo e a mensagem manda apagá-la no painel; não há o que terminar rodando de novo. Chave de outro computador (perdido, roubado) a rotação não revoga: apagar no painel do Infisical.
+- **Um comando só para ler e gravar, qualquer que seja o cofre.** `npx -y auroq-os@latest segredo ler|gravar|listar|apagar|qual <Item>[/<campo>]` funciona igual no 1Password e no Infisical, para os agentes, squads e skills não precisarem saber qual dos dois está por trás. O valor para gravar vai por stdin (ou `--arquivo`), nunca na linha de comando; o `gravar` confere lendo de volta e tira o BOM, a quebra de linha final e os espaços das pontas; `ler` escreve só o valor e **nunca** sai com sucesso e saída vazia (segredo que não existe, ou que existe sem valor, sai com código 3); `ler` imprime o valor, então os textos mandam usá-lo sempre dentro do comando que o usa, numa variável, e nunca sozinho. Apagar exige `--confirmo`; no 1Password isso arquiva o **item inteiro** (todos os campos dele; volta pelo Arquivo do app), por isso a confirmação avisa antes, lista os campos com valor e recusa `ITEM/CAMPO` quando o item tem outros campos. As mensagens de erro não repetem o que foi digitado. No 1Password, `op read "op://Claude/<Item>/<campo>"` continua valendo.
+- **Começou no grátis e assinou o 1Password?** O Companion conecta o 1Password e roda `conectar-cofre --migrar`: as chaves são levadas para o cofre `Claude`, cada uma lida de volta para conferir, sem mostrar valor nenhum. Nada é apagado do Infisical. **Ligar o 1Password sozinho não troca o cofre de quem já usa o Infisical** (a linha `AUROQ_AVISO cofre=infisical mantido=sim` avisa): o cofre ativo só vira o 1Password quando a migração leva **todas** as chaves (ou não havia nenhuma); com falhas (`migrado-parcial`), segue o grátis. Nomes que só diferem na caixa (`abc` e `ABC`) são falha explícita (no 1Password seriam o mesmo nome) e nenhuma das duas é passada; nomes que o Auroq não usa (espaço, mais de 64 caracteres) não se resolvem rodando de novo: renomear no painel ou usar `--ignorar-fora-do-formato`, que os deixa no Infisical sem apagar. Chave que já existia no 1Password com outro valor fica com o valor do Infisical e a mensagem avisa quais (só nomes). Se o Infisical recusar a chave deste computador (revogada, ou identidade ou projeto apagado), a migração para com `origem-indisponivel` e manda gerar a chave de novo (`conectar-cofre --cofre infisical --agente`) em vez de mandar esperar; só instabilidade (rede, limite, bloqueio) continua pedindo para esperar. O segredo de teste da conexão (`AUROQ_TESTE_<código>`) nunca é levado. O caminho contrário não é automático: conectar o Infisical com o 1Password ativo troca o cofre ativo (escolha explícita do aluno) e avisa (`AUROQ_AVISO cofre=infisical chaves-antigas=1password`) que as chaves do 1Password não foram levadas, mas continuam lá e se leem com `segredo ler NOME --cofre 1password`.
+- **Limites do plano grátis (confira na tela do Infisical):** 5 vagas no total, somando o aluno e cada agente (identidade) que ele criar (o Auroq usa 1 identidade, então o aluno usa 2; um segundo computador ganha só uma chave nova e não gasta vaga); projetos ilimitados; 3 ambientes por projeto; sem histórico de versões dos segredos nem registro de auditoria; o plano grátis pode ser alterado ou encerrado pela empresa e os termos do Infisical falam em uso profissional. Região: Estados Unidos por padrão; Europa com `--regiao eu`.
+- **O Companion aciona sozinho, nos mesmos gatilhos do 1Password** (primeiro uso, tarefa que precisa de credencial sem cofre, erro de autenticação, `*cofre`, computador novo). A skill agora se chama `conectar-cofre` (`agents/companion/tasks/conectar-cofre.md`; o gatilho e o comando antigos continuam funcionando).
+
+### Para o suporte (cofre grátis)
+
+- **Comandos:** `npx -y auroq-os@latest conectar-cofre --cofre infisical --agente` (Windows: `npx.cmd`; dê 10 minutos de tempo-limite à ferramenta: o comando espera o aluno entrar no navegador por até 9 minutos). Sem `--cofre` e sem cofre em andamento, devolve `AUROQ_RESULTADO cofre=aguardando codigo=escolher-cofre`. `conectar-cofre --estado --agente` imprime `AUROQ_ESTADO cofre=<1password|infisical|nenhum> ...`. `--migrar` leva as chaves do Infisical para o 1Password (`--ignorar-fora-do-formato` deixa no Infisical as chaves com nome que o Auroq não usa).
+- **Flags da rota B:** `--agente`, `--estado`, `--rotacionar`, `--regiao us|eu`, `--dominio <https://...>`, `--esperar N` (segundos; teto 570, descontado o tempo gasto antes, como instalar a ferramenta; mínimo 5, então `--esperar 0` devolve `aguardando` na hora). Numa máquina já conectada, o endereço novo (`--regiao`/`--dominio`) só é gravado quando a chave nova fica guardada: depois de um `aguardando` numa troca de região, repetir `--regiao eu` na rodada seguinte.
+- **Linhas lidas pelo Ops:** `AUROQ_RESULTADO infisical=<ok|aguardando|erro> codigo=<codigo> [aviso=identidades-extras|revogacao-pendente|chave-antiga-nao-identificada|chave-orfa] [url="..."] mensagem="..."` (um aviso por resultado, na prioridade `revogacao-pendente`, `chave-antiga-nao-identificada`, `identidades-extras`; a `url` é de um login que já terminou, não serve para o aluno abrir: o link vivo sai na tela durante a espera), `AUROQ_AVISO cofre=infisical mantido=sim mensagem="..."` (depois do resultado do 1Password, quando o Infisical continua o cofre ativo), `AUROQ_AVISO cofre=infisical chaves-antigas=1password mensagem="..."` (depois do resultado do Infisical, quando ele trocou o 1Password como cofre ativo; pode vir também depois de `ja-conectado`, quando o aluno volta do 1Password para o grátis, e diz que nada foi copiado: o Infisical só tem o que já foi guardado nele) e `AUROQ_ESTADO infisical=<pronto|em-andamento|nao-iniciado> proxima=<etapa> feitas=... credencial=<configurado|ausente> ultimo=<codigo> conferido=nao`. Migração: `AUROQ_RESULTADO cofre=<ok|aguardando|erro> codigo=<migrado|migrado-parcial|nada-a-migrar|conectar-1password-primeiro|origem-indisponivel|falha> movidos=N iguais=M falhas=K mensagem="..."`. Código de saída: 0 para `ok` e `aguardando`, 1 para `erro`.
+- **Códigos `ok`:** `criada` (identidade nova), `reaproveitada` (a identidade `Auroq` já existia; se o comando criou chave, ela é só deste computador; numa troca pendente ou numa configuração perdida ele só reaproveita a chave que já estava aqui, sem criar outra, e a linha de resultado é a mesma; é aqui que vêm `aviso=identidades-extras`, `aviso=revogacao-pendente` e `aviso=chave-antiga-nao-identificada`, este só com `--rotacionar`: a chave nova existe, mas nenhuma chave antiga foi revogada) e `ja-conectado` (a chave do computador já entra no projeto; confere sem abrir navegador, mas só diz isso depois de provar que um terminal novo a enxerga e que ela grava, e nunca com uma troca de chave pela metade).
+- **Códigos `aguardando`:** `login-no-navegador` (o aluno ainda não entrou na conta; a sessão vencida cai aqui também, e o código antigo `sessao-expirada` nunca é devolvido) e `outra-execucao`.
+- **Códigos `erro`:** `sem-cli`, `cli-antigo` (precisa da 0.43.139 ou mais), `rede`, `sem-organizacao`, `projeto-sem-acesso` (o endereço `auroq` já é de outro projeto da organização), `falha-projeto`, `limite-plano` (só aqui é falta de vaga: as 5 do grátis acabaram; apagar uma **identidade** que não usa no painel), `plano-restringe` (o plano grátis barrou outra etapa, como papel, faixa de IP, ambiente ou projeto: **não** é falta de vaga e apagar identidade não resolve), `sem-permissao`, `falha-identidade`, `falha-chave`, `nao-gravou` (a chave criada é revogada; se nem isso der, `aviso=chave-orfa`), `teste-falhou` (a chave ficou gravada: rodar de novo, sem `--rotacionar`; numa troca, a chave antiga não foi revogada), `credencial-indisponivel`, `arquivo-ambiente`, `bloqueada` (3 falhas de login seguidas travam a chave por 5 minutos: esperar 6), `limite` (limite de uso) e `falha`. Os que o aluno ou o plano dele resolve saem com 1 mas a telemetria os registra como etapa do fluxo.
+- **Arquivos no computador do aluno (sem segredo, fora do git), em `~/.arcane/`:** `cofre.json` (qual cofre está ativo), `infisical.json` (endereço, projeto, identidade, caminho da ferramenta), `infisical-etapas.json` (as 7 etapas), `infisical.lock` (uma execução por vez), e, do comando `segredo`, `cofre-op.lock` (uma gravação por vez no 1Password), `cofre-infisical-login.lock` (um login por vez no Infisical) e `cofre-infisical-bloqueio.json` (marca de "chave bloqueada por uns 5 minutos", só com o código da chave e a hora). O `infisical.json` pode ganhar `instalacaoId` (só quando o sistema não informa o identificador do computador) e `rotacaoPendente` (só códigos das chaves antigas a revogar). As chaves ficam nas variáveis `AUROQ_INFISICAL_CLIENT_ID` e `AUROQ_INFISICAL_CLIENT_SECRET` (nome próprio para não colidir com as `INFISICAL_*` do trabalho do aluno).
+- **Falha passageira nunca cria chave nova:** erro 500, limite de uso, falta de internet ou bloqueio na hora de conferir a chave do computador param com `credencial-indisponivel`/`limite`/`rede`/`bloqueada` e não criam nada (vale também quando a chave está válida mas a configuração se perdeu). Só "credenciais inválidas" prova chave morta e gera outra. Pelo mesmo motivo, erro 5xx ou de rede ao CRIAR projeto, identidade ou chave não repete sozinho: vira `falha-projeto`/`falha-identidade`/`falha-chave` e a rodada seguinte reaproveita o que o servidor gravou.
+- **Desfazer:** `infisical logout --profile auroq` (a sessão já é encerrada no fim da conexão; se o `infisical` não estiver no PATH, use o caminho do programa que o Auroq instalou, o mesmo que a tela mostra quando não consegue sair da sessão: `<caminho> logout --profile auroq`); apagar a identidade `Auroq` e o projeto `Auroq` no painel do Infisical revoga tudo (apagar a identidade é o que libera vaga; apagar só uma chave dentro dela não); remover o bloco "Infisical - identidade do agente" do arquivo de ambiente (ou as duas variáveis do usuário no Windows) e a pasta `~/.arcane/infisical*`; a ferramenta instalada fica em `~/.local/bin/infisical` (Mac) ou `%LOCALAPPDATA%\Programs\infisical` (Windows).
+
+### Ainda não publicado
+
+Precisa de nova versão do npm ANTES de subir o catálogo `auroq-core`: o `ops.md` e a skill `conectar-cofre` vivem no catálogo e mandam rodar comandos novos (`conectar-1password --agente`, `conectar-cofre`, `segredo`). A versão atual do npm não entende `--agente` nem `conectar-cofre` e cai no jeito antigo de colar o token. Ainda falta o teste manual numa conta 1Password nova **e numa conta Infisical nova**, em Mac e em Windows (ver `docs/stories/AUROQ-1password-automatico.md`). Sem número de versão por enquanto.
+
+## 2.8.1 — 2026-10-22
+
+### Mapa do Negócio: o sistema conhece o seu negócio e toda a equipe lê isso primeiro
+
+- **Um resumo de uma página do seu negócio.** Nova semente `docs/knowledge/mapa-do-negocio.md`: quem você é, o que vende e por quanto, para quem, por onde vende, a meta dos próximos 90 dias e o tom, com links para o detalhe de cada parte e, no fim, "Ainda não sei" (o que falta) e "Atualizado em". Até uns 3.000 caracteres.
+- **Toda a equipe lê o mapa primeiro.** O `AGENTS.md` da sua pasta manda todo agente, squad e skill ler esse resumo antes de trabalhar em qualquer coisa do negócio, não tratar "Ainda não sei" como fato e atualizar o mapa pelo Companion quando aparece fato novo. A regra da memória e o guia do sistema (`como-funciona.md`) ganharam a mesma linha.
+- **Sementes novas dos blocos** (chegam também em quem já tem a pasta, sem sobrescrever nada): `expert-business/canais-e-numeros.md`, `metas.md`, `provas.md`, `referencias.md`, `equipe-e-ferramentas.md` e `expert-mind/vida-pessoal.md` (opcional).
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.30): **skill `auroq-contexto` no Companion.** 11 blocos (quem é você, o que vende, para quem, como vende, meta e o que trava, posicionamento, provas, tom e valores, referências, vida pessoal opcional, equipe e ferramentas). Primeiro lê o seu material (bio, site, Instagram, apresentação, PDF, prints, áudio, página de vendas) e só pergunta o que faltou, uma pergunta por vez, em português simples. Cada fato fica com a fonte (`o aluno disse, 22/10`, `do site, 22/10`); o que o Companion só deduziu fica "a confirmar" e nunca vira fato sem você dizer que está certo. Nunca pede senha, token ou dado bancário; vida pessoal é opcional e qualquer pergunta pode ser pulada.
+- **Primeiro uso mais rápido** (decisão do Euriler, 22/10: ver resultado logo). O `*primeiro-uso` agora pede o material primeiro, faz só o bloco essencial (blocos 1 a 5) e termina como antes: organiza os projetos no app e no GitHub e grava `.auroq/primeiro-uso.json`. O resto do mapa vem aos poucos.
+- **Pergunta do dia.** Na conversa normal, se o mapa tem lacunas, o Companion faz UMA pergunta no começo (pode pular), no máximo uma por dia, nunca no meio de uma tarefa. Comando novo `*contexto [bloco]` para ver, completar, revisar ou refazer uma parte do mapa. "Lancei um produto" ou "mudei o preço" atualizam o mapa na hora; a cada 90 dias o Companion propõe revisar a meta.
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.31, 22/10): **o Companion confere e conserta o computador.** O primeiro uso começa com uma conferência técnica (`doctor --leve` e as contas): o que faltar de programa ou do sistema o próprio Companion conserta na mesma conversa, seguindo o guia do Ops, e confere de novo; conta faltando vira um aviso de uma linha para Configurações → Conexões; conserto que demora ou falha duas vezes vai para as pendências e a entrevista segue. Fora do primeiro uso, "algo do computador quebrou" também fica com o Companion, sem trocar de agente (decisão do Euriler: o aluno só fala com o Companion).
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.34, 22/10): **depoimento não é obrigatório.** O Companion nunca pergunta por provas e depoimentos (nem no primeiro uso, nem na pergunta do dia) e não ter não vira lacuna; o bloco só se preenche quando aparece no material ou o aluno conta.
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.33, 22/10): quem ainda não vende nada fica registrado em `produto/ainda-nao-vende.md` (o app conta como respondido).
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.32, 22/10): **a entrevista nunca trava o aluno.** Toda pergunta aceita "não tenho ainda" (vira fato no mapa, ex.: "ainda não tem produto", e não fica cobrando), "não sei ainda" e "pular" (viram lacuna, sem repetir antes de 30 dias). Sem material, segue direto para a entrevista básica. No primeiro uso, no máximo 7 perguntas; quem ainda não tem negócio responde só quem é, o que gostaria de vender e a meta.
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.35, 22/10): **no app, o aluno não é mais mandado ao Ops.** Conflito ao salvar, cofre de senhas (1Password ou Bitwarden) e publicar site ficam com o próprio Companion, seguindo o guia técnico do Ops; atualizar o sistema é do app. O Ops segue como o Bootstrap de quem não usa o app (decisão do Euriler: "não faz sentido chamar ops").
+- Mantém `arcane-mcp@0.7.0`. Instaladores do repositório preparados para 2.8.1.
+
+### Também nesta versão
+
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.29, 22/10): **organizar os projetos no fim da primeira conversa.** No P5 do `*primeiro-uso`, o Companion passa a organização inteira para a skill `auroq-configurar` do app: ela lê a memória gravada no P4, as pastas e o GitHub, conversa com o aluno até a organização ficar do jeito dele e, com o "sim", arruma a barra, cria as cópias privadas que faltam no GitHub e anota na memória. O Companion só faz o GitHub sozinho quando a skill não existe ou é a versão antiga, que só arruma a barra.
+- Conteúdo ao vivo (catálogo `auroq-core` 2.3.28, 22/10): **"Conexões" no app.** A seção das contas no app Auroq OS virou Configurações → **Conexões**: "Essenciais — nível 1" (GitHub, Vercel e Supabase) no topo, depois "Essenciais — nível 2" (Cloudflare, cofre de senhas e Google) e "Outras conexões úteis" (Higgsfield, HeyGen, Canva, Meta Ads, Notion e a conexão personalizada). O Companion manda para "Configurações → Conexões" quando falta conta; o `*bootstrap-2` do Ops diz que, no app, as extras se conectam ali; e o `*conectar-1password` ganhou o caminho do Bitwarden (Secrets Manager, conta de máquina, token sem passar pelo chat), que o app abre numa conversa com o Ops.
+
 ## 2.8.0 — 2026-10-22
 
 ### A memória do sistema procura sozinha, salva no fim do trabalho e se arruma todo dia (com o app Auroq OS)

package/README.md

@@ -53,12 +53,45 @@ O caminho manual antigo foi aposentado. Use a instalacao guiada acima. Em negoci
 | `auroq-os doctor` | Diagnostico do suporte: arquivos, motor do sistema (e se o programa aberto pelo icone enxerga ele), registro do conteudo ao vivo, login e servidor |
 | `auroq-os register-mcp` | Reescreve o registro do conteudo ao vivo no projeto (use se o `doctor` apontar que ele falta) |
 | `auroq-os sync-codex` | Regenera e verifica as skills locais do Codex |
-| `auroq-os conectar-1password` | Conecta o 1Password CLI — le o token de Service Account direto do Ctrl+C (nunca digitado nem exposto), instala o `op` se faltar, valida online e salva permanente (Mac/Windows) |
-
-> **Seguranca do token 1Password:** o token fica salvo no computador e qualquer programa seu consegue usa-lo.
-> Crie a Service Account com acesso a **um cofre so**, dedicado ao Auroq (o cofre `Claude`), sem senhas
-> pessoais, de banco ou da empresa. Permissao **so leitura**; libere escrita apenas nesse cofre se quiser
-> que o Auroq guarde ali as credenciais novas que voce conectar.
+| `auroq-os conectar-1password` | Liga o 1Password ao Auroq sozinho (Mac/Windows): instala o `op` se faltar, cria o cofre `Claude` e uma conta de servico que so enxerga esse cofre (sem data de validade), guarda a chave no computador e testa. Voce so aprova no app do 1Password. O Ops roda isto por voce (`--agente`). Opcoes: `--conta "<e-mail>"` (escolhe a conta quando o app tem mais de uma), `--rotacionar` (cria uma chave nova), `--estado` (mostra em que etapa voce parou, sem falar com o 1Password; com `--agente` imprime a linha `AUROQ_ESTADO ...`). Pode ser retomado a qualquer hora: ele reconfere cada etapa e continua de onde parou. O Companion roda isto sozinho quando falta o cofre (skill `conectar-cofre`, que pergunta qual cofre) |
+| `auroq-os conectar-cofre` | Escolhe e liga o cofre de senhas: **1Password** (pago, uns US$ 3 por mes, confira o preco na tela, recomendado; preenche senha no navegador) ou **Infisical** (gratis, so guarda as chaves que o agente usa). Opcoes: `--cofre 1password\|infisical` (sem ela, pergunta qual), `--regiao us\|eu` (Infisical), `--estado` (em que etapa voce parou, sem falar com o cofre; com `--agente` imprime a linha `AUROQ_ESTADO ...`), `--rotacionar` (chave nova) e `--migrar` (passa as chaves do Infisical para o 1Password, sem apagar nada; so depois que todas passaram o 1Password vira o cofre ativo, e `--ignorar-fora-do-formato` deixa no Infisical as chaves com nome que o Auroq nao usa). Ligar o 1Password sozinho nao troca o cofre de quem ja usa o Infisical; ligar o Infisical com o 1Password ativo troca, e as chaves do 1Password nao sao levadas (continuam la, `segredo ler NOME --cofre 1password`). O Ops e o Companion rodam isto por voce (`--agente`) |
+| `auroq-os segredo` | Le e guarda credenciais no cofre que voce escolheu, igual nos dois: `segredo ler\|gravar\|listar\|apagar\|qual <referencia>`. O valor de `gravar` entra por stdin, nunca como argumento; `ler` imprime o valor, entao use sempre dentro do comando que o usa (`X="$(auroq-os segredo ler Item/campo)" && comando "$X"`), nunca sozinho; a referencia e `op://Claude/<Item>/<campo>` ou `cofre://<Item>/<campo>`. Com 1Password, `op read` direto continua valendo. Squads, skills e agentes usam este comando |
+
+> **Um cofre de senhas e obrigatorio** para guardar credenciais: senha, token e chave nunca ficam em arquivo do
+> projeto. Em `business/vault/` fica so o status e a referencia `op://...`, nunca o valor. Voce escolhe:
+>
+> - **1Password (recomendado, pago).** Quem nao tem e guiado pelo Ops (ou pelo Companion) a criar a conta (teste
+>   gratis de 14 dias, sem cartao; o plano Individual custa ~US$ 2,99 a 3,99/mes, confira o preco na tela). Voce so
+>   (1) cria a conta, (2) instala o app, (3) liga "Integrar com a CLI do 1Password" em Configuracoes >
+>   Desenvolvedor e (4) aprova com a digital (Mac) ou o Windows Hello. O resto o Ops faz. Preenche senha no
+>   navegador.
+> - **Infisical (gratis).** Para quem nao quer gastar nem 1 real. Voce so (1) cria a conta em
+>   https://app.infisical.com/signup (plano gratis; **nao** clique em "Start a free trial", que e o teste dos
+>   planos pagos e pede cartao) e (2) aprova o login que abre no navegador. O resto o Ops faz. Nao e tao bom: **nao
+>   preenche senha no navegador**, so guarda as chaves que o agente usa. Plano gratis (confira os limites na tela):
+>   5 vagas (voce e o agente Auroq; um segundo computador ganha chave nova mas nao gasta vaga), sem historico de versoes e sem registro de auditoria. Os termos do
+>   Infisical falam em uso profissional e o gratis pode mudar. Se um dia assinar o 1Password, `conectar-cofre
+>   --migrar` leva as chaves para la.
+>
+> Nao existe cofre de valores guardado em arquivo no computador, em nenhuma das duas rotas.
+
+> **Seguranca da chave 1Password:** o comando cria sozinho o cofre `Claude` e a conta de servico, e essa
+> chave **so enxerga o cofre `Claude`** (leitura e escrita), nunca suas senhas pessoais, de banco ou da empresa.
+> Ela nao expira. A chave fica salva no computador e qualquer programa seu consegue usa-la; por isso o cofre
+> `Claude` deve ter so o que o Auroq precisa. Em conta de empresa (Teams/Business), em geral so o dono ou
+> administrador cria conta de servico. Se um dia quiser trocar a chave, rode com `--rotacionar` e revogue a
+> antiga em 1password.com > Developer > Service accounts. Plano B escondido: `--manual`, para quem prefere
+> criar a conta de servico na mao e copiar o token (Cmd+C / Ctrl+C), sem colar em lugar nenhum: o comando le da
+> area de transferencia e a limpa depois.
+
+> **Seguranca da chave do Infisical:** o comando cria sozinho o projeto `Auroq` e uma chave do agente que **so
+> enxerga esse projeto** (leitura e escrita), sem data de validade. Ela fica salva no computador (arquivo so seu no
+> Mac, variavel do usuario no Windows) e qualquer programa seu consegue usa-la; por isso o projeto deve ter so o que
+> o Auroq precisa. Para trocar, rode com `--rotacionar` (depois do teste ele revoga as chaves antigas deste
+> computador, reconhecido por um codigo proprio e nao pelo nome, e tambem a chave que este computador usa agora;
+> se a revogacao falhar, ou se ele nao achar nenhuma chave antiga para revogar, avisa que a chave antiga ainda vale
+> e que voce deve apaga-la no painel do Infisical). A sessao do seu login no Infisical so existe durante a conexao e e encerrada no fim. A chave nunca
+> passa pela conversa.
 
 Dentro do projeto instalado, os mesmos checks ficam disponiveis como
 `npm run auroq:sync:codex`, `npm run auroq:sync:codex:check` e
@@ -76,12 +109,13 @@ npx auroq-os clone          # lista seus repos do GitHub e baixa o negocio intei
 cd meu-negocio
 claude
 /AuroqOS:agents:ops
-*conectar-1password         # reconectar o cofre (uma vez so nesta maquina)
+*conectar-cofre            # 1Password: reaproveita a chave que ja existe no seu cofre (uma vez so nesta maquina; so aprovar no app). Infisical gratis: cria uma chave nova so para esta maquina (voce aprova o login no navegador). Antes, ele pergunta qual cofre voce usa
+*conectar-1password        # atalho antigo, so para o 1Password
 ```
 
 Ritual diario em toda maquina: **abriu o `claude` → o sistema puxa sozinho o que mudou · terminou → diga "salva e entrega"** (qualquer agente executa o ritual do Ops; `*sync`/`*commit`/`*push` seguem como atalhos).
 Colaborador usa conta propria de tudo (GitHub via convite, assinatura Claude propria,
-cofre 1Password com escopo) — nunca a senha do dono. **Colaborador nao precisa ser
+cofre 1Password ou Infisical com escopo) — nunca a senha do dono. **Colaborador nao precisa ser
 aluno**: o acesso dele e o convite do GitHub (o `clone` nao pede login); quem atualiza
 o sistema e o dono, e o colaborador recebe as atualizacoes automaticamente ao abrir o `claude`.
 
@@ -236,7 +270,8 @@ agents/             → Seu exercito (companion, workers, minds, squads)
 1. Ative o Ops (`/AuroqOS:agents:ops` no Claude/Grok ou `$ops` no Codex) e peca o Bootstrap 1.
 2. O Ops prepara browser oficial, Computer Use quando elegivel e Playwright como fallback, sempre com smoke test real.
 3. Ative o Companion (`/auroq-companion` no Claude/Grok ou `$companion` no Codex).
-4. Preencha os templates em `docs/knowledge/expert-mind/` e `docs/knowledge/expert-business/`.
+4. O Companion monta o seu Mapa do Negocio (`docs/knowledge/mapa-do-negocio.md`): le o material que voce tiver,
+   pergunta so o que faltou e completa o resto aos poucos (`*contexto`). Todo squad le esse resumo primeiro.
 5. Pronto — o sistema ja te conhece.
 
 ## Filosofia
@@ -254,13 +289,13 @@ agents/             → Seu exercito (companion, workers, minds, squads)
 
 ## Observabilidade e integridade do motor
 
-Apos publicacao, `npx -y auroq-os@2.8.0 doctor` mostra a fila local segura e os comandos pinados de
-manutencao/diagnostico. `npx -y auroq-os@2.8.0 manutencao` preserva o caminho existente
+Apos publicacao, `npx -y auroq-os@2.8.2 doctor` mostra a fila local segura e os comandos pinados de
+manutencao/diagnostico. `npx -y auroq-os@2.8.2 manutencao` preserva o caminho existente
 de consentimento legado, studentFiles, customizacoes e dados do negocio. Nao ha
-migracao forcada. O registro MCP aponta para `arcane-mcp@0.7.0` — o pin mora no campo
+migracao forcada. O registro MCP aponta para `arcane-mcp@0.7.1` — o pin mora no campo
 `arcaneMcpPin` do package.json (fonte unica; o servidor le o mesmo campo no npm).
 `npm run release:verify` recusa publicar com um pin que o npm nao resolva.
-Os instaladores do repositorio ficam preparados para 2.8.0; as copias publicas so recebem
+Os instaladores do repositorio ficam preparados para 2.8.2; as copias publicas so recebem
 a versao apos os gates nativos e a verificacao do tarball publicado.
 O pacote inclui `lib/runtime-integrity.json`: inventario SHA-256 gerado depois da montagem da casca, verificavel com `npm run integrity:verify` dentro do pacote extraido. Ele comprova consistencia do conteudo; nao e uma assinatura de autoria.