@game_ryo/lsji 1.2.0 → 1.2.1

package/AGENTS.md

@@ -4,7 +4,7 @@
 
 **LSJI** (Learning System for JavaScript Intelligence) is a general-purpose Reinforcement Learning agent framework for Node.js. It provides a clean abstraction for building RL agents with pluggable storage backends, environments, and learning algorithms.
 
-Originally migrated from a Cloudflare Workers implementation (Rock-Paper-Scissors AI), now redesigned as a standalone npm package with Apache 2.0 license, targeting Apache Incubator entry.
+Originally migrated from a Cloudflare Workers implementation (Rock-Paper-Scissors AI), now redesigned as a standalone npm package with MIT license, targeting MIT licensed.
 
 ## Architecture
 
@@ -19,6 +19,23 @@ src/
 │   ├── sqlite.js       # node:sqlite implementation (Node 22+)
 │   ├── better-sqlite.js # better-sqlite3 implementation
 │   └── memory.js       # In-memory implementation
+├── execution/          # Production execution systems
+│   ├── budget/         # TokenCounter, CostTracker, CircuitBreaker
+│   ├── hitl/           # ApprovalGate, ApprovalStore, Notifier
+│   ├── idempotency.js  # Duplicate prevention
+│   └── engine.js       # Durable execution with checkpoints
+├── llm/                # LLM Agent Framework
+│   ├── providers/      # OpenAI, Anthropic, Gemini, Local (Ollama)
+│   ├── llm-agent.js    # ReAct agent with tools & memory
+│   ├── tools/          # Built-in tools (web_search, file_read, file_write, code_exec, api_call, send_email, db_query)
+│   ├── memory/         # Conversation, Semantic, Episodic
+│   ├── plugins/        # Dynamic plugin system
+│   └── prompt-manager.js
+├── server/             # Runtime server + Web UI
+│   ├── index.js        # Express + Socket.io
+│   └── ui/             # React + Vite control panel
+├── envs/
+│   └── rps.js          # Rock-Paper-Scissors environment
 ├── cli.js              # Command-line interface
 └── index.js            # Public API exports
 ```
@@ -59,9 +76,9 @@ Pluggable backends:
 
 ## Usage
 
-### As Library
+### As Library (RL)
 ```javascript
