memory-lucia 2.0.0 → 2.0.2

package/CLAWHUB-FIXES.md

@@ -0,0 +1,127 @@
+# ClawHub Audit Fixes
+
+This document summarizes the fixes applied to address ClawHub security audit feedback.
+
+## Issues Fixed
+
+### ✅ 1. Missing Files
+
+| File | Status | Description |
+|------|--------|-------------|
+| `database/schema.sql` | ✅ Created | Complete database schema with tables, indexes, and views |
+| `migrations/v1-to-v2.js` | ✅ Created | Migration script from V1 to V2 database |
+| `references/API.md` | ✅ Created | Complete API documentation |
+
+### ✅ 2. Version Consistency
+
+| Location | Before | After |
+|----------|--------|-------|
+| SKILL.md | 2.0.0 | 2.0.1 |
+| README.md | 2.0.0 | 2.0.1 |
+| package.json | 2.0.1 | 2.0.1 (already correct) |
+
+### ✅ 3. Removed Development Files
+
+Removed from repository:
+- `publish.bat`
+- `publish-with-otp.bat`
+- `push-final.bat`
+- `push-gh-cli.bat`
+- `push-manual.bat`
+- `push-to-github.bat`
+- `push-with-gh.bat`
+
+Updated `.gitignore` to exclude:
+- `*.bat` files
+- Publish documentation files
+- GitHub workflows (if not ready)
+
+### ✅ 4. Source Verification
+
+All source URLs are valid:
+- **npm**: https://www.npmjs.com/package/memory-lucia
+- **GitHub**: https://github.com/wen521/memory-lucia-
+- **Issues**: https://github.com/wen521/memory-lucia-/issues
+
+## Security Considerations Addressed
+
+### Database Safety
+- ✅ Schema file (`schema.sql`) now included with proper table definitions
+- ✅ All views (`v_pending_decisions`, `v_skill_summary`, `v_weekly_learning_report`, `v_high_priority`) defined in schema
+- ✅ Database initialization script (`database/init.js`) properly references schema.sql
+- ✅ Migration script (`migrations/v1-to-v2.js`) included for data portability
+
+### File System Operations
+- ✅ Database path is configurable (default: `./memory-v2.db`)
+- ✅ Backup directory created relative to working directory
+- ✅ No system files or critical directories accessed
+
+### Backup Management
+- ✅ Backup retention configurable via `keepCount` parameter
+- ✅ Automatic cleanup only removes old backups, never active database
+- ✅ Rollback requires explicit backup path selection
+
+## File Structure
+
+```
+memory-v2-skill/
+├── SKILL.md                    # Skill description (version 2.0.1)
+├── README.md                   # Documentation (version 2.0.1)
+├── package.json                # Package metadata
+├── LICENSE                     # MIT License
+├── .gitignore                  # Excludes dev files
+├── api/
+│   └── index.js               # Main API module
+├── database/
+│   ├── init.js                # Database initialization
+│   └── schema.sql             # ✅ Database schema (NEW)
+├── modules/
+│   ├── priority.js            # Priority analysis
+│   ├── learning.js            # Learning tracking
+│   ├── decision.js            # Decision recording
+│   ├── evolution.js           # Skill evolution
+│   └── version.js             # Version management
+├── migrations/
+│   └── v1-to-v2.js            # ✅ Migration script (NEW)
+├── references/
+│   └── API.md                 # ✅ API documentation (NEW)
+└── scripts/
+    └── init-memory.js         # Setup script
+```
+
+## Pre-Publish Checklist
+
+Before publishing to ClawHub/npm:
+
+- [ ] Verify all files listed above are present
+- [ ] Run `npm test` to ensure tests pass
+- [ ] Run `node scripts/init-memory.js` to verify database initialization
+- [ ] Verify no `.bat` files in the package
+- [ ] Verify version is consistent across all files (2.0.1)
+- [ ] Verify GitHub repository is public and accessible
+- [ ] Verify npm package is published and accessible
+
+## Testing
+
+```bash
+# Install dependencies
+npm install
+
+# Initialize database
+node scripts/init-memory.js
+
+# Run tests
+npm test
+```
+
+## Notes for Reviewers
+
+1. **Database Views**: All SQL views referenced in the code are defined in `database/schema.sql`
+2. **Migration**: The `migrations/v1-to-v2.js` script handles data migration from V1 format
+3. **API Documentation**: Complete API reference available in `references/API.md`
+4. **No Executables**: All `.bat` files have been removed; only Node.js scripts remain
+
+---
+
+Last updated: 2026-03-25
+Version: 2.0.1

package/README.md

@@ -1,64 +1,111 @@
 # Memory Lucia
 
