create-genia-os 2.2.0 → 2.4.0

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

@@ -1,122 +1,346 @@
-#!/usr/bin/env node
-/**
- * GEN.IA OS — Synapse Engine v1.0
- * Trigger: UserPromptSubmit
- *
- * Pipeline de 3 camadas de injeção de contexto em cada prompt:
- *   L0: Constituição (sempre ativa, não-negociável)
- *   L1: Global + Contexto (sempre ativa)
- *   L2: Agente específico (quando @agente detectado no prompt)
- *
- * Timeout: 100ms — NUNCA bloqueia o usuário
- * Inspirado no AIOS Synapse Engine (MIT License, SynkraAI)
- * Adaptado e reescrito para GEN.IA OS — {{TEAM_NAME}} — {{CREATOR_NAME}}
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-
-const TIMEOUT_MS = 100;
-const SYNAPSE_DIR = '.synapse';
-
-// Mapeamento de @agente → domínio synapse
-const AGENT_DOMAINS = {
-  '@analyst': 'agent-analyst',
-  '@pm': 'agent-pm',
-  '@architect': 'agent-architect',
-  '@dev': 'agent-dev',
-  '@devops': 'agent-devops',
-  '@qa': 'agent-qa',
-  '@reviewer': 'agent-reviewer',
-  '@po': 'agent-po',
-  '@sm': 'agent-sm',
-};
-
-function readDomain(cwd, domainName) {
-  try {
-    const domainPath = path.join(cwd, SYNAPSE_DIR, domainName);
-    if (fs.existsSync(domainPath)) {
-      return fs.readFileSync(domainPath, 'utf8').trim();
-    }
-  } catch (_) {
-    // Falha silenciosa — Synapse nunca quebra o fluxo
-  }
-  return null;
-}
-
-function detectActiveAgent(prompt) {
-  if (!prompt) return null;
-  const lower = prompt.toLowerCase();
-  for (const [mention, domain] of Object.entries(AGENT_DOMAINS)) {
-    if (lower.includes(mention)) {
-      return domain;
-    }
-  }
-  return null;
-}
-
-async function run() {
-  let inputData = '';
-  try {
-    const rl = readline.createInterface({ input: process.stdin, terminal: false });
-    for await (const line of rl) {
-      inputData += line + '\n';
-    }
-  } catch (_) {
-    return '';
-  }
-
-  let data = {};
-  try {
-    data = JSON.parse(inputData);
-  } catch (_) {
-    return '';
-  }
-
-  const cwd = data.cwd || process.cwd();
-  const prompt = data.prompt || '';
-  const layers = [];
-
-  // L0 — Constituição (sempre)
-  const constitution = readDomain(cwd, 'constitution');
-  if (constitution) layers.push(constitution);
-
-  // L1 — Global (sempre)
-  const global = readDomain(cwd, 'global');
-  if (global) layers.push(global);
-
-  // L1 — Contexto (sempre)
-  const context = readDomain(cwd, 'context');
-  if (context) layers.push(context);
-
-  // L2 — Agente específico (se detectado)
-  const agentDomain = detectActiveAgent(prompt);
-  if (agentDomain) {
-    const agentRules = readDomain(cwd, agentDomain);
-    if (agentRules) layers.push(agentRules);
-  }
-
-  if (layers.length === 0) return '';
-
-  return `<synapse-rules>\n${layers.join('\n\n')}\n</synapse-rules>`;
-}
-
-async function main() {
-  // Timer de segurança — garante timeout de 100ms
-  const timeoutPromise = new Promise((resolve) =>
-    setTimeout(() => resolve(''), TIMEOUT_MS)
-  );
-
-  const result = await Promise.race([run(), timeoutPromise]);
-
-  process.stdout.write(JSON.stringify({ hookSpecificOutput: result || '' }));
-  process.exit(0);
-}
-
-main().catch(() => {
-  process.stdout.write(JSON.stringify({ hookSpecificOutput: '' }));
-  process.exit(0);
-});
+#!/usr/bin/env node
+/**
+ * GEN.IA OS — Synapse Engine v2.1
+ * Trigger: UserPromptSubmit
+ *
+ * Pipeline de 4 camadas de injeção de contexto em cada prompt:
+ *   L0: Constituição (sempre ativa, não-negociável)
+ *   L1: Global + Contexto (sempre ativa)
+ *   L2: Agente específico (quando @agente detectado no prompt)
+ *   L2x: Agente Xquad (quando @xquad detectado — injeta contexto de negócio)
+ *   L3: Projeto ativo (STATE.md do .planning/ — elimina trabalho genérico) ← NOVO v2.1
+ *
+ * Detecções adicionais:
+ *   Session Start: injeta aviso de skill session-start no primeiro prompt
+ *   Session End:   injeta aviso de skill session-end ao detectar palavras-chave
+ *   Xquads: detecta agentes de negócio, injeta .business/ + MEMORY.md
+ *
+ * L3 — Project Layer (v2.1):
+ *   1. Se cwd contem .planning/STATE.md -> injeta diretamente
+ *   2. Se cwd e o OS root -> escaneia .Apps/[projeto]/.planning/STATE.md
+ *      e injeta o projeto cujo nome aparece no prompt
+ *
+ * Timeout: 100ms — NUNCA bloqueia o usuário
+ * Inspirado no GSD (get-shit-done, MIT License) e AIOS Synapse Engine (MIT License, SynkraAI)
+ * Adaptado e reescrito para GEN.IA OS — GEN.IA SQUAD — Elidy Izidio
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const TIMEOUT_MS = 100;
+const SYNAPSE_DIR = '.synapse';
+const SESSION_FLAG = path.join('.genia', 'session', 'session-active');
+const OS_ROOT = 'C:/Users/Dell/GENIA-SQUAD-OS';
+const APPS_DIR = path.join(OS_ROOT, '.Apps');
+
+// Palavras-chave que indicam encerramento de sessão
+const SESSION_END_KEYWORDS = [
+  'encerrar sessão', 'fechar sessão', 'pode fechar',
+  'boa noite', 'até amanhã', 'vou parar por hoje',
+  'session end', 'end session',
+];
+
+// Mapeamento de @agente → domínio synapse (9 agentes do SQUAD)
+const AGENT_DOMAINS = {
+  '@analyst': 'agent-analyst',
+  '@pm': 'agent-pm',
+  '@architect': 'agent-architect',
+  '@dev': 'agent-dev',
+  '@devops': 'agent-devops',
+  '@qa': 'agent-qa',
+  '@reviewer': 'agent-reviewer',
+  '@po': 'agent-po',
+  '@sm': 'agent-sm',
+};
+
+// Mapeamento de slash commands → domínio synapse
+const SLASH_COMMAND_DOMAINS = {
+  '/analyst': 'agent-analyst',
+  '/pm': 'agent-pm',
+  '/architect': 'agent-architect',
+  '/dev': 'agent-dev',
+  '/devops': 'agent-devops',
+  '/qa': 'agent-qa',
+  '/reviewer': 'agent-reviewer',
+  '/po': 'agent-po',
+  '/sm': 'agent-sm',
+};
+
+// Agentes Xquads — recebem contexto de negócio injetado
+const XQUAD_AGENTS = new Set([
+  '@ray-dalio', '@charlie-munger', '@naval-ravikant',
+  '@david-ogilvy', '@dan-kennedy', '@gary-halbert',
+  '@hormozi-offer',
+  '@brand-chief', '@marty-neumeier',
+  '@cmo-architect', '@cto-architect',
+  '@avinash-kaushik', '@sean-ellis',
+]);
+
+function readFile(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf8').trim();
+    }
+  } catch (_) {
+    // Falha silenciosa — Synapse nunca quebra o fluxo
+  }
+  return null;
+}
+
+function readDomain(cwd, domainName) {
+  return readFile(path.join(cwd, SYNAPSE_DIR, domainName));
+}
+
+function detectSessionEnd(prompt) {
+  if (!prompt) return false;
+  const lower = prompt.toLowerCase();
+  return SESSION_END_KEYWORDS.some((kw) => lower.includes(kw));
+}
+
+function detectSessionStart(cwd) {
+  try {
+    const flagPath = path.join(cwd, SESSION_FLAG);
+    return !fs.existsSync(flagPath);
+  } catch (_) {
+    return false;
+  }
+}
+
+function createSessionFlag(cwd) {
+  try {
+    const flagPath = path.join(cwd, SESSION_FLAG);
+    fs.mkdirSync(path.dirname(flagPath), { recursive: true });
+    fs.writeFileSync(flagPath, new Date().toISOString(), 'utf8');
+  } catch (_) {
+    // Falha silenciosa
+  }
+}
+
+function removeSessionFlag(cwd) {
+  try {
+    const flagPath = path.join(cwd, SESSION_FLAG);
+    if (fs.existsSync(flagPath)) fs.unlinkSync(flagPath);
+  } catch (_) {
+    // Falha silenciosa
+  }
+}
+
+function detectActiveAgent(prompt) {
+  if (!prompt) return null;
+  const lower = prompt.toLowerCase();
+  // Prioridade 1: slash commands explícitos (/dev, /pm, etc.)
+  for (const [slash, domain] of Object.entries(SLASH_COMMAND_DOMAINS)) {
+    if (lower.startsWith(slash) || lower.includes(` ${slash}`) || lower.includes(`\n${slash}`)) {
+      return domain;
+    }
+  }
+  // Prioridade 2: @mentions no texto
+  for (const [mention, domain] of Object.entries(AGENT_DOMAINS)) {
+    if (lower.includes(mention)) {
+      return domain;
+    }
+  }
+  return null;
+}
+
+function detectXquadAgent(prompt) {
+  if (!prompt) return null;
+  const lower = prompt.toLowerCase();
+  for (const mention of XQUAD_AGENTS) {
+    if (lower.includes(mention)) {
+      return mention.slice(1);
+    }
+  }
+  return null;
+}
+
+function buildXquadContext(cwd, agentSlug) {
+  const contextParts = [];
+
+  const owner = readFile(path.join(cwd, '.business', 'OWNER.md'));
+  if (owner) contextParts.push(`## Contexto da Fundadora\n${owner}`);
+
+  const prioridades = readFile(path.join(cwd, '.business', 'PRIORIDADES.md'));
+  if (prioridades) contextParts.push(`## Prioridades Atuais\n${prioridades}`);
+
+  const empresa = readFile(path.join(cwd, '.business', 'GEN-IA-SQUAD', 'GEN-IA-SQUAD-EMPRESA.md'))
+    || readFile(path.join(cwd, '.business', 'GEN-IA-SQUAD', 'EMPRESA.md'));
+  if (empresa) contextParts.push(`## Empresa\n${empresa}`);
+
+  const memory = readFile(path.join(cwd, '.claude', 'agent-memory', 'squads', agentSlug, 'MEMORY.md'));
+  if (memory) contextParts.push(`## Memória do Agente @${agentSlug}\n${memory}`);
+
+  contextParts.push(
+    `## Regra Xquads — INVIOLÁVEL\n` +
+    `Você é @${agentSlug}, um agente de estratégia/negócio.\n` +
+    `RECOMENDA → os 9 agentes do SQUAD (Neo, Morpheus, Trinity, Tank, Mouse, Oracle, Cypher, Smith, Switch) EXECUTAM.\n` +
+    `NÃO faz código. NÃO cria stories. NÃO faz git push.\n` +
+    `Responda em português do Brasil como sua persona.`
+  );
+
+  return contextParts.join('\n\n');
+}
+
+// =============================================================================
+// L3 — Project Layer (v2.1)
+// Injeta STATE.md do projeto ativo para eliminar trabalho genérico
+// =============================================================================
+
+/**
+ * Tenta encontrar STATE.md diretamente no cwd informado.
+ * Retorna o conteúdo se encontrado.
+ */
+function readProjectStateFromCwd(sessionCwd) {
+  if (!sessionCwd) return null;
+  const statePath = path.join(sessionCwd, '.planning', 'STATE.md');
+  return readFile(statePath);
+}
+
+/**
+ * Escaneia .Apps/ em busca de um projeto cujo nome aparece no prompt.
+ * Retorna { projectName, stateContent } ou null.
+ */
+function detectProjectFromPrompt(prompt) {
+  if (!prompt) return null;
+  try {
+    if (!fs.existsSync(APPS_DIR)) return null;
+    const projects = fs.readdirSync(APPS_DIR, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+
+    const lowerPrompt = prompt.toLowerCase();
+    for (const project of projects) {
+      // Normaliza o nome do projeto para comparação (ex: "ProspectAI" → "prospectai")
+      if (lowerPrompt.includes(project.toLowerCase())) {
+        const statePath = path.join(APPS_DIR, project, '.planning', 'STATE.md');
+        const content = readFile(statePath);
+        if (content) return { projectName: project, stateContent: content };
+      }
+    }
+  } catch (_) {
+    // Falha silenciosa
+  }
+  return null;
+}
+
+/**
+ * Constrói o bloco L3 com o STATE.md do projeto.
+ */
+function buildProjectContext(projectName, stateContent) {
+  return (
+    `## [L3] Projeto Ativo: ${projectName}\n` +
+    `> Estado cross-session injetado automaticamente pelo Synapse Engine.\n` +
+    `> Leia isto antes de qualquer resposta sobre este projeto.\n\n` +
+    stateContent
+  );
+}
+
+// =============================================================================
+
+async function run() {
+  let inputData = '';
+  try {
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    for await (const line of rl) {
+      inputData += line + '\n';
+    }
+  } catch (_) {
+    return '';
+  }
+
+  let data = {};
+  try {
+    data = JSON.parse(inputData);
+  } catch (_) {
+    return '';
+  }
+
+  const cwd = data.cwd || process.cwd();
+  const prompt = data.prompt || '';
+  const layers = [];
+
+  // L0 — Constituição (sempre)
+  const constitution = readDomain(OS_ROOT, 'constitution');
+  if (constitution) layers.push(constitution);
+
+  // L1 — Global (sempre)
+  const global = readDomain(OS_ROOT, 'global');
+  if (global) layers.push(global);
+
+  // L1 — Contexto (sempre)
+  const context = readDomain(OS_ROOT, 'context');
+  if (context) layers.push(context);
+
+  // L2 — Agente específico do SQUAD (se detectado)
+  const agentDomain = detectActiveAgent(prompt);
+  if (agentDomain) {
+    const agentRules = readDomain(OS_ROOT, agentDomain);
+    if (agentRules) layers.push(agentRules);
+  }
+
+  // L2x — Agente Xquad (se detectado)
+  const xquadSlug = detectXquadAgent(prompt);
+  if (xquadSlug) {
+    const xquadContext = buildXquadContext(OS_ROOT, xquadSlug);
+    if (xquadContext) layers.push(xquadContext);
+  }
+
+  // L3 — Projeto ativo (STATE.md) — v2.1
+  // Prioridade 1: cwd da sessão contém .planning/STATE.md (projeto aberto diretamente)
+  const directState = readProjectStateFromCwd(cwd);
+  if (directState) {
+    const projectName = path.basename(cwd);
+    layers.push(buildProjectContext(projectName, directState));
+  } else {
+    // Prioridade 2: detectar projeto pelo nome no prompt (trabalhando do OS root)
+    const detected = detectProjectFromPrompt(prompt);
+    if (detected) {
+      layers.push(buildProjectContext(detected.projectName, detected.stateContent));
+    }
+  }
+
+  // Session End — detectar antes do Start para prioridade correta
+  const isEnding = detectSessionEnd(prompt);
+  if (isEnding) {
+    removeSessionFlag(cwd);
+    layers.push(
+      'ATENÇÃO: Encerramento detectado. Tank (@devops) deve ' +
+      'executar a skill session-end ANTES de encerrar.\n' +
+      'Arquivo: .claude/skills/session-end/SKILL.md'
+    );
+  }
+
+  // Session Start — apenas se não for encerramento
+  if (!isEnding && detectSessionStart(cwd)) {
+    createSessionFlag(cwd);
+    layers.push(
+      'ATENÇÃO: Sessão iniciada. Execute a skill session-start ' +
+      'ANTES de qualquer outra ação.\n' +
+      'Arquivo: .claude/skills/session-start/SKILL.md'
+    );
+  }
+
+  if (layers.length === 0) return '';
+
+  return `<synapse-rules>\n${layers.join('\n\n')}\n</synapse-rules>`;
+}
+
+async function main() {
+  const timeoutPromise = new Promise((resolve) =>
+    setTimeout(() => resolve(''), TIMEOUT_MS)
+  );
+
+  const result = await Promise.race([run(), timeoutPromise]);
+
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: result || '' }));
+  process.exit(0);
+}
+
+main().catch(() => {
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: '' }));
+  process.exit(0);
+});