-import { Agent, QLearning, createStorage, Env } from 'lsji';
+import { Agent, QLearning, createStorage, Env } from '@game_ryo/lsji';
 
 // Create custom environment
 class MyEnv extends Env {
@@ -77,23 +94,60 @@ await agent.train({ episodes: 1000 });
 const result = await agent.play(userAction);
 ```
 
+### As Library (LLM Agent)
+```javascript
+import { createLLMAgent, startServer } from '@game_ryo/lsji';
+
+// Create an agent with full production features
+const agent = await createLLMAgent({
+  llm: { provider: 'gemini', model: 'gemini-1.5-flash', apiKey: process.env.GEMINI_API_KEY },
+  budget: { maxCostPerRun: 5, maxCostPerDay: 50 },
+  hitl: { enabled: true, defaultTimeout: 300000 }, // 5 min approval timeout
+  memory: { conversation: true, episodic: true, semantic: true },
+  storage: { type: 'sqlite', options: { path: './lsji.db' } },
+});
+
+const result = await agent.run("Research TypeScript best practices and create a summary");
+console.log(result.answer);
+
+// Or start the full runtime server
+const server = await startServer({ port: 3456 });
+// Visit http://localhost:3456 for the web control panel
+```
+
 ### CLI
 ```bash
 # Install globally or use npx
 npm link  # for local development
 
-# Train
-lsji train --episodes 500 --pattern 0
-
-# Play
-lsji play --hand 0  # 0=Rock, 1=Scissors, 2=Paper
-
-# Status
-lsji status --json
-
-# Control
-lsji start
-lsji stop
+# RL Commands
+npx @game_ryo/lsji train --episodes 500 --pattern 0
+npx @game_ryo/lsji play --hand 0  # 0=Rock, 1=Scissors, 2=Paper
+npx @game_ryo/lsji status --json
+npx @game_ryo/lsji start
+npx @game_ryo/lsji stop
+
+# LLM Agent Commands
+npx @game_ryo/lsji agent run --task "Search for latest AI news and summarize" --provider gemini --model gemini-1.5-flash
+npx @game_ryo/lsji agent run-durable --task "Analyze codebase and create report" --workflow-id my-analysis
+npx @game_ryo/lsji agent status
+
+# Budget & Approvals
+npx @game_ryo/lsji budget status --budgetId my-project
+npx @game_ryo/lsji hitl list                       # Pending approvals
+npx @game_ryo/lsji hitl approve --id <id> --reason "Approved"
+
+# Durability
+npx @game_ryo/lsji checkpoint list
+npx @game_ryo/lsji checkpoint show --workflowId my-analysis
+npx @game_ryo/lsji checkpoint recover --workflowId my-analysis
+
+# Plugins
+npx @game_ryo/lsji plugin list
+npx @game_ryo/lsji plugin create --name my-tools
+
+# Server
+npx @game_ryo/lsji serve --port 3456
 ```
 
 ## Development
@@ -102,20 +156,20 @@ lsji stop
 ```bash
 npm test        # Run tests (vitest)
 npm run build   # No build step (ESM)
+npm run build:ui # Build web UI
+npm run serve   # Start runtime server
 ```
 
 ### Testing
-- Tests use `vitest` with `MemoryStorage` for isolation
-- Run `npm test` to verify all functionality
-
-## Key Design Decisions
+- Tests use `vitest` with `Memo## Key Design Decisions
 
 1. **ESM only** - Uses `"type": "module"` in package.json
 2. **Node 22+** - Requires Node 22 for built-in `node:sqlite`
-3. **Apache 2.0** - License compatible with Apache Incubator
+3. **MIT** - License compatible with open source
 4. **Single package** - All core functionality in one npm package
 5. **Storage abstraction** - Easy to swap backends
 6. **Worker.js compatibility** - Training patterns and reward logic match original
+7. **Production-grade** - HITL, durability, budget controls, idempotency built-in
 
 ## Common Tasks
 
@@ -129,6 +183,11 @@ npm run build   # No build step (ESM)
 2. Implement all abstract methods
 3. Add to `createStorage` factory
 
+### Adding a New LLM Tool
+1. Create tool definition in `src/llm/tools/registry.js` or plugin
+2. Implement `execute` function
+3. Add to tool registry
+
 ### Modifying Learning Algorithm
 - Extend `QLearning` class or create new algorithm in `src/core/`
 
@@ -140,4 +199,14 @@ npm run build   # No build step (ESM)
 
 ## License
 
-Apache 2.0 - see LICENSE file
+MIT - see LICENSE file
+
+## Git Workflow
+
+- Commit messages in English
+- Format: `<type>: <subject>` (e.g., `feat: add new environment base class`)
+- Types: feat, fix, docs, refactor, test, chore
+
+## License
+
+MIT - see LICENSE file

package/README.md

@@ -25,14 +25,14 @@
 
 ```bash
 # Install
-npm install lsji
+npm install @game_ryo/lsji
 
 # Set your API key (Gemini, OpenAI, or Anthropic)
 export GEMINI_API_KEY="your-gemini-key"
 # or: export OPENAI_API_KEY="your-openai-key"
 
 # Start the runtime server with web UI
-npx lsji serve
+npx @game_ryo/npx @game_ryo/lsji serve
 
 # Open http://localhost:3456 — create runs, watch thought logs, approve actions
 ```
@@ -41,25 +41,25 @@ npx lsji serve
 
 ```bash
 # Runtime server with control panel
-lsji serve --port 3456              # Start server + UI
-lsji serve --no-ui                  # Headless mode
+npx @game_ryo/lsji serve --port 3456              # Start server + UI
+npx @game_ryo/lsji serve --no-ui                  # Headless mode
 
 # Agent operations
-lsji agent run --task "Write a report on AI trends" --provider gemini --model gemini-1.5-flash
-lsji agent run-durable --task "Analyze codebase" --workflow-id my-analysis
+npx @game_ryo/lsji agent run --task "Write a report on AI trends" --provider gemini --model gemini-1.5-flash
+npx @game_ryo/lsji agent run-durable --task "Analyze codebase" --workflow-id my-analysis
 
 # Budget & approvals
-lsji budget status --budgetId my-project
-lsji hitl list                       # Pending approvals
-lsji hitl approve --id <id> --reason "Approved"
+npx @game_ryo/lsji budget status --budgetId my-project
+npx @game_ryo/lsji hitl list                       # Pending approvals
+npx @game_ryo/lsji hitl approve --id <id> --reason "Approved"
 
 # Plugins
-lsji plugin list
-lsji plugin create --name my-tools   # Generate template
+npx @game_ryo/lsji plugin list
+npx @game_ryo/lsji plugin create --name my-tools   # Generate template
 
 # RL (legacy)
-lsji train --episodes 500
-lsji play --hand 0
+npx @game_ryo/lsji train --episodes 500
+npx @game_ryo/lsji play --hand 0
 ```
 
 ## Programmatic Usage
@@ -85,7 +85,7 @@ const server = await startServer({ port: 3456 });
 
 ## Web Control Panel
 
-When you run `lsji serve`, you get a real-time dashboard at **http://localhost:3456**:
+When you run `npx @game_ryo/lsji serve`, you get a real-time dashboard at **http://localhost:3456**:
 
 | Panel | Features |
 |-------|----------|
@@ -117,7 +117,7 @@ export default {
 ```
 
 ```bash
-lsji plugin list  # Shows: my-tools (1 tools)
+npx @game_ryo/lsji plugin list  # Shows: my-tools (1 tools)
 ```
 
 ## Architecture

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@game_ryo/lsji",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "A general-purpose reinforcement learning agent framework (Node.js) with LLM agent capabilities",
   "license": "MIT",
   "type": "module",
@@ -23,6 +23,7 @@
     "vitest": "^2.0.0"
   },
   "dependencies": {
+    "better-sqlite3": "^13.0.3",
     "cors": "^2.8.5",
     "express": "^4.19.2",
     "openai": "^7.8.0",
@@ -32,4 +33,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/cli.js

@@ -215,6 +215,7 @@ export async function main() {
             
             console.log(`Running agent on task: ${task}`);
             
+            const storageConfig = { type: storageType, options: { path: dbPath } };
             const agent = await createLLMAgent({
               llm: {
                 provider: options.provider || 'openai',
@@ -234,6 +235,7 @@ export async function main() {
                 semantic: options.semantic === 'true',
                 episodic: options.episodic !== 'false',
               },
+              storage: storageConfig,
             });
             
             const result = await agent.run(task, {
@@ -257,6 +259,7 @@ export async function main() {
             
             console.log(`Running durable agent on task: ${task}`);
             
+            const storageConfig = { type: storageType, options: { path: dbPath } };
             const agent = await createLLMAgent({
               llm: {
                 provider: options.provider || 'openai',
@@ -266,6 +269,7 @@ export async function main() {
               execution: {
                 checkpointInterval: parseInt(options.checkpointInterval) || 3,
               },
+              storage: storageConfig,
             });
             
             const result = await agent.runDurable(task, {
@@ -280,13 +284,16 @@ export async function main() {
           }
           
           case 'status': {
-            const agent = await createLLMAgent({
-              llm: { provider: 'openai', model: 'gpt-4o-mini' },
+            const storageConfig = { type: storageType, options: { path: dbPath } };
+            // Create agent without initializing LLM for status check
+            const { LLMAgent } = await import('./llm/llm-agent.js');
+            const agent = new LLMAgent({
+              llm: { provider: 'local', model: 'test', baseUrl: 'http://localhost:11434/v1' },
+              storage: storageConfig,
             });
-            
+            // Don't initialize - just get status
             const status = agent.getStatus();
             output(status, jsonOutput);
-            await agent.shutdown();
             break;
           }
           

package/src/execution/hitl/approval-gate.js

@@ -199,7 +199,9 @@ export class ApprovalGate {
  * Create approval gate from config
  */
 export async function createApprovalGate(config = {}) {
-  const store = await createApprovalStore(config.store || {});
+  // Support both config.store and config.storage for storage configuration
+  const storageConfig = config.storage || config.store || { type: 'sqlite', options: {} };
+  const store = await createApprovalStore(storageConfig);
   const notifier = new Notifier(config.notifier || {});
   
   return new ApprovalGate({

package/src/execution/idempotency.js

@@ -323,9 +323,11 @@ export class IdempotencyStore {
  * Create idempotency store from config
  */
 export async function createIdempotencyStore(config = {}) {
+  // Support both config.storage and config.type/config.options for storage configuration
+  const storageConfig = config.storage || { type: config.type || 'sqlite', options: config.options || {} };
   const storage = await createStorage(
-    config.type || 'sqlite',
-    config.options || {}
+    storageConfig.type || 'sqlite',
+    storageConfig.options || {}
   );
   const store = new IdempotencyStore(storage, { ttl: config.ttl });
   await store.initialize();

package/src/index.js

@@ -96,4 +96,4 @@ export {
 } from './llm/plugins/index.js';
 
 // Version
-export const VERSION = '0.3.0';
+export const VERSION = '1.2.1';

package/src/llm/llm-agent.js

@@ -14,7 +14,7 @@ import { createPromptManager } from './prompt-manager.js';
 import { createExecutionEngine } from '../execution/engine.js';
 import { createApprovalGate } from '../execution/hitl/approval-gate.js';
 import { createBudgetController } from '../execution/budget/index.js';
-import { IdempotencyStore } from '../execution/idempotency.js';
+import { createIdempotencyStore } from '../execution/idempotency.js';
 import { v4 as uuidv4 } from 'uuid';
 
 /**
@@ -27,6 +27,8 @@ import { v4 as uuidv4 } from 'uuid';
  * @property {Object} [hitl] - HITL approval config
  * @property {Object} [budget] - Budget control config
  * @property {Object} [idempotency] - Idempotency config
+ * @property {Object} [prompts] - Prompt manager config
+ * @property {string} [sessionId] - Session ID for conversation memory
  */
 
 /**
@@ -61,6 +63,9 @@ export class LLMAgent {
       throw new Error(`LLM validation failed: ${valid.error}`);
     }
     
+    // Get storage config
+    const storageConfig = this.config.storage || { type: 'sqlite', options: {} };
+    
     // Initialize tool registry
     this.tools = createToolRegistry({
       idempotencyStore: this.idempotency,
@@ -69,24 +74,39 @@ export class LLMAgent {
     
     // Initialize memory systems
     if (this.config.memory?.conversation !== false) {
-      this.memory.conversation = await createConversationMemory(this.config.memory?.conversation);
+      this.memory.conversation = await createConversationMemory({
+        ...this.config.memory?.conversation,
+        storage: storageConfig
+      });
       await this.memory.conversation.startSession(this.config.sessionId);
     }
     
     if (this.config.memory?.semantic) {
-      this.memory.semantic = await createSemanticMemory(this.config.memory.semantic);
+      this.memory.semantic = await createSemanticMemory({
+        ...this.config.memory.semantic,
+        storage: storageConfig
+      });
     }
     
     if (this.config.memory?.episodic) {
-      this.memory.episodic = await createEpisodicMemory(this.config.memory.episodic);
+      this.memory.episodic = await createEpisodicMemory({
+        ...this.config.memory.episodic,
+        storage: storageConfig
+      });
     }
     
     // Initialize execution engine
-    this.execution = await createExecutionEngine(this.config.execution);
+    this.execution = await createExecutionEngine({
+      ...this.config.execution,
+      storage: storageConfig
+    });
     
     // Initialize HITL
     if (this.config.hitl?.enabled !== false) {
-      this.hitl = await createApprovalGate(this.config.hitl);
+      this.hitl = await createApprovalGate({
+        ...this.config.hitl,
+        store: storageConfig
+      });
       // Update tool registry with HITL
       this.tools.approvalGate = this.hitl;
     }
@@ -95,7 +115,10 @@ export class LLMAgent {
     this.budget = createBudgetController(this.config.budget);
     
     // Initialize idempotency
-    this.idempotency = await IdempotencyStore.create(this.config.idempotency);
+    this.idempotency = await createIdempotencyStore({
+      ...this.config.idempotency,
+      ...storageConfig
+    });
     this.tools.idempotencyStore = this.idempotency;
     
     // Initialize prompt manager

package/src/llm/memory/conversation.js

@@ -37,8 +37,9 @@ export class ConversationMemory {
   async initialize() {
     if (this.initialized) return;
     
-    if (this.storage.db) {
-      await this.storage.db.exec(`
+    // Use the new storage interface method
+    if (typeof this.storage.exec === 'function') {
+      await this.storage.exec(`
         CREATE TABLE IF NOT EXISTS conversations (
           id TEXT PRIMARY KEY,
           session_id TEXT NOT NULL,
@@ -52,11 +53,11 @@ export class ConversationMemory {
         )
       `);
       
-      await this.storage.db.exec(`
+      await this.storage.exec(`
         CREATE INDEX IF NOT EXISTS idx_conversations_session ON conversations(session_id)
       `);
       
-      await this.storage.db.exec(`
+      await this.storage.exec(`
         CREATE INDEX IF NOT EXISTS idx_conversations_created ON conversations(created_at)
       `);
     }
@@ -86,8 +87,8 @@ export class ConversationMemory {
   async loadSession(sessionId) {
     await this.initialize();
     
-    if (this.storage.db) {
-      const rows = await this.storage.db.all(
+    if (typeof this.storage.all === 'function') {
+      const rows = await this.storage.all(
         'SELECT * FROM conversations WHERE session_id = ? ORDER BY created_at ASC',
         [sessionId]
       );
@@ -123,12 +124,12 @@ export class ConversationMemory {
     this.messages.push(msg);
     
     // Persist to storage
-    if (this.storage.db && this.sessionId) {
+    if (typeof this.storage.run === 'function' && this.sessionId) {
       const tokens = this.tokenCounter 
         ? await this.tokenCounter.estimateTokens([msg], { provider: 'openai', model: 'gpt-4o-mini' })
         : 0;
       
-      await this.storage.db.run(
+      await this.storage.run(
         `INSERT INTO conversations (id, session_id, role, content, name, tool_call_id, tool_calls, tokens, created_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         [
@@ -229,8 +230,8 @@ export class ConversationMemory {
   async clear() {
     this.messages = [];
     
-    if (this.storage.db && this.sessionId) {
-      await this.storage.db.run(
+    if (typeof this.storage.run === 'function' && this.sessionId) {
+      await this.storage.run(
         'DELETE FROM conversations WHERE session_id = ?',
         [this.sessionId]
       );

package/src/llm/prompt-manager.js

@@ -34,8 +34,9 @@ export class PromptManager {
   async initialize() {
     if (this.initialized) return;
     
-    if (this.storage.db) {
-      await this.storage.db.exec(`
+    // Use the new storage interface
+    if (typeof this.storage.exec === 'function') {
+      await this.storage.exec(`
         CREATE TABLE IF NOT EXISTS prompts (
           name TEXT NOT NULL,
           version TEXT NOT NULL,
@@ -78,8 +79,8 @@ export class PromptManager {
     this.templates.get(name).set(version, prompt);
     
     // Persist
-    if (this.storage.db) {
-      await this.storage.db.run(
+    if (typeof this.storage.run === 'function') {
+      await this.storage.run(
         `INSERT OR REPLACE INTO prompts (name, version, template, variables, description, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?, ?)`,
         [name, version, template, JSON.stringify(extractedVars), description, prompt.createdAt, prompt.updatedAt]
@@ -102,18 +103,14 @@ export class PromptManager {
       return versions.get(version) || null;
     }
     
-    // Get latest version
-    const sortedVersions = Array.from(versions.keys()).sort((a, b) => {
-      const parseVersion = v => v.split('.').map(Number);
-      const va = parseVersion(a);
-      const vb = parseVersion(b);
-      for (let i = 0; i < 3; i++) {
-        if (va[i] !== vb[i]) return vb[i] - va[i];
+    // Return latest version (highest semver)
+    let latest = null;
+    for (const [ver, prompt] of versions) {
+      if (!latest || this.compareVersions(ver, latest) > 0) {
+        latest = ver;
       }
-      return 0;
-    });
-    
-    return versions.get(sortedVersions[0]) || null;
+    }
+    return versions.get(latest);
   }
 
   /**
@@ -123,110 +120,79 @@ export class PromptManager {
     await this.initialize();
     const versions = this.templates.get(name);
     if (!versions) return [];
-    return Array.from(versions.values()).sort((a, b) => 
-      new Date(b.createdAt) - new Date(a.createdAt)
-    );
+    return Array.from(versions.values());
   }
 
   /**
-   * Render a prompt with variables
+   * Render a template with variables
    */
-  async render(name, variables, version = null) {
+  async render(name, variables = {}, version = null) {
     const prompt = await this.get(name, version);
     if (!prompt) {
       throw new Error(`Prompt not found: ${name}${version ? `@${version}` : ''}`);
     }
     
-    // Check required variables
-    for (const v of prompt.variables) {
-      if (!(v in variables)) {
-        throw new Error(`Missing required variable: ${v}`);
-      }
-    }
-    
-    // Substitute variables
     let rendered = prompt.template;
     for (const [key, value] of Object.entries(variables)) {
-      const placeholder = `{{${key}}}`;
-      rendered = rendered.replaceAll(placeholder, String(value));
+      rendered = rendered.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
     }
     
-    return rendered;
-  }
-
-  /**
-   * Render multiple prompts (for system + user messages)
-   */
-  async renderAll(prompts, variables) {
-    const results = [];
-    for (const { name, version, role = 'user' } of prompts) {
-      const content = await this.render(name, variables, version);
-      results.push({ role, content });
+    // Check for missing variables
+    const missingVars = prompt.variables.filter(v => !(v in variables));
+    if (missingVars.length > 0) {
+      console.warn(`Missing variables for prompt ${name}: ${missingVars.join(', ')}`);
     }
-    return results;
+    
+    return rendered;
   }
 
   /**
    * Extract variables from template
    */
   extractVariables(template) {
-    const matches = template.match(/{{(\w+)}}/g);
+    const matches = template.match(/\{\{(\w+)\}\}/g);
     if (!matches) return [];
     return [...new Set(matches.map(m => m.slice(2, -2)))];
   }
 
   /**
-   * List all prompt names
+   * Compare semantic versions
    */
-  async list() {
-    await this.initialize();
-    return Array.from(this.templates.keys());
-  }
-
-  /**
-   * Delete a prompt version
-   */
-  async delete(name, version) {
-    await this.initialize();
-    
-    const versions = this.templates.get(name);
-    if (!versions || !versions.has(version)) {
-      return false;
-    }
-    
-    versions.delete(version);
-    
-    if (this.storage.db) {
-      await this.storage.db.run(
-        'DELETE FROM prompts WHERE name = ? AND version = ?',
-        [name, version]
-      );
-    }
-    
-    return true;
+  compareVersions(a, b) {
+    const parse = v => v.split('.').map(Number);
+    const [aMajor, aMinor, aPatch] = parse(a);
+    const [bMajor, bMinor, bPatch] = parse(b);
+    if (aMajor !== bMajor) return aMajor - bMajor;
+    if (aMinor !== bMinor) return aMinor - bMinor;
+    return aPatch - bPatch;
   }
 
   /**
    * Load all prompts from storage
    */
-  async loadAll() {
+  async loadFromStorage() {
     await this.initialize();
     
-    if (this.storage.db) {
-      const rows = await this.storage.db.all('SELECT * FROM prompts');
+    if (typeof this.storage.all === 'function') {
+      const rows = await this.storage.all(
+        'SELECT * FROM prompts ORDER BY name, version'
+      );
+      
       for (const row of rows) {
-        if (!this.templates.has(row.name)) {
-          this.templates.set(row.name, new Map());
-        }
-        this.templates.get(row.name).set(row.version, {
+        const prompt = {
           name: row.name,
           version: row.version,
           template: row.template,
-          variables: JSON.parse(row.variables || '[]'),
+          variables: JSON.parse(row.variables),
           description: row.description,
           createdAt: row.created_at,
           updatedAt: row.updated_at,
-        });
+        };
+        
+        if (!this.templates.has(prompt.name)) {
+          this.templates.set(prompt.name, new Map());
+        }
+        this.templates.get(prompt.name).set(prompt.version, prompt);
       }
     }
   }
@@ -237,79 +203,31 @@ export class PromptManager {
  */
 export const BUILTIN_PROMPTS = {
   'system:react': {
-    template: `You are an AI assistant that uses the ReAct pattern (Reasoning + Acting) to solve tasks.
+    name: 'system:react',
+    version: '1.0.0',
+    template: `You are an AI assistant that uses the ReAct (Reasoning + Acting) pattern.
 
 You have access to the following tools:
 {{tools}}
 
-When you need to use a tool, respond with:
+Your task is: {{task}}
+
+Use the following format:
+
 THOUGHT: Your reasoning about what to do next
-ACTION: The tool name to use
+ACTION: The tool to use (must be one of the available tools)
 ACTION_INPUT: The parameters for the tool
 
-After the tool returns, you'll see:
-OBSERVATION: The result
-
-Continue this pattern until you can provide the final answer.
+When you have the final answer, respond directly without THOUGHT/ACTION format.
 
-Current task: {{task}}`,
+Begin!`,
     variables: ['tools', 'task'],
-    description: 'ReAct system prompt with tool definitions',
-  },
-  
-  'system:planner': {
-    template: `You are a planning agent. Break down the task into a sequence of steps.
-
-Task: {{task}}
-
-Available tools: {{tools}}
-
-Create a plan with numbered steps. Each step should specify:
-1. What tool to use (if any)
-2. What parameters to pass
-3. What you expect to learn or achieve
-
-Output as JSON:
-{
-  "steps": [
-    {"step": 1, "tool": "tool_name", "params": {}, "description": "..."}
-  ]
-}`,
-    variables: ['task', 'tools'],
-    description: 'Planning agent prompt',
-  },
-  
-  'system:code-reviewer': {
-    template: `You are an expert code reviewer. Analyze the provided code for:
-- Bugs and logic errors
-- Security vulnerabilities
-- Performance issues
-- Code style and best practices
-- Test coverage gaps
-
-Code to review:
-{{code}}
-
-Context: {{context}}
-
-Provide your review in this format:
-## Summary
-Brief overall assessment
-
-## Issues Found
-- [Severity] File:Line - Description
-
-## Suggestions
-- Improvement suggestions
-
-## Approved: true/false`,
-    variables: ['code', 'context'],
-    description: 'Code review prompt',
+    description: 'System prompt for ReAct agent',
   },
 };
 
 /**
- * Create prompt manager with built-in templates
+ * Create prompt manager from config
  */
 export async function createPromptManager(config = {}) {
   const storage = await createStorage(
@@ -323,6 +241,7 @@ export async function createPromptManager(config = {}) {
   // Register built-in prompts
   for (const [name, prompt] of Object.entries(BUILTIN_PROMPTS)) {
     await manager.register(name, prompt.template, {
+      version: prompt.version,
       variables: prompt.variables,
       description: prompt.description,
     });

package/src/server/index.js

@@ -280,7 +280,7 @@ export function createApp(config = {}) {
     connectedClients.add(socket.id);
     console.log(`Client connected: ${socket.id} (total: ${connectedClients.size})`);
 
-    // Send current state - use Promise.all for async operations
+    // Send current state
     Promise.all(
       Array.from(activeRuns.entries()).map(async ([runId, run]) => {
         const approvals = await run.hitl.getPendingApprovals(50);
@@ -316,12 +316,7 @@ export function createApp(config = {}) {
     });
   });
 
-  // Broadcast helper
-  function broadcast(event, data) {
-    io.emit(event, data);
-  }
-
-  return { app, httpServer, io, broadcast, activeRuns };
+  return { app, httpServer, io, activeRuns };
 }
 
 /**
@@ -362,7 +357,7 @@ async function runAgent(runId, task, hitlGate, budgetCtrl, workflowId, io) {
     io.to(`run:${runId}`).emit('thought:new', run.thoughts[run.thoughts.length - 1]);
     
     io.to(`run:${runId}`).emit('run:completed', { runId, result });
-    broadcast('run:updated', { runId, status: run.status, result });
+    io.emit('run:updated', { runId, status: run.status, result });
     
   } catch (error) {
     run.status = 'error';
@@ -377,7 +372,7 @@ async function runAgent(runId, task, hitlGate, budgetCtrl, workflowId, io) {
     io.to(`run:${runId}`).emit('thought:new', run.thoughts[run.thoughts.length - 1]);
     
     io.to(`run:${runId}`).emit('run:error', { runId, error: error.message });
-    broadcast('run:updated', { runId, status: 'error', error: error.message });
+    io.emit('run:updated', { runId, status: 'error', error: error.message });
   }
 }
 
@@ -385,7 +380,7 @@ async function runAgent(runId, task, hitlGate, budgetCtrl, workflowId, io) {
  * Start the server
  */
 export async function startServer(config = {}) {
-  const { app, httpServer, io, broadcast, activeRuns: runs } = createApp(config);
+  const { app, httpServer, io, activeRuns: runs } = createApp(config);
   
   const port = config.port || process.env.LSJI_SERVER_PORT || 3456;
   const host = config.host || '0.0.0.0';
@@ -394,7 +389,7 @@ export async function startServer(config = {}) {
     httpServer.listen(port, host, () => {
       console.log(`LSJI Server running at http://${host}:${port}`);
       console.log(`WebSocket ready for connections`);
-      resolve({ app, httpServer, io, broadcast, activeRuns: runs, port, host });
+      resolve({ app, httpServer, io, activeRuns: runs, port, host });
     });
   });
 }

package/src/storage/better-sqlite.js

@@ -130,4 +130,35 @@ export class BetterSqliteStorage extends Storage {
     `);
     return stmt.all();
   }
+
+  // ===== Generic SQL methods =====
+
+  async all(sql, params = []) {
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
+  }
+
+  async get(sql, params = []) {
+    const stmt = this.db.prepare(sql);
+    return stmt.get(...params);
+  }
+
+  async run(sql, params = []) {
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...params);
+    return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
+  }
+
+  async exec(sql) {
+    this.db.exec(sql);
+  }
+
+  prepare(sql) {
+    const stmt = this.db.prepare(sql);
+    return {
+      run: (...params) => stmt.run(...params),
+      get: (...params) => stmt.get(...params),
+      all: (...params) => stmt.all(...params),
+    };
+  }
 }

package/src/storage/index.js

@@ -114,6 +114,56 @@ export class Storage {
   async getPerformanceStats() {
     throw new Error('getPerformanceStats() must be implemented');
   }
+
+  // ===== Generic SQL methods for custom queries =====
+
+  /**
+   * Execute a SELECT query returning all rows
+   * @param {string} sql - SQL query
+   * @param {Array} params - Query parameters
+   * @returns {Promise<Array<Object>>}
+   */
+  async all(sql, params = []) {
+    throw new Error('all() must be implemented');
+  }
+
+  /**
+   * Execute a SELECT query returning first row
+   * @param {string} sql - SQL query
+   * @param {Array} params - Query parameters
+   * @returns {Promise<Object|null>}
+   */
+  async get(sql, params = []) {
+    throw new Error('get() must be implemented');
+  }
+
+  /**
+   * Execute an INSERT/UPDATE/DELETE query
+   * @param {string} sql - SQL query
+   * @param {Array} params - Query parameters
+   * @returns {Promise<{changes: number, lastInsertRowid: number|bigint}>}
+   */
+  async run(sql, params = []) {
+    throw new Error('run() must be implemented');
+  }
+
+  /**
+   * Execute multiple SQL statements
+   * @param {string} sql - SQL statements
+   * @returns {Promise<void>}
+   */
+  async exec(sql) {
+    throw new Error('exec() must be implemented');
+  }
+
+  /**
+   * Prepare a statement for repeated execution
+   * @param {string} sql - SQL query
+   * @returns {Object} Prepared statement with run(), get(), all() methods
+   */
+  prepare(sql) {
+    throw new Error('prepare() must be implemented');
+  }
 }
 
 /**

package/src/storage/memory.js

@@ -17,6 +17,7 @@ export class MemoryStorage extends Storage {
     this.settings = new Map();
     this.battleHistory = [];
     this.qTable = new Map(); // key: "state:action" -> q_value
+    this.conversations = []; // For conversation memory
     this.initialized = false;
   }
 
@@ -93,6 +94,193 @@ export class MemoryStorage extends Storage {
     this.settings.clear();
     this.battleHistory = [];
     this.qTable.clear();
+    this.conversations = [];
     this.settings.set('is_active', '1');
   }
+
+  // ===== Generic SQL methods (in-memory implementation) =====
+
+  async all(sql, params = []) {
+    // Simple in-memory SQL-like query parser for basic SELECT queries
+    // This is a simplified implementation for testing
+    const lowerSql = sql.toLowerCase().trim();
+    
+    if (lowerSql.startsWith('select')) {
+      if (lowerSql.includes('from conversations')) {
+        let results = [...this.conversations];
+        
+        // Simple WHERE clause handling for session_id
+        const whereMatch = lowerSql.match(/where\s+session_id\s*=\s*\?/i);
+        if (whereMatch && params.length > 0) {
+          const sessionId = params[0];
+          results = results.filter(r => r.session_id === sessionId);
+        }
+        
+        // ORDER BY created_at ASC
+        results.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
+        
+        return results;
+      }
+      
+      if (lowerSql.includes('from idempotency_keys')) {
+        // For idempotency store
+        return [];
+      }
+      
+      if (lowerSql.includes('from checkpoints')) {
+        // For execution engine
+        return [];
+      }
+      
+      if (lowerSql.includes('from approvals')) {
+        // For HITL
+        return [];
+      }
+    }
+    
+    return [];
+  }
+
+  async get(sql, params = []) {
+    const results = await this.all(sql, params);
+    return results[0] || null;
+  }
+
+  async run(sql, params = []) {
+    const lowerSql = sql.toLowerCase().trim();
+    
+    if (lowerSql.startsWith('insert')) {
+      if (lowerSql.includes('into conversations')) {
+        // INSERT INTO conversations (id, session_id, role, content, name, tool_call_id, tool_calls, tokens, created_at)
+        const id = params[0];
+        const sessionId = params[1];
+        const role = params[2];
+        const content = params[3];
+        const name = params[4];
+        const toolCallId = params[5];
+        const toolCalls = params[6];
+        const tokens = params[7];
+        const createdAt = params[8];
+        
+        this.conversations.push({
+          id,
+          session_id: sessionId,
+          role,
+          content,
+          name,
+          tool_call_id: toolCallId,
+          tool_calls: toolCalls,
+          tokens,
+          created_at: createdAt,
+        });
+      }
+      
+      if (lowerSql.includes('into idempotency_keys')) {
+        // For idempotency store
+      }
+      
+      if (lowerSql.includes('into checkpoints')) {
+        // For execution engine
+      }
+      
+      if (lowerSql.includes('into approvals')) {
+        // For HITL
+      }
+      
+      if (lowerSql.includes('into settings')) {
+        // Handled by setSetting
+      }
+      
+      if (lowerSql.includes('into battle_history')) {
+        // Handled by addBattle
+      }
+      
+      if (lowerSql.includes('into q_table')) {
+        // Handled by updateQ
+      }
+      
+      return { changes: 1, lastInsertRowid: Date.now() };
+    }
+    
+    if (lowerSql.startsWith('update')) {
+      if (lowerSql.includes('idempotency_keys')) {
+        // For idempotency store
+      }
+      
+      if (lowerSql.includes('approvals')) {
+        // For HITL
+      }
+      
+      return { changes: 1, lastInsertRowid: 0 };
+    }
+    
+    if (lowerSql.startsWith('delete')) {
+      if (lowerSql.includes('from conversations')) {
+        if (params[0]) {
+          this.conversations = this.conversations.filter(c => c.session_id !== params[0]);
+        }
+      }
+      
+      if (lowerSql.includes('from idempotency_keys')) {
+        // For idempotency store
+      }
+      
+      return { changes: 1, lastInsertRowid: 0 };
+    }
+    
+    return { changes: 0, lastInsertRowid: 0 };
+  }
+
+  async exec(sql) {
+    // No-op for memory storage
+  }
+
+  prepare(sql) {
+    const self = this;
+    return {
+      run: async (...params) => (await self.run(sql, params)),
+      get: async (...params) => (await self.get(sql, params)),
+      all: async (...params) => (await self.all(sql, params)),
+    };
+  }
+
+  // Helper methods for conversation memory
+  _addConversation(message) {
+    this.conversations.push(message);
+  }
+
+  _getConversations(sessionId) {
+    return this.conversations.filter(c => c.session_id === sessionId);
+  }
+
+  _clearConversations(sessionId) {
+    this.conversations = this.conversations.filter(c => c.session_id !== sessionId);
+  }
+
+  // For idempotency store
+  _getIdempotencyKeys() {
+    return this.idempotencyKeys || new Map();
+  }
+
+  _setIdempotencyKeys(keys) {
+    this.idempotencyKeys = keys;
+  }
+
+  // For checkpoints
+  _getCheckpoints() {
+    return this.checkpoints || new Map();
+  }
+
+  _setCheckpoints(checkpoints) {
+    this.checkpoints = checkpoints;
+  }
+
+  // For approvals
+  _getApprovals() {
+    return this.approvals || new Map();
+  }
+
+  _setApprovals(approvals) {
+    this.approvals = approvals;
+  }
 }

package/src/storage/sqlite.js

@@ -120,4 +120,35 @@ export class SqliteStorage extends Storage {
     `);
     return stmt.all();
   }
+
+  // ===== Generic SQL methods =====
+
+  async all(sql, params = []) {
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
+  }
+
+  async get(sql, params = []) {
+    const stmt = this.db.prepare(sql);
+    return stmt.get(...params);
+  }
+
+  async run(sql, params = []) {
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...params);
+    return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
+  }
+
+  async exec(sql) {
+    this.db.exec(sql);
+  }
+
+  prepare(sql) {
+    const stmt = this.db.prepare(sql);
+    return {
+      run: (...params) => stmt.run(...params),
+      get: (...params) => stmt.get(...params),
+      all: (...params) => stmt.all(...params),
+    };
+  }
 }