-[![Version](https://img.shields.io/badge/version-2.0.0-blue.svg)](https://github.com/YOUR_USERNAME/memory-lucia/releases)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![npm version](https://img.shields.io/npm/v/memory-lucia.svg)](https://www.npmjs.com/package/memory-lucia)
+[![GitHub](https://img.shields.io/badge/github-memory--lucia-blue.svg)](https://github.com/wen521/memory-lucia-)
+[![License](https://img.shields.io/npm/l/memory-lucia.svg)](LICENSE)
 
 Advanced memory system for OpenClaw agents with priority analysis, learning tracking, decision recording, and skill evolution.
 
-## Features
-
-- 🎯 **Priority Analysis** - Analyze and store message priorities
-- 📚 **Learning Tracking** - Track learning progress and milestones
-- 🎯 **Decision Recording** - Record decisions with outcomes and reviews
-- 📈 **Skill Evolution** - Monitor skill usage and growth
-- 💾 **Version Management** - Automatic backups with rollback
-- 📊 **Dashboard** - Unified view of all memory data
-
-## Quick Start
+## 📦 Installation
 
 ```bash
-# Install
 npm install memory-lucia
 ```
 
+## 🚀 Quick Start
+
 ```javascript
 const MemoryAPI = require('memory-lucia');
 
-const api = new MemoryAPI('./memory-v2.db');
+const api = new MemoryAPI('./memory.db');
 await api.init();
 
-// Track learning
+// Track learning progress
 await api.startLearning(msgId, convId, message);
+await api.updateLearningProgress(learningId, { progress: 50 });
+
+// Record a decision
+await api.recordDecision(msgId, convId, {
+  summary: 'Choose SQLite over PostgreSQL',
+  context: 'For local deployment',
+  expectedOutcome: 'Simpler setup'
+});
 
 // Get dashboard
 const dashboard = await api.getDashboard();
+console.log(dashboard);
 ```
 
-## Core Modules
+## ✨ Features
 
-- **Priority** - Message priority analysis
-- **Learning** - Learning progress tracking
-- **Decision** - Decision recording and review
-- **Evolution** - Skill usage monitoring
-- **Version** - Backup and rollback
+- 🎯 **Priority Analysis** - Analyze and store message priorities
+- 📚 **Learning Tracking** - Track learning progress and milestones
+- 🎯 **Decision Recording** - Record decisions with outcomes and reviews
+- 📈 **Skill Evolution** - Monitor skill usage and growth
+- 💾 **Version Management** - Automatic backups with rollback
+- 📊 **Dashboard** - Unified view of all memory data
 
-## Documentation
+## 📖 Core Modules
+
+### 1. Priority Module
+Analyze and store message priorities.
+
+```javascript
+const analysis = await api.analyzePriority(message);
+await api.storePriority(msgId, convId, analysis);
+const highPriority = await api.getHighPriority(10);
+```
+
+### 2. Learning Module
+Track learning topics and progress.
+
+```javascript
+const learning = await api.startLearning(msgId, convId, message);
+await api.addMilestone(learning.id, { title: 'Completed Chapter 1' });
+const active = await api.getActiveLearning(5);
+```
+
+### 3. Decision Module
+Record and review decisions.
+
+```javascript
+await api.recordDecision(msgId, convId, decisionData);
+await api.updateDecisionOutcome(decisionId, { actualOutcome: 'Success' });
+const pending = await api.getPendingDecisions();
+```
+
+### 4. Evolution Module
+Monitor skill usage.
+
+```javascript
+await api.recordSkillUsage('skill-name', 'category', 'success');
+const topSkills = await api.getTopSkills(10);
+```
+
+## 📚 Documentation
 
 - [SKILL.md](SKILL.md) - Skill description and usage
 - [API Reference](references/API.md) - Complete API documentation
+- [Architecture](references/ARCHITECTURE.md) - System design
 
-## Database
+## 🗄️ Database
 
 SQLite backend with tables:
-- `memory_priorities`
-- `memory_learning`
-- `memory_decisions`
-- `memory_evolution`
+- `memory_priorities` - Priority analysis
+- `memory_learning` - Learning tracking
+- `memory_decisions` - Decision records
+- `memory_evolution` - Skill usage
+
+## 🔗 Links
+
+- **npm**: https://www.npmjs.com/package/memory-lucia
+- **GitHub**: https://github.com/wen521/memory-lucia-
+- **Issues**: https://github.com/wen521/memory-lucia-/issues
 
-## Version
+## 📋 Version
 
-Current: 2.0.0
+Current: 2.0.2
 
-## License
+## 📄 License
 
-MIT
+MIT © Chief of Staff

package/SKILL.md

@@ -113,7 +113,7 @@ node migrations/v1-to-v2.js old-memory.db
 
 ## Version
 
-Current: 2.0.0
+Current: 2.0.2
 
 ## License
 

package/database/schema.sql

@@ -0,0 +1,152 @@
+-- Memory V2.0 Database Schema
+-- SQLite database schema for OpenClaw Memory System
+
+-- Priority Analysis Table
+CREATE TABLE IF NOT EXISTS memory_priorities (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    msg_id TEXT NOT NULL,
+    conv_id TEXT,
+    priority_level TEXT CHECK(priority_level IN ('critical', 'high', 'medium', 'low')),
+    reasoning TEXT,
+    category TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Learning Tracking Table
+CREATE TABLE IF NOT EXISTS memory_learning (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    msg_id TEXT NOT NULL,
+    conv_id TEXT,
+    topic TEXT,
+    description TEXT,
+    status TEXT CHECK(status IN ('active', 'paused', 'completed', 'abandoned')) DEFAULT 'active',
+    progress INTEGER DEFAULT 0 CHECK(progress >= 0 AND progress <= 100),
+    started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    completed_at DATETIME
+);
+
+-- Learning Milestones Table
+CREATE TABLE IF NOT EXISTS memory_learning_milestones (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    learning_id INTEGER NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    achieved_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (learning_id) REFERENCES memory_learning(id) ON DELETE CASCADE
+);
+
+-- Decision Records Table
+CREATE TABLE IF NOT EXISTS memory_decisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    msg_id TEXT NOT NULL,
+    conv_id TEXT,
+    summary TEXT NOT NULL,
+    context TEXT,
+    expected_outcome TEXT,
+    actual_outcome TEXT,
+    status TEXT CHECK(status IN ('pending', 'implemented', 'validated', 'rejected')) DEFAULT 'pending',
+    review_scheduled_at DATETIME,
+    reviewed_at DATETIME,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Skill Evolution Table
+CREATE TABLE IF NOT EXISTS memory_evolution (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_name TEXT NOT NULL,
+    category TEXT,
+    usage_count INTEGER DEFAULT 0,
+    success_count INTEGER DEFAULT 0,
+    last_used_at DATETIME,
+    first_used_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Database Version Tracking
+CREATE TABLE IF NOT EXISTS memory_schema_version (
+    version TEXT PRIMARY KEY,
+    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Insert initial version
+INSERT OR IGNORE INTO memory_schema_version (version) VALUES ('2.0.0');
+
+-- Create indexes for performance
+CREATE INDEX IF NOT EXISTS idx_priorities_level ON memory_priorities(priority_level);
+CREATE INDEX IF NOT EXISTS idx_priorities_created ON memory_priorities(created_at);
+CREATE INDEX IF NOT EXISTS idx_learning_status ON memory_learning(status);
+CREATE INDEX IF NOT EXISTS idx_learning_topic ON memory_learning(topic);
+CREATE INDEX IF NOT EXISTS idx_decisions_status ON memory_decisions(status);
+CREATE INDEX IF NOT EXISTS idx_decisions_review ON memory_decisions(review_scheduled_at);
+CREATE INDEX IF NOT EXISTS idx_evolution_skill ON memory_evolution(skill_name);
+CREATE INDEX IF NOT EXISTS idx_evolution_category ON memory_evolution(category);
+
+-- Views for common queries
+
+-- View: Pending Decisions
+CREATE VIEW IF NOT EXISTS v_pending_decisions AS
+SELECT 
+    d.*,
+    CASE 
+        WHEN review_scheduled_at < CURRENT_TIMESTAMP THEN 'overdue'
+        WHEN review_scheduled_at <= datetime('now', '+7 days') THEN 'due_soon'
+        ELSE 'scheduled'
+    END as review_status
+FROM memory_decisions d
+WHERE status IN ('pending', 'implemented')
+    AND (review_scheduled_at IS NULL OR review_scheduled_at <= datetime('now', '+7 days'))
+ORDER BY review_scheduled_at ASC;
+
+-- View: Skill Summary
+CREATE VIEW IF NOT EXISTS v_skill_summary AS
+SELECT 
+    skill_name,
+    category,
+    usage_count,
+    success_count,
+    CASE 
+        WHEN usage_count > 0 THEN ROUND(100.0 * success_count / usage_count, 2)
+        ELSE 0
+    END as success_rate,
+    last_used_at,
+    first_used_at
+FROM memory_evolution
+ORDER BY usage_count DESC;
+
+-- View: Weekly Learning Report
+CREATE VIEW IF NOT EXISTS v_weekly_learning_report AS
+SELECT 
+    topic,
+    COUNT(*) as session_count,
+    AVG(progress) as avg_progress,
+    MAX(updated_at) as last_activity,
+    SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_count
+FROM memory_learning
+WHERE updated_at >= datetime('now', '-7 days')
+GROUP BY topic
+ORDER BY last_activity DESC;
+
+-- View: High Priority Items
+CREATE VIEW IF NOT EXISTS v_high_priority AS
+SELECT 
+    'priority' as type,
+    id,
+    msg_id,
+    priority_level as level,
+    category,
+    reasoning as details,
+    created_at
+FROM memory_priorities
+WHERE priority_level IN ('critical', 'high')
+UNION ALL
+SELECT 
+    'decision' as type,
+    id,
+    msg_id,
+    status as level,
+    'decision' as category,
+    summary as details,
+    created_at
+FROM memory_decisions
+WHERE status = 'pending' AND review_scheduled_at <= CURRENT_TIMESTAMP
+ORDER BY created_at DESC;

package/migrations/v1-to-v2.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+/**
+ * Memory V1 to V2 Migration Script
+ * Migrates data from old memory format to V2 schema
+ */
+
+const sqlite3 = require('sqlite3').verbose();
+const fs = require('fs');
+const path = require('path');
+
+class MemoryMigration {
+    constructor(sourceDbPath, targetDbPath = './memory-v2.db') {
+        this.sourceDbPath = sourceDbPath;
+        this.targetDbPath = targetDbPath;
+        this.sourceDb = null;
+        this.targetDb = null;
+    }
+
+    async init() {
+        // Check if source exists
+        if (!fs.existsSync(this.sourceDbPath)) {
+            throw new Error(`Source database not found: ${this.sourceDbPath}`);
+        }
+
+        // Open source database
+        this.sourceDb = new sqlite3.Database(this.sourceDbPath, sqlite3.OPEN_READONLY);
+        
+        // Open/create target database
+        this.targetDb = new sqlite3.Database(this.targetDbPath);
+        
+        console.log('✅ Connected to source and target databases');
+    }
+
+    async runSchema() {
+        const schemaPath = path.join(__dirname, '..', 'database', 'schema.sql');
+        
+        if (!fs.existsSync(schemaPath)) {
+            throw new Error(`Schema file not found: ${schemaPath}`);
+        }
+
+        const schema = fs.readFileSync(schemaPath, 'utf8');
+        const statements = schema
+            .split(';')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+
+        for (const statement of statements) {
+            await this.runTarget(statement);
+        }
+        
+        console.log('✅ Target database schema initialized');
+    }
+
+    async migratePriorities() {
+        console.log('🔄 Migrating priorities...');
+        
+        try {
+            const rows = await this.allSource(
+                "SELECT * FROM memory_priorities WHERE created_at >= datetime('now', '-90 days')"
+            );
+
+            for (const row of rows) {
+                await this.runTarget(
+                    `INSERT INTO memory_priorities 
+                     (msg_id, conv_id, priority_level, reasoning, category, created_at)
+                     VALUES (?, ?, ?, ?, ?, ?)`,
+                    [row.msg_id, row.conv_id, row.priority_level, row.reasoning, row.category, row.created_at]
+                );
+            }
+
+            console.log(`✅ Migrated ${rows.length} priority records`);
+        } catch (err) {
+            console.log('ℹ️ No priorities to migrate or table does not exist');
+        }
+    }
+
+    async migrateLearning() {
+        console.log('🔄 Migrating learning records...');
+        
+        try {
+            const rows = await this.allSource(
+                "SELECT * FROM memory_learning WHERE status != 'abandoned'"
+            );
+
+            for (const row of rows) {
+                await this.runTarget(
+                    `INSERT INTO memory_learning 
+                     (msg_id, conv_id, topic, description, status, progress, started_at, updated_at, completed_at)
+                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+                    [row.msg_id, row.conv_id, row.topic, row.description, row.status, 
+                     row.progress, row.started_at, row.updated_at, row.completed_at]
+                );
+            }
+
+            console.log(`✅ Migrated ${rows.length} learning records`);
+        } catch (err) {
+            console.log('ℹ️ No learning records to migrate or table does not exist');
+        }
+    }
+
+    async migrateDecisions() {
+        console.log('🔄 Migrating decisions...');
+        
+        try {
+            const rows = await this.allSource(
+                "SELECT * FROM memory_decisions WHERE status IN ('pending', 'implemented')"
+            );
+
+            for (const row of rows) {
+                await this.runTarget(
+                    `INSERT INTO memory_decisions 
+                     (msg_id, conv_id, summary, context, expected_outcome, actual_outcome, 
+                      status, review_scheduled_at, reviewed_at, created_at)
+                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+                    [row.msg_id, row.conv_id, row.summary, row.context, row.expected_outcome,
+                     row.actual_outcome, row.status, row.review_scheduled_at, row.reviewed_at, row.created_at]
+                );
+            }
+
+            console.log(`✅ Migrated ${rows.length} decision records`);
+        } catch (err) {
+            console.log('ℹ️ No decisions to migrate or table does not exist');
+        }
+    }
+
+    async migrateEvolution() {
+        console.log('🔄 Migrating skill evolution...');
+        
+        try {
+            const rows = await this.allSource(
+                "SELECT * FROM memory_evolution WHERE usage_count > 0"
+            );
+
+            for (const row of rows) {
+                await this.runTarget(
+                    `INSERT INTO memory_evolution 
+                     (skill_name, category, usage_count, success_count, last_used_at, first_used_at)
+                     VALUES (?, ?, ?, ?, ?, ?)`,
+                    [row.skill_name, row.category, row.usage_count, row.success_count, 
+                     row.last_used_at, row.first_used_at]
+                );
+            }
+
+            console.log(`✅ Migrated ${rows.length} skill evolution records`);
+        } catch (err) {
+            console.log('ℹ️ No evolution records to migrate or table does not exist');
+        }
+    }
+
+    async runTarget(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.targetDb.run(sql, params, function(err) {
+                if (err) reject(err);
+                else resolve({ id: this.lastID, changes: this.changes });
+            });
+        });
+    }
+
+    async allSource(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.sourceDb.all(sql, params, (err, rows) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+    }
+
+    async close() {
+        if (this.sourceDb) {
+            await new Promise((resolve) => this.sourceDb.close(resolve));
+        }
+        if (this.targetDb) {
+            await new Promise((resolve) => this.targetDb.close(resolve));
+        }
+        console.log('✅ Database connections closed');
+    }
+
+    async migrate() {
+        try {
+            await this.init();
+            await this.runSchema();
+            await this.migratePriorities();
+            await this.migrateLearning();
+            await this.migrateDecisions();
+            await this.migrateEvolution();
+            
+            console.log('\n🎉 Migration completed successfully!');
+            console.log(`📁 New database: ${path.resolve(this.targetDbPath)}`);
+        } catch (err) {
+            console.error('\n❌ Migration failed:', err.message);
+            process.exit(1);
+        } finally {
+            await this.close();
+        }
+    }
+}
+
+// CLI usage
+if (require.main === module) {
+    const sourceDb = process.argv[2];
+    const targetDb = process.argv[3] || './memory-v2.db';
+
+    if (!sourceDb) {
+        console.log('Usage: node migrations/v1-to-v2.js <source-v1.db> [target-v2.db]');
+        console.log('Example: node migrations/v1-to-v2.js ./memory-v1.db ./memory-v2.db');
+        process.exit(1);
+    }
+
+    const migration = new MemoryMigration(sourceDb, targetDb);
+    migration.migrate();
+}
+
+module.exports = MemoryMigration;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-lucia",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Advanced memory system for OpenClaw agents with priority analysis, learning tracking, decision recording, and skill evolution",
   "main": "api/index.js",
   "scripts": {
@@ -26,10 +26,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/YOUR_USERNAME/memory-lucia.git"
+    "url": "https://github.com/wen521/memory-lucia-.git"
   },
   "bugs": {
-    "url": "https://github.com/YOUR_USERNAME/memory-lucia/issues"
+    "url": "https://github.com/wen521/memory-lucia-/issues"
   },
-  "homepage": "https://github.com/YOUR_USERNAME/memory-lucia#readme"
+  "homepage": "https://github.com/wen521/memory-lucia-#readme"
 }

package/references/API.md

@@ -0,0 +1,364 @@
+# Memory V2 API Reference
+
+Complete API documentation for the Memory V2 system.
+
+## Table of Contents
+
+- [Initialization](#initialization)
+- [Priority Module](#priority-module)
+- [Learning Module](#learning-module)
+- [Decision Module](#decision-module)
+- [Evolution Module](#evolution-module)
+- [Dashboard](#dashboard)
+- [Version Management](#version-management)
+
+---
+
+## Initialization
+
+```javascript
+const MemoryAPI = require('./api');
+
+// Create instance
+const api = new MemoryAPI('./memory-v2.db');
+
+// Initialize database
+await api.init();
+
+// Close when done
+await api.close();
+```
+
+---
+
+## Priority Module
+
+### analyzePriority(message)
+Analyze a message and return priority assessment.
+
+**Parameters:**
+- `message` (string): The message to analyze
+
+**Returns:**
+```javascript
+{
+  priority_level: 'critical' | 'high' | 'medium' | 'low',
+  reasoning: string,
+  category: string
+}
+```
+
+### storePriority(msgId, convId, analysis)
+Store priority analysis in database.
+
+**Parameters:**
+- `msgId` (string): Message ID
+- `convId` (string): Conversation ID
+- `analysis` (object): Result from analyzePriority
+
+**Returns:** `Promise<{id: number}>`
+
+### getHighPriority(limit = 10)
+Get recent high/critical priority items.
+
+**Parameters:**
+- `limit` (number): Maximum results
+
+**Returns:** `Promise<Array>`
+
+### getPriorityStats()
+Get priority distribution statistics.
+
+**Returns:**
+```javascript
+{
+  critical: number,
+  high: number,
+  medium: number,
+  low: number,
+  total: number
+}
+```
+
+---
+
+## Learning Module
+
+### startLearning(msgId, convId, message)
+Start tracking a new learning topic.
+
+**Parameters:**
+- `msgId` (string): Message ID
+- `convId` (string): Conversation ID  
+- `message` (string): Message describing the learning topic
+
+**Returns:**
+```javascript
+{
+  id: number,
+  topic: string,
+  status: 'active',
+  progress: 0
+}
+```
+
+### updateLearningProgress(learningId, updates)
+Update learning progress.
+
+**Parameters:**
+- `learningId` (number): Learning record ID
+- `updates` (object):
+  - `progress` (number): 0-100
+  - `status` (string): 'active' | 'paused' | 'completed' | 'abandoned'
+
+### addMilestone(learningId, milestone)
+Add a milestone to a learning record.
+
+**Parameters:**
+- `learningId` (number): Learning record ID
+- `milestone` (object):
+  - `title` (string): Milestone title
+  - `description` (string): Optional description
+
+### getActiveLearning(limit = 5)
+Get currently active learning topics.
+
+**Parameters:**
+- `limit` (number): Maximum results
+
+**Returns:** `Promise<Array>`
+
+### getLearningStats()
+Get learning statistics.
+
+**Returns:**
+```javascript
+{
+  active: number,
+  completed: number,
+  total: number,
+  avg_progress: number
+}
+```
+
+---
+
+## Decision Module
+
+### recordDecision(msgId, convId, decisionData)
+Record a new decision.
+
+**Parameters:**
+- `msgId` (string): Message ID
+- `convId` (string): Conversation ID
+- `decisionData` (object):
+  - `summary` (string): Decision summary (required)
+  - `context` (string): Decision context
+  - `expectedOutcome` (string): Expected result
+  - `reviewDate` (string): ISO date for review
+
+**Returns:** `Promise<{id: number}>`
+
+### updateDecisionOutcome(decisionId, outcome)
+Update the actual outcome of a decision.
+
+**Parameters:**
+- `decisionId` (number): Decision ID
+- `outcome` (object):
+  - `actualOutcome` (string): What actually happened
+  - `status` (string): 'implemented' | 'validated' | 'rejected'
+
+### getPendingDecisions()
+Get decisions pending review or implementation.
+
+**Returns:** `Promise<Array>`
+
+### scheduleReview(decisionId, reviewDate)
+Schedule a review for a decision.
+
+**Parameters:**
+- `decisionId` (number): Decision ID
+- `reviewDate` (string): ISO date string
+
+---
+
+## Evolution Module
+
+### recordSkillUsage(skillName, category, result)
+Record skill usage.
+
+**Parameters:**
+- `skillName` (string): Name of the skill
+- `category` (string): Skill category
+- `result` (string): 'success' | 'failure'
+
+### getTopSkills(limit = 10)
+Get most frequently used skills.
+
+**Parameters:**
+- `limit` (number): Maximum results
+
+**Returns:** `Promise<Array>`
+
+### getSkillStats(skillName)
+Get statistics for a specific skill.
+
+**Parameters:**
+- `skillName` (string): Skill name
+
+**Returns:**
+```javascript
+{
+  skill_name: string,
+  category: string,
+  usage_count: number,
+  success_count: number,
+  success_rate: number,
+  last_used_at: string
+}
+```
+
+---
+
+## Dashboard
+
+### getDashboard()
+Get unified dashboard of all memory data.
+
+**Returns:**
+```javascript
+{
+  summary: {
+    total_priorities: number,
+    total_learning: number,
+    total_decisions: number,
+    total_skills: number
+  },
+  recent: {
+    priorities: Array,
+    learning: Array,
+    decisions: Array
+  },
+  stats: {
+    priorities: Object,
+    learning: Object,
+    skills: Array
+  }
+}
+```
+
+---
+
+## Version Management
+
+### createBackup(label)
+Create a database backup.
+
+**Parameters:**
+- `label` (string): Optional label for the backup
+
+**Returns:** `Promise<{backupPath: string}>`
+
+### listBackups()
+List all available backups.
+
+**Returns:** `Promise<Array>`
+
+### restoreBackup(backupPath)
+Restore from a backup.
+
+**Parameters:**
+- `backupPath` (string): Path to backup file
+
+**Returns:** `Promise<boolean>`
+
+### cleanupBackups(keepCount = 10)
+Clean up old backups, keeping only the specified number.
+
+**Parameters:**
+- `keepCount` (number): Number of backups to keep
+
+---
+
+## Database Views
+
+The following SQL views are available for direct queries:
+
+### v_pending_decisions
+Decisions that need attention (pending, overdue, or due soon).
+
+### v_skill_summary
+Skill usage statistics with success rates.
+
+### v_weekly_learning_report
+Learning activity summary for the past week.
+
+### v_high_priority
+Combined view of high priority items and pending decisions.
+
+---
+
+## Error Handling
+
+All API methods return Promises and may throw:
+
+```javascript
+try {
+  const result = await api.storePriority(msgId, convId, analysis);
+} catch (err) {
+  console.error('API Error:', err.message);
+}
+```
+
+Common errors:
+- Database not initialized
+- Invalid parameters
+- Constraint violations
+- File system errors (backups)
+
+---
+
+## Examples
+
+### Complete Workflow
+
+```javascript
+const MemoryAPI = require('./api');
+const api = new MemoryAPI('./memory-v2.db');
+
+async function example() {
+  await api.init();
+  
+  // Record a decision
+  const decision = await api.recordDecision('msg-123', 'conv-456', {
+    summary: 'Use SQLite for local storage',
+    context: 'Need embedded database for skill',
+    expectedOutcome: 'Simpler deployment'
+  });
+  
+  // Start learning
+  const learning = await api.startLearning('msg-124', 'conv-456', 
+    'Learning SQLite advanced features'
+  );
+  
+  // Update progress
+  await api.updateLearningProgress(learning.id, { progress: 50 });
+  
+  // Record skill usage
+  await api.recordSkillUsage('memory-v2', 'storage', 'success');
+  
+  // Get dashboard
+  const dashboard = await api.getDashboard();
+  console.log(dashboard);
+  
+  await api.close();
+}
+
+example();
+```
+
+---
+
+## License
+
+MIT

package/NPM-PUBLISH-GUIDE.md

@@ -1,169 +0,0 @@
-# Memory V2 Skill - NPM 发布指南
-
-> 将 Memory V2 发布为 npm 包，供 ClawHub Skill 使用
-
----
-
-## 📋 发现：ClawHub Skill 格式
-
-**ClawHub 上的 Skill 只有 SKILL.md**，代码通过 npm 安装。
-
-### 标准结构
-
-```
-clawhub-skill/
-└── SKILL.md          # 只有描述文件
-```
-
-### npm 包结构
-
-```
-memory-v2/            # npm 包
-├── package.json
-├── README.md
-├── LICENSE
-├── api/
-│   └── index.js      # 主入口
-├── modules/          # 核心模块
-└── ...
-```
-
----
-
-## 🚀 发布流程
-
-### 步骤 1: 准备 npm 包
-
-```bash
-cd memory-v2-skill
-
-# 1. 确保 package.json 正确
-# 2. 更新版本号
-npm version 2.0.0
-
-# 3. 创建 .npmignore
-echo "tests/" > .npmignore
-echo "backups/" >> .npmignore
-echo "*.db" >> .npmignore
-
-# 4. 发布到 npm
-npm publish
-```
-
-### 步骤 2: 创建 ClawHub Skill
-
-创建 `clawhub-memory-v2/` 目录，只包含 SKILL.md：
-
-```yaml
----
-name: memory-v2
-description: |
-  Advanced memory system for OpenClaw agents with priority analysis, 
-  learning tracking, decision recording, and skill evolution.
-  Use when: (1) Tracking learning progress and milestones, (2) Recording decisions with outcomes, 
-  (3) Analyzing message priorities, (4) Monitoring skill usage and growth.
-  Requires: npm install memory-v2-skill
----
-
-# Memory V2
-
-## Installation
-
-```bash
-npm install memory-v2-skill
-```
-
-## Usage
-
-```javascript
-const MemoryAPI = require('memory-v2-skill');
-
-const api = new MemoryAPI('./memory-v2.db');
-await api.init();
-
-// Track learning
-await api.startLearning(msgId, convId, message);
-
-// Record decision
-await api.recordDecision(msgId, convId, decisionData);
-
-// Get dashboard
-const dashboard = await api.getDashboard();
-```
-
-## API
-
-See: https://github.com/YOUR_USERNAME/memory-v2-skill#api
-```
-
-### 步骤 3: 打包并提交
-
-```bash
-# 打包 ClawHub Skill
-cd clawhub-memory-v2
-zip ../memory-v2.skill SKILL.md
-
-# 提交到 ClawHub
-# 上传 memory-v2.skill 文件
-```
-
----
-
-## 📦 两种发布方式对比
-
-| 方式 | 适用场景 | 复杂度 |
-|------|---------|--------|
-| **npm + ClawHub** | 正式发布，用户易安装 | 高 |
-| **GitHub 直接安装** | 快速分享，开发者使用 | 低 |
-
----
-
-## 🎯 推荐方案：GitHub 直接安装
-
-对于 Memory V2，推荐直接 GitHub 安装：
-
-### 用户使用
-
-```bash
-# 克隆到 skills 目录
-cd ~/.openclaw/skills
-git clone https://github.com/YOUR_USERNAME/memory-v2-skill.git memory-v2
-
-# 安装依赖
-cd memory-v2
-npm install
-
-# 使用
-const MemoryAPI = require('memory-v2');
-```
-
-### 优点
-- 无需 npm 账号
-- 无需打包
-- 用户可直接修改
-- 适合自用和分享
-
----
-
-## ✅ 当前状态
-
-您的 `memory-v2-skill/` 已经可以直接使用：
-
-```bash
-# 本地测试
-cd memory-v2-skill
-npm install
-node -e "const M = require('./api'); console.log('OK')"
-
-# 打包 (zip 格式)
-zip -r memory-v2.skill . -x "*.db" "node_modules/*"
-```
-
-**用户安装后可以直接使用！**
-
----
-
-## 📚 参考
-
-- npm 发布: https://docs.npmjs.com/packages-and-modules/contributing-packages-to-the-registry
-- ClawHub: https://clawhub.com

package/PUBLISH-STEPS.md

@@ -1,102 +0,0 @@
-# Memory Lucia 发布步骤
-
-## 🚀 一键发布
-
-在 `memory-v2-skill` 目录下执行：
-
-### Windows
-```bash
-publish.bat
-```
-
-### Linux/Mac
-```bash
-bash publish.sh
-```
-
----
-
-## 📋 手动发布步骤
-
-### 步骤 1: 进入目录
-```bash
-cd C:\Users\snowya\.openclaw\workspace-chief_of_staff\memory-v2-skill
-```
-
-### 步骤 2: 登录 npm
-```bash
-npm login --auth-type=legacy
-```
-
-**输入信息：**
-- Username: `712724810@qq.com`
-- Password: `Q6Ymk#x_4dqM#T@`
-- Email: `712724810@qq.com`
-- Enter one-time password: (如果开启 2FA，输入验证码)
-
-### 步骤 3: 发布
-```bash
-npm publish --access=public
-```
-
----
-
-## ✅ 验证发布
-
-发布成功后，访问：
-https://www.npmjs.com/package/memory-lucia
-
----
-
-## 📦 用户使用
-
-发布后，用户可以直接安装：
-
-```bash
-npm install memory-lucia
-```
-
-```javascript
-const MemoryAPI = require('memory-lucia');
-const api = new MemoryAPI('./memory.db');
-await api.init();
-```
-
----
-
-## 🔧 如果发布失败
-
-### 错误 1: 包名已存在
-```bash
-# 修改 package.json 中的 name
-# 或者使用 scoped name: @yourname/memory-lucia
-```
-
-### 错误 2: 未登录
-```bash
-npm login --auth-type=legacy
-# 重新登录
-```
-
-### 错误 3: 版本已存在
-```bash
-# 更新版本号
-npm version patch  # 2.0.0 -> 2.0.1
-npm publish
-```
-
----
-
-## 📊 发布信息
-
-| 属性 | 值 |
-|------|-----|
-| 包名 | `memory-lucia` |
-| 版本 | `2.0.0` |
-| 大小 | 14.4 KB |
-| 主入口 | `api/index.js` |
-| 依赖 | `sqlite3` |
-
----
-
-**执行 `publish.bat` 或 `publish.sh` 即可发布！**

package/publish-with-otp.bat

@@ -1,13 +0,0 @@
-@echo off
-echo 🚀 Publishing memory-lucia to npm...
-echo.
-echo This package requires 2FA authentication.
-echo.
-echo Please enter your 6-digit 2FA code from your Authenticator app:
-set /p OTP="2FA Code: "
-echo.
-echo Publishing with OTP: %OTP%
-npm publish --access=public --otp=%OTP%
-echo.
-echo ✅ Done!
-pause

package/publish.bat

@@ -1,17 +0,0 @@
-@echo off
-echo 🚀 Publishing memory-lucia to npm...
-echo.
-
-echo Logging in to npm...
-npm login --auth-type=legacy
-
-echo.
-echo Publishing package...
-npm publish --access=public
-
-echo.
-echo ✅ Published!
-echo.
-echo Users can now install with:
-echo   npm install memory-lucia
-pause

package/publish.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-# Memory Lucia Publish Script
-
-echo "🚀 Publishing memory-lucia to npm..."
-echo ""
-
-# Login
-echo "Logging in to npm..."
-npm login --auth-type=legacy
-
-# Publish
-echo ""
-echo "Publishing package..."
-npm publish --access=public
-
-echo ""
-echo "✅ Published!"
-echo ""
-echo "Users can now install with:"
-echo "  npm install memory-lucia"