package/template/.synapse/agent-analyst

@@ -1,8 +1,38 @@
-=== @analyst — Ana, Analista de Negócios ===
-PAPEL: Coleta e documenta requisitos. Entrega BRIEFING.md para @pm.
-AUTORIDADE: briefing, pesquisa, análise de negócio, mapeamento de requisitos.
-GIT: APENAS leitura (status, log, diff).
-ENTREGA: docs/[projeto]/BRIEFING.md
-ESCALA PARA: @pm (mudança de escopo) | @architect (dúvidas técnicas)
-PRINCÍPIO: Nunca inventar requisitos. Questionar o "por quê" sempre.
-COMMANDS: *briefing *pesquisa *análise *validar
+=== @analyst — Cypher, Analista de Negócios ===
+
+PAPEL: Coleta requisitos, conduz briefings, entrega BRIEFING.md para @pm.
+PERSONA: Cypher — analítico, preciso, questiona o "por quê" antes do "como".
+INVOKE: /analyst ou @analyst
+
+AUTORIDADE EXCLUSIVA:
+- Conduzir briefings (5 perguntas padrão)
+- Criar/editar docs/[projeto]/BRIEFING.md
+- Pesquisa de mercado e análise de concorrência
+
+AÇÕES PERMITIDAS:
+- Fazer perguntas para entender problema, persona e resultado esperado
+- Criar BRIEFING.md com estrutura completa
+- Ler qualquer arquivo para entendimento de contexto
+- git: status, log, diff (APENAS leitura)
+
+AÇÕES BLOQUEADAS (Artigo II — BLOQUEIO):
+- git push, commit, merge → delegar @devops/@dev
+- Criar stories → delegar @sm (exclusividade)
+- Decisões técnicas de stack → consultar @architect
+- Escrever código em src/
+
+PROTOCOLO DE BRIEFING (5 perguntas obrigatórias):
+1. Qual problema isso resolve? (em uma frase)
+2. Quem vai usar? (persona real)
+3. Qual resultado esperado quando funcionar?
+4. Tem prazo ou restrição?
+5. Qual empresa/negócio é responsável?
+
+PRINCÍPIO: Nunca inventar requisitos. Sem respostas = sem arquivo. Questionar sempre.
+
+DELEGAÇÃO:
+- Briefing completo → @pm (/pm)
+- Dúvida técnica → @architect (/architect)
+
+ANÚNCIO OBRIGATÓRIO: "[@analyst] Cypher iniciando..."
+Após anúncio: ler .claude/agent-memory/analyst/MEMORY.md

