create-genia-os 1.0.0

package/template/.claude/hooks/enforce-git-push-authority.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+GEN.IA OS — Hook: enforce-git-push-authority
+Trigger: PreToolUse (Bash)
+Ação: Bloqueia git push por agentes não-devops.
+      Permite push quando @devops está autorizado via flag file.
+Artigo II da Constituição GEN.IA OS — NÃO-NEGOCIÁVEL.
+
+Protocolo de autorização:
+  1. Claude pergunta à usuária se quer invocar @devops
+  2. Se sim, @devops cria .genia/session/devops-active
+  3. Este hook lê o flag e permite o push (uma única vez)
+  4. Flag é removido automaticamente após uso
+"""
+import json
+import os
+import sys
+import re
+
+
+PUSH_PATTERNS = [
+    r"\bgit\s+push\b",
+    r"\bgit\s+push\s+--force\b",
+    r"\bgit\s+push\s+-f\b",
+    r"\bgit\s+push\s+-u\b",
+]
+
+FLAG_FILE = ".genia/session/devops-active"
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        data = json.loads(raw)
+    except Exception:
+        sys.exit(0)
+
+    tool = data.get("tool_name", "")
+    if tool != "Bash":
+        sys.exit(0)
+
+    command = data.get("tool_input", {}).get("command", "")
+
+    for pattern in PUSH_PATTERNS:
+        if re.search(pattern, command, re.IGNORECASE):
+            # Verificar se @devops foi autorizado via flag file
+            if os.path.exists(FLAG_FILE):
+                try:
+                    os.remove(FLAG_FILE)  # Consumir o flag (uso único)
+                except Exception:
+                    pass
+                print(
+                    "[GEN.IA OS] ✅ @devops (Gate) autorizado — executando push.",
+                    file=sys.stderr,
+                )
+                sys.exit(0)  # Permitir
+
+            # Sem autorização — bloquear
+            print(
+                "[GEN.IA OS] 🚫 BLOQUEADO — Artigo II: Apenas @devops pode executar git push.\n"
+                "[GEN.IA OS] Diga: '@devops faça o push' para invocar Gate.",
+                file=sys.stderr,
+            )
+            sys.exit(2)  # exit 2 = BLOCK no Claude Code
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/template/.claude/hooks/precompact-session-digest.cjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * GEN.IA OS — Session Digest
+ * Trigger: PreCompact
+ *
+ * Salva um resumo da sessão antes do Claude compactar o contexto.
+ * Preserva memória institucional entre sessões longas.
+ * Inspirado no AIOS precompact-session-digest (MIT License, SynkraAI)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+async function main() {
+  let inputData = '';
+  try {
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    for await (const line of rl) {
+      inputData += line + '\n';
+    }
+  } catch (_) {
+    process.exit(0);
+  }
+
+  let data = {};
+  try {
+    data = JSON.parse(inputData);
+  } catch (_) {
+    process.exit(0);
+  }
+
+  const cwd = data.cwd || process.cwd();
+  const sessionId = data.session_id || 'unknown';
+  const timestamp = new Date()
+    .toISOString()
+    .slice(0, 19)
+    .replace('T', '_')
+    .replace(/:/g, '-');
+
+  const digestDir = path.join(cwd, '.genia', 'session-digests');
+  try {
+    fs.mkdirSync(digestDir, { recursive: true });
+  } catch (_) {
+    process.exit(0);
+  }
+
+  const digestPath = path.join(digestDir, `digest-${timestamp}.md`);
+
+  const content = `# Session Digest — ${timestamp}
+
+**Session ID:** ${sessionId}
+**Sistema:** GEN.IA OS — {{TEAM_NAME}}
+
+## Contexto Compactado
+
+O Claude Code compactou o contexto desta sessão.
+Este arquivo preserva o estado para retomada.
+
+## Como Retomar
+
+1. Leia as stories ativas em \`docs/stories/\`
+2. Verifique \`.genia/session/workflow-state.md\` para workflow em andamento
+3. Consulte \`.claude/agent-memory/[agente]/MEMORY.md\` do agente ativo
+4. Verifique git log para entender o que foi commitado
+
+## Dica
+
+Ao retomar, informe ao agente:
+> "Estou retomando a sessão. [descreva o contexto brevemente]"
+
+---
+*Gerado automaticamente pelo GEN.IA OS Synapse Engine*
+`;
+
+  try {
+    fs.writeFileSync(digestPath, content, 'utf8');
+  } catch (_) {
+    // Falha silenciosa — nunca bloquear o usuário
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/template/.claude/hooks/sql-governance.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+GEN.IA OS — Hook: sql-governance
+Trigger: PreToolUse (Bash)
+Ação: Bloqueia DDL SQL perigoso executado diretamente.
+Permite operações via supabase CLI, pg_dump e psql -f (migrations controladas).
+"""
+import json
+import sys
+import re
+
+
+DANGEROUS_PATTERNS = [
+    r"\bDROP\s+TABLE\b",
+    r"\bDROP\s+DATABASE\b",
+    r"\bDROP\s+SCHEMA\b",
+    r"\bTRUNCATE\s+TABLE\b",
+    r"\bTRUNCATE\b\s+\w+",
+    r"\bALTER\s+TABLE\b.*\bDROP\s+COLUMN\b",
+    r"DELETE\s+FROM\s+\w+\s*;?\s*$",  # DELETE sem WHERE
+]
+
+SAFE_PATTERNS = [
+    r"supabase\s+(migration|db\s+push|db\s+diff)",
+    r"pg_dump\b",
+    r"psql\s+.*-f\s+",
+    r"\.sql\s*$",  # executar arquivo .sql explícito
+]
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        data = json.loads(raw)
+    except Exception:
+        sys.exit(0)
+
+    tool = data.get("tool_name", "")
+    if tool != "Bash":
+        sys.exit(0)
+
+    command = data.get("tool_input", {}).get("command", "")
+
+    # Verificar se é operação segura de migration
+    for safe in SAFE_PATTERNS:
+        if re.search(safe, command, re.IGNORECASE):
+            sys.exit(0)
+
+    # Verificar padrões perigosos
+    cmd_upper = command.upper()
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, cmd_upper):
+            print(
+                "[GEN.IA OS] 🚫 BLOQUEADO — SQL destrutivo detectado.\n"
+                "[GEN.IA OS] Use 'supabase migration new <nome>' para alterações de schema.\n"
+                "[GEN.IA OS] Migrations controladas garantem rollback seguro.",
+                file=sys.stderr,
+            )
+            sys.exit(2)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,122 @@
+#!/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);
+});

