grimoire-framework 1.2.0 → 1.3.0

package/.grimoire/install-manifest.yaml

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

package/bin/commands/report.js

@@ -0,0 +1,200 @@
+/**
+ * grimoire report — Daily / Weekly Consolidated Report
+ *
+ * grimoire report               Relatório de hoje
+ * grimoire report --period week Última semana (7 dias)
+ * grimoire report --period all  Histórico completo
+ * grimoire report --md          Exporta para .grimoire/reports/YYYY-MM-DD.md
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    const direct = path.join(cwd, '.grimoire');
+    const sub = path.join(cwd, 'grimoire', '.grimoire');
+    if (fs.existsSync(direct)) return direct;
+    if (fs.existsSync(sub)) return sub;
+    return null;
+}
+
+// ── Date helpers ───────────────────────────────────────────────────────────────
+function today() { return new Date().toISOString().split('T')[0]; }
+function daysAgo(n) {
+    const d = new Date();
+    d.setDate(d.getDate() - n);
+    return d.toISOString().split('T')[0];
+}
+function dateRange(period) {
+    if (period === 'week') return { from: daysAgo(6), to: today(), label: 'semana' };
+    if (period === 'month') return { from: daysAgo(29), to: today(), label: 'mês' };
+    return { from: '2000-01-01', to: today(), label: 'histórico' };
+}
+
+// ── Helpers: read JSONL sessions ───────────────────────────────────────────────
+function readSessionEntries(grimoireDir, from, to) {
+    const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+    if (!fs.existsSync(sessionsDir)) return [];
+    const files = fs.readdirSync(sessionsDir)
+        .filter(f => f.endsWith('.jsonl') && f.slice(0, 10) >= from && f.slice(0, 10) <= to);
+    const entries = [];
+    for (const f of files) {
+        const raw = fs.readFileSync(path.join(sessionsDir, f), 'utf8');
+        for (const line of raw.split('\n').filter(l => l.trim())) {
+            try { entries.push({ date: f.slice(0, 10), ...JSON.parse(line) }); } catch (_) { }
+        }
+    }
+    return entries;
+}
+
+// ── Helpers: read metrics JSONL ────────────────────────────────────────────────
+function readMetricsEntries(grimoireDir, from, to) {
+    const metricsDir = path.join(grimoireDir, 'metrics');
+    if (!fs.existsSync(metricsDir)) return [];
+    const files = fs.readdirSync(metricsDir)
+        .filter(f => f.endsWith('.jsonl') && f.slice(0, 10) >= from && f.slice(0, 10) <= to);
+    const entries = [];
+    for (const f of files) {
+        const raw = fs.readFileSync(path.join(metricsDir, f), 'utf8');
+        for (const line of raw.split('\n').filter(l => l.trim())) {
+            try { entries.push({ date: f.slice(0, 10), ...JSON.parse(line) }); } catch (_) { }
+        }
+    }
+    return entries;
+}
+
+// ── Read stories ───────────────────────────────────────────────────────────────
+function readStories(grimoireDir, from, to) {
+    const storiesDir = path.join(grimoireDir, 'stories');
+    if (!fs.existsSync(storiesDir)) return [];
+    return fs.readdirSync(storiesDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => { try { return JSON.parse(fs.readFileSync(path.join(storiesDir, f), 'utf8')); } catch (_) { return null; } })
+        .filter(Boolean)
+        .filter(s => s.createdAt && s.createdAt.slice(0, 10) >= from);
+}
+
+// ── Build report object ────────────────────────────────────────────────────────
+function buildReport(grimoireDir, period) {
+    const { from, to, label } = dateRange(period);
+    const memEntries = readSessionEntries(grimoireDir, from, to);
+    const metricEntries = readMetricsEntries(grimoireDir, from, to);
+    const stories = readStories(grimoireDir, from, to);
+
+    // Tag buckets
+    const byTag = {};
+    for (const e of memEntries) {
+        if (e.tag) {
+            byTag[e.tag] = byTag[e.tag] || [];
+            byTag[e.tag].push(e);
+        }
+    }
+
+    // Agent usage from metrics
+    const agentUse = {};
+    for (const e of metricEntries) {
+        if (e.agent) agentUse[e.agent] = (agentUse[e.agent] || 0) + 1;
+        if (e.type === 'agent_session' && e.agent) agentUse[e.agent] = (agentUse[e.agent] || 0) + 1;
+    }
+    const topAgents = Object.entries(agentUse).sort((a, b) => b[1] - a[1]).slice(0, 5);
+
+    // Metrics summary
+    const sessions = metricEntries.filter(e => e.type === 'session_start' || e.type === 'session' || e.type === 'agent_session').length;
+    const commits = metricEntries.filter(e => e.type === 'commit').length;
+    const done = stories.filter(s => s.status === 'done').length;
+    const open = stories.filter(s => s.status !== 'done').length;
+
+    return { from, to, label, memEntries, byTag, topAgents, sessions, commits, stories, done, open };
+}
+
+// ── Render text report ─────────────────────────────────────────────────────────
+function renderReport(r) {
+    const lines = [];
+    const sep = '═'.repeat(50);
+    lines.push(`\n📊 Grimoire Report — ${r.to}  (${r.label}: ${r.from} → ${r.to})`);
+    lines.push(sep);
+
+    // Metrics
+    lines.push('\n📈 Métricas:');
+    lines.push(`  Sessões:  ${r.sessions}   Commits: ${r.commits}   Stories: ${r.done} concluídas / ${r.open} abertas`);
+    if (r.topAgents.length) {
+        lines.push(`  Agentes: ${r.topAgents.map(([a, n]) => `@${a} (${n}×)`).join(' · ')}`);
+    }
+
+    // Memory by tag
+    const tagKeys = Object.keys(r.byTag);
+    if (tagKeys.length > 0) {
+        lines.push('\n🧠 Memória por tag:');
+        for (const tag of tagKeys) {
+            lines.push(`\n  #${tag}:`);
+            for (const e of r.byTag[tag].slice(0, 5)) {
+                lines.push(`    ${e.date}  ${e.content}`);
+            }
+        }
+    }
+
+    // Untagged entries summary
+    const untagged = r.memEntries.filter(e => !e.tag);
+    if (untagged.length) {
+        lines.push(`\n🗒️  Memórias sem tag: ${untagged.length} entradas`);
+        untagged.slice(0, 3).forEach(e => lines.push(`  ${e.date}  ${e.content}`));
+        if (untagged.length > 3) lines.push(`  ... e mais ${untagged.length - 3}`);
+    }
+
+    // Stories
+    if (r.stories.length > 0) {
+        lines.push('\n📋 Stories:');
+        r.stories.filter(s => s.status === 'done').forEach(s =>
+            lines.push(`  ✅ [${s.id}] ${s.title} — concluída`)
+        );
+        r.stories.filter(s => s.status !== 'done').forEach(s =>
+            lines.push(`  🔄 [${s.id}] ${s.title} — em andamento`)
+        );
+    }
+
+    if (r.memEntries.length === 0 && r.sessions === 0 && r.stories.length === 0) {
+        lines.push('\n  (nenhuma atividade registrada no período)');
+        lines.push('  Dica: grimoire memory save "texto" · grimoire metrics track session');
+    }
+
+    lines.push('\n' + sep + '\n');
+    return lines.join('\n');
+}
+
+// ── Main run ───────────────────────────────────────────────────────────────────
+function run(args) {
+    const grimoireDir = findGrimoireDir();
+    if (!grimoireDir) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+
+    const periodIdx = args.findIndex(a => a === '--period' || a.startsWith('--period='));
+    let period = 'day';
+    if (periodIdx !== -1) {
+        period = args[periodIdx].includes('=')
+            ? args[periodIdx].split('=')[1]
+            : (args[periodIdx + 1] || 'day');
+    } else if (args.includes('week')) {
+        period = 'week';
+    }
+
+    const exportMd = args.includes('--md');
+    const report = buildReport(grimoireDir, period);
+    const text = renderReport(report);
+
+    console.log(text);
+
+    if (exportMd) {
+        const reportsDir = path.join(grimoireDir, 'reports');
+        if (!fs.existsSync(reportsDir)) fs.mkdirSync(reportsDir, { recursive: true });
+        const filename = path.join(reportsDir, `${report.to}-${period}.md`);
+        fs.writeFileSync(filename, text.replace(/\n/g, '\n'), 'utf8');
+        console.log(`✅ Relatório exportado: ${path.relative(process.cwd(), filename)}\n`);
+    }
+}
+
+module.exports = { run };

package/bin/commands/session.js

@@ -0,0 +1,217 @@
+/**
+ * grimoire session — Session Bootstrap Command
+ *
+ * grimoire session start                   Gera prompt de início de sessão
+ * grimoire session start --squad <squad>   Com squad específico
+ * grimoire session start --copy            (legacy alias)
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    const direct = path.join(cwd, '.grimoire');
+    const sub = path.join(cwd, 'grimoire', '.grimoire');
+    if (fs.existsSync(direct)) return direct;
+    if (fs.existsSync(sub)) return sub;
+    return null;
+}
+
+function findSquadsDir() {
+    const cwd = process.cwd();
+    const home = path.join(cwd, '.grimoire', 'squads');
+    const local = path.join(cwd, 'squads');
+    const pkg = path.join(cwd, 'node_modules', 'grimoire-framework', 'squads');
+    if (fs.existsSync(home)) return home;
+    if (fs.existsSync(local)) return local;
+    if (fs.existsSync(pkg)) return pkg;
+    return null;
+}
+
+function readSquadYaml(squadDir) {
+    const yamlFile = path.join(squadDir, 'squad.yaml');
+    if (!fs.existsSync(yamlFile)) return null;
+    const raw = fs.readFileSync(yamlFile, 'utf8');
+    const squad = { agents: [] };
+    for (const line of raw.split('\n')) {
+        const s = line.trim();
+        if (s.startsWith('name:')) squad.name = s.slice(5).trim().replace(/^"|"$/g, '');
+        if (s.startsWith('description:')) squad.description = s.slice(12).trim().replace(/^"|"$/g, '');
+        if (s.startsWith('- ') && squad._inAgents) squad.agents.push(s.slice(2).trim());
+        if (s === 'agents:') squad._inAgents = true;
+        else if (s.endsWith(':')) squad._inAgents = false;
+    }
+    delete squad._inAgents;
+    return squad;
+}
+
+function getLastMemoryEntries(grimoireDir, tag, n = 3) {
+    const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+    if (!fs.existsSync(sessionsDir)) return [];
+    const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl')).sort().reverse();
+    const results = [];
+    for (const f of files) {
+        if (results.length >= n) break;
+        const raw = fs.readFileSync(path.join(sessionsDir, f), 'utf8');
+        const lines = raw.split('\n').filter(l => l.trim()).reverse();
+        for (const line of lines) {
+            if (results.length >= n) break;
+            try {
+                const e = JSON.parse(line);
+                if (!tag || e.tag === tag) results.push(e);
+            } catch (_) { }
+        }
+    }
+    return results;
+}
+
+function loadConfig(grimoireDir) {
+    const file = path.join(grimoireDir, 'config.yaml');
+    if (!fs.existsSync(file)) return {};
+    const result = {};
+    for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+        const s = line.trim();
+        if (!s || s.startsWith('#')) continue;
+        const i = s.indexOf(':');
+        if (i === -1) continue;
+        let val = s.slice(i + 1).trim();
+        if (val === 'true') val = true;
+        else if (val === 'false') val = false;
+        result[s.slice(0, i).trim()] = val;
+    }
+    return result;
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    const sub = args[0];
+    if (sub === 'start' || !sub) {
+        sessionStart(args.slice(sub === 'start' ? 1 : 0));
+    } else {
+        console.log('Usage: grimoire session start [--squad <squad>]\n');
+    }
+}
+
+function sessionStart(args) {
+    const grimoireDir = findGrimoireDir();
+    if (!grimoireDir) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+
+    // Detect project name
+    let projectName = '';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+        projectName = pkg.name || '';
+    } catch (_) { }
+
+    // Squad
+    const squadIdx = args.findIndex(a => a === '--squad' || a.startsWith('--squad='));
+    let squadName = null;
+    if (squadIdx !== -1) {
+        squadName = args[squadIdx].includes('=') ? args[squadIdx].split('=')[1] : args[squadIdx + 1];
+    }
+    // Fallback to config
+    const config = loadConfig(grimoireDir);
+    if (!squadName && config.default_squad) squadName = config.default_squad;
+
+    let squadInfo = null;
+    if (squadName) {
+        const squadsDir = findSquadsDir();
+        if (squadsDir && fs.existsSync(path.join(squadsDir, squadName))) {
+            squadInfo = readSquadYaml(path.join(squadsDir, squadName));
+            if (squadInfo) squadInfo.id = squadName;
+        }
+    }
+
+    // Active stories
+    let activeStories = [];
+    try {
+        const { getActiveStories } = require('./story');
+        activeStories = getActiveStories(grimoireDir).slice(0, 5);
+    } catch (_) { }
+
+    // Recent memory by tag
+    const decisions = getLastMemoryEntries(grimoireDir, 'decisão', 3);
+    const patterns = getLastMemoryEntries(grimoireDir, 'padrão', 2);
+
+    // Default agent
+    const defaultAgent = config.default_agent || 'dev';
+
+    // Build prompt
+    const now = new Date();
+    const dateStr = now.toLocaleDateString('pt-BR');
+    const timeStr = now.toTimeString().slice(0, 5);
+    const sep = '═'.repeat(52);
+
+    const lines = [];
+    lines.push(`${sep}`);
+    lines.push(`🚀 INÍCIO DE SESSÃO — ${projectName || 'projeto'}`);
+    lines.push(`Data: ${dateStr} ${timeStr}${squadInfo ? ` | Squad: ${squadInfo.id}` : ''}`);
+    lines.push('');
+
+    if (squadInfo) {
+        const agentList = squadInfo.agents.map(a => `@${a}`).join(' · ');
+        lines.push(`Squad ativo: ${agentList}`);
+    } else {
+        lines.push(`Agente padrão: @${defaultAgent}`);
+    }
+
+    if (config.metrics_enabled !== false) lines.push('Métricas: ✅ ativas');
+    if (config.hooks_enabled) lines.push('Hooks: ✅ instalado');
+    lines.push('');
+
+    if (activeStories.length > 0) {
+        lines.push('Stories abertas:');
+        activeStories.forEach(s => lines.push(`  [IN PROGRESS] [${s.id}] — ${s.title}`));
+        lines.push('');
+    }
+
+    if (decisions.length > 0) {
+        lines.push('Últimas decisões (#decisão):');
+        decisions.forEach(d => lines.push(`  - ${d.content}`));
+        lines.push('');
+    }
+
+    if (patterns.length > 0) {
+        lines.push('Padrões ativos (#padrão):');
+        patterns.forEach(p => lines.push(`  - ${p.content}`));
+        lines.push('');
+    }
+
+    const firstStory = activeStories[0];
+    const firstAgent = squadInfo?.agents[0] || defaultAgent;
+    if (firstStory) {
+        lines.push(`Contexto: Continue o desenvolvimento com base nas stories abertas.`);
+        lines.push(`Para iniciar: @${firstAgent} apresente o estado atual de [${firstStory.id}] ${firstStory.title}.`);
+    } else {
+        lines.push(`Para iniciar: @${firstAgent} apresente-se e sugira o próximo passo.`);
+    }
+
+    lines.push(sep);
+
+    const prompt = lines.join('\n');
+
+    console.log('\n📋 Prompt de sessão (copie e cole no chat da IDE):\n');
+    console.log(prompt);
+    console.log('\n💡 Atalhos:');
+    console.log('  grimoire story create "título"     ← criar nova story');
+    console.log('  grimoire memory save "observação"  ← salvar decisão');
+    console.log('  grimoire report --period week      ← relatório da semana\n');
+
+    // Track session start in metrics
+    try {
+        const metricsDir = path.join(grimoireDir, 'metrics');
+        if (fs.existsSync(metricsDir)) {
+            const today = now.toISOString().split('T')[0];
+            const mFile = path.join(metricsDir, `${today}.jsonl`);
+            fs.appendFileSync(mFile, JSON.stringify({ timestamp: now.toISOString(), type: 'session_start', squad: squadName || null }) + '\n');
+        }
+    } catch (_) { }
+}
+
+module.exports = { run };

package/bin/commands/story.js

@@ -0,0 +1,215 @@
+/**
+ * grimoire story — Story Tracking CLI
+ *
+ * grimoire story create "Título da story"   Cria nova story
+ * grimoire story list                       Lista stories ativas
+ * grimoire story list --all                 Lista todas (inclui concluídas)
+ * grimoire story done <id>                  Marca story como concluída
+ * grimoire story show <id>                  Detalhes da story
+ * grimoire story delete <id>               Remove story
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    const direct = path.join(cwd, '.grimoire');
+    const sub = path.join(cwd, 'grimoire', '.grimoire');
+    if (fs.existsSync(direct)) return direct;
+    if (fs.existsSync(sub)) return sub;
+    return null;
+}
+
+function getStoriesDir(grimoireDir) {
+    const d = path.join(grimoireDir, 'stories');
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+
+function loadStories(storiesDir) {
+    return fs.readdirSync(storiesDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+            try { return JSON.parse(fs.readFileSync(path.join(storiesDir, f), 'utf8')); }
+            catch (_) { return null; }
+        })
+        .filter(Boolean)
+        .sort((a, b) => a.createdAt > b.createdAt ? 1 : -1);
+}
+
+function nextId(stories) {
+    const nums = stories.map(s => parseInt(s.id.replace(/\D/g, '')) || 0);
+    const max = nums.length ? Math.max(...nums) : 0;
+    return `US-${String(max + 1).padStart(3, '0')}`;
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+
+    const grimoireDir = findGrimoireDir();
+    if (!grimoireDir) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+    const storiesDir = getStoriesDir(grimoireDir);
+
+    switch (sub) {
+        case 'create': storyCreate(rest, storiesDir, grimoireDir); break;
+        case 'done': storyDone(rest[0], storiesDir, grimoireDir); break;
+        case 'delete':
+        case 'remove': storyDelete(rest[0], storiesDir); break;
+        case 'show': storyShow(rest[0], storiesDir); break;
+        case 'list':
+        default: storyList(rest, storiesDir); break;
+    }
+}
+
+// ── create ────────────────────────────────────────────────────────────────────
+function storyCreate(args, storiesDir, grimoireDir) {
+    const title = args.filter(a => !a.startsWith('--')).join(' ');
+    if (!title) {
+        console.log('Usage: grimoire story create "Título da story"\n');
+        return;
+    }
+    const stories = loadStories(storiesDir);
+    const id = nextId(stories);
+    const story = {
+        id,
+        title,
+        status: 'in_progress',
+        createdAt: new Date().toISOString(),
+        doneAt: null,
+        tags: [],
+        notes: [],
+    };
+    const filename = path.join(storiesDir, `${id}.json`);
+    fs.writeFileSync(filename, JSON.stringify(story, null, 2), 'utf8');
+
+    // Track in metrics
+    try {
+        const metricsDir = path.join(grimoireDir, 'metrics');
+        if (fs.existsSync(metricsDir)) {
+            const today = new Date().toISOString().split('T')[0];
+            const mFile = path.join(metricsDir, `${today}.jsonl`);
+            fs.appendFileSync(mFile, JSON.stringify({ timestamp: new Date().toISOString(), type: 'story_create', story: id, title }) + '\n');
+        }
+    } catch (_) { }
+
+    console.log(`\n✅ Story criada: [${id}] ${title}\n`);
+    console.log(`  Status: 🔄 em andamento`);
+    console.log(`  Para concluir: grimoire story done ${id}`);
+    console.log(`  Para ver: grimoire story show ${id}\n`);
+}
+
+// ── list ──────────────────────────────────────────────────────────────────────
+function storyList(args, storiesDir) {
+    const all = args.includes('--all');
+    const stories = loadStories(storiesDir);
+    const filtered = all ? stories : stories.filter(s => s.status !== 'done');
+
+    console.log(`\n📋 Stories${all ? '' : ' ativas'} (${filtered.length}):\n`);
+
+    if (filtered.length === 0) {
+        if (!all) {
+            console.log('  (nenhuma story ativa)');
+            console.log('  grimoire story create "Título" para criar uma nova\n');
+        } else {
+            console.log('  (nenhuma story)\n');
+        }
+        return;
+    }
+
+    const done = filtered.filter(s => s.status === 'done');
+    const open = filtered.filter(s => s.status !== 'done');
+
+    open.forEach(s => console.log(`  🔄 [${s.id}] ${s.title}`));
+    done.forEach(s => {
+        const d = s.doneAt ? ` — concluída ${s.doneAt.slice(0, 10)}` : '';
+        console.log(`  ✅ [${s.id}] ${s.title}${d}`);
+    });
+    console.log(`\n  grimoire story done <id>   ← marcar como concluída`);
+    console.log(`  grimoire story show <id>   ← ver detalhes\n`);
+}
+
+// ── done ──────────────────────────────────────────────────────────────────────
+function storyDone(id, storiesDir, grimoireDir) {
+    if (!id) { console.log('Usage: grimoire story done <id>\nEx:    grimoire story done US-001\n'); return; }
+    const storyFile = path.join(storiesDir, id.endsWith('.json') ? id : `${id}.json`);
+    if (!fs.existsSync(storyFile)) {
+        console.log(`❌ Story "${id}" not found. Use: grimoire story list\n`); return;
+    }
+    const story = JSON.parse(fs.readFileSync(storyFile, 'utf8'));
+    story.status = 'done';
+    story.doneAt = new Date().toISOString();
+    fs.writeFileSync(storyFile, JSON.stringify(story, null, 2), 'utf8');
+
+    // Track in metrics
+    try {
+        const metricsDir = path.join(grimoireDir, 'metrics');
+        if (fs.existsSync(metricsDir)) {
+            const today = new Date().toISOString().split('T')[0];
+            const mFile = path.join(metricsDir, `${today}.jsonl`);
+            fs.appendFileSync(mFile, JSON.stringify({ timestamp: new Date().toISOString(), type: 'story_complete', story: id, title: story.title }) + '\n');
+        }
+    } catch (_) { }
+
+    console.log(`\n✅ [${story.id}] ${story.title} — marcada como concluída! 🎉\n`);
+}
+
+// ── show ──────────────────────────────────────────────────────────────────────
+function storyShow(id, storiesDir) {
+    if (!id) { storyList([], storiesDir); return; }
+    const storyFile = path.join(storiesDir, id.endsWith('.json') ? id : `${id}.json`);
+    if (!fs.existsSync(storyFile)) {
+        console.log(`❌ Story "${id}" not found.\n`); return;
+    }
+    const s = JSON.parse(fs.readFileSync(storyFile, 'utf8'));
+    const statusIcon = s.status === 'done' ? '✅' : '🔄';
+    console.log(`\n${statusIcon} [${s.id}] ${s.title}`);
+    console.log(`${'─'.repeat(50)}`);
+    console.log(`  Status:    ${s.status}`);
+    console.log(`  Criada:    ${s.createdAt.slice(0, 10)}`);
+    if (s.doneAt) console.log(`  Concluída: ${s.doneAt.slice(0, 10)}`);
+    if (s.notes && s.notes.length) {
+        console.log('\n  Notas:');
+        s.notes.forEach(n => console.log(`    - ${n}`));
+    }
+    console.log();
+}
+
+// ── delete ────────────────────────────────────────────────────────────────────
+function storyDelete(id, storiesDir) {
+    if (!id) { console.log('Usage: grimoire story delete <id>\n'); return; }
+    const storyFile = path.join(storiesDir, id.endsWith('.json') ? id : `${id}.json`);
+    if (!fs.existsSync(storyFile)) { console.log(`❌ Story "${id}" not found.\n`); return; }
+    fs.unlinkSync(storyFile);
+    console.log(`✅ Story "${id}" removida.\n`);
+}
+
+// ── Public API for use by other modules ───────────────────────────────────────
+function getActiveStories(grimoireDir) {
+    const dir = path.join(grimoireDir, 'stories');
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => { try { return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')); } catch (_) { return null; } })
+        .filter(Boolean)
+        .filter(s => s.status !== 'done')
+        .sort((a, b) => a.createdAt > b.createdAt ? -1 : 1);
+}
+
+function getAllStories(grimoireDir) {
+    const dir = path.join(grimoireDir, 'stories');
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => { try { return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')); } catch (_) { return null; } })
+        .filter(Boolean);
+}
+
+module.exports = { run, getActiveStories, getAllStories };

package/bin/grimoire-cli.js

@@ -133,6 +133,15 @@ async function main() {
     case 'status':
       handleStatus();
       break;
+    case 'report':
+      require('./commands/report').run(args.slice(1));
+      break;
+    case 'story':
+      require('./commands/story').run(args.slice(1));
+      break;
+    case 'session':
+      require('./commands/session').run(args.slice(1));
+      break;
     case 'whoami':
       handleWhoami();
       break;
@@ -321,12 +330,10 @@ function handleWhoami() {
 
   // Detect IDE from environment
   const inCursor = process.env.CURSOR_TRACE_ID || process.env.VSCODE_PID;
-  const inVSCode = process.env.VSCODE_PID && !inCursor;
   const inGemini = process.env.GEMINI_CLI || process.env.CLOUD_SHELL;
   const inClaude = process.env.CLAUDE_AGENT;
-  let ide = 'Unknown IDE';
+  let ide = 'Terminal';
   if (inCursor) ide = 'Cursor';
-  else if (inVSCode) ide = 'VS Code';
   else if (inGemini) ide = 'Gemini CLI';
   else if (inClaude) ide = 'Claude';
 
@@ -334,55 +341,112 @@ function handleWhoami() {
   const projectPkg = path.join(cwd, 'package.json');
   let projectName = path.basename(cwd);
   if (fs.existsSync(projectPkg)) {
-    try { projectName = JSON.parse(fs.readFileSync(projectPkg, 'utf8')).name || projectName; } catch (e) { }
+    try { projectName = JSON.parse(fs.readFileSync(projectPkg, 'utf8')).name || projectName; } catch (_) { }
   }
 
-  // Read grimoire config if exists
-  const configPath = path.join(cwd, '.grimoire', 'config.json');
-  let config = {};
-  if (fs.existsSync(configPath)) {
-    try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (e) { }
+  // Read grimoire config (.grimoire/config.yaml)
+  const configFile = (() => {
+    const d = path.join(cwd, '.grimoire', 'config.yaml');
+    const s = path.join(cwd, 'grimoire', '.grimoire', 'config.yaml');
+    return fs.existsSync(d) ? d : fs.existsSync(s) ? s : null;
+  })();
+  const config = {};
+  if (configFile) {
+    for (const line of fs.readFileSync(configFile, 'utf8').split('\n')) {
+      const t = line.trim();
+      if (!t || t.startsWith('#')) continue;
+      const i = t.indexOf(':');
+      if (i === -1) continue;
+      let v = t.slice(i + 1).trim();
+      if (v === 'true') v = true; else if (v === 'false') v = false;
+      config[t.slice(0, i).trim()] = v;
+    }
   }
 
-  // Available agents with personas
-  const agentNames = {
-    'dev': 'Da Vinci', 'qa': 'Dürer', 'sm': 'Monet', 'devops': 'Boccioni',
-    'ux-design-expert': 'Matisse', 'grimoire-master': 'Michelangelo',
-    'analyst': 'Vermeer', 'architect': 'Gaudí', 'data-engineer': 'Escher',
-    'pm': 'Raphael', 'po': 'Velázquez', 'squad-creator': 'Rodin',
-  };
+  // Git hooks check
+  const gitHookFile = path.join(cwd, '.git', 'hooks', 'post-commit');
+  const hooksInstalled = fs.existsSync(gitHookFile) &&
+    fs.readFileSync(gitHookFile, 'utf8').includes('grimoire-hook-v1');
+
+  // Pro status
+  let proStatus = '⭕ Community';
+  try {
+    const { isPro } = require('./commands/pro');
+    if (isPro()) proStatus = '🔐 Pro (ativo)';
+  } catch (_) { }
 
+  // Agents
   const agentsDir = path.join(cwd, '.codex', 'agents');
-  const availableAgents = fs.existsSync(agentsDir)
+  const allAgents = fs.existsSync(agentsDir)
     ? fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''))
     : [];
+  const coreAgentIds = ['grimoire-master', 'dev', 'qa', 'architect', 'pm', 'po', 'sm', 'devops', 'data-engineer', 'analyst', 'ux-design-expert', 'squad-creator'];
+  const coreCount = allAgents.filter(a => coreAgentIds.includes(a)).length;
+  const customCount = allAgents.filter(a => !coreAgentIds.includes(a)).length;
+
+  // Memory stats
+  const memDir = path.join(cwd, '.grimoire', 'memory', 'sessions');
+  let memEntries = 0;
+  const tagSet = new Set();
+  if (fs.existsSync(memDir)) {
+    const today = new Date().toISOString().split('T')[0];
+    const todayFile = path.join(memDir, `${today}.jsonl`);
+    if (fs.existsSync(todayFile)) {
+      const lines = fs.readFileSync(todayFile, 'utf8').split('\n').filter(l => l.trim());
+      memEntries = lines.length;
+      for (const l of lines) {
+        try { const e = JSON.parse(l); if (e.tag) tagSet.add(e.tag); } catch (_) { }
+      }
+    }
+  }
 
-  const agentList = availableAgents
-    .map(a => agentNames[a] ? `@${a} (${agentNames[a]})` : `@${a}`)
-    .join(', ');
+  // Stories
+  let activeStories = [], totalStories = 0;
+  try {
+    const { getActiveStories, getAllStories } = require('./commands/story');
+    const grimoireDir = path.join(cwd, '.grimoire');
+    activeStories = getActiveStories(grimoireDir);
+    totalStories = getAllStories(grimoireDir).length;
+  } catch (_) { }
+
+  const agentNames = {
+    'dev': 'Da Vinci', 'qa': 'Dürer', 'sm': 'Monet', 'devops': 'Boccioni',
+    'ux-design-expert': 'Matisse', 'grimoire-master': 'Michelangelo', 'analyst': 'Vermeer',
+    'architect': 'Gaudí', 'data-engineer': 'Escher', 'pm': 'Raphael', 'po': 'Velázquez', 'squad-creator': 'Rodin'
+  };
 
   console.log(`
 🧙 Grimoire — Who Am I?
-${'='.repeat(40)}
-📌  You are:      ${process.env.USER || process.env.USERNAME || 'unknown user'}
-📂  Project:      ${projectName}
-📍  Directory:    ${cwd}
-💻  IDE:          ${ide}
-🔮  Framework:    Grimoire v${packageJson.version}
-${config.squad ? `👥  Squad:        ${config.squad}` : ''}
-
-🧙 Available Agents:
-  ${agentList || '(none found — run grimoire install)'}
-
-💡 How to activate an agent:
-  In your IDE chat, type:  @dev  or  @qa  or  @grimoire-master
-  The agent will greet you by their persona name (Da Vinci, Dürer, etc.)
-
-🔧 Framework vs CLI:
-  CLI commands  → Run in terminal:    grimoire status | grimoire agents list
-  Agent chat    → Activate in IDE:    @agentname (e.g. @dev, @qa)
-  These are DIFFERENT interfaces — the CLI manages the framework,
-  agents respond inside your IDE's AI chat window.
+${'='.repeat(44)}
+
+  Projeto:    ${projectName}
+  Diretório:  ${cwd}
+  IDE:        ${ide}
+  Framework:  Grimoire v${packageJson.version}
+  Pro:        ${proStatus}
+
+⚙️  Config (.grimoire/config.yaml):
+  default_agent: @${config.default_agent || 'grimoire-master'}
+  metrics:       ${config.metrics_enabled !== false ? '✅ ativo' : '⭕ desabilitado'}
+  hooks git:     ${hooksInstalled ? '✅ instalado' : '⭕ não instalado'}
+  linguagem:     ${config.language || 'pt-BR'}
+
+🤖 Agentes (${allAgents.length}):
+  ${coreCount} core${customCount > 0 ? ` · ${customCount} custom` : ''}
+  Rota rápida: ${allAgents.slice(0, 4).map(a => `@${a}`).join(' · ')}...
+
+📋 Stories:
+  ${activeStories.length} abertas${totalStories > 0 ? ` | ${totalStories - activeStories.length} concluídas` : ''}
+${activeStories.slice(0, 3).map(s => `  🔄 [${s.id}] ${s.title}`).join('\n') || ''}
+
+🧠 Memória (hoje):
+  ${memEntries} entradas${tagSet.size > 0 ? '  Tags: ' + [...tagSet].map(t => '#' + t).join(' · ') : ''}
+
+💡 Comandos úteis:
+  grimoire session start     ← prompt de início de sessão
+  grimoire story list        ← stories ativas
+  grimoire report            ← relatório de hoje
+  grimoire config list       ← ver configurações
 `);
 }
 
@@ -471,6 +535,48 @@ function handleDoctor() {
     ok(false, 'package.json found');
   }
 
+  // ── New checks: hooks, config, pro, marketplace, stories ────────
+  console.log('\n🪝 Git Hooks (auto-metrics):');
+  const gitHook = path.join(cwd, '.git', 'hooks', 'post-commit');
+  const hookInstalled = check(gitHook) && fs.readFileSync(gitHook, 'utf8').includes('grimoire-hook-v1');
+  warn(hookInstalled, 'git post-commit hook (auto-tracking de commits)',
+    'Run: grimoire hooks install');
+
+  console.log('\n⚙️  Config (.grimoire/config.yaml):');
+  const configYaml = path.join(cwd, '.grimoire', 'config.yaml');
+  warn(check(configYaml), '.grimoire/config.yaml presente',
+    'Run: grimoire config set default_agent dev');
+  if (check(configYaml)) {
+    try {
+      const cfg = fs.readFileSync(configYaml, 'utf8');
+      const hasKeys = cfg.includes('default_agent') || cfg.includes('metrics_enabled');
+      warn(hasKeys, 'Config tem chaves válidas', 'Run: grimoire config list');
+    } catch (_) { }
+  }
+
+  console.log('\n🔐 Grimoire Pro:');
+  let proActive = false;
+  try { const { isPro } = require('./commands/pro'); proActive = isPro(); } catch (_) { }
+  warn(true, `Licença: ${proActive ? '🔐 Pro ativa' : 'Community (gratuito)'}`,
+    proActive ? null : 'grimoire pro activate <chave> para ativar Pro');
+
+  console.log('\n🏪 Marketplace:');
+  const mktDir = path.join(cwd, '.grimoire', 'marketplace');
+  const installedMkt = check(mktDir) ? fs.readdirSync(mktDir).filter(f => f.endsWith('.md')).length : 0;
+  warn(true, `Agentes do marketplace instalados: ${installedMkt}`,
+    installedMkt === 0 ? 'grimoire marketplace list  para explorar agentes da comunidade' : null);
+
+  console.log('\n📋 Stories:');
+  let activeCount = 0;
+  try {
+    const { getActiveStories } = require('./commands/story');
+    activeCount = getActiveStories(path.join(cwd, '.grimoire')).length;
+    warn(true, `Stories ativas: ${activeCount}`,
+      activeCount === 0 ? 'grimoire story create "Título" para começar' : null);
+  } catch (_) {
+    warn(false, 'stories.js não disponível');
+  }
+
   // ── Other IDEs ────────────────────────────────────────────────
   console.log('\n🔗 Other IDE Integration:');
   warn(check(path.join(cwd, '.cursor', 'rules')), '.cursor/rules (Cursor)');
@@ -478,6 +584,7 @@ function handleDoctor() {
 
   console.log('\n  Run \'grimoire status\' for full framework state.');
   console.log('  Run \'npx grimoire-framework update --force\' to resync all files.\n');
+
 }
 
 function showHelp() {
@@ -491,13 +598,23 @@ function showHelp() {
   (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
+  grimoire status              Saúde do framework
+  grimoire whoami              Contexto completo (config+pro+stories)
+  grimoire doctor              Diagnóstico completo
+  grimoire update              Atualiza agentes e arquivos
+  grimoire update --dry-run    Mostra diff sem aplicar
+  grimoire config list         Configurações do projeto
+  grimoire config set <k> <v>  Define uma configuração
+
+SESSÃO & WORKFLOW:
+  grimoire session start             🆕 Prompt de início de sessão para IDE
+  grimoire session start --squad <s> 🆕 Com squad específico
+  grimoire story create "Título"     🆕 Criar story
+  grimoire story list                🆕 Ver stories ativas
+  grimoire story done US-001         🆕 Marcar concluída
+  grimoire report                    🆕 Relatório de hoje
+  grimoire report --period week      🆕 Relatório da semana
+  grimoire report --md               🆕 Exportar relatório
 
 AGENTES:
   grimoire agents list          Lista todos os agentes com personas
@@ -552,7 +669,8 @@ OUTROS:
 
 QUICK START:
   npx grimoire-framework install    Setup em novo projeto
-  grimoire squads use fullstack     Ativar squad fullstack
+  grimoire session start            Gerar prompt de sessão
+  grimoire squads use fullstack     Ativar squad
   @dev  @qa  @architect             No chat da sua IDE
 `);
 }

package/package.json

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