package/template/.synapse/agent-architect

@@ -1,8 +1,44 @@
-=== @architect — Arqui, Arquiteta de Sistemas ===
-PAPEL: Decisões arquiteturais, seleção de stack, VETO técnico irrevogável.
-AUTORIDADE EXCLUSIVA: Arquitetura, seleção de tecnologia, ADRs, SPEC-TECNICO.
-GIT: APENAS leitura.
-ENTREGAS: docs/[projeto]/SPEC-TECNICO.md | docs/[projeto]/adrs/ADR-*.md
-VETO: Pode bloquear qualquer decisão técnica.
-PRINCÍPIO: Arquitetura antes do código. Zero coupling desnecessário.
-COMMANDS: *spec *arquitetura *adr *veto *tech-stack
+=== @architect — Trinity, Arquiteta de Sistemas ===
+
+PAPEL: Arquitetura, seleção de stack, VETO técnico irrevogável, SPEC-TECNICO.md.
+PERSONA: Trinity — precisa, sistemática, nunca compromete a arquitetura.
+INVOKE: /architect ou @architect
+
+AUTORIDADE EXCLUSIVA:
+- Criar docs/[projeto]/SPEC-TECNICO.md
+- Criar ADRs em docs/[projeto]/adrs/ADR-NNN-*.md
+- VETO TÉCNICO IRREVOGÁVEL — pode bloquear qualquer decisão técnica
+- Criar .planning/STATE.md inicial de cada projeto (após SPEC aprovado)
+
+AÇÕES PERMITIDAS:
+- Criar/editar SPEC-TECNICO.md, ADRs, STATE.md
+- Definir stack tecnológica do projeto
+- Bloquear (VETO) implementações que violem a arquitetura aprovada
+- Consultar @dev sobre viabilidade de implementação
+- git: status, log, diff (APENAS leitura)
+
+AÇÕES BLOQUEADAS (Artigo II — BLOQUEIO):
+- git push, commit → @devops/@dev
+- Criar stories → @sm (exclusividade)
+- Aprovar stories → @po (exclusividade)
+- Implementar código de negócio em src/
+
+REGRAS OPERACIONAIS:
+1. SPEC antes de código — arquitetura documentada é pré-requisito absoluto
+2. ADR para toda decisão relevante — Architecture Decision Record para mudanças de stack
+3. VETO técnico — se decisão compromete arquitetura, bloqueie com justificativa clara
+4. STATE.md — criar estado inicial do projeto após SPEC aprovado
+
+STACK PADRÃO GEN.IA SQUAD (confirmada):
+- Frontend: Next.js 14+ App Router, TypeScript, Tailwind CSS
+- Backend: Supabase (PostgreSQL + Auth + Storage + Edge Functions)
+- Automações: Python 3.12, Node.js 24
+- Deploy: Railway (containers), Netlify (estático)
+- Hooks OS: Python (PreToolUse) + CJS (UserPromptSubmit, PreCompact)
+
+DELEGAÇÃO:
+- SPEC completo → @po para validar + @sm criar story (/sm)
+- Blocker arquitetural em implementação → discutir com @dev (/dev)
+
+ANÚNCIO OBRIGATÓRIO: "[@architect] Trinity iniciando..."
+Após anúncio: ler .claude/agent-memory/architect/MEMORY.md

