@blackms/aistack 1.2.0 → 1.3.1

package/dist/memory/sqlite-store.js

@@ -26,6 +26,62 @@ CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory(namespace);
 CREATE INDEX IF NOT EXISTS idx_memory_key ON memory(key);
 CREATE INDEX IF NOT EXISTS idx_memory_updated ON memory(updated_at DESC);
 
+-- Tags table
+CREATE TABLE IF NOT EXISTS tags (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_tags_name ON tags(name);
+
+-- Memory-Tags junction table
+CREATE TABLE IF NOT EXISTS memory_tags (
+  memory_id TEXT NOT NULL,
+  tag_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (memory_id, tag_id),
+  FOREIGN KEY (memory_id) REFERENCES memory(id) ON DELETE CASCADE,
+  FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_tags_memory ON memory_tags(memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag_id);
+
+-- Memory relationships table
+CREATE TABLE IF NOT EXISTS memory_relationships (
+  id TEXT PRIMARY KEY,
+  from_id TEXT NOT NULL,
+  to_id TEXT NOT NULL,
+  relationship_type TEXT NOT NULL,
+  metadata TEXT,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (from_id) REFERENCES memory(id) ON DELETE CASCADE,
+  FOREIGN KEY (to_id) REFERENCES memory(id) ON DELETE CASCADE,
+  UNIQUE(from_id, to_id, relationship_type)
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_relationships_from ON memory_relationships(from_id);
+CREATE INDEX IF NOT EXISTS idx_memory_relationships_to ON memory_relationships(to_id);
+CREATE INDEX IF NOT EXISTS idx_memory_relationships_type ON memory_relationships(relationship_type);
+
+-- Memory versions table (for version history)
+CREATE TABLE IF NOT EXISTS memory_versions (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  key TEXT NOT NULL,
+  namespace TEXT NOT NULL,
+  content TEXT NOT NULL,
+  metadata TEXT,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES memory(id) ON DELETE CASCADE,
+  UNIQUE(memory_id, version)
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_versions_memory ON memory_versions(memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_versions_created ON memory_versions(created_at DESC);
+
 -- Full-text search table
 CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
   key, content, namespace,
@@ -142,6 +198,45 @@ CREATE TABLE IF NOT EXISTS specifications (
 
 CREATE INDEX IF NOT EXISTS idx_specifications_task ON specifications(project_task_id);
 CREATE INDEX IF NOT EXISTS idx_specifications_status ON specifications(status);
+
+-- Active Agents table for state persistence
+CREATE TABLE IF NOT EXISTS active_agents (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  name TEXT NOT NULL UNIQUE,
+  status TEXT NOT NULL,
+  session_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  metadata TEXT,
+  FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_active_agents_status ON active_agents(status);
+CREATE INDEX IF NOT EXISTS idx_active_agents_session ON active_agents(session_id);
+CREATE INDEX IF NOT EXISTS idx_active_agents_name ON active_agents(name);
+
+-- Review Loops table for state persistence
+CREATE TABLE IF NOT EXISTS review_loops (
+  id TEXT PRIMARY KEY,
+  coder_id TEXT NOT NULL,
+  adversarial_id TEXT NOT NULL,
+  session_id TEXT,
+  status TEXT NOT NULL,
+  iteration INTEGER DEFAULT 0,
+  max_iterations INTEGER DEFAULT 3,
+  code_input TEXT NOT NULL,
+  current_code TEXT,
+  reviews TEXT,
+  final_verdict TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  FOREIGN KEY (session_id) REFERENCES sessions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_review_loops_status ON review_loops(status);
+CREATE INDEX IF NOT EXISTS idx_review_loops_session ON review_loops(session_id);
 `;
 export class SQLiteStore {
     db;
@@ -173,6 +268,11 @@ export class SQLiteStore {
         const id = existing?.id ?? randomUUID();
         const metadataJson = options.metadata ? JSON.stringify(options.metadata) : null;
         if (existing) {
+            // Save current version before updating
+            const currentEntry = this.getById(id);
+            if (currentEntry) {
+                this.saveVersion(currentEntry);
+            }
             // Update existing entry
             this.db
                 .prepare(`
@@ -283,7 +383,335 @@ export class SQLiteStore {
             embedding: Array.from(new Float32Array(row.embedding.buffer)),
         }));
     }
+    // ==================== Tag Operations ====================
+    // Get tags for a specific memory entry
+    getEntryTags(entryId) {
+        const rows = this.db
+            .prepare(`
+        SELECT t.name
+        FROM tags t
+        INNER JOIN memory_tags mt ON t.id = mt.tag_id
+        WHERE mt.memory_id = ?
+        ORDER BY t.name
+      `)
+            .all(entryId);
+        return rows.map(row => row.name);
+    }
+    // Add a tag to a memory entry (creates tag if it doesn't exist)
+    addTag(entryId, tagName) {
+        const normalizedTag = tagName.trim().toLowerCase();
+        // Validate tag name
+        if (!normalizedTag) {
+            throw new Error('Tag name cannot be empty');
+        }
+        if (normalizedTag.length > 50) {
+            throw new Error('Tag name must be 50 characters or less');
+        }
+        if (!/^[a-z0-9_-]+$/.test(normalizedTag)) {
+            throw new Error('Tag name can only contain lowercase letters, numbers, hyphens, and underscores');
+        }
+        // Check if entry exists
+        const entry = this.get(entryId);
+        if (!entry) {
+            throw new Error(`Memory entry not found: ${entryId}`);
+        }
+        // Get or create tag
+        let tagRow = this.db
+            .prepare('SELECT id FROM tags WHERE name = ?')
+            .get(normalizedTag);
+        if (!tagRow) {
+            const tagId = randomUUID();
+            this.db
+                .prepare('INSERT INTO tags (id, name, created_at) VALUES (?, ?, ?)')
+                .run(tagId, normalizedTag, Date.now());
+            tagRow = { id: tagId };
+        }
+        // Add tag to entry (ignore if already exists)
+        try {
+            this.db
+                .prepare('INSERT INTO memory_tags (memory_id, tag_id, created_at) VALUES (?, ?, ?)')
+                .run(entryId, tagRow.id, Date.now());
+        }
+        catch (err) {
+            // Ignore duplicate key errors
+            if (!(err instanceof Error) || !err.message.includes('UNIQUE constraint failed')) {
+                throw err;
+            }
+        }
+        log.debug(`Tag "${normalizedTag}" added to entry ${entryId}`);
+    }
+    // Remove a tag from a memory entry
+    removeTag(entryId, tagName) {
+        const normalizedTag = tagName.trim().toLowerCase();
+        const result = this.db
+            .prepare(`
+        DELETE FROM memory_tags
+        WHERE memory_id = ?
+        AND tag_id = (SELECT id FROM tags WHERE name = ?)
+      `)
+            .run(entryId, normalizedTag);
+        log.debug(`Tag "${normalizedTag}" removed from entry ${entryId}`);
+        return result.changes > 0;
+    }
+    // Get all unique tags with usage counts
+    getAllTags() {
+        const rows = this.db
+            .prepare(`
+        SELECT t.name, COUNT(mt.memory_id) as count
+        FROM tags t
+        LEFT JOIN memory_tags mt ON t.id = mt.tag_id
+        GROUP BY t.id, t.name
+        ORDER BY count DESC, t.name
+      `)
+            .all();
+        return rows;
+    }
+    // Search entries by tags (AND logic - entry must have all specified tags)
+    searchByTags(tags, namespace) {
+        if (tags.length === 0) {
+            return [];
+        }
+        const normalizedTags = tags.map(t => t.trim().toLowerCase());
+        const placeholders = normalizedTags.map(() => '?').join(',');
+        let query = `
+      SELECT m.*
+      FROM memory m
+      WHERE m.id IN (
+        SELECT mt.memory_id
+        FROM memory_tags mt
+        INNER JOIN tags t ON mt.tag_id = t.id
+        WHERE t.name IN (${placeholders})
+        GROUP BY mt.memory_id
+        HAVING COUNT(DISTINCT t.name) = ?
+      )
+    `;
+        const params = [...normalizedTags, normalizedTags.length];
+        if (namespace) {
+            query += ' AND m.namespace = ?';
+            params.push(namespace);
+        }
+        query += ' ORDER BY m.updated_at DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => this.rowToEntry(row));
+    }
+    // ==================== Relationship Operations ====================
+    // Create a relationship between two memory entries
+    createRelationship(fromId, toId, relationshipType, metadata) {
+        // Validate input
+        if (!fromId || !toId) {
+            throw new Error('Both fromId and toId are required');
+        }
+        if (fromId === toId) {
+            throw new Error('Cannot create relationship to self');
+        }
+        // Validate relationship type
+        const validTypes = [
+            'related_to',
+            'derived_from',
+            'references',
+            'depends_on',
+            'supersedes',
+            'conflicts_with',
+            'validates'
+        ];
+        if (!validTypes.includes(relationshipType)) {
+            throw new Error(`Invalid relationship type: ${relationshipType}. Valid types: ${validTypes.join(', ')}`);
+        }
+        // Validate that both entries exist
+        const fromEntry = this.getById(fromId);
+        const toEntry = this.getById(toId);
+        if (!fromEntry) {
+            throw new Error(`Source entry not found: ${fromId}`);
+        }
+        if (!toEntry) {
+            throw new Error(`Target entry not found: ${toId}`);
+        }
+        const id = randomUUID();
+        const metadataJson = metadata ? JSON.stringify(metadata) : null;
+        try {
+            this.db
+                .prepare(`
+          INSERT INTO memory_relationships (id, from_id, to_id, relationship_type, metadata, created_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `)
+                .run(id, fromId, toId, relationshipType, metadataJson, Date.now());
+            log.debug(`Relationship created: ${fromId} --[${relationshipType}]--> ${toId}`);
+            return id;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes('UNIQUE constraint failed')) {
+                throw new Error('Relationship already exists');
+            }
+            throw err;
+        }
+    }
+    // Get relationships for an entry
+    getRelationships(entryId, direction = 'both') {
+        let query = 'SELECT * FROM memory_relationships WHERE ';
+        const params = [];
+        if (direction === 'outgoing') {
+            query += 'from_id = ?';
+            params.push(entryId);
+        }
+        else if (direction === 'incoming') {
+            query += 'to_id = ?';
+            params.push(entryId);
+        }
+        else {
+            query += '(from_id = ? OR to_id = ?)';
+            params.push(entryId, entryId);
+        }
+        query += ' ORDER BY created_at DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => ({
+            id: row.id,
+            fromId: row.from_id,
+            toId: row.to_id,
+            relationshipType: row.relationship_type,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    // Get related entries (follows relationships and fetches the connected entries)
+    getRelatedEntries(entryId, relationshipType) {
+        let query = `
+      SELECT m.*, r.id as rel_id, r.relationship_type, r.from_id, r.to_id
+      FROM memory_relationships r
+      INNER JOIN memory m ON (
+        CASE
+          WHEN r.from_id = ? THEN m.id = r.to_id
+          WHEN r.to_id = ? THEN m.id = r.from_id
+        END
+      )
+      WHERE (r.from_id = ? OR r.to_id = ?)
+    `;
+        const params = [entryId, entryId, entryId, entryId];
+        if (relationshipType) {
+            query += ' AND r.relationship_type = ?';
+            params.push(relationshipType);
+        }
+        query += ' ORDER BY r.created_at DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => ({
+            entry: this.rowToEntry(row),
+            relationship: {
+                id: row.rel_id,
+                type: row.relationship_type,
+                direction: row.from_id === entryId ? 'outgoing' : 'incoming',
+            },
+        }));
+    }
+    // Delete a relationship
+    deleteRelationship(relationshipId) {
+        const result = this.db
+            .prepare('DELETE FROM memory_relationships WHERE id = ?')
+            .run(relationshipId);
+        log.debug(`Relationship deleted: ${relationshipId}`);
+        return result.changes > 0;
+    }
+    // Delete all relationships for an entry
+    deleteAllRelationships(entryId) {
+        const result = this.db
+            .prepare('DELETE FROM memory_relationships WHERE from_id = ? OR to_id = ?')
+            .run(entryId, entryId);
+        log.debug(`All relationships deleted for entry: ${entryId}`);
+        return result.changes;
+    }
+    // ==================== Version Operations ====================
+    // Save current state as a version (called before updates)
+    saveVersion(entry) {
+        // Get the next version number
+        const versionRow = this.db
+            .prepare('SELECT COALESCE(MAX(version), 0) as max_version FROM memory_versions WHERE memory_id = ?')
+            .get(entry.id);
+        const nextVersion = versionRow.max_version + 1;
+        const versionId = randomUUID();
+        const metadataJson = entry.metadata ? JSON.stringify(entry.metadata) : null;
+        this.db
+            .prepare(`
+        INSERT INTO memory_versions (id, memory_id, version, key, namespace, content, metadata, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+            .run(versionId, entry.id, nextVersion, entry.key, entry.namespace, entry.content, metadataJson, entry.updatedAt.getTime());
+        log.debug(`Version saved for entry ${entry.id}: v${nextVersion}`);
+    }
+    // Get version history for an entry
+    getVersionHistory(entryId) {
+        const rows = this.db
+            .prepare(`
+        SELECT id, memory_id, version, key, namespace, content, metadata, created_at
+        FROM memory_versions
+        WHERE memory_id = ?
+        ORDER BY version DESC
+      `)
+            .all(entryId);
+        return rows.map(row => ({
+            id: row.id,
+            memoryId: row.memory_id,
+            version: row.version,
+            key: row.key,
+            namespace: row.namespace,
+            content: row.content,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    // Get a specific version of an entry
+    getVersion(entryId, version) {
+        const row = this.db
+            .prepare(`
+        SELECT id, memory_id, version, key, namespace, content, metadata, created_at
+        FROM memory_versions
+        WHERE memory_id = ? AND version = ?
+      `)
+            .get(entryId, version);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            memoryId: row.memory_id,
+            version: row.version,
+            key: row.key,
+            namespace: row.namespace,
+            content: row.content,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            createdAt: new Date(row.created_at),
+        };
+    }
+    // Get the current version number for an entry
+    getCurrentVersion(entryId) {
+        const row = this.db
+            .prepare('SELECT COALESCE(MAX(version), 0) as version FROM memory_versions WHERE memory_id = ?')
+            .get(entryId);
+        return row.version;
+    }
+    // Restore a specific version (creates a new version with old content)
+    restoreVersion(entryId, version) {
+        const versionEntry = this.getVersion(entryId, version);
+        if (!versionEntry) {
+            return false;
+        }
+        const currentEntry = this.getById(entryId);
+        if (!currentEntry) {
+            return false;
+        }
+        // Save current state before restoring
+        this.saveVersion(currentEntry);
+        // Update with old content
+        const metadataJson = versionEntry.metadata ? JSON.stringify(versionEntry.metadata) : null;
+        this.db
+            .prepare(`
+        UPDATE memory
+        SET content = ?, metadata = ?, updated_at = ?
+        WHERE id = ?
+      `)
+            .run(versionEntry.content, metadataJson, Date.now(), entryId);
+        log.info(`Version ${version} restored for entry ${entryId}`);
+        return true;
+    }
     rowToEntry(row) {
+        // Fetch tags for this entry
+        const tags = this.getEntryTags(row.id);
         return {
             id: row.id,
             key: row.key,
@@ -293,6 +721,7 @@ export class SQLiteStore {
                 ? new Float32Array(row.embedding.buffer)
                 : undefined,
             metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            tags: tags.length > 0 ? tags : undefined,
             createdAt: new Date(row.created_at),
             updatedAt: new Date(row.updated_at),
         };
@@ -342,6 +771,18 @@ export class SQLiteStore {
             .get();
         return row ? this.rowToSession(row) : null;
     }
+    listSessions(status, limit = 50, offset = 0) {
+        let query = 'SELECT * FROM sessions';
+        const params = [];
+        if (status) {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY started_at DESC LIMIT ? OFFSET ?';
+        params.push(limit, offset);
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => this.rowToSession(row));
+    }
     rowToSession(row) {
         return {
             id: row.id,
@@ -483,15 +924,18 @@ export class SQLiteStore {
         return rows.map(row => this.rowToProject(row));
     }
     deleteProject(id) {
-        // First delete related project tasks and specifications
-        const tasks = this.listProjectTasks(id);
-        for (const task of tasks) {
-            this.deleteProjectTask(task.id);
-        }
-        const result = this.db
-            .prepare('DELETE FROM projects WHERE id = ?')
-            .run(id);
-        return result.changes > 0;
+        // Use transaction to ensure atomic deletion of project and related data
+        return this.transaction((db) => {
+            // First delete specifications for each project task
+            const tasks = this.listProjectTasks(id);
+            for (const task of tasks) {
+                db.prepare('DELETE FROM specifications WHERE project_task_id = ?').run(task.id);
+                db.prepare('DELETE FROM project_tasks WHERE id = ?').run(task.id);
+            }
+            // Delete the project itself
+            const result = db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+            return result.changes > 0;
+        });
     }
     rowToProject(row) {
         return {
@@ -591,12 +1035,14 @@ export class SQLiteStore {
         return rows.map(row => this.rowToProjectTask(row));
     }
     deleteProjectTask(id) {
-        // First delete related specifications
-        this.db.prepare('DELETE FROM specifications WHERE project_task_id = ?').run(id);
-        const result = this.db
-            .prepare('DELETE FROM project_tasks WHERE id = ?')
-            .run(id);
-        return result.changes > 0;
+        // Use transaction to ensure atomic deletion
+        return this.transaction((db) => {
+            // First delete related specifications
+            db.prepare('DELETE FROM specifications WHERE project_task_id = ?').run(id);
+            // Delete the task itself
+            const result = db.prepare('DELETE FROM project_tasks WHERE id = ?').run(id);
+            return result.changes > 0;
+        });
     }
     rowToProjectTask(row) {
         return {
@@ -714,7 +1160,193 @@ export class SQLiteStore {
             comments: row.comments ? JSON.parse(row.comments) : undefined,
         };
     }
+    // ==================== Active Agents Persistence ====================
+    /**
+     * Save active agent state
+     */
+    saveActiveAgent(agent) {
+        const now = Date.now();
+        const metadataJson = agent.metadata ? JSON.stringify(agent.metadata) : null;
+        const existing = this.db
+            .prepare('SELECT id FROM active_agents WHERE id = ?')
+            .get(agent.id);
+        if (existing) {
+            this.db
+                .prepare(`
+          UPDATE active_agents
+          SET type = ?, name = ?, status = ?, session_id = ?, updated_at = ?, metadata = ?
+          WHERE id = ?
+        `)
+                .run(agent.type, agent.name, agent.status, agent.sessionId ?? null, now, metadataJson, agent.id);
+        }
+        else {
+            this.db
+                .prepare(`
+          INSERT INTO active_agents (id, type, name, status, session_id, created_at, updated_at, metadata)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `)
+                .run(agent.id, agent.type, agent.name, agent.status, agent.sessionId ?? null, agent.createdAt.getTime(), now, metadataJson);
+        }
+    }
+    /**
+     * Load active agents
+     */
+    loadActiveAgents() {
+        const rows = this.db
+            .prepare('SELECT * FROM active_agents WHERE status IN (?, ?, ?)')
+            .all('idle', 'running', 'stopped');
+        return rows.map(row => ({
+            id: row.id,
+            type: row.type,
+            name: row.name,
+            status: row.status,
+            sessionId: row.session_id ?? undefined,
+            createdAt: new Date(row.created_at),
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        }));
+    }
+    /**
+     * Delete active agent
+     */
+    deleteActiveAgent(agentId) {
+        const result = this.db
+            .prepare('DELETE FROM active_agents WHERE id = ?')
+            .run(agentId);
+        return result.changes > 0;
+    }
+    /**
+     * Update agent status
+     */
+    updateAgentStatus(agentId, status) {
+        const now = Date.now();
+        const result = this.db
+            .prepare('UPDATE active_agents SET status = ?, updated_at = ? WHERE id = ?')
+            .run(status, now, agentId);
+        return result.changes > 0;
+    }
+    /**
+     * Clear completed/failed agents
+     */
+    clearInactiveAgents() {
+        this.db
+            .prepare('DELETE FROM active_agents WHERE status IN (?, ?)')
+            .run('completed', 'failed');
+    }
+    // ==================== Review Loops Persistence ====================
+    /**
+     * Save review loop state
+     */
+    saveReviewLoop(loopId, state) {
+        const now = Date.now();
+        const reviewsJson = JSON.stringify(state.reviews);
+        const finalVerdictJson = state.finalVerdict ? JSON.stringify(state.finalVerdict) : null;
+        const existing = this.db
+            .prepare('SELECT id FROM review_loops WHERE id = ?')
+            .get(loopId);
+        if (existing) {
+            this.db
+                .prepare(`
+          UPDATE review_loops
+          SET status = ?, iteration = ?, current_code = ?, reviews = ?,
+              final_verdict = ?, updated_at = ?, completed_at = ?
+          WHERE id = ?
+        `)
+                .run(state.status, state.iteration, state.currentCode ?? null, reviewsJson, finalVerdictJson, now, state.completedAt?.getTime() ?? null, loopId);
+        }
+        else {
+            this.db
+                .prepare(`
+          INSERT INTO review_loops (
+            id, coder_id, adversarial_id, session_id, status,
+            iteration, max_iterations, code_input, current_code,
+            reviews, final_verdict, created_at, updated_at, completed_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `)
+                .run(loopId, state.coderId, state.adversarialId, state.sessionId ?? null, state.status, state.iteration, state.maxIterations, state.codeInput, state.currentCode ?? null, reviewsJson, finalVerdictJson, state.startedAt.getTime(), now, state.completedAt?.getTime() ?? null);
+        }
+    }
+    /**
+     * Load review loop state
+     */
+    loadReviewLoop(loopId) {
+        const row = this.db
+            .prepare('SELECT * FROM review_loops WHERE id = ?')
+            .get(loopId);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            coderId: row.coder_id,
+            adversarialId: row.adversarial_id,
+            sessionId: row.session_id ?? undefined,
+            status: row.status,
+            iteration: row.iteration,
+            maxIterations: row.max_iterations,
+            codeInput: row.code_input,
+            currentCode: row.current_code ?? undefined,
+            reviews: JSON.parse(row.reviews),
+            finalVerdict: row.final_verdict ? JSON.parse(row.final_verdict) : undefined,
+            startedAt: new Date(row.created_at),
+            completedAt: row.completed_at ? new Date(row.completed_at) : undefined,
+        };
+    }
+    /**
+     * Load active review loops
+     */
+    loadActiveReviewLoops() {
+        const rows = this.db
+            .prepare('SELECT * FROM review_loops WHERE status IN (?, ?, ?, ?)')
+            .all('pending', 'coding', 'reviewing', 'fixing');
+        return rows.map(row => ({
+            id: row.id,
+            coderId: row.coder_id,
+            adversarialId: row.adversarial_id,
+            sessionId: row.session_id ?? undefined,
+            status: row.status,
+            iteration: row.iteration,
+            maxIterations: row.max_iterations,
+            codeInput: row.code_input,
+            currentCode: row.current_code ?? undefined,
+            reviews: JSON.parse(row.reviews),
+            finalVerdict: row.final_verdict ? JSON.parse(row.final_verdict) : undefined,
+            startedAt: new Date(row.created_at),
+            completedAt: row.completed_at ? new Date(row.completed_at) : undefined,
+        }));
+    }
+    /**
+     * Delete review loop
+     */
+    deleteReviewLoop(loopId) {
+        const result = this.db
+            .prepare('DELETE FROM review_loops WHERE id = ?')
+            .run(loopId);
+        return result.changes > 0;
+    }
+    /**
+     * Clear completed review loops
+     */
+    clearCompletedReviewLoops() {
+        this.db
+            .prepare('DELETE FROM review_loops WHERE status IN (?, ?)')
+            .run('approved', 'failed');
+    }
     // ==================== Cleanup ====================
+    /**
+     * Get the underlying database instance
+     * Used for authentication and other features that need direct DB access
+     */
+    getDatabase() {
+        return this.db;
+    }
+    /**
+     * Execute a function within a transaction
+     * Automatically commits on success and rolls back on error
+     */
+    transaction(fn) {
+        const transaction = this.db.transaction(fn);
+        return transaction(this.db);
+    }
     close() {
         this.db.close();
         log.debug('SQLite store closed');