grimoire-framework 1.6.0 → 1.7.1

package/.grimoire/install-manifest.yaml

@@ -7,8 +7,8 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.6.0
-generated_at: "2026-02-22T17:57:17.499Z"
+version: 1.7.1
+generated_at: "2026-02-22T18:21:15.311Z"
 generator: scripts/generate-install-manifest.js
 file_count: 1011
 files:

package/bin/commands/analyze.js

@@ -0,0 +1,242 @@
+/**
+ * grimoire analyze — Project Stack Analyzer
+ *
+ * 🎨 Da Vinci: detecta stack, frameworks, estrutura e sugere atividades
+ *
+ * grimoire analyze         Analisa pasta atual e sugere atividades
+ * grimoire analyze --save  Salva análise como memórias no RAG
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, '.grimoire'))) return path.join(cwd, '.grimoire');
+    if (fs.existsSync(path.join(cwd, 'grimoire', '.grimoire'))) return path.join(cwd, 'grimoire', '.grimoire');
+    return null;
+}
+
+// ── Detectors ─────────────────────────────────────────────────────────────────
+function detectFromPackageJson(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) return null;
+
+    let pkg;
+    try { pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8')); } catch (_) { return null; }
+
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const result = { name: pkg.name, version: pkg.version, runtime: 'Node.js', frameworks: [], tools: [], suggestions: [] };
+
+    // Frameworks
+    if (deps['next']) result.frameworks.push('Next.js');
+    if (deps['nuxt']) result.frameworks.push('Nuxt.js');
+    if (deps['react']) result.frameworks.push('React');
+    if (deps['vue']) result.frameworks.push('Vue');
+    if (deps['@angular/core']) result.frameworks.push('Angular');
+    if (deps['svelte']) result.frameworks.push('Svelte');
+    if (deps['express']) result.frameworks.push('Express');
+    if (deps['fastify']) result.frameworks.push('Fastify');
+    if (deps['@nestjs/core']) result.frameworks.push('NestJS');
+    if (deps['hono']) result.frameworks.push('Hono');
+
+    // Databases
+    if (deps['prisma'] || deps['@prisma/client']) result.tools.push('Prisma ORM');
+    if (deps['mongoose']) result.tools.push('MongoDB/Mongoose');
+    if (deps['sequelize']) result.tools.push('Sequelize');
+    if (deps['drizzle-orm']) result.tools.push('Drizzle ORM');
+    if (deps['pg']) result.tools.push('PostgreSQL');
+    if (deps['mysql2']) result.tools.push('MySQL');
+    if (deps['sqlite3'] || deps['better-sqlite3']) result.tools.push('SQLite');
+    if (deps['redis'] || deps['ioredis']) result.tools.push('Redis');
+
+    // Auth
+    if (deps['jsonwebtoken'] || deps['jose']) result.tools.push('JWT Auth');
+    if (deps['passport']) result.tools.push('Passport.js');
+    if (deps['next-auth']) result.tools.push('NextAuth');
+    if (deps['clerk']) result.tools.push('Clerk');
+
+    // Testing
+    if (deps['jest']) result.tools.push('Jest');
+    if (deps['vitest']) result.tools.push('Vitest');
+    if (deps['cypress']) result.tools.push('Cypress E2E');
+    if (deps['playwright']) result.tools.push('Playwright E2E');
+
+    // TypeScript
+    if (deps['typescript'] || pkg.scripts?.['typecheck']) result.tools.push('TypeScript');
+
+    // Hosting/Deploy
+    if (fs.existsSync(path.join(cwd, 'vercel.json'))) result.tools.push('Vercel');
+    if (fs.existsSync(path.join(cwd, 'railway.json'))) result.tools.push('Railway');
+    if (fs.existsSync(path.join(cwd, '.fly.toml'))) result.tools.push('Fly.io');
+
+    return result;
+}
+
+function detectFromFiles(cwd) {
+    const result = { runtime: null, frameworks: [], tools: [] };
+
+    if (fs.existsSync(path.join(cwd, 'requirements.txt')) || fs.existsSync(path.join(cwd, 'pyproject.toml'))) {
+        result.runtime = 'Python';
+        try {
+            const req = fs.readFileSync(path.join(cwd, 'requirements.txt'), 'utf8');
+            if (req.includes('fastapi')) result.frameworks.push('FastAPI');
+            if (req.includes('django')) result.frameworks.push('Django');
+            if (req.includes('flask')) result.frameworks.push('Flask');
+        } catch (_) { }
+    }
+
+    if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) result.runtime = 'Rust';
+    if (fs.existsSync(path.join(cwd, 'go.mod'))) result.runtime = 'Go';
+    if (fs.existsSync(path.join(cwd, 'pom.xml'))) result.runtime = 'Java/Maven';
+    if (fs.existsSync(path.join(cwd, 'build.gradle'))) result.runtime = 'Java/Gradle';
+
+    if (fs.existsSync(path.join(cwd, 'docker-compose.yml'))) result.tools.push('Docker Compose');
+    if (fs.existsSync(path.join(cwd, 'Dockerfile'))) result.tools.push('Docker');
+    if (fs.existsSync(path.join(cwd, '.github', 'workflows'))) result.tools.push('GitHub Actions CI/CD');
+    if (fs.existsSync(path.join(cwd, 'terraform'))) result.tools.push('Terraform');
+
+    return result;
+}
+
+function countFiles(cwd) {
+    const counts = {};
+    function walk(dir, depth = 0) {
+        if (depth > 3) return;
+        try {
+            for (const f of fs.readdirSync(dir)) {
+                if (f.startsWith('.') || f === 'node_modules' || f === '.git') continue;
+                const full = path.join(dir, f);
+                const stat = fs.statSync(full);
+                if (stat.isDirectory()) { walk(full, depth + 1); }
+                else {
+                    const ext = path.extname(f).toLowerCase();
+                    if (ext) counts[ext] = (counts[ext] || 0) + 1;
+                }
+            }
+        } catch (_) { }
+    }
+    walk(cwd);
+    return counts;
+}
+
+function generateSuggestions(pkg, files, extra) {
+    const suggestions = [];
+
+    const testFiles = (files['.test.js'] || 0) + (files['.spec.js'] || 0) + (files['.test.ts'] || 0);
+    if (testFiles === 0) suggestions.push({ title: 'Configurar cobertura de testes', priority: 'alta' });
+
+    if (!extra.has_ci) suggestions.push({ title: 'Configurar CI/CD (GitHub Actions)', priority: 'média' });
+    if (!extra.has_readme) suggestions.push({ title: 'Criar/melhorar README.md', priority: 'média' });
+    if (!extra.has_env_example) suggestions.push({ title: 'Criar .env.example', priority: 'baixa' });
+    if (!extra.has_docker) suggestions.push({ title: 'Containerizar com Docker', priority: 'baixa' });
+
+    if (pkg?.frameworks?.includes('Next.js') || pkg?.frameworks?.includes('React')) {
+        suggestions.push({ title: 'Auditoria de acessibilidade (a11y)', priority: 'média' });
+        suggestions.push({ title: 'Implementar SEO/meta tags', priority: 'baixa' });
+    }
+
+    if (pkg?.tools?.includes('PostgreSQL') || pkg?.tools?.includes('Prisma ORM')) {
+        suggestions.push({ title: 'Implementar connection pooling', priority: 'média' });
+    }
+
+    return suggestions.slice(0, 6);
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+async function run(args) {
+    const save = args.includes('--save');
+    const cwd = process.cwd();
+    const sep = '─'.repeat(52);
+
+    console.log(`\n🔍 Grimoire Analyze — ${path.basename(cwd)}\n${sep}\n`);
+    console.log('  Analisando estrutura do projeto...\n');
+
+    // Detect
+    const pkg = detectFromPackageJson(cwd);
+    const extra = detectFromFiles(cwd);
+    const files = countFiles(cwd);
+
+    const runtime = pkg?.runtime || extra.runtime || 'Desconhecido';
+    const frameworks = [...(pkg?.frameworks || []), ...(extra.frameworks || [])];
+    const tools = [...(pkg?.tools || []), ...(extra.tools || [])];
+
+    const extraFlags = {
+        has_ci: fs.existsSync(path.join(cwd, '.github', 'workflows')),
+        has_readme: fs.existsSync(path.join(cwd, 'README.md')),
+        has_env_example: fs.existsSync(path.join(cwd, '.env.example')),
+        has_docker: fs.existsSync(path.join(cwd, 'Dockerfile')) || fs.existsSync(path.join(cwd, 'docker-compose.yml')),
+    };
+
+    // Output
+    if (pkg?.name) console.log(`  📦 Projeto:      ${pkg.name}${pkg.version ? ` v${pkg.version}` : ''}`);
+    console.log(`  ⚙️  Runtime:      ${runtime}`);
+    if (frameworks.length) console.log(`  🏗️  Frameworks:   ${frameworks.join(', ')}`);
+    if (tools.length) console.log(`  🔧 Tools:         ${tools.join(', ')}`);
+
+    // File counts
+    const topExts = Object.entries(files).sort((a, b) => b[1] - a[1]).slice(0, 5);
+    if (topExts.length) {
+        console.log(`\n  📁 Arquivos:      ${topExts.map(([e, n]) => `${n}×${e}`).join('  ')}`);
+    }
+
+    // Check flags
+    console.log('\n  📋 Checklist:');
+    console.log(`    ${extraFlags.has_readme ? '✅' : '❌'} README.md`);
+    console.log(`    ${extraFlags.has_env_example ? '✅' : '❌'} .env.example`);
+    console.log(`    ${extraFlags.has_ci ? '✅' : '❌'} CI/CD configurado`);
+    console.log(`    ${extraFlags.has_docker ? '✅' : '❌'} Docker`);
+
+    // Suggestions
+    const suggestions = generateSuggestions(pkg, files, extraFlags);
+    if (suggestions.length) {
+        console.log('\n  💡 Atividades sugeridas para o Backlog:\n');
+        suggestions.forEach((s, i) =>
+            console.log(`    ${i + 1}. [${s.priority.toUpperCase()}] ${s.title}`)
+        );
+    }
+
+    // Save to grimoire
+    if (save || suggestions.length > 0) {
+        const grimoireDir = findGrimoireDir();
+        if (grimoireDir) {
+            // Save as memory
+            if (save) {
+                const { run: memRun } = require('./memory');
+                const stackSummary = `Stack: ${runtime}${frameworks.length ? ' + ' + frameworks.join(' + ') : ''}${tools.length ? ' · ' + tools.slice(0, 3).join(', ') : ''}`;
+                await memRun(['save', '--tag', 'stack', stackSummary]);
+            }
+
+            // Create suggested stories
+            if (suggestions.length > 0) {
+                console.log('\n  Criar atividades sugeridas no Backlog? [S/N] ');
+                if (process.stdin.isTTY) {
+                    const readline = require('readline');
+                    readline.emitKeypressEvents(process.stdin);
+                    process.stdin.setRawMode?.(true);
+                    await new Promise(resolve => {
+                        process.stdin.once('keypress', (str) => {
+                            process.stdin.setRawMode?.(false);
+                            if ((str || '').toLowerCase() === 's') {
+                                console.log('\n  Criando...');
+                                const { run: storyRun } = require('./story');
+                                suggestions.forEach(s => storyRun(['create', s.title, '--backlog']));
+                                console.log(`  ✅ ${suggestions.length} atividades criadas no Backlog\n`);
+                            } else {
+                                console.log('  Pulado.\n');
+                            }
+                            resolve();
+                        });
+                    });
+                }
+            }
+        }
+    }
+
+    console.log(`\n${sep}`);
+    console.log('  grimoire dashboard  ← ver kanban\n');
+}
+
+module.exports = { run };

package/bin/commands/context.js

@@ -227,6 +227,117 @@ function regEscape(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+// ── Live Status block ──────────────────────────────────────────────────
+const STATUS_START = '<!-- grimoire-MANAGED-START: live-status -->';
+const STATUS_END = '<!-- grimoire-MANAGED-END: live-status -->';
+
+function loadActiveStories(grimoireDir) {
+    const storiesDir = path.join(grimoireDir, 'stories');
+    if (!fs.existsSync(storiesDir)) return { active: [], backlog: [] };
+    const stories = 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);
+    return {
+        active: stories.filter(s => s.status === 'in_progress'),
+        backlog: stories.filter(s => s.status === 'backlog'),
+    };
+}
+
+function timeSpentLabel(story) {
+    if (!story.startedAt) return '';
+    const ms = new Date() - new Date(story.startedAt);
+    const h = Math.floor(ms / 3600000);
+    const m = Math.floor((ms % 3600000) / 60000);
+    return ` ⏱ ${h}h${m}min`;
+}
+
+function loadRagStatus(grimoireDir) {
+    const cfgF = path.join(grimoireDir, 'config.yaml');
+    if (!fs.existsSync(cfgF)) return null;
+    const lines = fs.readFileSync(cfgF, 'utf8').split('\n');
+    const get = (k) => { const l = lines.find(l => l.startsWith(k + ':')); return l ? l.split(':')[1]?.trim() : null; };
+    return get('embedding_provider') || null;
+}
+
+function buildLiveStatusBlock(grimoireDir, entries) {
+    const now = new Date();
+    const dateStr = now.toISOString().replace('T', ' ').slice(0, 16);
+    const { active, backlog } = loadActiveStories(grimoireDir);
+    const ragProvider = loadRagStatus(grimoireDir);
+
+    // Count memories
+    const todayKey = now.toISOString().split('T')[0];
+    const todayCount = entries.filter(e => e.date === todayKey).length;
+    const totalCount = entries.length;
+
+    // Detect sprint from stories or memory tags
+    const sprintMem = entries.filter(e => /sprint/i.test(e.content)).slice(-1)[0];
+
+    const block = [STATUS_START];
+    block.push('');
+    block.push('## 🟢 Grimoire Ativo');
+    block.push('');
+    block.push('> Este bloco é auto-gerado pelo `grimoire context update` e confirma que o Grimoire Framework está ativo neste projeto.');
+    block.push('');
+    block.push('```');
+    block.push(`Data:          ${dateStr}`);
+
+    if (active.length) {
+        block.push(`\nAtividades em andamento (${active.length}):`);
+        active.forEach(s => block.push(`  [${s.id}] ${s.title}${timeSpentLabel(s)}`));
+    } else {
+        block.push(`\nAtividades:    nenhuma em andamento`);
+    }
+
+    if (backlog.length) {
+        block.push(`Backlog:       ${backlog.length} atividade(s) aguardando`);
+    }
+
+    const ragLabel = ragProvider && ragProvider !== 'tfidf'
+        ? `ativo (${ragProvider})`
+        : 'tfidf (sem embedding — rode grimoire setup rag)';
+    block.push(`\nMemória:       ${totalCount} total · ${todayCount} hoje`);
+    block.push(`RAG:           ${ragLabel}`);
+    block.push(`\nComandos úteis:`);
+    block.push(`  grimoire           → dashboard kanban`);
+    block.push(`  grimoire memory search "query"  → busca semântica`);
+    block.push(`  grimoire context update         → atualizar este bloco`);
+    block.push(`  *status                          → verificar estado no chat`);
+    block.push('```');
+    block.push('');
+    block.push(STATUS_END);
+    return block.join('\n');
+}
+
+function injectLiveStatus(grimoireDir, entries) {
+    const cwd = process.cwd();
+    const candidates = [
+        path.join(cwd, 'GEMINI.md'),
+        path.join(path.dirname(grimoireDir), 'GEMINI.md'),
+    ];
+    const geminiPath = candidates.find(p => fs.existsSync(p));
+    if (!geminiPath) return false;
+
+    const original = fs.readFileSync(geminiPath, 'utf8');
+    const newBlock = buildLiveStatusBlock(grimoireDir, entries);
+
+    let updated;
+    if (original.includes(STATUS_START)) {
+        const re = new RegExp(`${regEscape(STATUS_START)}[\\s\\S]*?${regEscape(STATUS_END)}`, 'g');
+        updated = original.replace(re, newBlock);
+    } else {
+        // Insert at the very end (after all managed blocks)
+        updated = original.trimEnd() + '\n\n' + newBlock + '\n';
+    }
+
+    if (updated !== original) {
+        fs.writeFileSync(geminiPath, updated, 'utf8');
+        return true;
+    }
+    return false;
+}
+
 // ── Core update logic ─────────────────────────────────────────────────────────
 function doUpdate(grimoireDir, silent = false) {
     const contextDir = getContextDir(grimoireDir);
@@ -255,16 +366,19 @@ function doUpdate(grimoireDir, silent = false) {
         fs.writeFileSync(path.join(contextDir, 'pinned.md'), pinnedLines.join('\n'), 'utf8');
     }
 
-    // Inject GEMINI.md
+    // Inject GEMINI.md memory-context block
     const injected = injectIntoGeminiMd(grimoireDir, entries);
 
+    // Inject live-status block (separate, always updated)
+    const statusInjected = injectLiveStatus(grimoireDir, entries);
+
     if (!silent) {
         console.log('\n✅ Contexto atualizado!\n');
         console.log(`   📄 .grimoire/context/CONTEXT.md`);
         if (dec) console.log(`   ✅ .grimoire/context/decisions.md`);
         if (pat) console.log(`   🔧 .grimoire/context/patterns.md`);
         if (pinned.length) console.log(`   📌 .grimoire/context/pinned.md`);
-        if (injected) console.log(`   🔮 GEMINI.md atualizado com bloco memory-context`);
+        if (injected || statusInjected) console.log(`   🟢 GEMINI.md — bloco live-status + memory-context atualizados`);
         console.log(`\n   ${entries.length} entradas indexadas`);
         console.log(`   grimoire context show  ← ver o resultado\n`);
     }

package/bin/commands/dashboard.js

@@ -0,0 +1,358 @@
+/**
+ * grimoire dashboard — Kanban TUI
+ *
+ * 🎭 Design: Matisse (UX) · 🎨 Da Vinci (Dev) · 🏛️ Gaudí (Arquitetura)
+ *
+ * Exibe kanban com colunas: BACKLOG | EM ANDAMENTO | CONCLUÍDO
+ * Com wizard se nenhum projeto for detectado.
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const readline = require('readline');
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, '.grimoire'))) return path.join(cwd, '.grimoire');
+    if (fs.existsSync(path.join(cwd, 'grimoire', '.grimoire'))) return path.join(cwd, 'grimoire', '.grimoire');
+    return null;
+}
+
+function getProjectName(grimoireDir) {
+    try {
+        const pkg = path.join(path.dirname(grimoireDir), 'package.json');
+        if (fs.existsSync(pkg)) return JSON.parse(fs.readFileSync(pkg, 'utf8')).name || 'Projeto';
+    } catch (_) { }
+    return path.basename(path.dirname(grimoireDir));
+}
+
+function loadConfig(grimoireDir) {
+    const f = path.join(grimoireDir, 'config.yaml');
+    if (!fs.existsSync(f)) return {};
+    const cfg = {};
+    fs.readFileSync(f, 'utf8').split('\n').forEach(l => {
+        const m = l.match(/^(\w[\w_]*)\s*:\s*(.+)$/);
+        if (m) cfg[m[1].trim()] = m[2].trim();
+    });
+    return cfg;
+}
+
+function loadStories(grimoireDir) {
+    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)
+        .sort((a, b) => a.createdAt > b.createdAt ? 1 : -1);
+}
+
+// ── Time helpers ──────────────────────────────────────────────────────────────
+function fmtDate(iso) {
+    if (!iso) return '—';
+    return iso.slice(0, 10).split('-').slice(1).join('/'); // MM/DD
+}
+
+function timeSpent(story) {
+    if (!story.startedAt) return null;
+    const end = story.completedAt ? new Date(story.completedAt) : new Date();
+    const ms = end - new Date(story.startedAt);
+    const h = Math.floor(ms / 3600000);
+    const m = Math.floor((ms % 3600000) / 60000);
+    return `${h}h ${m}min`;
+}
+
+// ── RAG status (quick check) ──────────────────────────────────────────────────
+function ragStatus(config) {
+    const p = config.embedding_provider;
+    if (!p || p === 'tfidf') return null;
+    return p;
+}
+
+// ── Today's memory count ──────────────────────────────────────────────────────
+function todayMemCount(grimoireDir) {
+    const today = new Date().toISOString().split('T')[0];
+    const f = path.join(grimoireDir, 'memory', 'sessions', `${today}.jsonl`);
+    if (!fs.existsSync(f)) return 0;
+    return fs.readFileSync(f, 'utf8').split('\n').filter(l => l.trim()).length;
+}
+
+// ── Terminal width ────────────────────────────────────────────────────────────
+function termWidth() {
+    return Math.max(process.stdout.columns || 80, 80);
+}
+
+// ── Box-drawing helpers ───────────────────────────────────────────────────────
+const C = {
+    tl: '╔', tr: '╗', bl: '╚', br: '╝',
+    h: '═', v: '║',
+    ml: '╠', mr: '╣', mt: '╦', mb: '╩', mc: '╬',
+    sep: '─', lsep: '├', rsep: '┤',
+};
+
+function pad(str, len, char = ' ') {
+    const visible = stripAnsi(str).length;
+    const diff = len - visible;
+    return diff > 0 ? str + char.repeat(diff) : str;
+}
+
+function stripAnsi(str) {
+    return String(str).replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function truncate(str, len) {
+    const clean = stripAnsi(str);
+    if (clean.length <= len) return str;
+    return clean.slice(0, len - 1) + '…';
+}
+
+// ── Colors ────────────────────────────────────────────────────────────────────
+const dim = s => `\x1b[2m${s}\x1b[0m`;
+const bold = s => `\x1b[1m${s}\x1b[0m`;
+const cyan = s => `\x1b[36m${s}\x1b[0m`;
+const yellow = s => `\x1b[33m${s}\x1b[0m`;
+const green = s => `\x1b[32m${s}\x1b[0m`;
+const red = s => `\x1b[31m${s}\x1b[0m`;
+const magenta = s => `\x1b[35m${s}\x1b[0m`;
+
+// ── Status icons ──────────────────────────────────────────────────────────────
+function statusIcon(status) {
+    if (status === 'done') return green('✓');
+    if (status === 'in_progress') return yellow('●');
+    return dim('○');
+}
+
+// ── Render single card ────────────────────────────────────────────────────────
+function renderCard(story, colW) {
+    const inner = colW - 2; // minus borders
+    const lines = [];
+
+    // ID + icon
+    const idStr = bold(cyan(truncate(story.id, 8)));
+    const icon = statusIcon(story.status);
+    lines.push(` ${icon} ${idStr}`);
+
+    // Title
+    lines.push(` ${truncate(story.title, inner - 1)}`);
+
+    // Dates
+    if (story.status === 'backlog') {
+        const dead = story.deliveryDate ? `Entrega: ${fmtDate(story.deliveryDate)}` : dim('Sem prazo');
+        lines.push(` ${dim(truncate(dead, inner - 1))}`);
+    } else if (story.status === 'in_progress') {
+        const start = `Início: ${fmtDate(story.startedAt || story.createdAt)}`;
+        const dead = story.deliveryDate ? `Entrega: ${fmtDate(story.deliveryDate)}` : '';
+        lines.push(` ${dim(truncate(start, inner - 1))}`);
+        if (dead) lines.push(` ${dim(truncate(dead, inner - 1))}`);
+        const spent = timeSpent(story);
+        if (spent) lines.push(` ${dim('⏱')} ${dim(spent)}`);
+    } else {
+        // done
+        const done = story.completedAt ? `✓ ${fmtDate(story.completedAt)}` : '';
+        const spent = timeSpent(story);
+        if (done) lines.push(` ${green(truncate(done, inner - 1))}`);
+        if (spent) lines.push(` ${dim('⏱')} ${dim(spent)}`);
+    }
+
+    return lines;
+}
+
+// ── Render full kanban ────────────────────────────────────────────────────────
+function renderKanban(stories, grimoireDir, config) {
+    const W = termWidth();
+    const colW = Math.floor((W - 4) / 3); // 3 cols, 4 borders
+
+    const backlog = stories.filter(s => s.status === 'backlog');
+    const inProgress = stories.filter(s => s.status === 'in_progress');
+    const done = stories.filter(s => s.status === 'done').slice(-5); // last 5
+
+    const output = [];
+
+    // Header
+    const projectName = getProjectName(grimoireDir);
+    const today = new Date().toISOString().split('T')[0];
+    const rag = ragStatus(config);
+    const ragBadge = rag ? cyan(` 🤖 ${rag}`) : '';
+    const headerText = bold(`🔮 Grimoire · ${projectName}`) + `  ${dim(today)}${ragBadge}`;
+    const headerInner = pad(headerText, W - 2);
+    output.push(C.tl + C.h.repeat(W - 2) + C.tr);
+    output.push(C.v + headerInner + C.v);
+
+    // Column headers separator
+    output.push(C.ml + C.h.repeat(colW) + C.mt + C.h.repeat(colW) + C.mt + C.h.repeat(W - 2 - colW * 2 - 2) + C.mr);
+
+    const col1H = bold(' 📋 BACKLOG') + dim(` (${backlog.length})`);
+    const col2H = bold(' 🔄 EM ANDAMENTO') + dim(` (${inProgress.length})`);
+    const col3H = bold(' ✅ CONCLUÍDO') + dim(` (${done.length})`);
+    const colW3 = W - 2 - colW * 2 - 2;
+    output.push(C.v + pad(col1H, colW) + C.v + pad(col2H, colW) + C.v + pad(col3H, colW3) + C.v);
+
+    // Row separator
+    output.push(C.ml + C.h.repeat(colW) + C.mc + C.h.repeat(colW) + C.mc + C.h.repeat(colW3) + C.mr);
+
+    // Cards
+    const col1Cards = backlog.map(s => renderCard(s, colW));
+    const col2Cards = inProgress.map(s => renderCard(s, colW));
+    const col3Cards = done.map(s => renderCard(s, colW3 + 2));
+
+    const maxRows = Math.max(col1Cards.flat().length + col1Cards.length,
+        col2Cards.flat().length + col2Cards.length,
+        col3Cards.flat().length + col3Cards.length, 3);
+
+    let r1 = 0, r2 = 0, r3 = 0;
+    let ci1 = 0, ci2 = 0, ci3 = 0;
+
+    for (let row = 0; row < maxRows; row++) {
+        const getCell = (cards, ci, ri) => {
+            if (ci >= cards.length) return { line: '', nextCi: ci, nextRi: ri };
+            const card = cards[ci];
+            if (ri < card.length) return { line: card[ri], nextCi: ci, nextRi: ri + 1 };
+            if (ri === card.length) return { line: dim(C.sep.repeat(Math.max(0, colW - 2))), nextCi: ci + 1, nextRi: 0 };
+            return { line: '', nextCi: ci + 1, nextRi: 0 };
+        };
+
+        const { line: l1, nextCi: nc1, nextRi: nr1 } = getCell(col1Cards, ci1, r1);
+        const { line: l2, nextCi: nc2, nextRi: nr2 } = getCell(col2Cards, ci2, r2);
+        const { line: l3, nextCi: nc3, nextRi: nr3 } = getCell(col3Cards, ci3, r3);
+
+        ci1 = nc1; r1 = nr1; ci2 = nc2; r2 = nr2; ci3 = nc3; r3 = nr3;
+
+        output.push(
+            C.v + pad(l1, colW) + C.v + pad(l2, colW) + C.v + pad(l3, colW3) + C.v
+        );
+    }
+
+    // Footer separator
+    output.push(C.ml + C.h.repeat(colW) + C.mb + C.h.repeat(colW) + C.mb + C.h.repeat(colW3) + C.mr);
+
+    // Status bar
+    const memCount = todayMemCount(grimoireDir);
+    const squad = config.default_squad || '';
+    const statusBar = dim(`  🧠 ${memCount} mem hoje`) +
+        (squad ? dim(`  ·  squad: ${squad}`) : '') +
+        `  ·  ${dim('[N]')}ova  ${dim('[S]')}ession  ${dim('[Enter]')} Detalhar  ${dim('[Q]')}sair`;
+    output.push(C.v + pad(statusBar, W - 2) + C.v);
+    output.push(C.bl + C.h.repeat(W - 2) + C.br);
+
+    console.log('\n' + output.join('\n'));
+
+    return { backlog, inProgress, done: stories.filter(s => s.status === 'done') };
+}
+
+// ── Interactive keys ──────────────────────────────────────────────────────────
+function waitForKey(stories, grimoireDir) {
+    if (!process.stdin.isTTY) return;
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+
+    process.stdin.once('keypress', (str, key) => {
+        process.stdin.setRawMode?.(false);
+        process.stdin.pause();
+
+        const k = (key?.name || str || '').toLowerCase();
+
+        if (k === 'q' || key?.ctrl && k === 'c') {
+            console.log('');
+            process.exit(0);
+        }
+
+        if (k === 'n') {
+            // New story — delegate to story create wizard
+            console.log('\n📝 Criando nova atividade...');
+            console.log('   grimoire story create "Título" [--deadline YYYY-MM-DD]\n');
+            process.exit(0);
+        }
+
+        if (k === 's') {
+            console.log('\n🚀 Iniciando sessão...');
+            try { require('./session').run([]); }
+            catch (_) { console.log('   grimoire session start\n'); process.exit(0); }
+            return;
+        }
+
+        if (k === 'return' || k === 'enter') {
+            // Show current in_progress story details
+            const active = stories.find(s => s.status === 'in_progress');
+            if (active) {
+                try { require('./story').run(['show', active.id]); }
+                catch (_) { }
+            } else {
+                console.log('\n  Nenhuma atividade em andamento.\n');
+            }
+            process.exit(0);
+        }
+
+        // Any other key — exit
+        console.log('');
+        process.exit(0);
+    });
+}
+
+// ── No-project wizard ─────────────────────────────────────────────────────────
+async function showNoProjectWizard() {
+    const cwd = process.cwd();
+    const W = Math.min(termWidth(), 50);
+
+    console.log('\n' + '╔' + '═'.repeat(W - 2) + '╗');
+    console.log('║' + pad(bold('  🔮 Grimoire Framework'), W - 2) + '║');
+    console.log('║' + pad(dim(`  ${cwd}`), W - 2) + '║');
+    console.log('╠' + '═'.repeat(W - 2) + '╣');
+    console.log('║' + pad(yellow('  ⚠️  Nenhum projeto detectado.'), W - 2) + '║');
+    console.log('║' + ' '.repeat(W - 2) + '║');
+    console.log('║' + pad('  O que você quer fazer?', W - 2) + '║');
+    console.log('║' + ' '.repeat(W - 2) + '║');
+    console.log('║' + pad('  ❯ 🆕  Novo projeto              [N]', W - 2) + '║');
+    console.log('║' + pad('     🔍  Analisar pasta atual     [A]', W - 2) + '║');
+    console.log('║' + pad('     ✖   Sair                     [Q]', W - 2) + '║');
+    console.log('╚' + '═'.repeat(W - 2) + '╝\n');
+
+    if (!process.stdin.isTTY) return;
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+
+    await new Promise(resolve => {
+        process.stdin.once('keypress', (str, key) => {
+            process.stdin.setRawMode?.(false);
+            process.stdin.pause();
+            const k = (key?.name || str || '').toLowerCase();
+
+            if (k === 'n') {
+                console.log('🆕 Iniciando novo projeto...');
+                console.log('   npx grimoire-framework install\n');
+            } else if (k === 'a') {
+                console.log('🔍 Analisando pasta...');
+                try { require('./analyze').run([]); }
+                catch (_) { console.log('   grimoire analyze\n'); }
+            } else {
+                console.log('');
+            }
+            resolve();
+        });
+    });
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+async function run(args) {
+    const grimoireDir = findGrimoireDir();
+
+    if (!grimoireDir) {
+        await showNoProjectWizard();
+        return;
+    }
+
+    const config = loadConfig(grimoireDir);
+    const stories = loadStories(grimoireDir);
+
+    const { backlog } = renderKanban(stories, grimoireDir, config);
+    waitForKey(stories, grimoireDir);
+}
+
+module.exports = { run, renderKanban };

package/bin/commands/story.js

@@ -1,12 +1,15 @@
 /**
  * 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
+ * grimoire story create "Título"          Cria story (status: backlog)
+ * grimoire story create "Título" --start  Cria e inicia imediatamente
+ * grimoire story create "Título" --deadline 2026-03-01
+ * grimoire story start <id>               Inicia story (→ in_progress)
+ * grimoire story list                     Lista stories ativas
+ * grimoire story list --all               Lista todas (inclui concluídas)
+ * grimoire story done <id>               Marca como concluída
+ * grimoire story show <id>               Detalhes + tempo gasto
+ * grimoire story delete <id>             Remove story
  */
 
 'use strict';
