grimoire-framework 1.3.0 → 1.4.1

package/.grimoire/install-manifest.yaml

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

package/README.md

@@ -1,171 +1,209 @@
-# Grimoire: AI-Orchestrated System for Full Stack Development 🧙‍♂️
+# 🔮 Grimoire Framework
 
-[![npm version](https://img.shields.io/npm/v/grimoire-framework.svg)](https://www.npmjs.com/package/grimoire-framework)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org)
+> **CLI de gestão para frameworks de agentes de IA** — instale uma vez, use em todos os seus projetos
 
-> Framework de desenvolvimento autônomo orientado por IA que orquestra equipes de agentes especializados para transformar requisitos em software funcional.
+[![npm](https://img.shields.io/npm/v/grimoire-framework.svg)](https://www.npmjs.com/package/grimoire-framework)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
 
 ---
 
-## 🚀 Início Rápido
+## ⚡ Quick Start (5 passos)
 
 ```bash
-# Instalar o Grimoire em um projeto existente
+# 1. Instale no projeto
 npx grimoire-framework install
 
-# Atualizar para a versão mais recente (preserva customizações)
-npx grimoire-framework update
-```
+# 2. Gere o prompt de início de sessão
+grimoire session start
 
-Após a instalação, abra o **Gemini CLI** no diretório do projeto:
+# 3. Cole o prompt no chat da sua IDE e ative um agente
+# @dev  @qa  @architect  @grimoire-master
 
-```bash
-gemini
-# 👑 Michelangelo (grimoire-master) pronto para orquestrar!
+# 4. Crie e rastreie stories
+grimoire story create "Implementar autenticação JWT"
+
+# 5. Veja o relatório ao final do dia
+grimoire report
 ```
 
 ---
 
-## 🛠️ Comandos CLI
-
-### Gerenciamento do Framework
-
-| Comando | Descrição |
-|---|---|
-| `npx grimoire-framework install` | Instalar no projeto atual |
-| `npx grimoire-framework update` | Atualizar preservando customizações |
-| `npx grimoire-framework update --force` | Forçar resync de todos os arquivos |
-| `npx grimoire-framework update --dry-run` | Simular update (sem aplicar) |
-
-### Diagnóstico
+## 🧙 O que é o Grimoire?
 
-| Comando | Descrição |
-|---|---|
-| `grimoire status` | Saúde do framework + integração IDE |
-| `grimoire doctor` | Diagnóstico detalhado com dicas de fix |
-| `grimoire agents list` | Listar agentes com personas |
-| `grimoire whoami` | Contexto da sessão atual |
-| `grimoire --version` | Versão instalada |
+O Grimoire é um framework que adiciona **agentes de IA especializados** ao chat da sua IDE (Gemini CLI, Cursor, VS Code, Claude). Cada agente tem uma persona, expertise e estilo próprios.
 
-> 💡 **CLI vs Agentes:** `grimoire` (terminal) gerencia o framework. `@dev`, `@qa`, `@architect` (chat da IDE) são os agentes de IA — interfaces completamente diferentes.
+```
+CLI (terminal)  →  gerencia o framework
+Agentes (IDE)   →  @dev, @qa, @architect no chat da IDE
+```
 
 ---
 
-## 🧙 Agentes Disponíveis
-
-Após instalar, ative os agentes diretamente no chat da sua IDE:
+## 🤖 Agentes incluídos
 
-| Comando | Persona | Especialidade |
+| Agente | Persona | Especialidade |
 |---|---|---|
-| `@grimoire-master` | 👑 Michelangelo | Orquestração & framework |
-| `@dev` | 🎨 Da Vinci | Desenvolvimento Full-Stack |
-| `@qa` | 🖌️ Dürer | Quality Assurance & Testes |
-| `@architect` | 🏛️ Gaudí | Arquitetura de Sistemas |
-| `@pm` | 📋 Raphael | Product Manager |
-| `@sm` | 🌊 Monet | Scrum Master |
-| `@devops` | ⚡ Boccioni | DevOps & Infraestrutura |
-| `@data-engineer` | 📊 Escher | Engenharia de Dados |
-| `@analyst` | 🔍 Vermeer | Pesquisa & Análise |
-| `@ux-design-expert` | 🎭 Matisse | UX/UI Design |
+| `@grimoire-master` | 👑 Michelangelo | Orquestração |
+| `@dev` | 🎨 Da Vinci | Full-stack |
+| `@qa` | 🖌️ Dürer | QA & testes |
+| `@architect` | 🏛️ Gaudí | Arquitetura |
+| `@pm` | 📋 Raphael | Produto |
+| `@ux-design-expert` | 🎭 Matisse | UX/Design |
+| `@devops` | ⚡ Boccioni | DevOps |
+| `@data-engineer` | 📊 Escher | Dados |
+| `@analyst` | 🔍 Vermeer | Pesquisa |
 | `@po` | 🎯 Velázquez | Product Owner |
+| `@sm` | 🌊 Monet | Scrum Master |
+| `@squad-creator` | 🗿 Rodin | Criação de squads |
 
 ---
 
-## 💻 Integração com IDEs
-
-### Gemini CLI (Recomendado)
-O Grimoire configura automaticamente o arquivo `GEMINI.md` na raiz do projeto. O Michelangelo se apresenta ao abrir o Gemini CLI.
+## 📋 Referência de comandos
 
+### Essenciais
 ```bash
-gemini
-# 👑 Michelangelo (grimoire-master) pronto para orquestrar!
-# Projeto: meu-projeto
+grimoire status              # saúde do framework
+grimoire whoami              # contexto completo (config+pro+stories)
+grimoire doctor              # diagnóstico completo com dicas
+grimoire update              # atualiza agentes e arquivos
+grimoire update --dry-run    # preview sem aplicar
 ```
 
-Para ativar um agente especializado:
-```
-@dev  ou  Da Vinci  ou  ative o @architect
+### Sessão & Workflow
+```bash
+grimoire session start               # prompt para IDE (squad+stories+memória)
+grimoire session start --squad dev   # com squad específico
+grimoire story create "Título"       # nova story
+grimoire story list                  # stories ativas
+grimoire story done US-001           # marcar concluída
+grimoire story note US-001 "obs"     # adicionar nota
+grimoire story show US-001           # detalhes + memórias linkadas
+grimoire report                      # relatório de hoje
+grimoire report --period week        # relatório da semana (7 dias)
+grimoire report --md                 # exportar relatório para Markdown
 ```
 
-### Claude Code
-Agentes disponíveis em `.claude/commands/grimoire/`. Use `/dev`, `/qa`, `/architect`.
-
-### Cursor
-Regras instaladas em `.cursor/rules/agents/`. Agentes ativados via contexto do chat.
-
----
+### Agentes
+```bash
+grimoire agents list          # lista com personas
+grimoire agent create         # wizard interativo
+grimoire agent validate dev   # valida YAML e campos (score 0-100)
+grimoire agent edit dev       # abre no $EDITOR
+grimoire agent remove dev     # remove agente customizado
+```
 
-## 🏗️ Estrutura Instalada
+### Squads
+```bash
+grimoire squads list                # lista squads disponíveis
+grimoire squads use fullstack       # prompt de ativação para IDE
+grimoire squads info fullstack      # detalhes do squad
+```
 
+### Memória
+```bash
+grimoire memory save "texto"                # salvar entrada
+grimoire memory save --tag decisão "txt"    # com tag
+grimoire memory save --story US-001 "txt"   # linkada a story
+grimoire memory show                        # entradas de hoje
+grimoire memory search "termo"              # buscar em sessões
+grimoire memory list-tags                   # tags únicas com contagem
+grimoire memory export                      # exportar para Markdown
+grimoire memory clear --older-than 30       # limpar antigas
 ```
-projeto/
-├── GEMINI.md              ← Config principal do Gemini CLI (Michelangelo)
-├── .gemini/
-│   ├── rules.md           ← Compatibilidade com versões antigas do Gemini CLI
-│   └── rules/grimoire/    ← Definições de agentes para Gemini
-├── .codex/agents/         ← Definições de todos os agentes (12 core)
-├── .cursor/rules/agents/  ← Agentes para Cursor
-├── .claude/commands/      ← Comandos para Claude Code
-└── .grimoire/             ← Memória, métricas e configurações
+
+### Busca & Backup
+```bash
+grimoire search "JWT"               # busca global (memória+stories+agentes)
+grimoire search "JWT" --memory      # só memória
+grimoire search "JWT" --stories     # só stories
+grimoire backup                     # backup de .grimoire/
+grimoire backup --list              # listar backups
+grimoire backup --restore <arq>     # restaurar backup
+grimoire export --all               # bundle Markdown completo
+grimoire export --all --json        # bundle JSON completo
 ```
 
----
+### Métricas
+```bash
+grimoire metrics                       # dashboard do mês
+grimoire metrics --period week         # últimos 7 dias
+grimoire metrics --period all          # histórico completo
+grimoire metrics export --csv          # exportar para CSV
+grimoire metrics track session "desc"  # registrar evento manual
+```
 
-## 🔄 Fluxo de Update
+### Config & Hooks
+```bash
+grimoire config list               # todas as configurações
+grimoire config get default_agent  # valor de uma chave
+grimoire config set default_agent dev  # definir valor
+grimoire config reset              # restaurar defaults
+grimoire hooks install             # git post-commit (auto-tracking)
+grimoire hooks status              # verificar status do hook
+grimoire hooks uninstall           # remover hook
+```
 
-O `grimoire update` é inteligente — preserva as suas customizações:
+### Sync Global
+```bash
+grimoire sync --global       # envia agentes → ~/.grimoire/agents/
+grimoire sync --from-global  # puxa agentes do store global
+grimoire sync --list         # lista agentes no store
+```
 
-- ✅ **Atualiza** arquivos do framework (agentes core, GEMINI.md)
-- 🔒 **Preserva** arquivos que só existem no seu projeto (agentes customizados)
-- ➕ **Adiciona** arquivos novos do framework
+### Marketplace
+```bash
+grimoire marketplace list           # navega agentes da comunidade
+grimoire marketplace install slug   # instala agente
+grimoire marketplace search "termo" # busca por especialidade
+grimoire marketplace submit         # guia para publicar
+```
 
+### Grimoire Pro
 ```bash
-npx grimoire-framework update          # Update normal
-npx grimoire-framework update --force  # Forçar re-sync completo
-npx grimoire-framework update --dry-run # Ver o que mudaria
+grimoire pro activate <chave>   # ativa licença Pro
+grimoire pro status             # status e features
+grimoire pro features           # lista features Pro
+grimoire pro deactivate         # remove licença
 ```
 
 ---
 
-## ⚙️ Requisitos
+## 📁 Estrutura do projeto
 
-- **Node.js** >= 18.0.0
-- **npm** >= 9.0.0
-- **Git** (recomendado)
+```
+seu-projeto/
+├── .grimoire/
+│   ├── memory/sessions/     # memória JSONL
+│   ├── metrics/             # métricas JSONL
+│   ├── stories/             # stories JSON
+│   ├── backups/             # backups .grimbak
+│   ├── exports/             # bundles exportados
+│   └── config.yaml          # configurações do projeto
+├── .codex/agents/           # agentes Gemini CLI
+├── .gemini/                 # config Gemini CLI
+├── .cursor/                 # regras Cursor
+└── GEMINI.md                # persona principal
+```
 
 ---
 
-## 🗺️ Roadmap
+## 📦 Versões
 
-- [x] Smart Update com preservação de customizações
-- [x] Publisher Quality Gate (CI/CD)
-- [x] Integração Gemini CLI via `GEMINI.md`
-- [x] 12 agentes com personas artísticas (Michelangelo, Da Vinci, Dürer...)
-- [ ] **Sistema de Login & Autenticação** — Governança para equipes
-- [ ] **Project Models** — Templates para SaaS, Mobile, API
-- [ ] **Persistent Memory Layer** — Aprendizado de padrões do seu código
-- [ ] **Enterprise Connectors** — Integração com Jira, Notion e Slack
+| Versão | Features |
+|---|---|
+| v1.0.x | Setup, agents, sync global |
+| v1.1.x | Marketplace, Grimoire Pro |
+| v1.2.0 | Squads use, config, hooks, agent validate, memory tags |
+| v1.3.0 | Report, story, session start, doctor v3, whoami v2 |
+| **v1.4.0** | **Search global, backup, export --all, memory --story, story note** |
 
 ---
 
 ## 🤝 Contribuindo
 
-Contribuições são bem-vindas! Veja [CONTRIBUTING.md](CONTRIBUTING.md) para detalhes.
-
-```bash
-git clone https://github.com/gabrielrlima/grimoire.git
-cd grimoire
-npm install
-npm test
-```
-
----
-
-## 📄 Licença
-
-Distribuído sob a licença MIT. Veja [LICENSE](LICENSE) para mais informações.
+Veja [CONTRIBUTING.md](CONTRIBUTING.md) e [docs/CHANGELOG.md](docs/CHANGELOG.md).
 
 ---
 
-Built with ❤️ by the **Grimoire Team** • [npm](https://www.npmjs.com/package/grimoire-framework) • [GitHub](https://github.com/gabrielrlima/grimoire)
+*Grimoire Framework · MIT License · Made with ❤️ by the community*

package/bin/commands/backup.js

@@ -0,0 +1,165 @@
+/**
+ * grimoire backup — Backup & Restore .grimoire/
+ *
+ * grimoire backup                  Cria backup zip de .grimoire/
+ * grimoire backup --restore <file> Restaura a partir de um zip
+ * grimoire backup --list           Lista backups existentes
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const zlib = require('zlib');
+
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    const direct = path.join(cwd, '.grimoire');
+    const sub = path.join(cwd, 'grimoire', '.grimoire');
+    if (fs.existsSync(direct)) return { dir: direct, root: cwd };
+    if (fs.existsSync(sub)) return { dir: sub, root: path.join(cwd, 'grimoire') };
+    return null;
+}
+
+function getBackupDir(grimoireDir) {
+    const d = path.join(grimoireDir, 'backups');
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+
+// Simple tar-like serialization using NDJSON (no native zip without deps)
+// Format: one header line + files as base64 encoded NDJSON entries
+function createBackup(grimoireDir, backupDir) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupFile = path.join(backupDir, `backup-${timestamp}.grimbak`);
+
+    const SKIP_DIRS = new Set(['backups', 'exports']);
+    const entries = [];
+
+    function walk(dir, rel = '') {
+        for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
+            const relPath = rel ? `${rel}/${item.name}` : item.name;
+            const abs = path.join(dir, item.name);
+            if (item.isDirectory()) {
+                if (!SKIP_DIRS.has(item.name)) walk(abs, relPath);
+            } else {
+                try {
+                    const content = fs.readFileSync(abs).toString('base64');
+                    entries.push({ path: relPath, content, size: fs.statSync(abs).size });
+                } catch (_) { }
+            }
+        }
+    }
+
+    walk(grimoireDir);
+
+    const header = JSON.stringify({
+        version: 1,
+        createdAt: new Date().toISOString(),
+        files: entries.length,
+        source: grimoireDir
+    });
+
+    const lines = [header, ...entries.map(e => JSON.stringify(e))];
+    const raw = lines.join('\n');
+    const buf = zlib.gzipSync(Buffer.from(raw, 'utf8'));
+    fs.writeFileSync(backupFile, buf);
+
+    return { file: backupFile, count: entries.length, size: buf.length };
+}
+
+function restoreBackup(backupFile, grimoireDir) {
+    if (!fs.existsSync(backupFile)) {
+        throw new Error(`Arquivo não encontrado: ${backupFile}`);
+    }
+    const buf = fs.readFileSync(backupFile);
+    const raw = zlib.gunzipSync(buf).toString('utf8');
+    const lines = raw.split('\n').filter(l => l.trim());
+    const header = JSON.parse(lines[0]);
+
+    let restored = 0;
+    for (const line of lines.slice(1)) {
+        try {
+            const entry = JSON.parse(line);
+            const dest = path.join(grimoireDir, entry.path);
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.writeFileSync(dest, Buffer.from(entry.content, 'base64'));
+            restored++;
+        } catch (_) { }
+    }
+    return { count: restored, header };
+}
+
+function listBackups(backupDir) {
+    if (!fs.existsSync(backupDir)) return [];
+    return fs.readdirSync(backupDir)
+        .filter(f => f.endsWith('.grimbak'))
+        .map(f => {
+            const stat = fs.statSync(path.join(backupDir, f));
+            return { name: f, size: stat.size, mtime: stat.mtime };
+        })
+        .sort((a, b) => b.mtime - a.mtime);
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    const found = findGrimoireDir();
+    if (!found) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+    const { dir: grimoireDir } = found;
+    const backupDir = getBackupDir(grimoireDir);
+
+    if (args.includes('--list')) {
+        const backups = listBackups(backupDir);
+        console.log(`\n💾 Backups (${backups.length}):\n`);
+        if (backups.length === 0) {
+            console.log('  (nenhum backup encontrado)');
+            console.log('  grimoire backup    ← criar agora\n');
+        } else {
+            backups.forEach(b => {
+                const kb = (b.size / 1024).toFixed(1);
+                const d = b.mtime.toLocaleDateString('pt-BR');
+                console.log(`  📦 ${b.name}  (${kb} KB · ${d})`);
+            });
+            console.log(`\n  grimoire backup --restore <arquivo>  ← restaurar\n`);
+        }
+        return;
+    }
+
+    const restoreIdx = args.indexOf('--restore');
+    if (restoreIdx !== -1) {
+        const file = args[restoreIdx + 1];
+        if (!file) {
+            console.log('Usage: grimoire backup --restore <arquivo.grimbak>\n');
+            return;
+        }
+        const absFile = path.isAbsolute(file) ? file : path.join(backupDir, file);
+        console.log(`\n⏳ Restaurando backup: ${path.basename(absFile)}...\n`);
+        try {
+            const { count, header } = restoreBackup(absFile, grimoireDir);
+            console.log(`✅ ${count} arquivos restaurados`);
+            console.log(`   Backup criado em: ${new Date(header.createdAt).toLocaleString('pt-BR')}\n`);
+        } catch (e) {
+            console.error(`❌ Erro ao restaurar: ${e.message}\n`);
+        }
+        return;
+    }
+
+    // Default: create backup
+    console.log('\n⏳ Criando backup de .grimoire/ ...\n');
+    try {
+        const { file, count, size } = createBackup(grimoireDir, backupDir);
+        const kb = (size / 1024).toFixed(1);
+        const rel = path.relative(process.cwd(), file);
+        console.log(`✅ Backup criado: ${rel}`);
+        console.log(`   ${count} arquivos · ${kb} KB\n`);
+        console.log(`💡 Para restaurar: grimoire backup --restore ${path.basename(file)}`);
+        console.log(`   Para listar:    grimoire backup --list\n`);
+    } catch (e) {
+        console.error(`❌ Erro ao criar backup: ${e.message}\n`);
+    }
+}
+
+module.exports = { run };

package/bin/commands/exportall.js

@@ -0,0 +1,200 @@
+/**
+ * grimoire export — Full Export
+ *
+ * grimoire export --all             Markdown bundle de tudo
+ * grimoire export --all --json      JSON bundle de tudo
+ * grimoire export --all --out <dir> Diretório de saída customizado
+ */
+
+'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;
+}
+
+// ── Loaders ───────────────────────────────────────────────────────────────────
+function loadAllStories(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)
+        .sort((a, b) => a.createdAt > b.createdAt ? 1 : -1);
+}
+
+function loadAllMemory(grimoireDir) {
+    const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+    if (!fs.existsSync(sessionsDir)) return [];
+    const entries = [];
+    const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl')).sort();
+    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;
+}
+
+function loadMetrics(grimoireDir) {
+    const dir = path.join(grimoireDir, 'metrics');
+    if (!fs.existsSync(dir)) return { sessions: 0, commits: 0, storiesDone: 0 };
+    let sessions = 0, commits = 0, storiesDone = 0;
+    for (const f of fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'))) {
+        const raw = fs.readFileSync(path.join(dir, f), 'utf8');
+        for (const line of raw.split('\n').filter(l => l.trim())) {
+            try {
+                const e = JSON.parse(line);
+                if (e.type === 'session_start' || e.type === 'agent_session') sessions++;
+                if (e.type === 'commit') commits++;
+                if (e.type === 'story_complete') storiesDone++;
+            } catch (_) { }
+        }
+    }
+    return { sessions, commits, storiesDone };
+}
+
+// ── Markdown export ───────────────────────────────────────────────────────────
+function buildMarkdown(stories, memory, metrics, projectName) {
+    const now = new Date().toISOString().split('T')[0];
+    const lines = [];
+
+    lines.push(`# Grimoire Export — ${projectName}`);
+    lines.push(`\n> Exportado em: ${now}\n`);
+
+    // Stats
+    lines.push(`## 📈 Resumo\n`);
+    lines.push(`| Métrica | Valor |`);
+    lines.push(`|---|---|`);
+    lines.push(`| Stories totais | ${stories.length} |`);
+    lines.push(`| Sessões | ${metrics.sessions} |`);
+    lines.push(`| Commits | ${metrics.commits} |`);
+    lines.push(`| Stories concluídas | ${metrics.storiesDone} |`);
+    lines.push(`| Entradas de memória | ${memory.length} |`);
+    lines.push('');
+
+    // Stories
+    lines.push(`## 📋 Stories\n`);
+    const openStories = stories.filter(s => s.status !== 'done');
+    const doneStories = stories.filter(s => s.status === 'done');
+
+    if (openStories.length) {
+        lines.push(`### Em andamento\n`);
+        openStories.forEach(s => {
+            lines.push(`#### 🔄 [${s.id}] ${s.title}`);
+            lines.push(`- **Criada:** ${s.createdAt.slice(0, 10)}`);
+            if (s.notes && s.notes.length) {
+                lines.push(`- **Notas:**`);
+                s.notes.forEach(n => lines.push(`  - ${n}`));
+            }
+            lines.push('');
+        });
+    }
+    if (doneStories.length) {
+        lines.push(`### Concluídas\n`);
+        doneStories.forEach(s => {
+            lines.push(`- ✅ **[${s.id}]** ${s.title}${s.doneAt ? ` — ${s.doneAt.slice(0, 10)}` : ''}`);
+        });
+        lines.push('');
+    }
+
+    // Memory by tag
+    lines.push(`## 🧠 Memória\n`);
+    const byTag = {};
+    const noTag = [];
+    for (const e of memory) {
+        if (e.tag) { byTag[e.tag] = byTag[e.tag] || []; byTag[e.tag].push(e); }
+        else noTag.push(e);
+    }
+
+    for (const [tag, entries] of Object.entries(byTag)) {
+        lines.push(`### #${tag}\n`);
+        entries.forEach(e => {
+            const story = e.story ? ` \`[${e.story}]\`` : '';
+            lines.push(`- **${e.date}**  ${e.content}${story}`);
+        });
+        lines.push('');
+    }
+
+    if (noTag.length) {
+        lines.push(`### Sem tag\n`);
+        noTag.slice(0, 20).forEach(e => lines.push(`- **${e.date}**  ${e.content}`));
+        if (noTag.length > 20) lines.push(`- *(e mais ${noTag.length - 20} entradas...)*`);
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}
+
+// ── JSON export ───────────────────────────────────────────────────────────────
+function buildJSON(stories, memory, metrics, projectName) {
+    return JSON.stringify({
+        exportedAt: new Date().toISOString(),
+        project: projectName,
+        metrics,
+        stories,
+        memory,
+    }, null, 2);
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    if (!args.includes('--all')) {
+        console.log('\nUsage:\n');
+        console.log('  grimoire export --all           Markdown bundle de tudo');
+        console.log('  grimoire export --all --json    JSON bundle de tudo\n');
+        return;
+    }
+
+    const grimoireDir = findGrimoireDir();
+    if (!grimoireDir) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+
+    // Project name
+    let projectName = path.basename(process.cwd());
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+        projectName = pkg.name || projectName;
+    } catch (_) { }
+
+    // Output dir
+    const outIdx = args.indexOf('--out');
+    const outDir = outIdx !== -1 && args[outIdx + 1]
+        ? args[outIdx + 1]
+        : path.join(grimoireDir, 'exports');
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+    const now = new Date().toISOString().split('T')[0];
+    const isJson = args.includes('--json');
+    const ext = isJson ? 'json' : 'md';
+    const outFile = path.join(outDir, `${now}-export.${ext}`);
+
+    console.log('\n⏳ Exportando dados do .grimoire/ ...\n');
+
+    const stories = loadAllStories(grimoireDir);
+    const memory = loadAllMemory(grimoireDir);
+    const metrics = loadMetrics(grimoireDir);
+
+    const content = isJson
+        ? buildJSON(stories, memory, metrics, projectName)
+        : buildMarkdown(stories, memory, metrics, projectName);
+
+    fs.writeFileSync(outFile, content, 'utf8');
+
+    const rel = path.relative(process.cwd(), outFile);
+    console.log(`✅ Export gerado: ${rel}`);
+    console.log(`   Stories: ${stories.length}  ·  Memória: ${memory.length}  ·  Formato: ${isJson ? 'JSON' : 'Markdown'}\n`);
+}
+
+module.exports = { run };

package/bin/commands/memory.js

@@ -85,6 +85,19 @@ async function saveMemory(args, memoryDir) {
     else { filteredArgs = filteredArgs.filter(a => a !== args[tagIdx] && a !== tag); }
   }
 
+  // Extract --story value if present
+  const storyIdx = filteredArgs.findIndex(a => a === '--story' || a.startsWith('--story='));
+  let storyId = null;
+  if (storyIdx !== -1) {
+    if (filteredArgs[storyIdx].includes('=')) {
+      storyId = filteredArgs[storyIdx].split('=')[1];
+      filteredArgs.splice(storyIdx, 1);
+    } else {
+      storyId = filteredArgs[storyIdx + 1];
+      filteredArgs.splice(storyIdx, 2);
+    }
+  }
+
   const content = filteredArgs.join(' ');
   if (!content) {
     console.error('❌ Please provide content to save.');
@@ -98,6 +111,7 @@ async function saveMemory(args, memoryDir) {
     timestamp: new Date().toISOString(),
     content: content,
     ...(tag ? { tag } : {}),
+    ...(storyId ? { story: storyId } : {}),
   };
 
   // Ensure file exists for lockfile

package/bin/commands/pro.js

@@ -1,13 +1,11 @@
 /**
- * grimoire pro — License & Feature Gate System
+ * grimoire pro — Feature Catalogue
  *
- * Phase 1: Offline-first with HMAC key validation
- * Phase 2: Online validation via Supabase Edge Function (future)
+ * Todos os recursos Pro estão disponíveis por padrão.
+ * O sistema de licença foi removido — sem chave, sem bloqueio.
  *
- * grimoire pro activate <key>    Ativa a licença Pro
- * grimoire pro status            Mostra status da licença
- * grimoire pro features          Lista features Pro disponíveis
- * grimoire pro deactivate        Remove a licença
+ * grimoire pro status    Mostra status e features
+ * grimoire pro features  Lista todas as features
  */
 
 'use strict';
@@ -69,17 +67,19 @@ function isLicenseValid(license) {
     return license.checksum === expected;
 }
 
-// ── Public API for other modules ───────────────────────────────────────────────
+// ── Public API (all features unlocked by default) ────────────────────────────
+/**
+ * Always returns true — all Pro features are available without a license key.
+ */
 function isPro() {
-    const license = loadLicense();
-    return isLicenseValid(license) && license.type === 'pro';
+    return true;
 }
 
+/**
+ * Always returns true — every feature ID is available.
+ */
 function hasFeature(featureId) {
-    const license = loadLicense();
-    if (!isLicenseValid(license)) return false;
-    if (license.type === 'pro') return PRO_FEATURES.some(f => f.id === featureId);
-    return license.features?.includes(featureId) || false;
+    return true;
 }
 
 // ── readline prompt ────────────────────────────────────────────────────────────
@@ -93,145 +93,43 @@ function prompt(q) {
 async function run(args) {
     const sub = args[0];
     switch (sub) {
-        case 'activate': await activate(args[1]); break;
-        case 'deactivate': deactivate(); break;
+        case 'activate': showAlreadyOpen(); break;
+        case 'deactivate': showAlreadyOpen(); break;
         case 'features': showFeatures(); break;
         case 'status':
         default: showStatus(); break;
     }
 }
 
-// ── Activate ───────────────────────────────────────────────────────────────────
-async function activate(keyArg) {
-    console.log('\n🔐 Grimoire Pro — Ativação de Licença\n');
-
-    const key = keyArg || await prompt('Chave de licença (PRO-XXXX-XXXX-XXXX-XXXX): ');
-
-    if (!validateKeyFormat(key)) {
-        console.error('❌ Formato inválido. Use: PRO-XXXX-XXXX-XXXX-XXXX');
-        console.log('   Obtenha sua chave em: https://grimoire.dev/pro\n');
-        return;
-    }
-
-    const email = await prompt('Email associado à licença: ');
-    if (!email || !email.includes('@')) {
-        console.error('❌ Email inválido.');
-        return;
-    }
-
-    // Offline HMAC validation
-    const checksum = generateKeyChecksum(email, key);
-
-    // Try online validation (Phase 2 ready but not blocking)
-    let onlineValidated = false;
-    try {
-        const https = require('https');
-        const result = await new Promise((resolve, reject) => {
-            const data = JSON.stringify({ key, email });
-            const req = https.request({
-                hostname: 'api.grimoire.dev',
-                path: '/v1/license/validate',
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'Content-Length': data.length },
-                timeout: 4000,
-            }, (res) => {
-                let body = '';
-                res.on('data', d => body += d);
-                res.on('end', () => { try { resolve(JSON.parse(body)); } catch (e) { reject(e); } });
-            });
-            req.on('error', reject);
-            req.on('timeout', () => req.destroy());
-            req.write(data);
-            req.end();
-        });
-        onlineValidated = result.valid === true;
-    } catch (_) {
-        // Offline — use local validation only
-    }
-
-    const license = {
-        type: 'pro',
-        key,
-        email,
-        checksum,
-        activatedAt: new Date().toISOString(),
-        expiresAt: null,    // null = never (or set by server in Phase 2)
-        onlineValidated,
-        features: PRO_FEATURES.map(f => f.id),
-    };
-
-    saveLicense(license);
-
-    console.log(`
-✅ Grimoire Pro ativado!
-
-   Email:   ${email}
-   Chave:   ${key.substring(0, 7)}...${key.slice(-4)}
-   Status:  ${onlineValidated ? '✅ Validado online' : '✅ Ativado (validação offline)'}
-
-🎯 Features ativas:`);
-    PRO_FEATURES.forEach(f => console.log(`  ✅ ${f.name} — ${f.desc}`));
-    console.log('\n💡 Use "grimoire pro status" para ver os detalhes\n');
+// ── showAlreadyOpen ───────────────────────────────────────────────────────────
+function showAlreadyOpen() {
+    console.log('\n🔓 Grimoire Pro está aberto!');
+    console.log('   Todos os recursos já estão disponíveis sem preciso de chave.\n');
+    showFeatures();
 }
 
 // ── Status ─────────────────────────────────────────────────────────────────────
 function showStatus() {
-    const license = loadLicense();
     const sep = '─'.repeat(50);
-
-    console.log(`\n🔐 Grimoire Pro — Status da Licença\n${sep}`);
-
-    if (!license) {
-        console.log(`  Status:  ⭕ Não ativado (Community)\n`);
-        console.log(`  ${sep}`);
-        console.log(`  Para ativar: grimoire pro activate <chave>`);
-        console.log(`  Obter licença: https://grimoire.dev/pro\n`);
-        showFeatureList(false);
-        return;
-    }
-
-    const valid = isLicenseValid(license);
-    const isPro = license.type === 'pro' && valid;
-    const expires = license.expiresAt ? new Date(license.expiresAt).toLocaleDateString('pt-BR') : 'Sem expiração';
-
-    console.log(`  Status:  ${valid ? (isPro ? '✅ Pro Ativo' : '✅ Community') : '❌ Licença inválida/expirada'}`);
-    if (license.email) console.log(`  Email:   ${license.email}`);
-    if (license.key) console.log(`  Chave:   ${license.key.substring(0, 7)}...${license.key.slice(-4)}`);
-    console.log(`  Ativado: ${license.activatedAt ? new Date(license.activatedAt).toLocaleDateString('pt-BR') : 'N/A'}`);
-    console.log(`  Expira:  ${expires}`);
+    console.log(`\n🔓 Grimoire Pro — Status\n${sep}`);
+    console.log(`  Status:   ✅ Aberto (todos os recursos disponíveis)`);
+    console.log(`  Licença:  Sem necessidade de chave`);
+    console.log(`  Features: ${PRO_FEATURES.length} recursos ativos`);
     console.log(`  ${sep}`);
-
-    showFeatureList(isPro);
+    showFeatureList(true);
 }
 
 // ── Features ───────────────────────────────────────────────────────────────────
 function showFeatures() {
-    const license = loadLicense();
-    const active = license && isLicenseValid(license) && license.type === 'pro';
-    console.log('\n🎯 Grimoire Pro — Features\n');
-    showFeatureList(active);
+    console.log('\n🎯 Grimoire Pro — Features (todas ativas)\n');
+    showFeatureList(true);
 }
 
 function showFeatureList(active) {
     PRO_FEATURES.forEach(f => {
-        const status = active ? '✅' : '🔒';
-        console.log(`  ${status} ${f.name}`);
+        console.log(`  ✅ ${f.name}`);
         console.log(`     ${f.desc}\n`);
     });
-    if (!active) {
-        console.log(`  🔗 Ative em: https://grimoire.dev/pro`);
-        console.log(`     grimoire pro activate\n`);
-    }
-}
-
-// ── Deactivate ─────────────────────────────────────────────────────────────────
-function deactivate() {
-    if (!fs.existsSync(LICENSE_FILE)) {
-        console.log('ℹ️  Nenhuma licença ativa encontrada.');
-        return;
-    }
-    fs.unlinkSync(LICENSE_FILE);
-    console.log('✅ Licença removida. Grimoire voltou ao modo Community.');
 }
 
 module.exports = { run, isPro, hasFeature };

package/bin/commands/search.js

@@ -0,0 +1,171 @@
+/**
+ * grimoire search — Global Search
+ *
+ * grimoire search "termo"           Busca em memory + stories + agents
+ * grimoire search "JWT" --memory    Só memória
+ * grimoire search "JWT" --stories   Só stories
+ * grimoire search "JWT" --agents    Só agentes
+ */
+
+'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 findAgentsDir() {
+    const cwd = process.cwd();
+    const dirs = [
+        path.join(cwd, '.codex', 'agents'),
+        path.join(cwd, 'node_modules', 'grimoire-framework', '.codex', 'agents'),
+    ];
+    return dirs.find(d => fs.existsSync(d)) || null;
+}
+
+function hl(text, query) {
+    if (!query) return text;
+    const re = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+    return text.replace(re, m => `\x1b[33m${m}\x1b[0m`);
+}
+
+// ── Search memory sessions ────────────────────────────────────────────────────
+function searchMemory(grimoireDir, query) {
+    const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+    if (!fs.existsSync(sessionsDir)) return [];
+    const lq = query.toLowerCase();
+    const results = [];
+    const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl')).sort().reverse();
+    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 {
+                const e = JSON.parse(line);
+                if ((e.content || '').toLowerCase().includes(lq)) {
+                    results.push({ date: f.slice(0, 10), content: e.content, tag: e.tag || null, story: e.story || null });
+                }
+            } catch (_) { }
+        }
+        if (results.length >= 20) break;
+    }
+    return results;
+}
+
+// ── Search stories ────────────────────────────────────────────────────────────
+function searchStories(grimoireDir, query) {
+    const storiesDir = path.join(grimoireDir, 'stories');
+    if (!fs.existsSync(storiesDir)) return [];
+    const lq = query.toLowerCase();
+    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.title || '').toLowerCase().includes(lq) ||
+            (s.notes || []).some(n => n.toLowerCase().includes(lq)));
+}
+
+// ── Search agents ─────────────────────────────────────────────────────────────
+function searchAgents(agentsDir, query) {
+    if (!agentsDir) return [];
+    const lq = query.toLowerCase();
+    const results = [];
+    for (const f of fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'))) {
+        const raw = fs.readFileSync(path.join(agentsDir, f), 'utf8').toLowerCase();
+        if (raw.includes(lq)) {
+            const id = f.replace('.md', '');
+            // Extract name from yaml block
+            let name = id;
+            const nameMatch = raw.match(/name:\s*([^\n]+)/);
+            if (nameMatch) name = nameMatch[1].trim();
+            const titleMatch = raw.match(/title:\s*([^\n]+)/);
+            const title = titleMatch ? titleMatch[1].trim() : '';
+            results.push({ id, name, title });
+        }
+    }
+    return results;
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    const query = args.filter(a => !a.startsWith('-')).join(' ');
+    if (!query) {
+        console.log('Usage: grimoire search "termo"\n');
+        console.log('Busca em: memória · stories · agentes\n');
+        return;
+    }
+
+    const onlyMemory = args.includes('--memory');
+    const onlyStories = args.includes('--stories');
+    const onlyAgents = args.includes('--agents');
+    const all = !onlyMemory && !onlyStories && !onlyAgents;
+
+    const grimoireDir = findGrimoireDir();
+    const agentsDir = findAgentsDir();
+
+    let totalResults = 0;
+
+    console.log(`\n🔍 Grimoire Search — "${query}"\n${'─'.repeat(44)}`);
+
+    // Memory
+    if (all || onlyMemory) {
+        if (grimoireDir) {
+            const memResults = searchMemory(grimoireDir, query);
+            if (memResults.length > 0) {
+                console.log('\n🧠 Memória:');
+                for (const r of memResults) {
+                    const tag = r.tag ? ` [#${r.tag}]` : '';
+                    const story = r.story ? ` [${r.story}]` : '';
+                    console.log(`  ${r.date}  ${hl(r.content, query)}${tag}${story}`);
+                }
+                totalResults += memResults.length;
+            }
+        }
+    }
+
+    // Stories
+    if (all || onlyStories) {
+        if (grimoireDir) {
+            const storyResults = searchStories(grimoireDir, query);
+            if (storyResults.length > 0) {
+                console.log('\n📋 Stories:');
+                for (const s of storyResults) {
+                    const icon = s.status === 'done' ? '✅' : '🔄';
+                    console.log(`  ${icon} [${s.id}] ${hl(s.title, query)}`);
+                    for (const n of (s.notes || []).filter(n => n.toLowerCase().includes(query.toLowerCase()))) {
+                        console.log(`       📝 ${hl(n, query)}`);
+                    }
+                }
+                totalResults += storyResults.length;
+            }
+        }
+    }
+
+    // Agents
+    if (all || onlyAgents) {
+        const agentResults = searchAgents(agentsDir, query);
+        if (agentResults.length > 0) {
+            console.log('\n🤖 Agentes:');
+            for (const a of agentResults) {
+                console.log(`  @${hl(a.id, query)} — ${a.name}${a.title ? '  ' + a.title : ''}`);
+            }
+            totalResults += agentResults.length;
+        }
+    }
+
+    if (totalResults === 0) {
+        console.log('\n  (nenhum resultado encontrado)');
+        console.log(`  Dica: tente termos mais curtos ou use --memory / --stories / --agents\n`);
+    } else {
+        console.log(`\n${'─'.repeat(44)}`);
+        console.log(`  ${totalResults} resultado(s)\n`);
+    }
+}
+
+module.exports = { run };

