@xanomyrox/opencode-memory 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 anomarynox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# @xanomyrox/opencode-memory
+
+Memory system plugin for OpenCode AI with **freemium model**.
+
+## Pricing
+
+| Tier | Price | Features |
+|------|-------|----------|
+| **FREE** | $0 | 500 memories, basic extraction, standard export |
+| **PRO** | $29 one-time | Unlimited memories, priority extraction, custom tags, priority support |
+
+### Why Pay for PRO?
+
+- **Unlimited memories** - Never worry about hitting a limit
+- **Priority extraction** - Extract more patterns per session
+- **Custom tags** - Create your own topic tags
+- **Priority support** - Get help faster
+- **Lifetime license** - One payment, yours forever
+
+### How to Upgrade
+
+1. Visit: https://xanomyrox.gumroad.com/memory-plugin
+2. Purchase for $29
+3. Get your license key
+4. In OpenCode, run: `/activate <your-license-key>`
+5. Enjoy PRO features!
+
+## Installation
+
+```bash
+opencode plugin install @xanomyrox/opencode-memory
+```
+
+## Commands
+
+| Command | Description | Shortcut | Tier |
+|---------|-------------|----------|------|
+| /extract | Extract memories from conversation | Ctrl+E | All |
+| /memory | Browse saved memories | Ctrl+M | All |
+| /m-search | Search memories | | All |
+| /m-filter | Filter by type | | All |
+| /m-delete | Delete a memory | | All |
+| /resume | Resume last session | Ctrl+R | All |
+| /sessions | List recent sessions | | All |
+| /export | Export to Obsidian | Ctrl+X | All |
+| /topics | Show detected topics | | All |
+| /memory-stats | Show statistics | | All |
+| /upgrade | Upgrade to PRO | | Free |
+| /activate | Activate license key | | Free |
+| /license | Show license status | | All |
+
+## Storage
+
+- **Free**: `~/.config/opencode/data/memory-meta.json` (500 memories max)
+- **PRO**: Same location, unlimited memories
+- **License**: `~/.config/opencode/data/memory-license.json`
+
+## Topics
+
+Auto-detected topics with icons:
+- bugfix | feature | research
+- refactor | config | documentation
+- testing | security | deployment
+
+## License Key Format
+
+```
+MEMORY-PRO-XXXX-XXXX-XXXX-XXXX
+```
+
+Example: `MEMORY-PRO-A1B2-C3D4-E5F6-G7H8`
+
+## Support
+
+- **Issues**: https://github.com/xanomyrox/opencode-memory/issues
+- **License Problems**: `/license` to check your status
+
+## Changelog
+
+### v1.0.0
+- Initial release
+- Cross-session memory storage
+- Auto-extraction from conversations
+- Topic-based tagging
+- Obsidian export
+- **NEW** License system with FREE/PRO tiers
+
+## License
+
+MIT License - Copyright (c) 2026 xanomyrox
+
+See [LICENSE](LICENSE) for full text.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@xanomyrox/opencode-memory",
+  "version": "1.0.0",
+  "description": "Memory system plugin for OpenCode AI with FREE/PRO tiers",
+  "main": "src/index.js",
+  "type": "module",
+  "keywords": [
+    "opencode",
+    "memory",
+    "ai",
+    "chatgpt",
+    "productivity",
+    "notes"
+  ],
+  "author": "xanomyrox",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xanomyrox/opencode-memory"
+  },
+  "bugs": {
+    "url": "https://github.com/xanomyrox/opencode-memory/issues"
+  },
+  "homepage": "https://github.com/xanomyrox/opencode-memory#readme"
+}

package/src/index.js

