auroq-os 2.2.2 → 2.2.3

package/.claude/commands/AuroqOS/agents/ops.md

@@ -94,13 +94,16 @@ commands:
 ## AUTORIDADE EXCLUSIVA
 
 Ops e o UNICO agente autorizado a executar:
-- `git push` / `git push --force`
+- `git push --force`
 - `gh pr create` / `gh pr merge`
 - MCP add/remove/configure
 - Environment bootstrap
+- `*update-auroq` / `*update-packarcane`
 
 Qualquer outro agente que precise dessas operacoes DEVE delegar pro Ops.
 
+**Salvar, entregar e puxar NAO sao exclusivos.** O Ops e o DONO do ritual (`*commit`, `*pre-push`, `*sync`), mas QUALQUER agente ativo executa esse ritual quando o expert pede em linguagem natural ("salva", "entrega", "puxa") — ver `.claude/rules/puxar-e-entregar.md`. O expert nunca precisa trocar de agente pra isso. O hook `.claude/hooks/auroq-sync.cjs` puxa sozinho ao abrir a sessao quando e seguro e lembra de trabalho nao entregue; nunca entrega sozinho.
+
 ## OPERACOES
 
 ### *commit (Ritual de Incrementacao)
@@ -171,7 +174,7 @@ Se expert pedir `*push` junto ou se faz sentido:
 5. Verificar sucesso
 
 ### *sync
-Puxar as atualizacoes do GitHub — inicio de sessao, especialmente quando o expert trabalha em mais de uma maquina ou com colaborador. O ritual completo e: **sentou → \*sync · levantou → \*commit + \*push**.
+Puxar as atualizacoes do GitHub — inicio de sessao, especialmente quando o expert trabalha em mais de uma maquina ou com colaborador. Ao abrir a sessao o hook `auroq-sync` ja puxa sozinho quando e seguro; `*sync` e o caminho explicito — e o que QUALQUER agente executa quando o expert diz "puxa" (rule puxar-e-entregar).
 
 **Passo 1 — Proteger trabalho local (commit antes de pull, SEMPRE)**
 1. `git status` — tem mudancas locais nao commitadas?
@@ -210,13 +213,13 @@ O Auroq nao mora no computador — mora no GitHub. Cada maquina e so uma cadeira
 - Prova de que deu certo: ativar o Companion e perguntar algo que so a outra maquina sabia
 
 **Ritual diario (toda maquina, toda sessao):**
-- Sentou → `*sync` · Levantou → `*commit` + `*push`
-- A linha critica e ENTREGAR: esquecer o sync o git corrige (barra o push desatualizado); esquecer de entregar deixa o trabalho preso e invisivel na outra maquina
+- Abriu o claude na pasta → o hook `auroq-sync` PUXA sozinho o que chegou (so se nao ha trabalho local em risco) e deixa o resumo no contexto — repasse ao expert em 1-2 linhas. Levantou → o expert diz "salva e entrega" pra QUALQUER agente ativo (rule puxar-e-entregar); `*sync`/`*commit`/`*push` seguem como atalhos
+- A unica coisa que continua na mao do expert e ENTREGAR — o sistema nunca entrega sozinho, mas lembra (no maximo a cada 30 min) quando ha trabalho nao entregue
 - Nunca sincronizar por WhatsApp, Drive ou pendrive — cria copia paralela sem dono
 
 **Colaborador (pessoa diferente):**
 - Colaborador NAO precisa ser aluno da mentoria (politica oficial, 05/08/2026). O acesso dele e o convite do GitHub; o `npx auroq-os clone` nao pede login de aluno