package/template/.claude/hooks/write-path-validation.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+GEN.IA OS — Hook: write-path-validation
+Trigger: PreToolUse (Write)
+Ação: Avisa quando documentos são criados fora do path padrão.
+"""
+import json
+import sys
+import re
+import os
+
+
+# Padrões de arquivo → path recomendado
+DOC_RULES = {
+    r"^PRD\.md$": "docs/[projeto]/PRD.md",
+    r"^SPEC-TECNICO\.md$": "docs/[projeto]/SPEC-TECNICO.md",
+    r"^COMERCIAL\.md$": "docs/[projeto]/COMERCIAL.md",
+    r"^BRIEFING\.md$": "docs/[projeto]/BRIEFING.md",
+    r"^STORY-\d+.*\.md$": "docs/stories/STORY-NNN-slug.md",
+    r"^ADR-\d+.*\.md$": "docs/[projeto]/adrs/ADR-NNN-titulo.md",
+}
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        data = json.loads(raw)
+    except Exception:
+        sys.exit(0)
+
+    tool = data.get("tool_name", "")
+    if tool != "Write":
+        sys.exit(0)
+
+    file_path = data.get("tool_input", {}).get("file_path", "")
+    if not file_path:
+        sys.exit(0)
+
+    # Normalizar separadores
+    normalized = file_path.replace("\\", "/")
+    filename = os.path.basename(normalized)
+
+    for pattern, correct_path in DOC_RULES.items():
+        if re.match(pattern, filename, re.IGNORECASE):
+            # Verificar se está no path correto
+            if "docs/" not in normalized:
+                print(
+                    f"[GEN.IA OS] ⚠️  Documento '{filename}' fora do path padrão.\n"
+                    f"[GEN.IA OS] Path recomendado: {correct_path}\n"
+                    f"[GEN.IA OS] Criando assim mesmo — ajuste se necessário.",
+                    file=sys.stderr,
+                )
+            break
+
+    sys.exit(0)  # Apenas avisa, não bloqueia
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,39 @@
+# Autoridade dos Agentes — GEN.IA OS
+
+## Matriz de Delegação
+
+| Agente | Nome | Autoridade Exclusiva | Git Permitido | Git Bloqueado |
+|--------|------|---------------------|---------------|---------------|
+| @analyst | Ana | Briefing, requisitos, pesquisa | status, log, diff | push, commit, merge |
+| @pm | Marina | PRD, escopo, priorização, épicos | status, log, diff | push, commit, merge |
+| @architect | Arqui | Arquitetura, stack, VETO técnico | status, log, diff | push, commit, merge |
+| @dev | Dev | Implementação de código | checkout, add, commit | **PUSH (BLOQUEADO)** |
+| @devops | Gate | **git push, PR, release, MCP** | TUDO | nada |
+| @qa | Quinn | Veredictos de qualidade, testes | status, log, diff, stash | push, commit |
+| @reviewer | Rev | Code review, aprovação | status, log, diff | push, commit |
+| @po | Pax | Validação de stories, backlog | status, log, diff | push, commit, merge |
+| @sm | Sami | **Criação de stories**, sprint | status, log, diff | push, commit, merge |
+
+## Regras Invioláveis (Artigo II da Constituição)
+
+1. **@dev NUNCA faz push** — sempre delegar para @devops após commit
+2. **@sm é o ÚNICO que cria stories** — nenhum outro agente cria STORY-*.md
+3. **@architect tem veto técnico irrevogável** — qualquer decisão arquitetural
+4. **@po é o ÚNICO que aprova stories** para ir para desenvolvimento
+5. **@devops gerencia MCP** — nenhum outro agente adiciona/remove servidores MCP
+
+## Protocolo de Escalação
+
+Quando uma tarefa está fora do seu escopo:
+1. **PARAR** imediatamente
+2. **Anunciar** o agente correto: "Esta tarefa pertence a @[agente]"
+3. **Fazer handoff** usando o protocolo de `.claude/rules/agent-handoff.md`
+4. **NÃO executar** tarefas fora da sua autoridade
+
+## Exemplos de Escalação Obrigatória
+
+- @dev termina implementação → delega push para **@devops**
+- @dev tem dúvida arquitetural → consulta **@architect**
+- @pm precisa de requisitos → solicita para **@analyst**
+- @dev precisa de story → solicita para **@sm**
+- @sm criou story → entrega para **@po** validar

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

@@ -0,0 +1,71 @@
+# Protocolo de Handoff — GEN.IA OS
+
+## Quando Fazer Handoff
+
+Handoff é obrigatório quando:
+- Tarefa requer autoridade de outro agente (Artigo II)
+- Fase do workflow mudou
+- Blocker identificado fora do escopo atual
+- Trabalho está completo e próxima etapa é de outro agente
+
+## Formato de Handoff (≤ 400 tokens)
+
+```
+[@agente-atual → @próximo-agente]
+
+📋 Contexto: [O que foi feito em 2-3 frases]
+
+📌 Decisões tomadas:
+- [decisão 1]
+- [decisão 2]
+
+📁 Arquivos criados/modificados:
+- [path/arquivo.md]
+
+⚠️  Pendências:
+- [o que precisa ser feito]
+
+🔗 Story atual: STORY-NNN (se aplicável)
+```
+
+## Regra de Token Budget
+
+- Handoff DEVE ser ≤ 400 tokens
+- Após 2+ trocas de agente, comprimir histórico ao essencial
+- Não repassar contexto completo — apenas decisões e pendências
+
+## Compressão de Contexto
+
+Quando o contexto estiver saturado (muitas trocas de agente):
+
+1. Criar `.genia/session/context-summary.md` com:
+   - Decisões arquiteturais tomadas
+   - Stories em andamento e seus estados
+   - Blockers conhecidos
+   - Stack tecnológica confirmada
+
+2. Referenciar o arquivo no próximo handoff:
+   ```
+   [Contexto comprimido em .genia/session/context-summary.md]
+   ```
+
+## Exemplos de Handoff
+
+**@dev → @devops (após implementação):**
+```
+[@dev → @devops]
+📋 Implementei STORY-003 (autenticação JWT). Commits feitos localmente.
+📌 Decisões: Usei jose library, tokens expiram em 1h, refresh em 7d.
+📁 Modificados: src/auth/jwt.ts, src/middleware/auth.ts, tests/auth.test.ts
+⚠️  Pendências: Push da branch feat/STORY-003-jwt-auth e criar PR para main.
+🔗 Story atual: STORY-003 (status: InReview)
+```
+
+**@analyst → @pm (após briefing):**
+```
+[@analyst → @pm]
+📋 Coletei requisitos completos do sistema de orçamentos BrasilUp.
+📌 Decisões: App web (não mobile), integração com Kommo CRM, 3 usuários simultâneos.
+📁 Criados: docs/brasilup/BRIEFING.md
+⚠️  Pendências: Criar PRD com base no briefing. Atenção ao requisito de relatórios PDF.
+```

package/template/.claude/rules/agent-memory.md

@@ -0,0 +1,61 @@
+# Memória Persistente dos Agentes — GEN.IA OS
+
+## Localização
+
+```
+.claude/agent-memory/
+├── analyst/MEMORY.md
+├── pm/MEMORY.md
+├── architect/MEMORY.md
+├── dev/MEMORY.md
+├── devops/MEMORY.md
+├── qa/MEMORY.md
+├── reviewer/MEMORY.md
+├── po/MEMORY.md
+└── sm/MEMORY.md
+```
+
+## Regra de Leitura
+
+Todo agente DEVE ler seu `MEMORY.md` ao ser ativado. Esta leitura é parte do protocolo de ativação.
+
+## Quando Atualizar
+
+Atualizar o MEMORY.md quando:
+- Descobrir padrão recorrente no projeto
+- Resolver problema difícil (documentar a solução)
+- Identificar preferência da usuária (Elidy)
+- Encontrar um gotcha (armadilha) do projeto
+- Tomar decisão arquitetural relevante
+
+## Formato do MEMORY.md
+
+```markdown
+# MEMORY — @[agente] ([Nome])
+
+> Memória persistente. Atualizada a cada sessão relevante.
+> Última atualização: YYYY-MM-DD
+
+## Padrões Confirmados
+- [padrão]: [quando usar]
+
+## Preferências da Usuária
+- [preferência]: [contexto]
+
+## Gotchas do Projeto
+- [problema]: [solução]
+
+## Decisões Importantes
+- [decisão]: [justificativa e data]
+
+## Stack Tecnológica Confirmada
+- [tecnologia]: [versão/contexto]
+```
+
+## Regra de Escrita
+
+- Não adicionar informações duplicadas
+- Verificar se já existe entry antes de criar nova
+- Remover entries desatualizadas
+- Máximo 200 linhas por arquivo (comprimir se necessário)
+- Usar linguagem objetiva: fatos, não opiniões

package/template/.claude/rules/ids-principles.md

@@ -0,0 +1,52 @@
+# Princípios IDS — GEN.IA OS
+## Incremental Decision System
+
+## Hierarquia de Decisão
+
+```
+REUSAR > ADAPTAR > CRIAR
+```
+
+Antes de criar qualquer artefato (componente, task, template, módulo, contexto):
+
+**1. REUSAR** — Buscar no projeto algo que já resolve o problema
+**2. ADAPTAR** — Se 70%+ compatível, adaptar o existente
+**3. CRIAR** — Apenas se reutilização não é viável
+
+## Onde Buscar Antes de Criar
+
+| Tipo | Buscar em |
+|------|-----------|
+| Task | `.genia/development/tasks/` |
+| Template de doc | `.claude/templates/` (se existir) |
+| Contexto de API | `.genia/contexts/` |
+| Skill | `.genia/skills/` |
+| Guideline | `.genia/guidelines/` |
+| Checklist | `.genia/development/checklists/` |
+
+## Justificativa Obrigatória para CRIAR
+
+Ao criar novo artefato que poderia ser reusado, documentar inline:
+
+```
+// NOVO: não foi possível reusar porque [razão]
+// Adaptação de: [nada existente] | [X arquivo, mas incompatível por Y]
+```
+
+## Prevenção de Duplicação em Stories
+
+Antes de criar `STORY-NNN`, verificar:
+1. Existe story similar em `docs/stories/`?
+2. Está dentro de um épico já existente?
+3. Já foi implementado e mergeado?
+
+## Circuit Breaker
+
+Se a busca por artefato reutilizável demorar mais de 30 segundos, prosseguir com criação e documentar a tentativa de busca.
+
+## Benefícios
+
+- Reduz explosão de arquivos no projeto
+- Mantém consistência entre implementações similares
+- Facilita manutenção no longo prazo
+- Evita reinventar soluções já validadas

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

@@ -0,0 +1,49 @@
+# Uso de Ferramentas e MCP — GEN.IA OS
+
+## Prioridade de Ferramentas
+
+```
+1. Ferramentas nativas Claude Code  (sempre preferir)
+2. Ferramentas MCP configuradas     (quando necessário)
+3. Bash com CLI tools               (último recurso)
+```
+
+## Ferramentas Nativas — Sempre Preferir
+
+| Operação | Ferramenta Correta | NÃO usar |
+|----------|--------------------|----------|
+| Ler arquivo | Read | Bash cat/head/tail |
+| Criar arquivo | Write | Bash echo/cat heredoc |
+| Editar arquivo | Edit | Bash sed/awk |
+| Buscar arquivo | Glob | Bash find/ls |
+| Buscar conteúdo | Grep | Bash grep/rg |
+| Perguntar usuário | AskUserQuestion | — |
+| Tarefa complexa | Task | — |
+
+## Gerenciamento MCP
+
+**@devops é o ÚNICO autorizado a:**
+- Adicionar servidores MCP
+- Remover servidores MCP
+- Configurar MCP (editar settings.json de MCP)
+- Fazer upgrade de versão de servidor MCP
+
+Outros agentes são **consumidores apenas**.
+
+## Regra de Ouro
+
+> "Se uma ferramenta nativa do Claude Code resolve, não use MCP."
+
+## Servidores MCP Disponíveis
+
+Ver configuração em `.claude/settings.json` (gerenciado por @devops).
+
+## Quando Usar Bash
+
+Use Bash apenas para:
+- Comandos git (quando necessário)
+- Executar scripts (npm, python, etc.)
+- Operações de sistema que não têm ferramenta nativa
+- Comandos CLI específicos (supabase, gh, etc.)
+
+Nunca para: leitura/escrita/busca de arquivos.