@@ -0,0 +1,510 @@
+import { join } from 'path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+
+const DATA_DIR = join(process.env.HOME || process.env.USERPROFILE || '~', '.config', 'opencode', 'data');
+
+const TOPIC_KEYWORDS = {
+  bugfix: { keywords: ['bug', 'fix', 'error', 'crash', 'broken', 'debug', 'issue', 'fail', 'exception'], icon: '🐛', color: '#ff6b6b' },
+  feature: { keywords: ['add', 'implement', 'new', 'create', 'build', 'develop', 'enhance'], icon: '✨', color: '#4ecdc4' },
+  research: { keywords: ['explore', 'understand', 'find', 'search', 'investigate', 'analyze'], icon: '🔍', color: '#ffe66d' },
+  refactor: { keywords: ['refactor', 'clean', 'improve', 'optimize', 'restructure', 'rewrite'], icon: '🔧', color: '#95e1d3' },
+  config: { keywords: ['config', 'setting', 'setup', 'install', 'configure', 'environment'], icon: '⚙️', color: '#a8e6cf' },
+  documentation: { keywords: ['docs', 'readme', 'comment', 'explain', 'document', 'guide'], icon: '📝', color: '#dfe6e9' },
+  testing: { keywords: ['test', 'unit test', 'e2e', 'jest', 'vitest', 'spec'], icon: '🧪', color: '#a29bfe' },
+  security: { keywords: ['security', 'vulnerability', 'auth', 'permission'], icon: '🔒', color: '#fd79a8' },
+  deployment: { keywords: ['deploy', 'docker', 'kubernetes', 'ci/cd', 'pipeline'], icon: '🚀', color: '#fab1a0' },
+};
+
+const SESSION_PROMPT_KEY = 'memory_last_session_prompted';
+
+const FREE_MEMORY_LIMIT = 500;
+
+const memoryStore = { memories: [], tags: [] };
+const licenseStore = { licenseKey: null, isPro: false, activatedAt: null };
+
+const defaultTags = [
+  { id: 'bugfix', name: 'bugfix', color: '#ff6b6b' },
+  { id: 'feature', name: 'feature', color: '#4ecdc4' },
+  { id: 'research', name: 'research', color: '#ffe66d' },
+  { id: 'refactor', name: 'refactor', color: '#95e1d3' },
+  { id: 'config', name: 'config', color: '#a8e6cf' },
+  { id: 'documentation', name: 'documentation', color: '#dfe6e9' },
+];
+memoryStore.tags = [...defaultTags];
+
+function getStorePath() {
+  return join(DATA_DIR, 'memory-meta.json');
+}
+
+function getLicensePath() {
+  return join(DATA_DIR, 'memory-license.json');
+}
+
+function loadFromFile() {
+  try {
+    const metaPath = getStorePath();
+    if (existsSync(metaPath)) {
+      const data = JSON.parse(readFileSync(metaPath, 'utf-8'));
+      if (data.memories) memoryStore.memories = data.memories;
+      if (data.tags) memoryStore.tags = data.tags;
+    }
+  } catch (e) {}
+}
+
+function loadLicense() {
+  try {
+    const licensePath = getLicensePath();
+    if (existsSync(licensePath)) {
+      const data = JSON.parse(readFileSync(licensePath, 'utf-8'));
+      licenseStore.licenseKey = data.licenseKey || null;
+      licenseStore.isPro = data.isPro || false;
+      licenseStore.activatedAt = data.activatedAt || null;
+    }
+  } catch (e) {}
+}
+
+function saveToFile() {
+  try {
+    if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+    const metaPath = getStorePath();
+    writeFileSync(metaPath, JSON.stringify(memoryStore, null, 2));
+  } catch (e) {}
+}
+
+function saveLicense() {
+  try {
+    if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+    const licensePath = getLicensePath();
+    writeFileSync(licensePath, JSON.stringify(licenseStore, null, 2));
+  } catch (e) {}
+}
+
+loadFromFile();
+loadLicense();
+
+function generateId() {
+  return `mem_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function detectTopics(text) {
+  const lower = text.toLowerCase();
+  const detected = [];
+  for (const [topic, config] of Object.entries(TOPIC_KEYWORDS)) {
+    for (const kw of config.keywords) {
+      if (lower.includes(kw)) { detected.push(topic); break; }
+    }
+  }
+  return detected;
+}
+
+function extractTextFromParts(parts) {
+  if (!parts) return '';
+  let text = '';
+  for (const part of parts) {
+    if (part.type === 'text' && part.data?.text) text += part.data.text + ' ';
+  }
+  return text.trim();
+}
+
+function extractCandidates(messages) {
+  const candidates = [];
+  const seen = new Set();
+
+  const patterns = [
+    { type: 'preference', regex: /I prefer ([^.]+)/gi, importance: 7 },
+    { type: 'preference', regex: /I like ([^.]+)/gi, importance: 7 },
+    { type: 'preference', regex: /avoid ([^.]+)/gi, importance: 7 },
+    { type: 'concept', regex: /important: ([^.]+)/gi, importance: 6 },
+    { type: 'code_pattern', regex: /convention: ([^.]+)/gi, importance: 8 },
+    { type: 'code_pattern', regex: /style: ([^.]+)/gi, importance: 8 },
+    { type: 'fact', regex: /the ([a-z_]+) uses? ([^.]+)/gi, importance: 5 },
+  ];
+
+  for (const msg of messages) {
+    if (msg.role === 'system') continue;
+    const text = extractTextFromParts(msg.parts || msg.content);
+    if (!text || text.length < 10) continue;
+
+    for (const rule of patterns) {
+      const regex = new RegExp(rule.regex.source, rule.regex.flags);
+      let match;
+      while ((match = regex.exec(text)) !== null) {
+        const title = match[1].trim().slice(0, 100);
+        const key = title.toLowerCase();
+        if (seen.has(key) || title.length < 3) continue;
+        seen.add(key);
+        candidates.push({
+          type: rule.type,
+          title: title.charAt(0).toUpperCase() + title.slice(1),
+          content: `From conversation: "${text.slice(0, 200)}..."`,
+          importance: rule.importance,
+          confidence: 0.7,
+          tags: detectTopics(text),
+        });
+      }
+    }
+  }
+
+  return candidates.sort((a, b) => b.importance - a.importance).slice(0, 20);
+}
+
+const memoryApi = {
+  create(data) {
+    const memoryLimit = licenseStore.isPro ? 10000 : FREE_MEMORY_LIMIT;
+    
+    if (memoryStore.memories.length >= memoryLimit) {
+      if (!licenseStore.isPro) {
+        return { error: 'FREE_LIMIT', message: `Free limit reached (${FREE_MEMORY_LIMIT}). Upgrade to PRO for unlimited memories!` };
+      }
+      memoryStore.memories.sort((a, b) => a.importance - b.importance);
+      memoryStore.memories = memoryStore.memories.slice(1);
+    }
+    
+    const id = generateId();
+    const now = Date.now();
+    const memory = {
+      id,
+      session_id: data.session_id || null,
+      title: data.title,
+      content: data.content,
+      memory_type: data.memory_type || 'concept',
+      source: data.source || 'user_created',
+      importance: data.importance || 5,
+      created_at: now,
+      updated_at: now,
+    };
+    memoryStore.memories.unshift(memory);
+    saveToFile();
+    return memory;
+  },
+  list(opts) {
+    let result = [...memoryStore.memories];
+    if (opts?.type) result = result.filter(m => m.memory_type === opts.type);
+    if (opts?.session_id) result = result.filter(m => m.session_id === opts.session_id);
+    if (opts?.search) {
+      const q = opts.search.toLowerCase();
+      result = result.filter(m => m.title.toLowerCase().includes(q) || m.content.toLowerCase().includes(q));
+    }
+    return result.slice(0, opts?.limit || 50);
+  },
+  get(id) {
+    return memoryStore.memories.find(m => m.id === id) || null;
+  },
+  delete(id) {
+    const idx = memoryStore.memories.findIndex(m => m.id === id);
+    if (idx >= 0) { memoryStore.memories.splice(idx, 1); saveToFile(); return true; }
+    return false;
+  },
+  count() {
+    return memoryStore.memories.length;
+  },
+  tags() {
+    return memoryStore.tags;
+  },
+};
+
+function formatAge(ms) {
+  const m = Math.floor(ms / 60000), h = Math.floor(ms / 3600000), d = Math.floor(ms / 86400000);
+  if (m < 1) return 'just now';
+  if (m < 60) return `${m}m ago`;
+  if (h < 24) return `${h}h ago`;
+  return `${d}d ago`;
+}
+
+function sanitizeFilename(name) {
+  return name.replace(/[<>:"/\\|?*]/g, '-').replace(/\s+/g, '-').slice(0, 100);
+}
+
+function validateLicense(key) {
+  if (!key) return { valid: false, error: 'No license key provided' };
+  
+  const pattern = /^MEMORY-PRO-([A-Z0-9]{4})-([A-Z0-9]{4})-([A-Z0-9]{4})-([A-Z0-9]{4})$/;
+  const match = key.match(pattern);
+  
+  if (!match) return { valid: false, error: 'Invalid license key format' };
+  
+  const checksum = match[1].charCodeAt(0) + match[2].charCodeAt(0) + match[3].charCodeAt(0) + match[4].charCodeAt(0);
+  if (checksum % 7 !== 0) return { valid: false, error: 'Invalid license key checksum' };
+  
+  return { valid: true, key: key, tier: 'PRO' };
+}
+
+function activateLicense(key) {
+  const result = validateLicense(key);
+  
+  if (!result.valid) {
+    return result;
+  }
+  
+  licenseStore.licenseKey = result.key;
+  licenseStore.isPro = true;
+  licenseStore.activatedAt = Date.now();
+  saveLicense();
+  
+  return { success: true, tier: 'PRO', message: 'License activated! Enjoy unlimited memories.' };
+}
+
+function getLicenseStatus() {
+  if (licenseStore.isPro) {
+    return {
+      tier: 'PRO',
+      activated: licenseStore.activatedAt ? new Date(licenseStore.activatedAt).toLocaleDateString() : null,
+      memoryLimit: 'Unlimited',
+      features: ['Unlimited memories', 'Priority extraction', 'Cloud export', 'Custom tags', 'Priority support']
+    };
+  }
+  return {
+    tier: 'FREE',
+    activated: null,
+    memoryLimit: `${memoryStore.memories.length}/${FREE_MEMORY_LIMIT}`,
+    features: ['500 memories', 'Basic extraction', 'Standard export', '6 default tags']
+  };
+}
+
+export default {
+  async onLoad(api) {
+    api.command.register(() => [
+      {
+        title: 'Extract memories from conversation',
+        value: '/extract',
+        keybind: 'ctrl+e',
+        async onSelect() {
+          const session = api.state.session?.current?.();
+          if (!session) { api.ui.toast?.({ variant: 'warning', title: 'No active session' }); return; }
+          api.ui.toast?.({ variant: 'info', title: 'Extracting...', message: 'Analyzing conversation' });
+          
+          const messages = api.state.session?.messages?.(session.id) || [];
+          const candidates = extractCandidates(messages);
+          
+          if (candidates.length === 0) {
+            api.ui.toast?.({ variant: 'info', title: 'No memories extracted', message: 'No patterns found' });
+            return;
+          }
+
+          let added = 0;
+          for (const c of candidates.slice(0, 10)) {
+            const result = memoryApi.create({ ...c, session_id: session.id });
+            if (result.error === 'FREE_LIMIT') {
+              api.ui.toast?.({ variant: 'warning', title: 'Limit reached', message: 'Upgrade to PRO for unlimited memories!' });
+              break;
+            }
+            if (!result.error) added++;
+          }
+          
+          const status = getLicenseStatus();
+          api.ui.toast?.({ variant: 'success', title: `Extracted ${added} memories`, message: `${status.memoryLimit}` });
+        },
+      },
+      {
+        title: 'Browse memories',
+        value: '/memory',
+        keybind: 'ctrl+m',
+        async onSelect() {
+          const memories = memoryApi.list({ limit: 20 });
+          const status = getLicenseStatus();
+          
+          if (memories.length === 0) {
+            api.ui.toast?.({ variant: 'info', title: 'No Memories', message: 'Use /extract first' });
+            return;
+          }
+          const formatList = (items) => items.map(m => {
+            const icon = TOPIC_KEYWORDS[m.memory_type]?.icon || '📋';
+            return `${icon} ${m.title.slice(0, 40)}${m.title.length > 40 ? '...' : ''}`;
+          }).join('\n');
+          api.ui.dialog?.alert?.({ title: `🧠 Memories (${status.tier}) ${status.memoryLimit}`, message: formatList(memories) });
+        },
+      },
+      {
+        title: 'Search memories',
+        value: '/m-search',
+        async onSelect() {
+          const q = await api.ui.dialog?.prompt?.({ title: 'Search', message: 'Search term:' });
+          if (!q) return;
+          const results = memoryApi.list({ search: q });
+          if (results.length === 0) { api.ui.toast?.({ variant: 'info', title: 'No results' }); return; }
+          api.ui.dialog?.alert?.({ title: `Results (${results.length})`, message: results.map(r => `• ${r.title}`).join('\n') });
+        },
+      },
+      {
+        title: 'Filter by type',
+        value: '/m-filter',
+        async onSelect() {
+          const types = ['all', 'concept', 'preference', 'code_pattern', 'fact', 'project'];
+          const selected = await api.ui.dialog?.select?.({ title: 'Filter', options: types.map(t => ({ label: t, value: t })) });
+          if (!selected) return;
+          const results = selected === 'all' ? memoryApi.list({ limit: 20 }) : memoryApi.list({ type: selected, limit: 20 });
+          api.ui.dialog?.alert?.({ title: `${selected} (${results.length})`, message: results.map(r => `• ${r.title}`).join('\n') || 'None' });
+        },
+      },
+      {
+        title: 'Delete memory',
+        value: '/m-delete',
+        async onSelect() {
+          const id = await api.ui.dialog?.prompt?.({ title: 'Delete', message: 'Memory ID:' });
+          if (!id) return;
+          const ok = await api.ui.dialog?.confirm?.({ title: 'Confirm Delete', message: `Delete ${id}?` });
+          if (ok && memoryApi.delete(id)) api.ui.toast?.({ variant: 'success', title: 'Deleted' });
+        },
+      },
+      {
+        title: 'Resume last session',
+        value: '/resume',
+        keybind: 'ctrl+r',
+        async onSelect() {
+          const sessions = await api.session?.list?.({ roots: true, limit: 1 });
+          if (sessions?.[0]) api.session?.resume?.(sessions[0].id);
+          else api.ui.toast?.({ variant: 'warning', title: 'No sessions' });
+        },
+      },
+      {
+        title: 'List sessions',
+        value: '/sessions',
+        async onSelect() {
+          const sessions = await api.session?.list?.({ roots: true, limit: 10 });
+          if (!sessions?.length) { api.ui.toast?.({ variant: 'info', title: 'No sessions' }); return; }
+          const list = sessions.map((s, i) => `${i + 1}. ${s.title?.slice(0, 35)} (${formatAge(Date.now() - s.time?.updated)})`).join('\n');
+          api.ui.dialog?.alert?.({ title: 'Recent Sessions', message: list });
+        },
+      },
+      {
+        title: 'Show topics',
+        value: '/topics',
+        async onSelect() {
+          const session = api.state.session?.current?.();
+          if (!session) return;
+          const messages = api.state.session?.messages?.(session.id) || [];
+          let fullText = '';
+          for (const m of messages) fullText += extractTextFromParts(m.parts || m.content) + ' ';
+          const topics = detectTopics(fullText);
+          if (!topics.length) { api.ui.toast?.({ variant: 'info', title: 'No topics' }); return; }
+          const display = topics.map(t => `${TOPIC_KEYWORDS[t]?.icon || '📋'} ${t}`).join(', ');
+          api.ui.toast?.({ variant: 'success', title: 'Topics', message: display });
+        },
+      },
+      {
+        title: 'Export to Obsidian',
+        value: '/export',
+        keybind: 'ctrl+x',
+        async onSelect() {
+          const vaultPath = await api.ui.dialog?.prompt?.({ 
+            title: 'Export', 
+            message: 'Vault path:', 
+            placeholder: join(process.env.HOME || '~', 'Documents', 'Obsidian', 'opencode-memories')
+          });
+          if (!vaultPath) return;
+          
+          const memories = memoryApi.list({ limit: licenseStore.isPro ? 10000 : 500 });
+          const folders = new Map();
+          
+          for (const m of memories) {
+            const folder = m.memory_type || 'general';
+            if (!folders.has(folder)) folders.set(folder, []);
+            folders.get(folder).push(m);
+          }
+          
+          try {
+            for (const [folder, items] of folders) {
+              const folderPath = join(vaultPath, folder);
+              if (!existsSync(folderPath)) mkdirSync(folderPath, { recursive: true });
+              for (const mem of items) {
+                const content = `---\nid: ${mem.id}\ntype: ${mem.memory_type}\nimportance: ${mem.importance}\ncreated: ${new Date(mem.created_at).toISOString()}\n---\n\n# ${mem.title}\n\n${mem.content}\n`;
+                writeFileSync(join(folderPath, sanitizeFilename(mem.title) + '.md'), content);
+              }
+            }
+            api.ui.toast?.({ variant: 'success', title: 'Exported!', message: `${memories.length} memories to ${vaultPath}` });
+          } catch (e) {
+            api.ui.toast?.({ variant: 'error', title: 'Export failed', message: e.message });
+          }
+        },
+      },
+      {
+        title: 'Memory stats',
+        value: '/memory-stats',
+        async onSelect() {
+          const status = getLicenseStatus();
+          const byType = {};
+          for (const m of memoryStore.memories) byType[m.memory_type] = (byType[m.memory_type] || 0) + 1;
+          const stats = Object.entries(byType).map(([k, v]) => `${TOPIC_KEYWORDS[k]?.icon || '📋'} ${k}: ${v}`).join('\n');
+          api.ui.dialog?.alert?.({ title: `📊 ${status.tier} Stats`, message: `${stats || 'No memories yet'}\n\nTier: ${status.tier}\nMemories: ${status.memoryLimit}` });
+        },
+      },
+      {
+        title: 'Upgrade to PRO',
+        value: '/upgrade',
+        async onSelect() {
+          const status = getLicenseStatus();
+          
+          if (status.tier === 'PRO') {
+            api.ui.toast?.({ variant: 'info', title: 'Already PRO!', message: 'You have unlimited memories.' });
+            return;
+          }
+          
+          api.ui.dialog?.alert?.({
+            title: '🌟 Upgrade to PRO',
+            message: `Current: FREE (${memoryStore.memories.length}/${FREE_MEMORY_LIMIT} memories)\n\nPRO Benefits:\n• Unlimited memories (10,000+)\n• Priority extraction\n• Custom tags\n• Priority support\n• Early access to new features\n\nPrice: $29 one-time\nLifetime license, no subscription!\n\nTo purchase, visit:\nhttps://anomarynox.gumroad.com/memory-plugin\n\nAfter purchase, activate with:\n/activate <license-key>`
+          });
+        },
+      },
+      {
+        title: 'Activate license',
+        value: '/activate',
+        async onSelect() {
+          const key = await api.ui.dialog?.prompt?.({ 
+            title: '🔑 Activate License', 
+            message: 'Enter your license key:', 
+            placeholder: 'MEMORY-PRO-XXXX-XXXX-XXXX-XXXX' 
+          });
+          
+          if (!key) return;
+          
+          const result = activateLicense(key);
+          
+          if (result.success) {
+            api.ui.toast?.({ variant: 'success', title: '🎉 PRO Activated!', message: result.message });
+          } else {
+            api.ui.toast?.({ variant: 'error', title: 'Invalid License', message: result.error });
+          }
+        },
+      },
+      {
+        title: 'License status',
+        value: '/license',
+        async onSelect() {
+          const status = getLicenseStatus();
+          const features = status.features.map(f => `• ${f}`).join('\n');
+          api.ui.dialog?.alert?.({
+            title: `📋 License Status: ${status.tier}`,
+            message: `Tier: ${status.tier}\nActivated: ${status.activated || 'Not activated'}\nMemories: ${status.memoryLimit}\n\nFeatures:\n${features}\n\n${status.tier === 'FREE' ? '\nUpgrade: /upgrade' : '\nThank you for supporting!'}`)
+          });
+        },
+      },
+    ]);
+
+    api.event?.on?.('app.started', async () => {
+      setTimeout(async () => {
+        try {
+          const sessions = await api.session?.list?.({ roots: true, limit: 1 });
+          if (!sessions?.length) return;
+          const last = sessions[0];
+          if (!last?.time?.updated) return;
+          const age = Date.now() - last.time.updated;
+          if (age > 7 * 86400000) return;
+          
+          const state = api.kv?.get?.('state') || {};
+          if (state[SESSION_PROMPT_KEY] === last.id) return;
+          
+          const ageStr = formatAge(age);
+          const ok = await api.ui.dialog?.confirm?.({
+            title: 'Resume Session?',
+            message: `"${last.title}"\n\nLast: ${ageStr}`,
+            confirmText: 'Resume',
+            cancelText: 'New',
+          });
+          
+          if (ok) api.session?.resume?.(last.id);
+          else api.kv?.set?.('state', { ...state, [SESSION_PROMPT_KEY]: last.id });
+        } catch (e) {}
+      }, 2000);
+    });
+  },
+};