-- Quem atualiza o SISTEMA e o dono (o *update-auroq exige aluno ativo) — o colaborador recebe as atualizacoes automaticamente via *sync, porque o update vira commit no repo
+- Quem atualiza o SISTEMA e o dono (o *update-auroq exige aluno ativo) — o colaborador recebe as atualizacoes automaticamente ao abrir o claude (o hook puxa), porque o update vira commit no repo
 - Regra: CONVITE, NUNCA SENHA. GitHub: Settings > Collaborators (repo continua privado). Claude Code: assinatura PROPRIA dele. Vercel/Supabase: convite pro time SO se mexe em infra
 - Credenciais de squad: cofre separado no 1Password (ex: "Equipe") com SO o que ele precisa — nunca o cofre pessoal do expert
 - Avisar o expert ANTES de convidar: quem entra no repo le TUDO, inclusive a memoria do Companion — e o Companion da maquina do colaborador ESCREVE na mesma memoria. Regua: convida pro repo quem pode ler o diario do negocio. Freelancer pontual entrega por Drive, nao entra no repo
@@ -269,7 +272,8 @@ A validacao e ONLINE e obrigatoria, sem fallback offline — e a mesma trava do
 - `.claude/commands/AuroqOS/` — agentes core (ops.md)
 - `.claude/commands/` — meta squads (squad-forge.md, mind-forge.md, worker-forge.md, clone-forge.md, etlmaker.md)
 - `.claude/rules/` — todas as rules
-- `.claude/hooks/` — synapse-engine.cjs, precompact
+- `.claude/hooks/` — synapse-engine.cjs, precompact, auroq-sync.cjs (sync automatico ao abrir)
+- `.claude/settings.json` — hooks do framework (SessionStart/UserPromptSubmit do auroq-sync) — sobrescrever
 - `.claude/settings.local.json` — hooks registrados
 - `AGENTS.md` — regras e contexto do Codex
 - `scripts/sync-codex-skills.mjs` e `scripts/validate-hybrid.mjs` — ponte Codex
@@ -1735,7 +1739,7 @@ GITHUB:
 DICA: *commit e o comando mais importante. Use no final de cada sessao.
 "Commit e o botao salvar do sistema."
 