@@ -60,6 +63,7 @@ function run(args) {
 
     switch (sub) {
         case 'create': storyCreate(rest, storiesDir, grimoireDir); break;
+        case 'start': storyStart(rest[0], storiesDir, grimoireDir); break;
         case 'done': storyDone(rest[0], storiesDir, grimoireDir); break;
         case 'note': storyNote(rest[0], rest.slice(1), storiesDir); break;
         case 'delete':
@@ -74,20 +78,36 @@ function run(args) {
 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');
+        console.log('Usage: grimoire story create "Título" [--start] [--deadline YYYY-MM-DD]\n');
         return;
     }
+
+    // Flags
+    const forceStart = args.includes('--start') || (args.some(a => a === '--backlog') === false && false);
+    const startNow = args.includes('--start');
+    const deadlineIdx = args.findIndex(a => a === '--deadline' || a.startsWith('--deadline='));
+    let deliveryDate = null;
+    if (deadlineIdx !== -1) {
+        deliveryDate = args[deadlineIdx].includes('=') ? args[deadlineIdx].split('=')[1] : args[deadlineIdx + 1];
+    }
+
     const stories = loadStories(storiesDir);
     const id = nextId(stories);
+    const now = new Date().toISOString();
+    const status = startNow ? 'in_progress' : 'backlog';
+
     const story = {
         id,
         title,
-        status: 'in_progress',
-        createdAt: new Date().toISOString(),
-        doneAt: null,
+        status,
+        createdAt: now,
+        startedAt: startNow ? now : null,
+        deliveryDate: deliveryDate || null,
+        completedAt: null,
         tags: [],
         notes: [],
     };
+
     const filename = path.join(storiesDir, `${id}.json`);
     fs.writeFileSync(filename, JSON.stringify(story, null, 2), 'utf8');
 
@@ -97,14 +117,34 @@ function storyCreate(args, storiesDir, grimoireDir) {
         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');
+            fs.appendFileSync(mFile, JSON.stringify({ timestamp: now, type: 'story_create', story: id, title }) + '\n');
         }
     } catch (_) { }
 
+    const statusLabel = status === 'in_progress' ? '🔄 em andamento' : '📋 backlog';
     console.log(`\n✅ Story criada: [${id}] ${title}\n`);
-    console.log(`  Status: 🔄 em andamento`);
+    console.log(`  Status: ${statusLabel}`);
+    if (deliveryDate) console.log(`  Prazo:  ${deliveryDate}`);
+    console.log(`  Para iniciar:  grimoire story start ${id}`);
     console.log(`  Para concluir: grimoire story done ${id}`);
-    console.log(`  Para ver: grimoire story show ${id}\n`);
+    console.log(`  Dashboard:     grimoire\n`);
+}
+
+// ── start ─────────────────────────────────────────────────────────────────────
+function storyStart(id, storiesDir, grimoireDir) {
+    if (!id) { console.log('Usage: grimoire story start <id>\n'); return; }
+    const f = path.join(storiesDir, `${id}.json`);
+    if (!fs.existsSync(f)) { console.error(`❌ Story ${id} não encontrada`); return; }
+    const story = JSON.parse(fs.readFileSync(f, 'utf8'));
+    if (story.status === 'in_progress') {
+        console.log(`⚠️  [${id}] já está em andamento.\n`); return;
+    }
+    story.status = 'in_progress';
+    story.startedAt = new Date().toISOString();
+    fs.writeFileSync(f, JSON.stringify(story, null, 2), 'utf8');
+    console.log(`\n🚀 [${id}] ${story.title}`);
+    console.log(`  Status: 🔄 em andamento`);
+    console.log(`  Iniciado: ${story.startedAt.slice(0, 10)}\n`);
 }
 
 // ── list ──────────────────────────────────────────────────────────────────────

package/bin/grimoire-cli.js

@@ -172,15 +172,26 @@ async function main() {
       console.log(`Delegating ${command} to core logic...`);
       require('./grimoire');
       break;
+    case 'dashboard':
+    case 'dash':
+      require('./commands/dashboard').run(args.slice(1));
+      break;
+    case 'analyze':
+    case 'analyse':
+      require('./commands/analyze').run(args.slice(1));
+      break;
     case '--version':
     case '-v':
       console.log(`Grimoire v${packageJson.version}`);
       break;
     case '--help':
     case '-h':
-    default:
       showHelp();
       break;
+    default:
+      // No args or unknown command → show dashboard
+      require('./commands/dashboard').run([]);
+      break;
   }
 
   // Wait for update check to finish (prints banner after main command if needed)

package/package.json

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