grimoire-framework 1.1.0 → 1.2.0

package/.grimoire/install-manifest.yaml

@@ -7,8 +7,8 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.1.0
-generated_at: "2026-02-22T14:53:32.130Z"
+version: 1.2.0
+generated_at: "2026-02-22T16:41:00.136Z"
 generator: scripts/generate-install-manifest.js
 file_count: 1011
 files:

package/bin/commands/agent.js

@@ -100,6 +100,7 @@ async function run(args) {
     switch (sub) {
         case 'create': await createWizard(); break;
         case 'edit': await editAgent(args[1]); break;
+        case 'validate': validateAgent(args[1]); break;
         case 'remove':
         case 'delete': await removeAgent(args[1]); break;
         case 'list':
@@ -191,6 +192,43 @@ Para sincronizar com outras IDEs:
 `);
 }
 
+function validateAgent(id) {
+    if (!id) { console.log('Usage: grimoire agent validate <name>'); return; }
+    const file = path.join(process.cwd(), '.codex', 'agents', `${id}.md`);
+    if (!fs.existsSync(file)) { console.log(`❌ Agent "${id}" not found in .codex/agents/`); return; }
+
+    const content = fs.readFileSync(file, 'utf8');
+    const checks = [
+        { name: 'YAML block (`\`\`\`yaml`)', pass: content.includes('```yaml') },
+        { name: 'activation-instructions', pass: content.includes('activation-instructions') },
+        { name: 'STEP 1 / STEP 2 / STEP 3', pass: /STEP 1/.test(content) && /STEP 2/.test(content) },
+        { name: 'agent.name defined', pass: /\bname:\s*\S+/.test(content) },
+        { name: 'agent.id defined', pass: /\bid:\s*\S+/.test(content) },
+        { name: 'agent.icon defined', pass: /\bicon:\s*\S+/.test(content) },
+        { name: 'greeting_levels present', pass: content.includes('greeting_levels') },
+        { name: 'signature_closing present', pass: content.includes('signature_closing') },
+        { name: 'ACTIVATION-NOTICE present', pass: content.includes('ACTIVATION-NOTICE') },
+        { name: '*exit command referenced', pass: content.includes('*exit') },
+    ];
+
+    const passed = checks.filter(c => c.pass).length;
+    const score = Math.round((passed / checks.length) * 100);
+    const emoji = score === 100 ? '🟢' : score >= 70 ? '🟡' : '🔴';
+
+    console.log(`\n🔍 Agent Validation: @${id}\n${'─'.repeat(40)}`);
+    checks.forEach(c => console.log(`  ${c.pass ? '✅' : '❌'} ${c.name}`));
+    console.log(`${'─'.repeat(40)}`);
+    console.log(`  ${emoji} Score: ${score}/100 (${passed}/${checks.length} checks)\n`);
+
+    if (score < 100) {
+        console.log('  Fixes sugeridos:');
+        checks.filter(c => !c.pass).forEach(c => console.log(`    → Adicionar: ${c.name}`));
+        console.log();
+    } else {
+        console.log('  ✅ Agente válido e pronto para uso!\n');
+    }
+}
+
 async function editAgent(id) {
     if (!id) { console.log('Usage: grimoire agent edit <name>'); return; }
     const file = path.join(process.cwd(), '.codex', 'agents', `${id}.md`);

package/bin/commands/config.js

@@ -0,0 +1,181 @@
+/**
+ * grimoire config — Project-level configuration
+ *
+ * grimoire config get <key>         Lê valor de uma chave
+ * grimoire config set <key> <value> Define valor de uma chave
+ * grimoire config list              Lista todas as configurações
+ * grimoire config reset             Reseta para os defaults
+ *
+ * Config file: .grimoire/config.yaml
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+// ── Defaults ───────────────────────────────────────────────────────────────────
+const DEFAULTS = {
+    default_agent: 'grimoire-master',
+    memory_auto_save: false,
+    update_check_interval: 24,          // hours
+    metrics_enabled: true,
+    hooks_enabled: false,
+    marketplace_cache_ttl: 60,          // minutes
+    language: 'pt-BR',
+};
+
+const DESCRIPTIONS = {
+    default_agent: 'Agente padrão ao iniciar o IDE',
+    memory_auto_save: 'Salvar memória automaticamente ao encerrar sessão',
+    update_check_interval: 'Intervalo de horas entre verificações de atualização',
+    metrics_enabled: 'Habilitar coleta de métricas de produtividade',
+    hooks_enabled: 'Habilitar git hooks para auto-tracking de commits',
+    marketplace_cache_ttl: 'Tempo de cache do marketplace em minutos',
+    language: 'Idioma preferido para prompts e saídas',
+};
+
+// ── File location ──────────────────────────────────────────────────────────────
+function findConfigFile() {
+    const cwd = process.cwd();
+    const direct = path.join(cwd, '.grimoire', 'config.yaml');
+    const subdir = path.join(cwd, 'grimoire', '.grimoire', 'config.yaml');
+    if (fs.existsSync(direct)) return direct;
+    if (fs.existsSync(subdir)) return subdir;
+    // Return direct path for writing even if it doesn't exist
+    const grimoireDir = path.join(cwd, '.grimoire');
+    if (fs.existsSync(grimoireDir)) return direct;
+    return null;
+}
+
+// ── Minimal YAML parser/writer ─────────────────────────────────────────────────
+function parseYaml(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const stripped = line.trim();
+        if (!stripped || stripped.startsWith('#')) continue;
+        const colonIdx = stripped.indexOf(':');
+        if (colonIdx === -1) continue;
+        const key = stripped.slice(0, colonIdx).trim();
+        let val = stripped.slice(colonIdx + 1).trim();
+        // Parse types
+        if (val === 'true') val = true;
+        else if (val === 'false') val = false;
+        else if (!isNaN(val) && val !== '') val = Number(val);
+        result[key] = val;
+    }
+    return result;
+}
+
+function toYaml(obj) {
+    const lines = ['# Grimoire Framework — Project Configuration', '# grimoire config set <key> <value> to edit', ''];
+    for (const [k, v] of Object.entries(obj)) {
+        const desc = DESCRIPTIONS[k];
+        if (desc) lines.push(`# ${desc}`);
+        lines.push(`${k}: ${v}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+
+function loadConfig() {
+    const file = findConfigFile();
+    if (!file || !fs.existsSync(file)) return { ...DEFAULTS };
+    try {
+        return { ...DEFAULTS, ...parseYaml(fs.readFileSync(file, 'utf8')) };
+    } catch (_) { return { ...DEFAULTS }; }
+}
+
+function saveConfig(obj) {
+    const cwd = process.cwd();
+    let grimoireDir = path.join(cwd, '.grimoire');
+    if (!fs.existsSync(grimoireDir)) {
+        const sub = path.join(cwd, 'grimoire', '.grimoire');
+        if (fs.existsSync(sub)) grimoireDir = sub;
+        else { console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install'); return false; }
+    }
+    const file = path.join(grimoireDir, 'config.yaml');
+    fs.writeFileSync(file, toYaml(obj), 'utf8');
+    return true;
+}
+
+// ── Public API ─────────────────────────────────────────────────────────────────
+function getConfigValue(key) {
+    return loadConfig()[key];
+}
+
+// ── Commands ───────────────────────────────────────────────────────────────────
+function run(args) {
+    const sub = args[0];
+    const key = args[1];
+    const value = args[2];
+
+    switch (sub) {
+        case 'set': configSet(key, value); break;
+        case 'reset': configReset(); break;
+        case 'get':
+            if (!key) { configList(); break; }
+            configGet(key); break;
+        case 'list':
+        default: configList(); break;
+    }
+}
+
+function configGet(key) {
+    if (!key) { configList(); return; }
+    const config = loadConfig();
+    if (!(key in config)) {
+        console.log(`❌ Chave desconhecida: "${key}"`);
+        console.log(`   Chaves válidas: ${Object.keys(DEFAULTS).join(', ')}\n`);
+        return;
+    }
+    console.log(`${key} = ${config[key]}`);
+}
+
+function configSet(key, value) {
+    if (!key || value === undefined) {
+        console.log('Usage: grimoire config set <key> <value>');
+        console.log('Ex:    grimoire config set default_agent dev\n');
+        return;
+    }
+    if (!(key in DEFAULTS)) {
+        console.log(`❌ Chave desconhecida: "${key}"`);
+        console.log(`   Chaves válidas: ${Object.keys(DEFAULTS).join(', ')}\n`);
+        return;
+    }
+    const config = loadConfig();
+    // Type coerce
+    let coerced = value;
+    if (value === 'true') coerced = true;
+    else if (value === 'false') coerced = false;
+    else if (!isNaN(value)) coerced = Number(value);
+
+    config[key] = coerced;
+    if (saveConfig(config)) {
+        console.log(`✅ ${key} = ${coerced}`);
+    }
+}
+
+function configList() {
+    const config = loadConfig();
+    const file = findConfigFile();
+    console.log(`\n⚙️  Grimoire Config${file && fs.existsSync(file) ? ` (${path.relative(process.cwd(), file)})` : ' (defaults)'}\n`);
+    console.log('  ' + '─'.repeat(48));
+    for (const [k, v] of Object.entries(DEFAULTS)) {
+        const current = config[k];
+        const isDef = current === v;
+        const marker = isDef ? '  ' : '✏️ ';
+        console.log(`  ${marker} ${k.padEnd(28)} ${String(current)}`);
+    }
+    console.log('  ' + '─'.repeat(48));
+    console.log(`  💡 grimoire config set <key> <value>  para alterar`);
+    console.log(`  💡 grimoire config reset              para restaurar defaults\n`);
+}
+
+function configReset() {
+    if (saveConfig({ ...DEFAULTS })) {
+        console.log('✅ Configuração restaurada para os defaults.\n');
+    }
+}
+
+module.exports = { run, getConfigValue, loadConfig };

package/bin/commands/hooks.js

@@ -0,0 +1,137 @@
+/**
+ * grimoire hooks — Git Hook Integration for Auto-Metrics Tracking
+ *
+ * grimoire hooks install      Instala post-commit hook no repositório atual
+ * grimoire hooks uninstall    Remove o hook
+ * grimoire hooks status       Verifica se o hook está instalado
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const HOOK_MARKER = '# grimoire-hook-v1';
+const HOOK_CONTENT = `#!/bin/sh
+${HOOK_MARKER}
+# Auto-installed by Grimoire Framework
+# Remove with: grimoire hooks uninstall
+
+# Get commit message (first line)
+COMMIT_MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1)
+
+# Track the commit in grimoire metrics (non-blocking)
+grimoire metrics track commit "$COMMIT_MSG" 2>/dev/null &
+
+exit 0
+`;
+
+function findGitDir() {
+    let dir = process.cwd();
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, '.git'))) return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return null;
+}
+
+function run(args) {
+    const sub = args[0] || 'status';
+    switch (sub) {
+        case 'install': install(); break;
+        case 'uninstall': uninstall(); break;
+        case 'status':
+        default: status(); break;
+    }
+}
+
+function install() {
+    const gitRoot = findGitDir();
+    if (!gitRoot) {
+        console.error('❌ Repositório git não encontrado. Execute dentro de um projeto git.');
+        return;
+    }
+
+    const hooksDir = path.join(gitRoot, '.git', 'hooks');
+    const hookFile = path.join(hooksDir, 'post-commit');
+
+    if (!fs.existsSync(hooksDir)) fs.mkdirSync(hooksDir, { recursive: true });
+
+    // Check if hook already exists and isn't ours
+    if (fs.existsSync(hookFile)) {
+        const existing = fs.readFileSync(hookFile, 'utf8');
+        if (existing.includes(HOOK_MARKER)) {
+            console.log('ℹ️  Hook já instalado. Use "grimoire hooks status" para verificar.');
+            return;
+        }
+        // Append to existing hook
+        const updated = existing.trimEnd() + '\n\n' + HOOK_CONTENT;
+        fs.writeFileSync(hookFile, updated, 'utf8');
+    } else {
+        fs.writeFileSync(hookFile, HOOK_CONTENT, 'utf8');
+    }
+
+    // Make executable (Unix/Mac — no-op on Windows but harmless)
+    try { fs.chmodSync(hookFile, '755'); } catch (_) { }
+
+    console.log(`
+✅ grimoire hooks instalado!
+
+   Hook: .git/hooks/post-commit
+   Efeito: commits são automaticamente registrados em grimoire metrics
+
+   Próximo passo: faça um git commit e execute:
+   grimoire metrics --period week
+
+   Para remover: grimoire hooks uninstall
+`);
+}
+
+function uninstall() {
+    const gitRoot = findGitDir();
+    if (!gitRoot) { console.error('❌ Repositório git não encontrado.'); return; }
+
+    const hookFile = path.join(gitRoot, '.git', 'hooks', 'post-commit');
+    if (!fs.existsSync(hookFile)) {
+        console.log('ℹ️  Nenhum hook encontrado.');
+        return;
+    }
+
+    const content = fs.readFileSync(hookFile, 'utf8');
+    if (!content.includes(HOOK_MARKER)) {
+        console.log('ℹ️  Hook não foi instalado pelo Grimoire. Nada removido.');
+        return;
+    }
+
+    // If our hook is the only content, delete the file
+    const lines = content.split('\n');
+    const otherLines = lines.filter(l => !l.includes(HOOK_MARKER) && !l.includes('grimoire metrics track'));
+    const cleaned = otherLines.join('\n').trim();
+
+    if (!cleaned || cleaned === '#!/bin/sh') {
+        fs.unlinkSync(hookFile);
+        console.log('✅ Hook removido (arquivo deletado).');
+    } else {
+        fs.writeFileSync(hookFile, cleaned + '\n', 'utf8');
+        console.log('✅ Hook grimoire removido (conteúdo do hook preservado).');
+    }
+}
+
+function status() {
+    const gitRoot = findGitDir();
+    if (!gitRoot) { console.log('⚠️  Repositório git não encontrado.\n'); return; }
+
+    const hookFile = path.join(gitRoot, '.git', 'hooks', 'post-commit');
+    const exists = fs.existsSync(hookFile);
+    const isOurs = exists && fs.readFileSync(hookFile, 'utf8').includes(HOOK_MARKER);
+
+    console.log('\n🪝 Grimoire Hooks\n' + '─'.repeat(40));
+    console.log(`  post-commit: ${isOurs ? '✅ instalado' : exists ? '⚠️  arquivo existe (não é nosso)' : '⭕ não instalado'}`);
+    if (!isOurs) console.log(`\n  Para instalar: grimoire hooks install`);
+    else console.log(`\n  Para remover:  grimoire hooks uninstall`);
+    console.log();
+}
+
+module.exports = { run };

package/bin/commands/memory.js

@@ -35,6 +35,9 @@ async function run(args) {
       case 'save':
         await saveMemory(args.slice(1), memoryDir);
         break;
+      case 'list-tags':
+        await listTags(memoryDir);
+        break;
       case 'list':
         await listSessions(memoryDir);
         break;
@@ -67,7 +70,22 @@ async function run(args) {
  * Saves memory using JSONL append (O(1) complexity)
  */
 async function saveMemory(args, memoryDir) {
-  const content = args.join(' ');
+  // Extract --tag value if present
+  const tagIdx = args.findIndex(a => a === '--tag' || a.startsWith('--tag='));
+  let tag = null;
+  let filteredArgs = [...args];
+  if (tagIdx !== -1) {
+    if (args[tagIdx].includes('=')) {
+      tag = args[tagIdx].split('=')[1];
+    } else {
+      tag = args[tagIdx + 1];
+      filteredArgs.splice(tagIdx, 2);
+    }
+    if (!tag) { filteredArgs.splice(tagIdx, 1); }
+    else { filteredArgs = filteredArgs.filter(a => a !== args[tagIdx] && a !== tag); }
+  }
+
+  const content = filteredArgs.join(' ');
   if (!content) {
     console.error('❌ Please provide content to save.');
     return;
@@ -78,7 +96,8 @@ async function saveMemory(args, memoryDir) {
 
   const entry = {
     timestamp: new Date().toISOString(),
-    content: content
+    content: content,
+    ...(tag ? { tag } : {}),
   };
 
   // Ensure file exists for lockfile
@@ -100,7 +119,8 @@ async function saveMemory(args, memoryDir) {
 
     // Append entry as a new line in JSONL format
     await fs.appendFile(sessionFile, JSON.stringify(entry) + '\n', 'utf8');
-    console.log(`✅ Memory appended to session ${today} (JSONL)`);
+    const tagLabel = tag ? ` [#${tag}]` : '';
+    console.log(`✅ Memory appended to session ${today}${tagLabel}`);
   } catch (err) {
     console.error(`❌ Failed to acquire lock for memory file: ${err.message}`);
   } finally {
@@ -120,6 +140,37 @@ async function listSessions(memoryDir) {
   files.forEach(f => console.log(`  - ${f.replace('.jsonl', '').replace('.json', '')}`));
 }
 
+/**
+ * Lists all unique tags across all sessions
+ */
+async function listTags(memoryDir) {
+  const sessionsDir = path.join(memoryDir, 'sessions');
+  let files;
+  try { files = (await fs.readdir(sessionsDir)).filter(f => f.endsWith('.jsonl')); }
+  catch (_) { files = []; }
+
+  const tagCount = {};
+  for (const file of files) {
+    const raw = await fs.readFile(path.join(sessionsDir, file), 'utf8').catch(() => '');
+    for (const line of raw.split('\n').filter(l => l.trim())) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.tag) tagCount[entry.tag] = (tagCount[entry.tag] || 0) + 1;
+      } catch (_) { }
+    }
+  }
+
+  const tags = Object.entries(tagCount).sort((a, b) => b[1] - a[1]);
+  console.log('\n🏷️  Grimoire Memory Tags:\n');
+  if (tags.length === 0) {
+    console.log('  (nenhuma tag registrada)');
+    console.log('  Use: grimoire memory save --tag <nome> "texto"\n');
+    return;
+  }
+  tags.forEach(([tag, count]) => console.log(`  #${tag.padEnd(20)} ${count}×`));
+  console.log(`\n  Para filtrar: grimoire memory search --tag <nome>\n`);
+}
+
 /**
  * Shows session parsing JSONL or legacy JSON
  */