-RITUAL MULTI-MAQUINA: Sentou → *sync · Levantou → *commit + *push
+RITUAL MULTI-MAQUINA: Abriu → puxa sozinho · Levantou → "salva e entrega" (qualquer agente)
 Segunda maquina ou colaborador? O caminho e "npx auroq-os clone" (nunca init).
 ```
 

package/.claude/hooks/auroq-sync.cjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Auroq OS — Sync Hook
+ *
+ *   --session-start  (SessionStart)      checa o GitHub ao abrir; PUXA se for seguro; relata o que chegou
+ *   --remind         (UserPromptSubmit)  lembra, com moderacao, de trabalho nao entregue
+ *
+ * Regras de ouro:
+ * - Nunca bloqueia a sessao (sempre exit 0) e fica em silencio quando nao ha o que dizer.
+ * - So PUXA quando nao ha trabalho local em risco (working tree limpo, nada por enviar).
+ * - NUNCA entrega (commit/push) sozinho — entregar e decisao do expert.
+ * - Estado fica fora do repositorio (tmpdir) — nunca suja o git do aluno.
+ * - Cross-platform (Mac/Windows/Linux): git via execFileSync, sem shell.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+
+const MODE = process.argv[2] || '--session-start';
+const CWD = process.cwd();
+const STATE_FILE = path.join(os.tmpdir(), 'auroq-sync', crypto.createHash('md5').update(CWD).digest('hex') + '.json');
+const REMIND_AFTER_MS = 30 * 60 * 1000; // lembra quando ha trabalho nao entregue ha 30 min
+const REMIND_EVERY_MS = 30 * 60 * 1000; // e no maximo 1 vez a cada 30 min
+
+function git(args, timeout) {
+  return execFileSync('git', args, { cwd: CWD, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: timeout || 5000 }).trim();
+}
+function tryGit(args, timeout) { try { return git(args, timeout); } catch { return null; } }
+
+function emit(eventName, text) {
+  if (!text) return;
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: eventName, additionalContext: text } }));
+}
+
+function readState() { try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { return {}; } }
+function writeState(s) { try { fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true }); fs.writeFileSync(STATE_FILE, JSON.stringify(s)); } catch { /* silencioso */ } }
+
+function isRepo() { return fs.existsSync(path.join(CWD, '.git')) && tryGit(['rev-parse', '--is-inside-work-tree']) === 'true'; }
+function hasRemote() { const r = tryGit(['remote']); return !!(r && r.length); }
+function dirtyFiles() { const out = tryGit(['status', '--porcelain']); return out ? out.split('\n').filter(Boolean) : []; }
+function upstream() { return tryGit(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']); }
+function countRange(range) { const n = tryGit(['rev-list', '--count', range]); return n === null ? 0 : (parseInt(n, 10) || 0); }
+function describeCommits(range, limit) {
+  const out = tryGit(['log', '--no-merges', '--format=%an|%s', range, `-${limit || 8}`]) || '';
+  return out.split('\n').filter(Boolean).map(l => { const i = l.indexOf('|'); return `- ${l.slice(0, i)}: ${l.slice(i + 1)}`; });
+}
+
+function sessionStart() {
+  if (!isRepo() || !hasRemote()) return;
+  const up = upstream();
+  if (!up) return;
+  const dirty = dirtyFiles();
+  if (tryGit(['fetch', '--quiet'], 8000) === null) {
+    emit('SessionStart', '[Auroq sync] Nao consegui checar o GitHub agora (sem conexao?). O trabalho local esta intacto. So mencione se o expert perguntar de sincronizacao.');
+    return;
+  }
+  const behind = countRange(`HEAD..${up}`);
+  const ahead = countRange(`${up}..HEAD`);
+  const lines = [];
+
+  if (behind > 0 && dirty.length === 0 && ahead === 0) {
+    const before = tryGit(['rev-parse', 'HEAD']);
+    if (tryGit(['pull', '--ff-only', '--quiet'], 10000) !== null) {
+      lines.push(`[Auroq sync] Puxei ${behind} atualizacao(oes) do GitHub automaticamente ao abrir a sessao. O que chegou:`);
+      lines.push(...describeCommits(`${before}..HEAD`));
+      lines.push('Informe o expert em 1-3 linhas, em portugues de negocio (traduza as mensagens de commit; cite o autor quando houver colaborador). Se algo tocar no que ele vai fazer agora, aponte.');
+    } else {
+      lines.push(`[Auroq sync] Ha ${behind} atualizacao(oes) no GitHub que nao consegui puxar sozinho (historico divergiu). Sugira ao expert: "puxa as atualizacoes" — o ritual de sync (rule puxar-e-entregar) resolve com ele.`);
+    }
+  } else if (behind > 0) {
+    lines.push(`[Auroq sync] Ha ${behind} atualizacao(oes) no GitHub, mas NAO puxei: existe trabalho local nao entregue (${dirty.length} arquivo(s) alterado(s)${ahead ? `, ${ahead} commit(s) nao enviado(s)` : ''}). Puxar agora poderia misturar coisa pela metade.`);
+    lines.push('Diga ao expert em 1-2 linhas: ha atualizacoes esperando; primeiro "salva e entrega" o que ficou pendente, depois "puxa". Se ele pedir, execute o ritual (rule puxar-e-entregar) sem trocar de agente.');
+  } else if (ahead > 0 && dirty.length === 0) {
+    lines.push(`[Auroq sync] Em dia com o GitHub, mas ha ${ahead} commit(s) salvo(s) e NAO entregue(s) (push pendente). Ofereca em 1 linha: "quer que eu entregue pro GitHub agora?"`);
+  } else if (dirty.length > 0) {
+    lines.push(`[Auroq sync] Sem novidades no GitHub, mas ha trabalho local nao entregue de uma sessao anterior (${dirty.length} arquivo(s)). Mencione em 1 linha e siga; quando ele fechar um bloco, ofereca "salva e entrega".`);
+  } else {
+    lines.push('[Auroq sync] Tudo em dia com o GitHub. Nao precisa mencionar, a menos que o expert pergunte.');
+  }
+
+  const st = readState();
+  st.dirtySince = dirty.length ? (st.dirtySince || Date.now()) : 0;
+  st.lastRemind = 0;
+  writeState(st);
+  emit('SessionStart', lines.join('\n'));
+}
+
+function remind() {
+  if (!isRepo()) return;
+  const dirty = dirtyFiles();
+  const up = upstream();
+  const ahead = up ? countRange(`${up}..HEAD`) : 0;
+  const st = readState();
+  const now = Date.now();
+  if (dirty.length === 0 && ahead === 0) {
+    if (st.dirtySince) { st.dirtySince = 0; writeState(st); }
+    return;
+  }
+  if (!st.dirtySince) { st.dirtySince = now; writeState(st); return; }
+  if (now - st.dirtySince < REMIND_AFTER_MS) return;
+  if (st.lastRemind && now - st.lastRemind < REMIND_EVERY_MS) return;
+  st.lastRemind = now;
+  writeState(st);
+  const mins = Math.round((now - st.dirtySince) / 60000);
+  emit('UserPromptSubmit', `[Auroq lembrete] Ha trabalho nao entregue ha ~${mins} min (${dirty.length} arquivo(s) alterado(s)${ahead ? `, ${ahead} commit(s) sem push` : ''}). NAO interrompa o raciocinio atual. Ao fechar o bloco em andamento, ofereca em UMA linha: "quer que eu salve e entregue pro GitHub?". Nunca entregue sem o expert pedir.`);
+}
+
+let ran = false;
+function main() {
+  if (ran) return;
+  ran = true;
+  try { if (MODE === '--remind') remind(); else sessionStart(); }
+  catch (e) { console.error(`[auroq-sync] ${e.message}`); }
+  process.exit(0);
+}
+
+// Consome o JSON que o Claude Code envia no stdin (nao depende dele) e roda no fim;
+// fallback por timer garante execucao mesmo se o stdin nao fechar.
+process.stdin.resume();
+process.stdin.on('data', () => {});
+process.stdin.on('end', main);
+process.stdin.on('error', main);
+setTimeout(main, 400).unref();

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

@@ -6,11 +6,12 @@
 
 | Operacao | Exclusivo? | Outros Agentes |
 |----------|-----------|--------------|
-| `git push` / `git push --force` | SIM | BLOQUEADO |
+| `git push --force` | SIM | BLOQUEADO |
+| `git commit` / `git push` / `git pull` (salvar, entregar, puxar) | NAO — Ops e o DONO do ritual | QUALQUER agente executa o ritual do Ops (`rules/puxar-e-entregar.md`), sem pedir troca de agente |
 | `gh pr create` / `gh pr merge` | SIM | BLOQUEADO |
 | MCP add/remove/configure | SIM | BLOQUEADO |
 | Environment bootstrap | SIM | BLOQUEADO |
-| Commit inteligente (ritual completo) | SIM | Outros agentes delegam |
+| Commit inteligente (definicao do ritual) | SIM (dono) | Outros agentes EXECUTAM o ritual quando o expert pede |
 
 ### Companion — Cerebro do Sistema
 
@@ -47,7 +48,7 @@
 
 | Permitido | Bloqueado |
 |---------|---------|
-| `git add`, `git commit`, `git status` | `git push` (delegar pra Ops) |
+| `git add`, `git commit`, `git status`, `git push`/`pull` (pelo ritual do Ops, com pre-push) | `git push --force` (so Ops) |
 | `git branch`, `git checkout` (local) | `gh pr create/merge` (delegar pra Ops) |
 | Execucao de tasks operacionais | Criar novos agentes (delegar pro Meta Squad adequado) |
 | Atualizacao de documentos de trabalho | Decisoes estrategicas (delegar pro Expert) |
@@ -56,15 +57,16 @@
 
 | Permitido | Bloqueado |
 |---------|---------|
-| Executar pipeline completo com quality gates | `git push` (delegar pra Ops) |
+| Executar pipeline completo com quality gates | `git push --force` / PR (so Ops) |
 | Criar documentos de output | Criar novos agentes (delegar pro Meta Squad adequado) |
 | Atualizar KBs e skills | Decisoes fora do escopo do squad |
 
 ## Cross-Agent Delegation
 
-### Git Push Flow
+### Salvar / Entregar / Puxar Flow
 ```
