grimoire-framework 1.4.0 → 1.5.0

package/.grimoire/install-manifest.yaml

@@ -7,8 +7,8 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.4.0
-generated_at: "2026-02-22T17:13:01.000Z"
+version: 1.5.0
+generated_at: "2026-02-22T17:38:38.314Z"
 generator: scripts/generate-install-manifest.js
 file_count: 1011
 files:

package/bin/commands/context.js

@@ -0,0 +1,319 @@
+/**
+ * grimoire context — Live Context Manager
+ *
+ * grimoire context update     Regenera CONTEXT.md a partir de todos os .jsonl
+ * grimoire context show       Exibe CONTEXT.md no terminal
+ * grimoire context clean       Remove arquivos context/ gerados
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+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 getGlobalMemoryDir() {
+    const d = path.join(os.homedir(), '.grimoire', 'memory');
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+
+function getContextDir(grimoireDir) {
+    const d = path.join(grimoireDir, 'context');
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+
+// ── Load all memory entries ───────────────────────────────────────────────────
+function loadAllEntries(grimoireDir, includeGlobal = true) {
+    const entries = [];
+
+    // Local sessions
+    const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+    if (fs.existsSync(sessionsDir)) {
+        for (const f of fs.readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl')).sort()) {
+            const raw = fs.readFileSync(path.join(sessionsDir, f), 'utf8');
+            for (const line of raw.split('\n').filter(l => l.trim())) {
+                try { entries.push({ ...JSON.parse(line), date: f.slice(0, 10), source: 'local' }); } catch (_) { }
+            }
+        }
+    }
+
+    // Pinned (local)
+    const pinnedFile = path.join(grimoireDir, 'memory', 'pinned.jsonl');
+    if (fs.existsSync(pinnedFile)) {
+        const raw = fs.readFileSync(pinnedFile, 'utf8');
+        for (const line of raw.split('\n').filter(l => l.trim())) {
+            try { entries.push({ ...JSON.parse(line), source: 'pinned' }); } catch (_) { }
+        }
+    }
+
+    // Global
+    if (includeGlobal) {
+        const globalFile = path.join(getGlobalMemoryDir(), 'global.jsonl');
+        if (fs.existsSync(globalFile)) {
+            const raw = fs.readFileSync(globalFile, 'utf8');
+            for (const line of raw.split('\n').filter(l => l.trim())) {
+                try { entries.push({ ...JSON.parse(line), source: 'global' }); } catch (_) { }
+            }
+        }
+    }
+
+    return entries;
+}
+
+// ── Build Markdown files ──────────────────────────────────────────────────────
+function buildContextMd(entries) {
+    const now = new Date().toISOString().split('T')[0];
+    const pinned = entries.filter(e => e.source === 'pinned');
+    const recent = entries.filter(e => e.source !== 'pinned').slice(-20).reverse();
+    const globals = entries.filter(e => e.source === 'global').slice(-10).reverse();
+
+    const lines = [];
+    lines.push(`# 🧠 Contexto do Projeto\n`);
+    lines.push(`> Auto-gerado em ${now} via \`grimoire context update\`\n`);
+
+    if (pinned.length) {
+        lines.push(`## 📌 Fixadas\n`);
+        pinned.forEach(e => lines.push(`- ${e.content}`));
+        lines.push('');
+    }
+
+    const decisions = recent.filter(e => e.tag === 'decisão' || e.tag === 'decisao' || e.tag === 'decision');
+    if (decisions.length) {
+        lines.push(`## ✅ Últimas Decisões\n`);
+        decisions.slice(0, 8).forEach(e => lines.push(`- **${e.date || ''}** ${e.content}`));
+        lines.push('');
+    }
+
+    const patterns = recent.filter(e => e.tag === 'padrão' || e.tag === 'padrao' || e.tag === 'pattern');
+    if (patterns.length) {
+        lines.push(`## 🔧 Padrões Estabelecidos\n`);
+        patterns.slice(0, 8).forEach(e => lines.push(`- **${e.date || ''}** ${e.content}`));
+        lines.push('');
+    }
+
+    const other = recent.filter(e => !['decisão', 'decisao', 'decision', 'padrão', 'padrao', 'pattern'].includes(e.tag));
+    if (other.length) {
+        lines.push(`## 📝 Entradas Recentes\n`);
+        other.slice(0, 10).forEach(e => {
+            const tag = e.tag ? ` \`#${e.tag}\`` : '';
+            const src = e.source === 'global' ? ' 🌐' : '';
+            lines.push(`- **${e.date || ''}** ${e.content}${tag}${src}`);
+        });
+        lines.push('');
+    }
+
+    if (globals.length) {
+        lines.push(`## 🌐 Memória Global (cross-projeto)\n`);
+        globals.slice(0, 5).forEach(e => {
+            const tag = e.tag ? ` \`#${e.tag}\`` : '';
+            lines.push(`- ${e.content}${tag}`);
+        });
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}
+
+function buildTagMd(entries, tag, title, emoji) {
+    const variants = [tag, tag.normalize('NFD').replace(/[\u0300-\u036f]/g, '')];
+    const filtered = entries.filter(e => variants.includes(e.tag)).slice(-30).reverse();
+    if (!filtered.length) return null;
+
+    const lines = [`# ${emoji} ${title}\n`, `> Auto-gerado pelo Grimoire\n`];
+    filtered.forEach(e => {
+        const src = e.source === 'global' ? ' 🌐' : '';
+        lines.push(`- **${e.date || ''}** ${e.content}${src}`);
+    });
+    return lines.join('\n');
+}
+
+// ── Inject into GEMINI.md ─────────────────────────────────────────────────────
+const MARKER_START = '<!-- grimoire-MANAGED-START: memory-context -->';
+const MARKER_END = '<!-- grimoire-MANAGED-END: memory-context -->';
+
+function buildGeminiBlock(entries) {
+    const now = new Date().toISOString().split('T')[0];
+    const pinned = entries.filter(e => e.source === 'pinned');
+    const recent = entries.filter(e => e.source !== 'pinned').slice(-15).reverse();
+    const decisions = recent.filter(e => ['decisão', 'decisao', 'decision'].includes(e.tag)).slice(0, 5);
+    const patterns = recent.filter(e => ['padrão', 'padrao', 'pattern'].includes(e.tag)).slice(0, 5);
+
+    const block = [];
+    block.push(MARKER_START);
+    block.push(`## 🧠 Contexto do Projeto (auto-gerado)\n`);
+
+    if (pinned.length) {
+        block.push(`### 📌 Fixadas\n`);
+        pinned.forEach(e => block.push(`- ${e.content}`));
+        block.push('');
+    }
+
+    if (decisions.length) {
+        block.push(`### ✅ Últimas decisões\n`);
+        decisions.forEach(e => block.push(`- ${e.date}: ${e.content}`));
+        block.push('');
+    }
+
+    if (patterns.length) {
+        block.push(`### 🔧 Padrões\n`);
+        patterns.forEach(e => block.push(`- ${e.date}: ${e.content}`));
+        block.push('');
+    }
+
+    // Any other recent entries without special tag
+    const others = recent.filter(e => !['decisão', 'decisao', 'decision', 'padrão', 'padrao', 'pattern'].includes(e.tag)).slice(0, 5);
+    if (others.length) {
+        block.push(`### 📝 Recentes\n`);
+        others.forEach(e => {
+            const tag = e.tag ? ` [#${e.tag}]` : '';
+            block.push(`- ${e.date}: ${e.content}${tag}`);
+        });
+        block.push('');
+    }
+
+    block.push(`> _Atualizado em ${now}. Use \`grimoire context update\` para regenerar._`);
+    block.push(MARKER_END);
+    return block.join('\n');
+}
+
+function injectIntoGeminiMd(grimoireDir, entries) {
+    // GEMINI.md can be at project root or parent
+    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 = buildGeminiBlock(entries);
+
+    let updated;
+    if (original.includes(MARKER_START)) {
+        // Replace existing block
+        const re = new RegExp(`${regEscape(MARKER_START)}[\\s\\S]*?${regEscape(MARKER_END)}`, 'g');
+        updated = original.replace(re, newBlock);
+    } else {
+        // Append before last ---
+        const lastHr = original.lastIndexOf('\n---');
+        if (lastHr !== -1) {
+            updated = original.slice(0, lastHr) + '\n\n' + newBlock + '\n' + original.slice(lastHr);
+        } else {
+            updated = original + '\n\n' + newBlock + '\n';
+        }
+    }
+
+    if (updated !== original) {
+        fs.writeFileSync(geminiPath, updated, 'utf8');
+        return true;
+    }
+    return false;
+}
+
+function regEscape(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ── Core update logic ─────────────────────────────────────────────────────────
+function doUpdate(grimoireDir, silent = false) {
+    const contextDir = getContextDir(grimoireDir);
+    const entries = loadAllEntries(grimoireDir, true);
+
+    // CONTEXT.md
+    fs.writeFileSync(path.join(contextDir, 'CONTEXT.md'), buildContextMd(entries), 'utf8');
+
+    // decisions.md
+    const dec = buildTagMd(entries, 'decisão', 'Decisões', '✅') ||
+        buildTagMd(entries, 'decisao', 'Decisões', '✅') ||
+        buildTagMd(entries, 'decision', 'Decisões', '✅');
+    if (dec) fs.writeFileSync(path.join(contextDir, 'decisions.md'), dec, 'utf8');
+
+    // patterns.md
+    const pat = buildTagMd(entries, 'padrão', 'Padrões', '🔧') ||
+        buildTagMd(entries, 'padrao', 'Padrões', '🔧') ||
+        buildTagMd(entries, 'pattern', 'Padrões', '🔧');
+    if (pat) fs.writeFileSync(path.join(contextDir, 'patterns.md'), pat, 'utf8');
+
+    // pinned.md
+    const pinned = entries.filter(e => e.source === 'pinned');
+    if (pinned.length) {
+        const pinnedLines = ['# 📌 Memórias Fixadas\n', '> Estas entradas são sempre incluídas no contexto dos agentes.\n'];
+        pinned.forEach(e => pinnedLines.push(`- ${e.content}`));
+        fs.writeFileSync(path.join(contextDir, 'pinned.md'), pinnedLines.join('\n'), 'utf8');
+    }
+
+    // Inject GEMINI.md
+    const injected = injectIntoGeminiMd(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`);
+        console.log(`\n   ${entries.length} entradas indexadas`);
+        console.log(`   grimoire context show  ← ver o resultado\n`);
+    }
+
+    return { entries, injected };
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    const sub = args[0] || 'update';
+
+    const grimoireDir = findGrimoireDir();
+    if (!grimoireDir) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+
+    switch (sub) {
+        case 'update':
+            doUpdate(grimoireDir);
+            break;
+
+        case 'show': {
+            const contextFile = path.join(grimoireDir, 'context', 'CONTEXT.md');
+            if (!fs.existsSync(contextFile)) {
+                console.log('\n⚠️  Contexto ainda não gerado. Rode: grimoire context update\n');
+                return;
+            }
+            console.log('\n' + fs.readFileSync(contextFile, 'utf8'));
+            break;
+        }
+
+        case 'clean': {
+            const contextDir = path.join(grimoireDir, 'context');
+            if (fs.existsSync(contextDir)) {
+                fs.readdirSync(contextDir).forEach(f => fs.unlinkSync(path.join(contextDir, f)));
+                console.log('\n✅ Arquivos de contexto removidos (.jsonl preservados)\n');
+            } else {
+                console.log('\nℹ️  Nada para limpar.\n');
+            }
+            break;
+        }
+
+        default:
+            console.log('\nUsage:\n');
+            console.log('  grimoire context update   Regenera CONTEXT.md + injeta GEMINI.md');
+            console.log('  grimoire context show     Exibe CONTEXT.md');
+            console.log('  grimoire context clean    Remove arquivos gerados\n');
+    }
+}
+
+module.exports = { run, doUpdate, loadAllEntries, getGlobalMemoryDir };

package/bin/commands/memory.js

@@ -23,7 +23,8 @@ async function run(args) {
     baseDir = path.join(baseDir, 'grimoire');
   }
 
-  const memoryDir = path.join(baseDir, '.grimoire', 'memory');
+  const grimoireDir = path.join(baseDir, '.grimoire');
+  const memoryDir = path.join(grimoireDir, 'memory');
 
   if (!existsSync(memoryDir)) {
     console.error('❌ Memory system not found. Run "grimoire install" first.');
@@ -33,7 +34,10 @@ async function run(args) {
   try {
     switch (subCommand) {
       case 'save':
-        await saveMemory(args.slice(1), memoryDir);
+        await saveMemory(args.slice(1), memoryDir, grimoireDir);
+        break;
+      case 'pin':
+        await pinMemory(args.slice(1), memoryDir, grimoireDir);
         break;
       case 'list-tags':
         await listTags(memoryDir);
@@ -66,10 +70,18 @@ async function run(args) {
   }
 }
 
+// ── Auto-update context (silent) ────────────────────────────────────────────
+function silentContextUpdate(grimoireDir) {
+  try {
+    const { doUpdate } = require('./context');
+    doUpdate(grimoireDir, true); // silent = true
+  } catch (_) { } // never block memory save
+}
+
 /**
  * Saves memory using JSONL append (O(1) complexity)
  */
