create-genia-os 2.4.0 → 3.0.0

package/template/.claude/hooks/mind-clone-governance.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""
+Hook: Mind Clone Governance
+
+REGRA: Agents baseados em pessoas reais (mind clones) DEVEM passar pelo
+pipeline de extração de DNA antes de serem criados.
+
+Este hook intercepta Write/Edit em squads/*/agents/*.md e verifica:
+1. Se é um mind clone (baseado em pessoa real)
+2. Se existe DNA extraído correspondente
+
+NÃO BLOQUEIA:
+- Orchestrators (nome contém 'chief', 'orchestrator', 'chair')
+- Tool agents (nome contém 'validator', 'calculator', 'generator')
+- Process agents (nome contém 'architect', 'mapper', 'designer')
+- Edição de arquivo existente (apenas criação é bloqueada)
+
+Exit Codes:
+- 0: Permitido
+- 2: Bloqueado (mind clone sem DNA)
+"""
+
+import json
+import sys
+import os
+import re
+from pathlib import Path
+
+# =============================================================================
+# CONFIGURAÇÃO
+# =============================================================================
+
+# Padrões que indicam que NÃO é um mind clone (agents funcionais)
+FUNCTIONAL_AGENT_PATTERNS = [
+    # Orchestrators
+    r'.*-chief$',
+    r'.*-orchestrator$',
+    r'.*-chair$',
+    r'^orchestrator$',
+
+    # Tool agents
+    r'.*-validator$',
+    r'.*-calculator$',
+    r'.*-generator$',
+    r'.*-extractor$',
+    r'.*-analyzer$',
+
+    # Process agents
+    r'.*-architect$',
+    r'.*-mapper$',
+    r'.*-designer$',
+    r'.*-engineer$',
+
+    # Generic functional
+    r'^tools?-.*',
+    r'^process-.*',
+    r'^workflow-.*',
+]
+
+# Locais onde DNA pode estar
+DNA_LOCATIONS = [
+    "squads/{pack}/data/minds/{agent_id}_dna.yaml",
+    "squads/{pack}/data/minds/{agent_id}_dna.md",
+    "squads/{pack}/data/{agent_id}-dna.yaml",
+    "outputs/minds/{agent_id}/",
+]
+
+# =============================================================================
+# LÓGICA DO HOOK
+# =============================================================================
+
+def get_project_root():
+    """Obtém o root do projeto via variável de ambiente ou cwd."""
+    return os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+
+def extract_agent_info(file_path: str) -> tuple:
+    """Extrai pack_name e agent_id do path."""
+    # squads/{pack}/agents/{agent_id}.md
+    match = re.match(r'.*/squads/([^/]+)/agents/([^/]+)\.md$', file_path)
+    if match:
+        return match.group(1), match.group(2)
+    return None, None
+
+def is_functional_agent(agent_id: str) -> bool:
+    """Verifica se o agent é funcional (não é mind clone)."""
+    for pattern in FUNCTIONAL_AGENT_PATTERNS:
+        if re.match(pattern, agent_id, re.IGNORECASE):
+            return True
+    return False
+
+def has_dna_extracted(project_root: str, pack_name: str, agent_id: str) -> tuple:
+    """Verifica se existe DNA extraído para o agent."""
+    for location_template in DNA_LOCATIONS:
+        location = location_template.format(pack=pack_name, agent_id=agent_id)
+        full_path = os.path.join(project_root, location)
+
+        # Se é diretório, verificar se existe
+        if location.endswith('/'):
+            if os.path.isdir(full_path):
+                return True, full_path
+        # Se é arquivo, verificar se existe
+        elif os.path.isfile(full_path):
+            return True, full_path
+
+    return False, None
+
+def file_already_exists(file_path: str) -> bool:
+    """Verifica se o arquivo já existe (edit vs create)."""
+    return os.path.isfile(file_path)
+
+def main():
+    # Ler input do stdin
+    try:
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        # Se não conseguir parsear, permitir (fail-open)
+        sys.exit(0)
+
+    tool_name = input_data.get("tool_name", "")
+    tool_input = input_data.get("tool_input", {})
+
+    # Só processar Write e Edit
+    if tool_name not in ["Write", "Edit"]:
+        sys.exit(0)
+
+    file_path = tool_input.get("file_path", "")
+    if not file_path:
+        sys.exit(0)
+
+    # Só processar arquivos em squads/*/agents/
+    if "/squads/" not in file_path or "/agents/" not in file_path:
+        sys.exit(0)
+
+    if not file_path.endswith(".md"):
+        sys.exit(0)
+
+    project_root = get_project_root()
+
+    # Extrair informações do path
+    pack_name, agent_id = extract_agent_info(file_path)
+    if not pack_name or not agent_id:
+        sys.exit(0)
+
+    # Se é edição de arquivo existente, permitir
+    if file_already_exists(file_path):
+        sys.exit(0)
+
+    # Se é agent funcional (não mind clone), permitir
+    if is_functional_agent(agent_id):
+        sys.exit(0)
+
+    # Verificar se existe DNA extraído
+    has_dna, dna_path = has_dna_extracted(project_root, pack_name, agent_id)
+
+    if has_dna:
+        sys.exit(0)
+
+    # BLOQUEAR: Tentando criar mind clone sem DNA
+    error_message = f"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║  🧬 MIND CLONE GOVERNANCE: DNA não encontrado                                 ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Agent: {agent_id:<60} ║
+║  Pack:  {pack_name:<60} ║
+║                                                                              ║
+║  PROBLEMA: Este parece ser um MIND CLONE (baseado em pessoa real),           ║
+║            mas não foi encontrado DNA extraído.                              ║
+║                                                                              ║
+║  Mind clones DEVEM passar pelo pipeline de extração:                         ║
+║  1. *collect-sources  → Coletar fontes (livros, entrevistas, artigos)        ║
+║  2. *extract-voice-dna → Extrair padrões linguísticos                        ║
+║  3. *extract-thinking-dna → Extrair frameworks e heurísticas                 ║
+║  4. *create-agent → Criar agent a partir do DNA                              ║
+║                                                                              ║
+║  LOCAIS VERIFICADOS:                                                         ║
+║  • squads/{pack_name}/data/minds/{agent_id}_dna.yaml
+║  • squads/{pack_name}/data/minds/{agent_id}_dna.md
+║  • outputs/minds/{agent_id}/
+║                                                                              ║
+║  SOLUÇÕES:                                                                   ║
+║  1. Execute o pipeline de clone: /squad-creator → *collect-sources           ║
+║  2. OU se é agent FUNCIONAL, renomeie com sufixo:                            ║
+║     -chief, -orchestrator, -validator, -architect, etc.                      ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+    print(error_message, file=sys.stderr)
+    sys.exit(2)
+
+if __name__ == "__main__":
+    main()