-QUALQUER agente → Ops (*commit / *push)
+Expert pede ("salva", "entrega", "puxa") → o agente ATIVO executa o ritual do Ops (rules/puxar-e-entregar.md)
+Abertura de sessao → hook auroq-sync puxa sozinho se for seguro (nunca entrega sozinho)
 ```
 
 ### Novo Agente Flow

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

@@ -0,0 +1,31 @@
+# Puxar e Entregar — Qualquer Agente Executa o Ritual do Ops
+
+> O expert 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.
+
+## Intents (linguagem natural → acao)
+
+| O expert diz (exemplos) | Acao |
+|-------------------------|------|
+| "salva", "guarda isso", "faz checkpoint", "commita" | SALVAR (commit inteligente) |
+| "entrega", "manda pro GitHub", "sobe", "faz push" | ENTREGAR (push com pre-push) |
+| "salva e entrega", "fecha o dia", "acabei por hoje" | SALVAR + ENTREGAR |
+| "puxa", "atualiza do GitHub", "traz o que mudou", "sync" | PUXAR (sync) |
+
+## O ritual — fonte da verdade: `.claude/commands/AuroqOS/agents/ops.md`
+
+Leia as secoes `*commit`, `*pre-push` e `*sync` do ops.md e execute os passos como estao. O minimo inegociavel:
+
+- **SALVAR:** revisar o que mudou → conferir tracker/contexto → mensagem em linguagem de negocio (`progresso:`, `decisao:`, `campanha:`...) → `git add` dos arquivos relevantes (NUNCA `business/vault/`, `.env`, chaves) → commit → confirmar ao expert em 1 linha.
+- **ENTREGAR:** pre-push OBRIGATORIO (vault/.env fora do staging, `.gitignore` protege, nenhum arquivo gigante, branch certa) → `git push` → confirmar.
+- **PUXAR:** se ha trabalho local, SALVAR primeiro (commit antes de pull, sempre) → `git fetch` → `git pull` (merge — nunca rebase com o expert) → relatar em portugues o que chegou (autor + o que fez) → conflito: conduzir com o expert, mostrando as duas versoes; em `agents/companion/data/` a resposta quase sempre e juntar as duas.
+
+## Regras
+
+1. Nao pedir troca de agente. Nao dizer "chama o Ops". Faca.
+2. **Nunca entregar (push) sem o expert 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`.
+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 expert 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.