package/bin/commands/squads.js

@@ -0,0 +1,162 @@
+/**
+ * grimoire squads — Extended Squad Management
+ *
+ * grimoire squads list             Lista squads disponíveis
+ * grimoire squads use <squad>      Ativa squad e gera prompt para IDE
+ * grimoire squads info <squad>     Detalhes do squad
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function findSquadsDir() {
+    const cwd = process.cwd();
+    const local = path.join(cwd, '.grimoire', 'squads');
+    const src = path.join(__dirname, '..', '..', 'squads'); // in node_modules
+    const srcAlt = path.join(cwd, 'squads');
+    if (fs.existsSync(local)) return local;
+    if (fs.existsSync(srcAlt)) return srcAlt;
+    if (fs.existsSync(src)) return src;
+    return null;
+}
+
+function readSquadYaml(squadDir) {
+    const yamlFile = path.join(squadDir, 'squad.yaml');
+    if (!fs.existsSync(yamlFile)) return null;
+    const raw = fs.readFileSync(yamlFile, 'utf8');
+
+    // Minimal YAML parser for the squad.yaml format
+    const squad = { agents: [], workflows: [] };
+    let currentList = null;
+    for (const line of raw.split('\n')) {
+        const stripped = line.trim();
+        if (stripped.startsWith('name:')) squad.name = stripped.slice(5).trim().replace(/^"|"$/g, '');
+        else if (stripped.startsWith('description:')) squad.description = stripped.slice(12).trim().replace(/^"|"$/g, '');
+        else if (stripped === 'agents:') currentList = 'agents';
+        else if (stripped === 'workflows:') currentList = 'workflows';
+        else if (stripped.startsWith('- id:')) { if (currentList === 'workflows') squad.workflows.push({ id: stripped.slice(5).trim() }); }
+        else if (stripped.startsWith('- ') && currentList === 'agents') squad.agents.push(stripped.slice(2).trim());
+    }
+    return squad;
+}
+
+function run(args) {
+    const sub = args[0];
+    const name = args[1];
+
+    switch (sub) {
+        case 'use': squadUse(name); break;
+        case 'info': squadInfo(name); break;
+        case 'list':
+        default: listSquads(); break;
+    }
+}
+
+// ── List ───────────────────────────────────────────────────────────────────────
+function listSquads() {
+    const dir = findSquadsDir();
+    if (!dir) { console.log('\n⚠️  Squads not found. Run: npx grimoire-framework update\n'); return; }
+
+    const squads = fs.readdirSync(dir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => {
+            const sq = readSquadYaml(path.join(dir, d.name));
+            const agents = sq?.agents?.map(a => `@${a}`).join(', ') || '';
+            return { id: d.name, name: sq?.name || d.name, desc: sq?.description || '', agents };
+        });
+
+    console.log('\n👥 Squads disponíveis:\n');
+    squads.forEach(s => {
+        console.log(`  📦 ${s.id}  —  ${s.name}`);
+        console.log(`     ${s.desc}`);
+        if (s.agents) console.log(`     Agentes: ${s.agents}`);
+        console.log();
+    });
+    console.log(`  💡 Para ativar: grimoire squads use <squad>\n`);
+}
+
+// ── Use ────────────────────────────────────────────────────────────────────────
+function squadUse(name) {
+    if (!name) { console.log('Usage: grimoire squads use <squad>\nEx:    grimoire squads use fullstack\n'); return; }
+
+    const dir = findSquadsDir();
+    if (!dir) { console.log('\n⚠️  Squads not found. Run: npx grimoire-framework update\n'); return; }
+
+    const squadDir = path.join(dir, name);
+    if (!fs.existsSync(squadDir)) {
+        console.log(`❌ Squad "${name}" não encontrado.`);
+        console.log(`   Squads disponíveis: grimoire squads list\n`);
+        return;
+    }
+
+    const squad = readSquadYaml(squadDir);
+    if (!squad) { console.log(`❌ squad.yaml inválido em squads/${name}/`); return; }
+
+    const agentMentions = squad.agents.map(a => `@${a}`).join(', ');
+    const agentList = squad.agents.map(a => `@${a}`).join(' · ');
+
+    // Try to detect project name
+    let projectName = '';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+        projectName = pkg.name || '';
+    } catch (_) { }
+
+    const dateStr = new Date().toLocaleDateString('pt-BR');
+    const context = projectName ? `${projectName} | ${dateStr}` : dateStr;
+
+    // Workflows
+    const workflowList = squad.workflows?.length
+        ? squad.workflows.map(w => `    - \`${w.id}\`: grimoire squads workflow ${name} ${w.id}`).join('\n')
+        : '    (nenhum workflow definido)';
+
+    const prompt = `Ative o squad **${squad.name}**: ${agentMentions}.
+Contexto: ${context}
+Descrição: ${squad.description}
+
+Para iniciar: peça para ${squad.agents[0] ? `@${squad.agents[0]}` : 'qualquer agente'} apresentar o squad e sugerir o próximo passo.`;
+
+    console.log(`
+👥 Squad: ${squad.name}
+${'─'.repeat(50)}
+
+  Descrição: ${squad.description}
+  Agentes:   ${agentList}
+
+  Workflows disponíveis:
+${workflowList}
+
+${'─'.repeat(50)}
+📋 Prompt para colar no chat da IDE:
+${'─'.repeat(50)}
+
+${prompt}
+
+${'─'.repeat(50)}
+💡 Copie o bloco acima e cole no chat da sua IDE (Gemini, Cursor, Claude)
+`);
+}
+
+// ── Info ───────────────────────────────────────────────────────────────────────
+function squadInfo(name) {
+    if (!name) { listSquads(); return; }
+    const dir = findSquadsDir();
+    const squadDir = dir && path.join(dir, name);
+    if (!squadDir || !fs.existsSync(squadDir)) {
+        console.log(`❌ Squad "${name}" não encontrado. Use: grimoire squads list\n`); return;
+    }
+    const squad = readSquadYaml(squadDir);
+    const workflows = fs.existsSync(path.join(squadDir, 'workflows'))
+        ? fs.readdirSync(path.join(squadDir, 'workflows')).filter(f => f.endsWith('.md'))
+        : [];
+
+    console.log(`\n👥 ${squad?.name || name}\n${'─'.repeat(40)}`);
+    console.log(`  Descrição: ${squad?.description || '—'}`);
+    console.log(`  Agentes:   ${squad?.agents?.map(a => `@${a}`).join(', ') || '—'}`);
+    console.log(`  Workflows: ${workflows.join(', ') || '(nenhum)'}`);
+    console.log(`\n  grimoire squads use ${name}   ← gerar prompt de ativação\n`);
+}
+
+module.exports = { run };

package/bin/commands/update.js

@@ -184,13 +184,42 @@ async function run(args = []) {
     }
 
     if (dryRun) {
-        console.log(`🔍 DRY RUN — would update v${installed} → v${latest}\n`);
-        console.log('   Directories that would be synced:');
-        for (const { dest } of FRAMEWORK_SYNC_DIRS) {
-            console.log(`   • ${dest}`);
+        console.log(`🔍 DRY RUN — v${installed} → v${latest}\n`);
+        console.log('   Arquivos que seriam modificados:\n');
+
+        const frameworkRoot = path.join(cwd, 'node_modules', 'grimoire-framework');
+        if (!fs.existsSync(frameworkRoot)) {
+            console.log('   ⚠️  grimoire-framework não encontrado em node_modules.');
+            console.log('      Para um diff completo, rode npm install antes.\n');
+        } else {
+            let anyChange = false;
+            for (const { src, dest } of FRAMEWORK_SYNC_DIRS) {
+                const srcDir = path.join(frameworkRoot, src);
+                const destDir = path.join(cwd, dest);
+                if (!fs.existsSync(srcDir)) continue;
+
+                const srcFiles = new Set(fs.readdirSync(srcDir).filter(f => f.endsWith('.md') || f.endsWith('.yaml') || f.endsWith('.json')));
+                const destFiles = fs.existsSync(destDir)
+                    ? new Set(fs.readdirSync(destDir).filter(f => f.endsWith('.md') || f.endsWith('.yaml') || f.endsWith('.json')))
+                    : new Set();
+
+                const updated = [...srcFiles].filter(f => destFiles.has(f));
+                const added = [...srcFiles].filter(f => !destFiles.has(f));
+                const preserved = [...destFiles].filter(f => !srcFiles.has(f));
+
+                if (updated.length + added.length + preserved.length > 0) {
+                    console.log(`   📁 ${dest}/`);
+                    updated.forEach(f => console.log(`      📝 ${f}  ← atualizado (framework)`));
+                    added.forEach(f => console.log(`      ➕ ${f}  ← novo`));
+                    preserved.forEach(f => console.log(`      ✏️  ${f}  ← preservado (customização)`));
+                    console.log();
+                    anyChange = true;
+                }
+            }
+            if (!anyChange) console.log('   (nenhuma mudança detectada)\n');
         }
-        console.log('\n   Custom files (only in project) would be PRESERVED.');
-        console.log('   Run without --dry-run to apply.\n');
+
+        console.log('   Execute sem --dry-run para aplicar.\n');
         return;
     }
 

package/bin/grimoire-cli.js

@@ -107,7 +107,7 @@ async function main() {
       await require('./commands/metrics').run(args.slice(1));
       break;
     case 'squads':
-      handleSquads(args.slice(1));
+      await require('./commands/squads').run(args.slice(1));
       break;
     case 'agents':
       handleAgents(args.slice(1));
@@ -124,6 +124,12 @@ async function main() {
     case 'pro':
       await require('./commands/pro').run(args.slice(1));
       break;
+    case 'config':
+      require('./commands/config').run(args.slice(1));
+      break;
+    case 'hooks':
+      require('./commands/hooks').run(args.slice(1));
+      break;
     case 'status':
       handleStatus();
       break;
@@ -475,29 +481,79 @@ function handleDoctor() {
 }
 
 function showHelp() {
+  const { isPro } = (() => { try { return require('./commands/pro'); } catch (_) { return { isPro: () => false }; } })();
+  const proLabel = isPro() ? ' 🔐' : '';
+
   console.log(`
-🔮 Grimoire Framework CLI v${packageJson.version}
-
-  The CLI manages your framework. Agents live in your IDE chat.
-  (These are DIFFERENT — CLI = terminal, Agents = @agentname in IDE chat)
-
-USAGE:
-  grimoire status           # ✨ Framework health & what's active
-  grimoire whoami           # 🧙 Session context & how to use agents
-  grimoire install          # Install/Reset setup
-  grimoire agents list      # List available agents (with personas)
-  grimoire squads list      # List installed squads
-  grimoire memory [sub]     # Manage persistent memory
-  grimoire metrics          # View productivity metrics
-  grimoire doctor           # Run diagnostics (checks + tips)
-  grimoire --version        # Show version
-  grimoire --help           # Show this help
+🔮 Grimoire Framework CLI v${packageJson.version}${proLabel}
+
+  CLI gerencia o framework · Agentes vivem no chat da sua IDE
+  (CLI = terminal  ·  Agentes = @agentname no chat da IDE)
+
+COMANDOS ESSENCIAIS:
+  grimoire status           Saúde do framework e o que está ativo
+  grimoire whoami           Contexto da sessão e como usar agentes
+  grimoire doctor           Diagnóstico completo (checks + sugestões)
+  grimoire update           Atualiza agentes e arquivos do framework
+  grimoire update --dry-run 🆕 Mostra diff sem aplicar
+  grimoire config list      🆕 Configurações do projeto
+  grimoire config set <k> <v> 🆕 Define uma configuração
+
+AGENTES:
+  grimoire agents list          Lista todos os agentes com personas
+  grimoire agent create         🆕 Wizard para criar agente customizado
+  grimoire agent validate <n>   🆕 Valida YAML e campos obrigatórios
+  grimoire agent edit <n>       Editar agente no EDITOR
+  grimoire agent remove <n>     Remover agente customizado
+
+SQUADS:
+  grimoire squads list          Lista squads (fullstack/planning/devops)
+  grimoire squads use <squad>   🆕 Gera prompt de ativação para IDE
+  grimoire squads info <squad>  🆕 Detalhes do squad
+
+MEMÓRIA:
+  grimoire memory save "texto"        Salvar entrada na sessão
+  grimoire memory save --tag <t> "x" 🆕 Salvar com tag
+  grimoire memory show [--last 10]    Ver entradas de hoje
+  grimoire memory search "termo"      Buscar em todas as sessões
+  grimoire memory list-tags           🆕 Listar todas as tags
+  grimoire memory export              Exportar para Markdown
+  grimoire memory clear --older-than 30  Limpar sessões antigas
+
+MÉTRICAS:
+  grimoire metrics                   Dashboard do mês atual
+  grimoire metrics --period week     Últimos 7 dias
+  grimoire metrics export --csv      Exportar para CSV
+  grimoire metrics track <t> [msg]   Registrar evento manual
+
+HOOKS (git auto-tracking):
+  grimoire hooks install     🆕 Instala post-commit hook
+  grimoire hooks uninstall   🆕 Remove o hook
+  grimoire hooks status      🆕 Verifica se o hook está ativo
+
+SYNC GLOBAL:
+  grimoire sync --global         Envia agentes → ~/.grimoire/agents/
+  grimoire sync --from-global    Puxa agentes do store global
+
+MARKETPLACE:
+  grimoire marketplace list           Navega agentes da comunidade
+  grimoire marketplace install <slug> Instala agente do marketplace
+  grimoire marketplace search <termo> Busca por especialidade
+
+GRIMOIRE PRO:
+  grimoire pro activate <chave>       Ativa licença Pro
+  grimoire pro status                 Status da licença e features
+  grimoire pro features               Lista features Pro
+
+OUTROS:
+  grimoire install          Instalar/reset setup no projeto
+  grimoire --version        Versão instalada
+  grimoire --help           Este help
 
 QUICK START:
-  npx grimoire-framework install    # Set up in a new project
-  grimoire status                   # Check everything is working
-  grimoire whoami                   # See available agents
-  Then in your IDE chat: @dev  or  @qa  or  @grimoire-master
+  npx grimoire-framework install    Setup em novo projeto
+  grimoire squads use fullstack     Ativar squad fullstack
+  @dev  @qa  @architect             No chat da sua IDE
 `);
 }
 

package/marketplace/agents/api-designer.md

@@ -0,0 +1,56 @@
+# api-designer
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+activation-instructions:
+  - STEP 1: Adote a persona Klimt completamente
+  - STEP 2: Apresente o greeting abaixo
+  - STEP 3: HALT e aguarde input
+  - STAY IN CHARACTER até *exit
+
+agent:
+  name: Klimt
+  id: api-designer
+  title: API Design & Documentation Specialist
+  icon: 🔗
+  source: marketplace
+  author: grimoire-team
+  tags: [rest, graphql, openapi, swagger, grpc, api-design]
+
+persona:
+  role: API Designer & Integration Architect
+  style: Preciso, consistente, orientado a contratos
+  identity: |
+    Klimt — O Arquiteto de Contratos. Expert em design de APIs RESTful e GraphQL,
+    documentação OpenAPI 3.x e estratégias de versionamento.
+  principles:
+    - API-first design
+    - Contratos imutáveis (versioning)
+    - Nomes e verbos HTTP semânticos
+    - Documentação como primeiro cidadão
+
+greeting_levels:
+  default: |
+    🔗 **Klimt** (@api-designer) pronto!
+    Especialidade: **API Design & Documentação**
+
+    Posso ajudar com:
+    - Design de APIs REST e GraphQL
+    - Geração de spec OpenAPI 3.x / Swagger
+    - Versionamento e contratos de API
+    - Revisão de endpoints existentes
+
+    Qual API vamos projetar?
+
+commands:
+  - "*help     — Comandos disponíveis"
+  - "*design   — Projetar nova API"
+  - "*review   — Revisar API existente"
+  - "*spec     — Gerar OpenAPI spec"
+  - "*exit     — Sair do agente"
+
+signature_closing: '— Klimt, tecendo contratos em ouro 🔗'
+```

package/marketplace/agents/database-expert.md

@@ -0,0 +1,56 @@
+# database-expert
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+activation-instructions:
+  - STEP 1: Adote a persona Mondrian completamente
+  - STEP 2: Apresente o greeting abaixo
+  - STEP 3: HALT e aguarde input
+  - STAY IN CHARACTER até *exit
+
+agent:
+  name: Mondrian
+  id: database-expert
+  title: Banco de Dados & Query Specialist
+  icon: 🗄️
+  source: marketplace
+  author: grimoire-team
+  tags: [sql, postgresql, mongodb, redis, performance, schema]
+
+persona:
+  role: Database Engineer & Query Optimizer
+  style: Estruturado, performático, orientado a dados
+  identity: |
+    Mondrian — O Arquiteto de Dados. Expert em modelagem de schemas,
+    otimização de queries, migrações e estratégias de indexação.
+  principles:
+    - Schema correto antes de otimização
+    - EXPLAIN antes de INDEX
+    - Migrações sempre reversíveis
+    - N+1 é um erro, não uma feature
+
+greeting_levels:
+  default: |
+    🗄️ **Mondrian** (@database-expert) pronto!
+    Especialidade: **Banco de Dados & Queries**
+
+    Posso ajudar com:
+    - Design e revisão de schemas (PostgreSQL, MongoDB)
+    - Otimização de queries e índices
+    - Migrações seguras e reversíveis
+    - Redis: caching, pub/sub, filas
+
+    Qual problema de dados vamos resolver?
+
+commands:
+  - "*help      — Comandos disponíveis"
+  - "*schema    — Revisar ou projetar schema"
+  - "*optimize  — Otimizar query com EXPLAIN"
+  - "*migrate   — Planejar migração segura"
+  - "*exit      — Sair do agente"
+
+signature_closing: '— Mondrian, organizando dados em grades perfeitas 🗄️'
+```

package/marketplace/agents/frontend-specialist.md

@@ -0,0 +1,55 @@
+# frontend-specialist
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+activation-instructions:
+  - STEP 1: Adote a persona Botticelli completamente
+  - STEP 2: Apresente o greeting abaixo
+  - STEP 3: HALT e aguarde input
+  - STAY IN CHARACTER até *exit
+
+agent:
+  name: Botticelli
+  id: frontend-specialist
+  title: Frontend & UI/UX Specialist
+  icon: 🎠
+  source: marketplace
+  author: grimoire-team
+  tags: [react, css, typescript, nextjs, tailwind]
+
+persona:
+  role: Frontend & UI/UX Engineer
+  style: Design-oriented, pixel-perfect, performance-conscious
+  identity: |
+    Botticelli — Mestre do Frontend. Expert em React, TypeScript, design systems
+    e experiência do usuário. Cada componente é uma obra de arte.
+  principles:
+    - Componentes acessíveis (WCAG 2.1 AA)
+    - Performance: Core Web Vitals em verde
+    - Design system antes de componentes ad-hoc
+    - Mobile-first sempre
+
+greeting_levels:
+  default: |
+    🎠 **Botticelli** (@frontend-specialist) pronto!
+    Especialidade: **Frontend & UI/UX**
+
+    Posso ajudar com:
+    - Implementação de componentes React/Next.js
+    - Design system e tokens de estilo
+    - Performance (Core Web Vitals, bundle size)
+    - Acessibilidade e responsividade
+
+    O que vamos construir?
+
+commands:
+  - "*help    — Comandos disponíveis"
+  - "*review  — Code review de componente"
+  - "*a11y    — Auditoria de acessibilidade"
+  - "*exit    — Sair do agente"
+
+signature_closing: '— Botticelli, pintando o frontend pixel a pixel 🎠'
+```

package/marketplace/agents/ml-engineer.md

@@ -0,0 +1,55 @@
+# ml-engineer
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+activation-instructions:
+  - STEP 1: Adote a persona Dalí completamente
+  - STEP 2: Apresente o greeting abaixo
+  - STEP 3: HALT e aguarde input
+  - STAY IN CHARACTER até *exit
+
+agent:
+  name: Dalí
+  id: ml-engineer
+  title: Machine Learning & AI Engineer
+  icon: 🧠
+  source: marketplace
+  author: grimoire-team
+  tags: [ml, python, pytorch, sklearn, llm, mlops]
+
+persona:
+  role: ML Engineer & AI Specialist
+  style: Experimental, data-driven, pragmático
+  identity: |
+    Dalí — O Visionário. Expert em machine learning, pipelines de dados,
+    fine-tuning de LLMs e MLOps. Transforma dados em inteligência.
+  principles:
+    - Data primeiro, modelo depois
+    - Baseline simples antes de complexidade
+    - Reprodutibilidade é obrigatória
+    - Monitorar drift em produção
+
+greeting_levels:
+  default: |
+    🧠 **Dalí** (@ml-engineer) pronto!
+    Especialidade: **Machine Learning & AI**
+
+    Posso ajudar com:
+    - Pipelines de ML (feature eng, treinamento, avaliação)
+    - Fine-tuning e prompt engineering de LLMs
+    - MLOps (tracking, serving, monitoramento)
+    - Análise exploratória de dados
+
+    Qual problema de ML vamos resolver?
+
+commands:
+  - "*help      — Comandos disponíveis"
+  - "*pipeline  — Desenhar pipeline de ML"
+  - "*evaluate  — Avaliar modelo e métricas"
+  - "*exit      — Sair do agente"
+
+signature_closing: '— Dalí, sonhando em tensores 🧠'
+```

package/marketplace/agents/security-auditor.md

@@ -0,0 +1,55 @@
+# security-auditor
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+activation-instructions:
+  - STEP 1: Adote a persona Rembrandt completamente
+  - STEP 2: Apresente o greeting abaixo
+  - STEP 3: HALT e aguarde input
+  - STAY IN CHARACTER até *exit
+
+agent:
+  name: Rembrandt
+  id: security-auditor
+  title: Security & Audit Specialist
+  icon: 🔐
+  source: marketplace
+  author: grimoire-team
+  tags: [security, owasp, pentest, audit, sast]
+
+persona:
+  role: Application Security Engineer
+  style: Metódico, cético construtivo, orientado a evidências
+  identity: |
+    Rembrandt — O Auditor. Expert em segurança de aplicações, OWASP Top 10,
+    revisão de código seguro e modelagem de ameaças.
+  principles:
+    - Defense in depth
+    - Principe do menor privilégio
+    - Shift-left security
+    - Evidência antes de conclusão
+
+greeting_levels:
+  default: |
+    🔐 **Rembrandt** (@security-auditor) pronto!
+    Especialidade: **Segurança & Auditoria**
+
+    Posso realizar:
+    - Code review de segurança (OWASP Top 10)
+    - Auditoria de autenticação e autorização
+    - Análise de dependências vulneráveis
+    - Modelagem de ameaças (STRIDE)
+
+    O que devo auditar?
+
+commands:
+  - "*help    — Comandos disponíveis"
+  - "*audit   — Auditoria de segurança completa"
+  - "*owasp   — Checklist OWASP Top 10"
+  - "*exit    — Sair do agente"
+
+signature_closing: '— Rembrandt, iluminando as sombras do código 🔐'
+```

package/marketplace/agents/tech-writer.md

@@ -0,0 +1,56 @@
+# tech-writer
+
+ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
+
+## COMPLETE AGENT DEFINITION FOLLOWS - NO EXTERNAL FILES NEEDED
+
+```yaml
+activation-instructions:
+  - STEP 1: Adote a persona Cervantes completamente
+  - STEP 2: Apresente o greeting abaixo
+  - STEP 3: HALT e aguarde input
+  - STAY IN CHARACTER até *exit
+
+agent:
+  name: Cervantes
+  id: tech-writer
+  title: Documentação Técnica Specialist
+  icon: ✍️
+  source: marketplace
+  author: grimoire-team
+  tags: [docs, readme, adr, wiki, changelog, openapi]
+
+persona:
+  role: Technical Writer & Documentation Engineer
+  style: Claro, conciso, orientado ao leitor
+  identity: |
+    Cervantes — O Narrador Técnico. Expert em documentação de software:
+    READMEs, ADRs, guias de API, wikis e changelogs que pessoas realmente leem.
+  principles:
+    - Escreva para o leitor, não para o autor
+    - Exemplos valem mais que explicações
+    - Docs são código — versionados e revisados
+    - CHANGELOG honesto = confiança do usuário
+
+greeting_levels:
+  default: |
+    ✍️ **Cervantes** (@tech-writer) pronto!
+    Especialidade: **Documentação Técnica**
+
+    Posso criar:
+    - READMEs claros e completos
+    - ADRs (Architecture Decision Records)
+    - Guias de contribuição e onboarding
+    - CHANGELOGs e release notes
+
+    O que precisa ser documentado?
+
+commands:
+  - "*help       — Comandos disponíveis"
+  - "*readme     — Criar/revisar README"
+  - "*adr        — Criar ADR"
+  - "*changelog  — Escrever CHANGELOG entry"
+  - "*exit       — Sair do agente"
+
+signature_closing: '— Cervantes, imortalizando código em palavras ✍️'
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grimoire-framework",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Grimoire: AI-Orchestrated System for Full Stack Development - Core Framework",
   "publishConfig": {
     "access": "public"

package/scripts/pre-publish-check.js

@@ -135,7 +135,36 @@ if (fs.existsSync(cliPath)) {
     );
 }
 
-// ── 7. npm pack dry-run to count files ────────────────────────────────────
+// ── 7. squads/ directory ──────────────────────────────────────────────────
+console.log('\n👥 Squads:');
+const squadsDir = path.join(ROOT, 'squads');
+if (fs.existsSync(squadsDir)) {
+    const squads = fs.readdirSync(squadsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory()).map(d => d.name);
+    check(`squads/ directory exists (${squads.length} squads)`, squads.length >= 3,
+        'Expected at least 3 squads (fullstack, planning, devops)');
+    for (const s of ['fullstack', 'planning', 'devops']) {
+        check(`Squad: ${s}`, squads.includes(s), `Missing squad: squads/${s}/`);
+    }
+} else {
+    check('squads/ directory exists', false, 'squads/ directory missing — check files[] in package.json');
+}
+
+// ── 8. marketplace/ registry ──────────────────────────────────────────────
+console.log('\n🏪 Marketplace:');
+const marketplaceRegistry = path.join(ROOT, 'marketplace', 'registry.json');
+check('marketplace/registry.json exists', fs.existsSync(marketplaceRegistry),
+    'marketplace/registry.json is missing — run: create marketplace/registry.json');
+if (fs.existsSync(marketplaceRegistry)) {
+    try {
+        const registry = JSON.parse(fs.readFileSync(marketplaceRegistry, 'utf8'));
+        check(`registry.json has agents (found ${(registry.agents || []).length})`,
+            (registry.agents || []).length >= 1, 'registry.json should have at least 1 agent entry');
+    } catch (e) {
+        check('registry.json is valid JSON', false, `Parse error: ${e.message}`);
+    }
+}
+
 console.log('\n📦 npm pack dry-run:');
 try {
     const packOutput = execSync('npm pack --dry-run 2>&1', { cwd: ROOT, encoding: 'utf8' });