-async function saveMemory(args, memoryDir) {
+async function saveMemory(args, memoryDir, grimoireDir) {
   // Extract --tag value if present
   const tagIdx = args.findIndex(a => a === '--tag' || a.startsWith('--tag='));
   let tag = null;
@@ -98,6 +110,10 @@ async function saveMemory(args, memoryDir) {
     }
   }
 
+  // Extract --global flag
+  const isGlobal = filteredArgs.includes('--global');
+  filteredArgs = filteredArgs.filter(a => a !== '--global');
+
   const content = filteredArgs.join(' ');
   if (!content) {
     console.error('❌ Please provide content to save.');
@@ -105,8 +121,6 @@ async function saveMemory(args, memoryDir) {
   }
 
   const today = new Date().toISOString().split('T')[0];
-  const sessionFile = path.join(memoryDir, 'sessions', `${today}.jsonl`);
-
   const entry = {
     timestamp: new Date().toISOString(),
     content: content,
@@ -114,6 +128,21 @@ async function saveMemory(args, memoryDir) {
     ...(storyId ? { story: storyId } : {}),
   };
 
+  if (isGlobal) {
+    // Save to global memory
+    const { getGlobalMemoryDir } = require('./context');
+    const globalDir = getGlobalMemoryDir();
+    const globalFile = require('path').join(globalDir, 'global.jsonl');
+    const fss = require('fs');
+    fss.appendFileSync(globalFile, JSON.stringify({ ...entry, source: 'global' }) + '\n', 'utf8');
+    const tagLabel = tag ? ` [#${tag}]` : '';
+    console.log(`✅ Memory saved globally 🌐${tagLabel}`);
+    silentContextUpdate(grimoireDir);
+    return;
+  }
+
+  const sessionFile = require('path').join(memoryDir, 'sessions', `${today}.jsonl`);
+
   // Ensure file exists for lockfile
   if (!existsSync(sessionFile)) {
     await fs.writeFile(sessionFile, '', 'utf8');
@@ -134,7 +163,10 @@ async function saveMemory(args, memoryDir) {
     // Append entry as a new line in JSONL format
     await fs.appendFile(sessionFile, JSON.stringify(entry) + '\n', 'utf8');
     const tagLabel = tag ? ` [#${tag}]` : '';
-    console.log(`✅ Memory appended to session ${today}${tagLabel}`);
+    const storyLabel = storyId ? ` [${storyId}]` : '';
+    console.log(`✅ Memory saved${tagLabel}${storyLabel}`);
+    // Auto-update .grimoire/context/ silently
+    silentContextUpdate(grimoireDir);
   } catch (err) {
     console.error(`❌ Failed to acquire lock for memory file: ${err.message}`);
   } finally {
@@ -142,6 +174,22 @@ async function saveMemory(args, memoryDir) {
   }
 }
 
+/**
+ * Pins a memory entry permanently in pinned.jsonl
+ */
+async function pinMemory(args, memoryDir, grimoireDir) {
+  const content = args.filter(a => !a.startsWith('-')).join(' ');
+  if (!content) {
+    console.log('Usage: grimoire memory pin "texto"\n');
+    return;
+  }
+  const pinnedFile = require('path').join(memoryDir, 'pinned.jsonl');
+  const entry = { timestamp: new Date().toISOString(), content, source: 'pinned' };
+  require('fs').appendFileSync(pinnedFile, JSON.stringify(entry) + '\n', 'utf8');
+  console.log(`📌 Memoria fixada: "${content}"`);
+  silentContextUpdate(grimoireDir);
+}
+
 /**
  * Lists sessions scanning the directory
  */

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/grimoire-cli.js

@@ -151,6 +151,9 @@ async function main() {
     case 'export':
       require('./commands/exportall').run(args.slice(1));
       break;
+    case 'context':
+      require('./commands/context').run(args.slice(1));
+      break;
     case 'whoami':
       handleWhoami();
       break;

package/package.json

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