package/.claude/settings.json

@@ -1 +1,21 @@
-{ "language": "portuguese" }
+{
+  "language": "portuguese",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear",
+        "hooks": [
+          { "type": "command", "command": "node .claude/hooks/auroq-sync.cjs --session-start", "timeout": 25000 }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "node .claude/hooks/auroq-sync.cjs --remind", "timeout": 5000 }
+        ]
+      }
+    ]
+  }
+}

package/AGENTS.md

@@ -78,7 +78,7 @@ instrucoes do arquivo ate `*exit`.
 ## Constitution — principios inegociaveis (replica de `.auroq-core/constitution.md`)
 
 1. **Centro de comando** — toda operacao passa pelo projeto Auroq no terminal, via Claude Code, Codex ou Grok. Ferramentas externas (Meta Ads, Hotmart, n8n) sao bracos, nao centros. *(NON-NEGOTIABLE)*
-2. **Cada um faz o seu** — `git commit/push/deploy` e o `*update` do framework sao **EXCLUSIVOS do Ops**. Outro agente delega. *(NON-NEGOTIABLE)*
+2. **Cada um faz o seu** — `deploy`, `git push --force`, PR, MCP/infra, bootstrap e o `*update` do framework sao **EXCLUSIVOS do Ops**. Salvar/entregar/puxar (`commit`, `push`, `pull`) QUALQUER agente executa seguindo o ritual do Ops (`.claude/rules/puxar-e-entregar.md`) — o expert nunca troca de agente pra isso. *(NON-NEGOTIABLE)*
 3. **Documentar = investir** — todo trabalho significativo vira `.md`. O que nao e documentado, morre. *(MUST)*
 4. **Nao inventar** — fundamenta em KB, instrucao ou plano. Nao gera dado/numero/fato sem fonte. Se precisa mudar o plano, PARA e pergunta. *(MUST)*
 5. **Qualidade com julgamento** — o expert julga; a IA nao se auto-aprova em entregas importantes. *(MUST)*