package/template/.claude/hooks/pre-commit-version-check.sh

@@ -0,0 +1,156 @@
+#!/bin/bash
+#
+# Pre-Commit Hook: Version Metadata Validation
+#
+# Ensures all tasks and agents have version metadata in frontmatter.
+# This prevents silent version mismatches (e.g., v1.0 agent + v2.0 task).
+#
+# Usage:
+#   Run manually: .aiox-core/hooks/pre-commit-version-check.sh
+#   Install: .aiox-core/hooks/install-hooks.sh
+#
+# Story: STORY-3.10 (Version Alignment & Compatibility Checks)
+
+set -e
+
+echo "🔍 Validating task and agent version metadata..."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Track validation status
+ERRORS=0
+
+# Function to check if file has required version fields
+check_task_version() {
+    local file="$1"
+    local missing_fields=()
+
+    if ! grep -q "^task_name:" "$file"; then
+        missing_fields+=("task_name")
+    fi
+
+    if ! grep -q "^task_version:" "$file"; then
+        missing_fields+=("task_version")
+    fi
+
+    if ! grep -q "^required_agent_version:" "$file"; then
+        missing_fields+=("required_agent_version")
+    fi
+
+    if ! grep -q "^description:" "$file"; then
+        missing_fields+=("description")
+    fi
+
+    if ! grep -q "^last_updated:" "$file"; then
+        missing_fields+=("last_updated")
+    fi
+
+    if [ ${#missing_fields[@]} -gt 0 ]; then
+        echo -e "${RED}❌ ERROR: $file missing version metadata${NC}"
+        for field in "${missing_fields[@]}"; do
+            echo -e "${RED}   - Missing field: '$field'${NC}"
+        done
+        echo ""
+        ERRORS=$((ERRORS + 1))
+        return 1
+    fi
+
+    return 0
+}
+
+check_agent_version() {
+    local file="$1"
+    local missing_fields=()
+
+    if ! grep -q "^agent_name:" "$file"; then
+        missing_fields+=("agent_name")
+    fi
+
+    if ! grep -q "^agent_version:" "$file"; then
+        missing_fields+=("agent_version")
+    fi
+
+    if ! grep -q "^compatible_task_versions:" "$file"; then
+        missing_fields+=("compatible_task_versions")
+    fi
+
+    if ! grep -q "^description:" "$file"; then
+        missing_fields+=("description")
+    fi
+
+    if ! grep -q "^last_updated:" "$file"; then
+        missing_fields+=("last_updated")
+    fi
+
+    if [ ${#missing_fields[@]} -gt 0 ]; then
+        echo -e "${RED}❌ ERROR: $file missing version metadata${NC}"
+        for field in "${missing_fields[@]}"; do
+            echo -e "${RED}   - Missing field: '$field'${NC}"
+        done
+        echo ""
+        ERRORS=$((ERRORS + 1))
+        return 1
+    fi
+
+    return 0
+}
+
+# Check all tasks in expansion-packs/creator-os/tasks/
+echo "Checking CreatorOS tasks..."
+TASK_COUNT=0
+for task in expansion-packs/creator-os/tasks/*.md; do
+    # Skip backup files
+    if [[ "$task" == *"-backup.md" ]]; then
+        echo -e "${YELLOW}⏭️  Skipping backup: $task${NC}"
+        continue
+    fi
+
+    if [ -f "$task" ]; then
+        if check_task_version "$task"; then
+            echo -e "${GREEN}✅ $task${NC}"
+        fi
+        TASK_COUNT=$((TASK_COUNT + 1))
+    fi
+done
+
+# Check all agents in expansion-packs/creator-os/agents/
+echo ""
+echo "Checking CreatorOS agents..."
+AGENT_COUNT=0
+for agent in expansion-packs/creator-os/agents/*.md; do
+    if [ -f "$agent" ]; then
+        if check_agent_version "$agent"; then
+            echo -e "${GREEN}✅ $agent${NC}"
+        fi
+        AGENT_COUNT=$((AGENT_COUNT + 1))
+    fi
+done
+
+echo ""
+echo "────────────────────────────────────────────────────────────"
+echo "Summary:"
+echo "  - Tasks checked: $TASK_COUNT"
+echo "  - Agents checked: $AGENT_COUNT"
+echo "  - Errors found: $ERRORS"
+echo "────────────────────────────────────────────────────────────"
+
+if [ $ERRORS -gt 0 ]; then
+    echo ""
+    echo -e "${RED}❌ Version validation FAILED${NC}"
+    echo ""
+    echo "How to fix:"
+    echo "1. Add YAML frontmatter to each flagged file"
+    echo "2. Include all required fields (task_name, task_version, etc.)"
+    echo "3. See Story 3.10 for examples"
+    echo ""
+    exit 1
+fi
+
+echo ""
+echo -e "${GREEN}✅ Version validation PASSED${NC}"
+echo ""
+exit 0

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

@@ -1,87 +1,141 @@
-#!/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));
+#!/usr/bin/env node
+/**
+ * Claude Code Hook: PreCompact Session Digest
+ *
+ * Registered as PreCompact event — fires before context compaction.
+ * Reads JSON from stdin (Claude Code hook protocol), delegates to
+ * the unified hook runner in aiox-core.
+ *
+ * Stdin format (PreCompact):
+ * {
+ *   "session_id": "abc123",
+ *   "transcript_path": "/path/to/session.jsonl",
+ *   "cwd": "/path/to/project",
+ *   "hook_event_name": "PreCompact",
+ *   "trigger": "auto" | "manual"
+ * }
+ *
+ * @see .aiox-core/hooks/unified/runners/precompact-runner.js
+ * @see Story MIS-3 - Session Digest (PreCompact Hook)
+ * @see Story MIS-3.1 - Fix Session-Digest Hook Registration
+ */
+
+'use strict';
+
+const path = require('path');
+
+// Resolve project root via __dirname (same pattern as synapse-engine.cjs)
+// More robust than input.cwd — doesn't depend on external input
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+
+/** Safety timeout (ms) — defense-in-depth; Claude Code also manages hook timeout. */
+const HOOK_TIMEOUT_MS = 9000;
+
+/**
+ * Read all data from stdin as a JSON object.
+ * Same pattern as synapse-engine.cjs.
+ * @returns {Promise<object>} Parsed JSON input
+ */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('error', (e) => reject(e));
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try { resolve(JSON.parse(data)); }
+      catch (e) { reject(e); }
+    });
+  });
+}
+
+/**
+ * Resolve runner path — works in both framework-dev and installed projects.
+ * Framework-dev: PROJECT_ROOT/.aiox-core/hooks/unified/runners/precompact-runner.js
+ * Installed:     PROJECT_ROOT/node_modules/aiox-core/.aiox-core/hooks/unified/runners/precompact-runner.js
+ */
+function resolveRunnerPath() {
+  const fs = require('fs');
+  const candidates = [
+    path.join(PROJECT_ROOT, '.aiox-core', 'hooks', 'unified', 'runners', 'precompact-runner.js'),
+    path.join(PROJECT_ROOT, 'node_modules', 'aiox-core', '.aiox-core', 'hooks', 'unified', 'runners', 'precompact-runner.js'),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/** Main hook execution pipeline. */
+async function main() {
+  const input = await readStdin();
+
+  const runnerPath = resolveRunnerPath();
+  if (!runnerPath) return; // Runner not available — silent exit
+
+  // Build context object expected by onPreCompact
+  const context = {
+    sessionId: input.session_id,
+    projectDir: input.cwd || PROJECT_ROOT,
+    transcriptPath: input.transcript_path,
+    trigger: input.trigger || 'auto',
+    hookEventName: input.hook_event_name || 'PreCompact',
+    permissionMode: input.permission_mode,
+    conversation: input,
+    provider: 'claude',
+  };
+
+  // Spawn a detached child process so the digest is fire-and-forget.
+  // Using require() in-process keeps the event loop alive (setImmediate inside
+  // the runner), causing the hook to block until the 9 s safety timeout.
+  // The child receives context via AIOX_HOOK_CONTEXT env var and calls
+  // onPreCompact() exported by the runner module.
+  try {
+    const { spawn } = require('child_process');
+    let contextJson;
+    try {
+      contextJson = JSON.stringify(context);
+    } catch (_) {
+      contextJson = '{}';
+    }
+    const inlineScript = [
+      `const ctx = JSON.parse(process.env.AIOX_HOOK_CONTEXT || '{}');`,
+      `const { onPreCompact } = require(${JSON.stringify(runnerPath)});`,
+      `onPreCompact(ctx).catch(() => {});`,
+    ].join('\n');
+    const child = spawn(process.execPath, ['-e', inlineScript], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, AIOX_HOOK_CONTEXT: contextJson },
+    });
+    child.on('error', () => {});
+    child.unref();
+  } catch (_) {
+    // Silent — spawn failures must not crash the hook
+  }
+}
+
+/** Entry point runner — sets safety timeout and executes main(). */
+function run() {
+  // Safety timeout — force exit only as last resort (no stdout to flush at this point).
+  const timer = setTimeout(() => {
+    process.exit(0);
+  }, HOOK_TIMEOUT_MS);
+  timer.unref();
+
+  main()
+    .then(() => {
+      clearTimeout(timer);
+      // Let event loop drain naturally — process.exitCode allows stdout flush
+      process.exitCode = 0;
+    })
+    .catch(() => {
+      clearTimeout(timer);
+      // Silent exit — never write to stderr (triggers "hook error" in Claude Code)
+      process.exitCode = 0;
+    });
+}
+
+if (require.main === module) run();
+
+module.exports = { readStdin, main, run, HOOK_TIMEOUT_MS };

package/template/.claude/hooks/precompact-wrapper.cjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * PreCompact Hook Wrapper
+ *
+ * Same isolation pattern as synapse-wrapper.cjs — runs the real hook
+ * as a child process to prevent stdout→stderr buffer leak from process.exit().
+ *
+ * @module precompact-hook-wrapper
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const hookPath = path.join(__dirname, 'precompact-session-digest.cjs');
+
+let stdinData = '';
+try {
+  stdinData = fs.readFileSync(0, 'utf8');
+} catch (_) {
+  process.exitCode = 0;
+}
+
+if (!stdinData) process.exit(0);
+
+try {
+  const stdout = execFileSync(process.execPath, [hookPath], {
+    input: stdinData,
+    timeout: 12000,
+    maxBuffer: 1024 * 1024,
+    env: process.env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  if (stdout && stdout.length > 0) {
+    process.stdout.write(stdout);
+  }
+} catch (err) {
+  if (err.stdout && err.stdout.length > 0) {
+    process.stdout.write(err.stdout);
+  }
+}
+
+process.exitCode = 0;