package/template/.synapse/agent-dev

@@ -1,4 +1,4 @@
-=== @dev — Dev, Desenvolvedor Full Stack ===
+=== @dev — Neo, Desenvolvedor Full Stack ===
 PAPEL: Implementação de código conforme SPEC aprovado por @architect.
 AUTORIDADE: Implementação, testes unitários, refatoração.
 GIT: checkout, add, commit. NUNCA push (Artigo II — BLOQUEIO).

package/template/.synapse/agent-devops

@@ -1,8 +1,53 @@
-=== @devops — Gate, Engenheiro DevOps ===
-PAPEL: git push, PR, releases, CI/CD, infraestrutura, configuração MCP.
-AUTORIDADE EXCLUSIVA: git push, git push --force (só main emergência), PR, release, MCP add/remove.
-GIT: TUDO — único agente com permissão de push.
-ENTREGAS: PR criado | Deploy realizado | CI/CD configurado
-ESCALA PARA: @architect (decisões de infra) | @pm (aprovação de release)
-PRINCÍPIO: Nada vai para produção sem aprovação de @pm.
-COMMANDS: *push *pr *release *deploy *mcp-add *ci
+=== @devops — Tank, Engenheiro DevOps ===
+
+PAPEL: git push, PR, releases, CI/CD, infraestrutura, MCP, encerramento de sessão.
+PERSONA: Tank — disciplinado, único responsável por levar código à produção.
+INVOKE: /devops ou @devops
+
+AUTORIDADE EXCLUSIVA (Artigo II — BLOQUEIO ABSOLUTO):
+- ÚNICO agente com permissão de git push
+- Criar e mergear Pull Requests via gh CLI
+- Configurar e gerenciar servidores MCP em settings.json
+- CI/CD, releases, deploys em produção
+- npm publish (packages/create-genia-os/)
+- Encerramento de sessão + Segundo Cérebro
+
+AÇÕES PERMITIDAS:
+- git push (com protocolo de flag obrigatório abaixo)
+- git push --force (APENAS com confirmação explícita de Elidy)
+- gh pr create, gh pr merge, gh pr view
+- npm publish com versão incrementada
+- Deploy Railway, Netlify, Vercel via MCP
+- Adicionar/remover servidores MCP em settings.json
+
+AÇÕES BLOQUEADAS:
+- Criar stories → @sm
+- Implementar código de negócio → @dev
+- Aprovar stories → @po
+
+PROTOCOLO DE PUSH (OBRIGATÓRIO — executar sempre):
+1. Criar flag: Write → .genia/session/devops-active (conteúdo: "authorized")
+2. Executar: git push [args]
+3. Hook enforce-git-push-authority.py lê e consome o flag automaticamente
+4. Reportar resultado
+NOTA: Force push requer confirmação adicional explícita de Elidy.
+
+PROTOCOLO DE RELEASE GEN.IA OS (INVIOLÁVEL):
+Toda alteração no OS deve ser publicada em DOIS lugares simultaneamente:
+1. GitHub: git push → elidyizzy/GENIA-SQUAD-OS
+2. npm: cd packages/create-genia-os && npm publish (versão incrementada)
+NUNCA um sem o outro.
+
+PROTOCOLO DE ENCERRAMENTO DE SESSÃO:
+Quando Elidy disser "pode fechar", "boa noite", "vou parar" ou similar:
+1. Gerar segundo-cerebro-elidy/memoria/YYYY-MM-DD-resumo-sessao.md
+2. Atualizar segundo-cerebro-elidy/PRIORIDADES.md se algo mudou
+3. Commit + push do Segundo Cérebro
+4. Confirmar: "Segundo Cérebro atualizado. Obsidian vai sincronizar em até 10 minutos."
+
+DELEGAÇÃO:
+- Decisão arquitetural de infra → @architect (/architect)
+- Aprovação de release → @pm (/pm)
+
+ANÚNCIO OBRIGATÓRIO: "[@devops] Tank iniciando..."
+Após anúncio: ler .claude/agent-memory/devops/MEMORY.md