@@ -94,7 +94,7 @@ instrucoes do arquivo ate `*exit`.
 
 ## Autoridade de agentes (de `.claude/rules/agent-authority`)
 
-- **Ops** detem exclusivamente `git push`, `commit`, `deploy`, gestao de MCP/infra e `*update`.
+- **Ops** e o dono do ritual de git e detem exclusivamente `deploy`, `git push --force`, PR, gestao de MCP/infra, bootstrap e `*update`. Salvar, entregar e puxar (`commit`/`push`/`pull`) qualquer agente executa pelo ritual do Ops (rule `puxar-e-entregar`), com as mesmas travas de seguranca (pre-push).
 - Os **Forges** criam agentes/squads/workers/clones; o **Companion** situa e roteia; o **Consultor** ensina o sistema.
 - Um agente nao invade o dominio de outro — **delega**. Em conflito de fronteira, escala pro Companion/expert.
 
@@ -122,6 +122,6 @@ Quando o pedido depender de contexto/memoria ja definidos, leia:
 
 ## Higiene de uso (do Consultor)
 
-- **Um chat por objetivo**: abre, resolve, o Ops commita + faz push, fecha. Chat-balaio engorda o contexto e a qualidade cai.
+- **Um chat por objetivo**: abre, resolve, pede "salva e entrega" pra quem estiver ativo, fecha. Chat-balaio engorda o contexto e a qualidade cai.
 - **O agente certo pra cada tarefa** — nao deixa o modelo cru fazer trabalho de especialista.
 - **Nao caia na labia da IA** — ela as vezes inventa, alucina ou te limita sem motivo. Questione, confirme, e pergunte no grupo da mentoria quando ela parecer viajando.

package/README.md