package/bin/commands/story.js

@@ -61,9 +61,10 @@ function run(args) {
     switch (sub) {
         case 'create': storyCreate(rest, storiesDir, grimoireDir); break;
         case 'done': storyDone(rest[0], storiesDir, grimoireDir); break;
+        case 'note': storyNote(rest[0], rest.slice(1), storiesDir); break;
         case 'delete':
         case 'remove': storyDelete(rest[0], storiesDir); break;
-        case 'show': storyShow(rest[0], storiesDir); break;
+        case 'show': storyShow(rest[0], storiesDir, grimoireDir); break;
         case 'list':
         default: storyList(rest, storiesDir); break;
     }
@@ -161,8 +162,22 @@ function storyDone(id, storiesDir, grimoireDir) {
     console.log(`\n✅ [${story.id}] ${story.title} — marcada como concluída! 🎉\n`);
 }
 
-// ── show ──────────────────────────────────────────────────────────────────────
-function storyShow(id, storiesDir) {
+// ── note ─────────────────────────────────────────────────────────────────────────
+function storyNote(id, args, storiesDir) {
+    if (!id) { console.log('Usage: grimoire story note <id> "nota"\n'); return; }
+    const note = args.filter(a => !a.startsWith('-')).join(' ');
+    if (!note) { console.log('Usage: grimoire story note <id> "nota"\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; }
+    const story = JSON.parse(fs.readFileSync(storyFile, 'utf8'));
+    story.notes = story.notes || [];
+    story.notes.push(note);
+    fs.writeFileSync(storyFile, JSON.stringify(story, null, 2), 'utf8');
+    console.log(`\n📝 Nota adicionada a [${id}]:\n  ${note}\n`);
+}
+
+// ── show ─────────────────────────────────────────────────────────────────────────
+function storyShow(id, storiesDir, grimoireDir) {
     if (!id) { storyList([], storiesDir); return; }
     const storyFile = path.join(storiesDir, id.endsWith('.json') ? id : `${id}.json`);
     if (!fs.existsSync(storyFile)) {
@@ -171,15 +186,39 @@ function storyShow(id, storiesDir) {
     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(`${'\u2500'.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:');
+        console.log('\n  📝 Notas:');
         s.notes.forEach(n => console.log(`    - ${n}`));
     }
-    console.log();
+    // Linked memory entries
+    if (grimoireDir) {
+        const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+        if (fs.existsSync(sessionsDir)) {
+            const linked = [];
+            for (const f of fs.readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl'))) {
+                const raw = fs.readFileSync(path.join(sessionsDir, f), 'utf8');
+                for (const line of raw.split('\n').filter(l => l.trim())) {
+                    try {
+                        const e = JSON.parse(line);
+                        if (e.story === s.id) linked.push({ date: f.slice(0, 10), ...e });
+                    } catch (_) { }
+                }
+            }
+            if (linked.length > 0) {
+                console.log('\n  🧠 Memórias linkadas:');
+                linked.forEach(e => {
+                    const tag = e.tag ? ` [#${e.tag}]` : '';
+                    console.log(`    ${e.date}  ${e.content}${tag}`);
+                });
+            }
+        }
+    }
+    console.log(`\n  grimoire story note ${s.id} "obs"  ← adicionar nota`);
+    console.log(`  grimoire memory save --story ${s.id} "texto"  ← linkar memória\n`);
 }
 
 // ── delete ────────────────────────────────────────────────────────────────────

package/bin/grimoire-cli.js

@@ -142,6 +142,15 @@ async function main() {
     case 'session':
       require('./commands/session').run(args.slice(1));
       break;
+    case 'search':
+      require('./commands/search').run(args.slice(1));
+      break;
+    case 'backup':
+      require('./commands/backup').run(args.slice(1));
+      break;
+    case 'export':
+      require('./commands/exportall').run(args.slice(1));
+      break;
     case 'whoami':
       handleWhoami();
       break;
@@ -607,14 +616,16 @@ COMANDOS ESSENCIAIS:
   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
+  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 note US-001 "obs"   🆕 Adicionar nota a uma story
+  grimoire story list                Ver stories ativas
+  grimoire story done US-001         Marcar concluída
+  grimoire story show US-001         🆕 Detalhes + memórias linkadas
+  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
@@ -629,13 +640,22 @@ SQUADS:
   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
+  grimoire memory save "texto"              Salvar entrada
+  grimoire memory save --tag <t> "x"       Salvar com tag
+  grimoire memory save --story US-001 "x"  🆕 Linkar memória a uma story
+  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
+
+BUSCA & BACKUP:
+  grimoire search "JWT"          🆕 Busca global (memória+stories+agentes)
+  grimoire backup                🆕 Cria backup de .grimoire/
+  grimoire backup --restore <f>  🆕 Restaura backup
+  grimoire backup --list         🆕 Lista backups
+  grimoire export --all          🆕 Bundle Markdown completo
+  grimoire export --all --json   🆕 Bundle JSON completo
 
 MÉTRICAS:
   grimoire metrics                   Dashboard do mês atual

package/package.json

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