@@ -80,11 +80,11 @@ claude
 *conectar-1password         # reconectar o cofre (uma vez so nesta maquina)
 ```
 
-Ritual diario em toda maquina: **sentou → `*sync` · levantou → `*commit` + `*push`**.
+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
 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 via `*sync`.
+o sistema e o dono, e o colaborador recebe as atualizacoes automaticamente ao abrir o `claude`.
 
 ## Estrutura
 
@@ -132,4 +132,4 @@ agents/             → Seu exercito (companion, workers, minds, squads)
 
 ---
 
-*Auroq OS v2.1.0 — by Euriler Jube / Arka*
+*Auroq OS v2.2.3 — by Euriler Jube / Arka*

package/agents/companion/agents/companion.md

@@ -97,7 +97,8 @@ Quando o expert precisa de algo que nao e dominio do Companion:
 
 | Precisa de... | Rotear para... |
 |--------------|---------------|
-| Git push/commit/deploy | Ops (`/AuroqOS:agents:ops`) |
+| Salvar, entregar, puxar ("salva", "entrega", "puxa") | O PROPRIO Companion executa o ritual do Ops (`rules/puxar-e-entregar.md`) — sem trocar de agente |
+| Deploy, push --force, PR, MCP/infra, bootstrap, update | Ops (`/AuroqOS:agents:ops`) |
 | Organizar, guardar documento, limpar, backup | Organizer (`/organizer`) |
 | Criar squad multi-agente a partir de processo | Squad Forge (`/squad-forge`) |
 | Criar mente sintetica ou consultor | Mind Forge (`/mind-forge`) |
@@ -200,8 +201,8 @@ O Companion protege o expert de si mesmo:
 1. BOOT → Carregar estado (contexto, cockpit, trackers, decisoes)
 2. BRIEFING → "Aqui e onde estamos. Isso e o que importa. Sugestao de foco."
 3. TRABALHO → Expert escolhe. Companion acompanha ou expert troca de agente.
-4. CHECKPOINT → Expert chama Ops *commit. Estado salvo.
-5. ENCERRAMENTO → Commit final. Contexto atualizado. Push.
+4. CHECKPOINT → Expert diz "salva" → Companion executa o ritual de commit. Estado salvo.
+5. ENCERRAMENTO → Expert diz "salva e entrega" → commit final + push. Contexto atualizado.
 ```
 
 ### Ciclo Semanal

package/bin/auroq-os.js

@@ -147,6 +147,8 @@ const HEALTH_CHECKS = [
   ['.auroq-core/constitution.md', 'Constitution'],
   ['.claude/CLAUDE.md', 'CLAUDE.md'],
   ['.claude/hooks/synapse-engine.cjs', 'Synapse Hook'],
+  ['.claude/hooks/auroq-sync.cjs', 'Sync Hook'],
+  ['.claude/rules/puxar-e-entregar.md', 'Rule puxar-e-entregar'],
   ['agents/companion/agents/companion.md', 'Companion'],
   ['agents/organizer/agents/organizer.md', 'Organizer'],
   ['.claude/commands/AuroqOS/agents/ops.md', 'Ops'],
@@ -343,10 +345,12 @@ async function init() {
     '.claude/rules/tool-response-filtering.md',
     '.claude/rules/natural-language-first.md',
     '.claude/rules/custom-do-aluno.md',
+    '.claude/rules/puxar-e-entregar.md',
 
     // Hooks
     '.claude/hooks/synapse-engine.cjs',
     '.claude/hooks/precompact-session-digest.cjs',
+    '.claude/hooks/auroq-sync.cjs',
 
     // Synapse domain files
     '.synapse/manifest',
@@ -805,10 +809,10 @@ ${DIM}  Uma vez so, nesta maquina:${RESET}
 
 ${DIM}  Ritual de todo dia, em toda maquina:${RESET}
 
-    ${GOLD}Sentou${RESET}    → ${CYAN}*sync${RESET}              ${DIM}— puxa o que mudou nas outras maquinas${RESET}
-    ${GOLD}Levantou${RESET}  → ${CYAN}*commit${RESET} + ${CYAN}*push${RESET}   ${DIM}— entrega o seu trabalho pro GitHub${RESET}
+    ${GOLD}Abriu${RESET}     → ${DIM}o sistema puxa sozinho o que mudou nas outras maquinas (e te conta)${RESET}
+    ${GOLD}Levantou${RESET}  → diga ${CYAN}"salva e entrega"${RESET} ${DIM}pra quem estiver na tela — vai pro GitHub${RESET}
 
-${DIM}  Nunca levante da maquina com trabalho nao entregue.${RESET}
+${DIM}  Nunca levante da maquina com trabalho nao entregue — o sistema lembra, mas so voce entrega.${RESET}
 
 ${PURPLE}${BOLD}  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}
 ${DIM}  Auroq OS v${PKG_VERSION} — Sistema Operacional de IA para Experts${RESET}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auroq-os",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "Auroq OS — Sistema Operacional de IA para Experts",
   "bin": {
     "auroq-os": "bin/auroq-os.js"