claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/hive-mind/session-manager.js

@@ -1,85 +1,115 @@
 /**
  * Hive Mind Session Manager
  * Handles session persistence and resume functionality for swarms
- */ import path from "path";
-import { existsSync, mkdirSync } from "fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { cwd } from "../../node-compat.js";
-import { createDatabase, isSQLiteAvailable, isWindows } from "../../../memory/sqlite-wrapper.js";
-import { sessionSerializer } from "../../../memory/enhanced-session-serializer.js";
+ */
+
+import path from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import chalk from 'chalk';
+import { cwd } from '../../node-compat.js';
+import { createDatabase, isSQLiteAvailable, isWindows } from '../../../memory/sqlite-wrapper.js';
+import { sessionSerializer } from '../../../memory/enhanced-session-serializer.js';
+import { SerializationError, DeserializationError } from '../../../memory/advanced-serializer.js';
+
 export class HiveMindSessionManager {
-    /**
+  constructor(hiveMindDir = null) {
+    this.hiveMindDir = hiveMindDir || path.join(cwd(), '.hive-mind');
+    this.sessionsDir = path.join(this.hiveMindDir, 'sessions');
+    this.dbPath = path.join(this.hiveMindDir, 'hive.db');
+    this.db = null;
+    this.isInMemory = false;
+    this.memoryStore = null;
+    this.initializationPromise = null;
+
+    // Ensure directories exist
+    this.ensureDirectories();
+
+    // Initialize database connection (store promise for later)
+    this.initializationPromise = this.initializeDatabase();
+  }
+
+  /**
    * Initialize database with fallback support
-   */ async initializeDatabase() {
-        try {
-            const sqliteAvailable = await isSQLiteAvailable();
-            if (!sqliteAvailable) {
-                console.warn('SQLite not available, using in-memory session storage');
-                this.initializeInMemoryFallback();
-                return;
-            }
-            this.db = await createDatabase(this.dbPath);
-            if (this.db) {
-                this.initializeSchema();
-            } else {
-                throw new Error('Failed to create database instance');
-            }
-        } catch (error) {
-            console.error('Failed to create SQLite database:', error.message);
-            console.warn('Falling back to in-memory session storage');
-            this.initializeInMemoryFallback();
-        }
+   */
+  async initializeDatabase() {
+    try {
+      const sqliteAvailable = await isSQLiteAvailable();
+
+      if (!sqliteAvailable) {
+        console.warn('SQLite not available, using in-memory session storage');
+        this.initializeInMemoryFallback();
+        return;
+      }
+
+      this.db = await createDatabase(this.dbPath);
+      if (this.db) {
+        this.initializeSchema();
+      } else {
+        throw new Error('Failed to create database instance');
+      }
+    } catch (error) {
+      console.error('Failed to create SQLite database:', error.message);
+      console.warn('Falling back to in-memory session storage');
+      this.initializeInMemoryFallback();
     }
-    /**
+  }
+
+  /**
    * Ensure database is initialized before use
-   */ async ensureInitialized() {
-        if (this.initializationPromise) {
-            await this.initializationPromise;
-            this.initializationPromise = null;
-        }
-        if (this.db === null && !this.isInMemory) {
-            await this.initializeDatabase();
-        }
+   */
+  async ensureInitialized() {
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+      this.initializationPromise = null;
     }
-    /**
+
+    if (this.db === null && !this.isInMemory) {
+      await this.initializeDatabase();
+    }
+  }
+
+  /**
    * Initialize in-memory fallback for session storage
-   */ initializeInMemoryFallback() {
-        this.isInMemory = true;
-        this.memoryStore = {
-            sessions: new Map(),
-            checkpoints: new Map(),
-            logs: new Map()
-        };
-        if (isWindows()) {
-            console.info(`
+   */
+  initializeInMemoryFallback() {
+    this.isInMemory = true;
+    this.memoryStore = {
+      sessions: new Map(),
+      checkpoints: new Map(),
+      logs: new Map(),
+    };
+
+    if (isWindows()) {
+      console.info(`
 Note: Session data will not persist between runs on Windows without SQLite.
 To enable persistence, see: https://github.com/ruvnet/claude-code-flow/docs/windows-installation.md
 `);
-        }
     }
-    /**
+  }
+
+  /**
    * Ensure required directories exist
-   */ ensureDirectories() {
-        if (!existsSync(this.hiveMindDir)) {
-            mkdirSync(this.hiveMindDir, {
-                recursive: true
-            });
-        }
-        if (!existsSync(this.sessionsDir)) {
-            mkdirSync(this.sessionsDir, {
-                recursive: true
-            });
-        }
+   */
+  ensureDirectories() {
+    if (!existsSync(this.hiveMindDir)) {
+      mkdirSync(this.hiveMindDir, { recursive: true });
+    }
+    if (!existsSync(this.sessionsDir)) {
+      mkdirSync(this.sessionsDir, { recursive: true });
     }
-    /**
+  }
+
+  /**
    * Initialize database schema for sessions
-   */ initializeSchema() {
-        if (!this.db) {
-            console.error('Database not initialized');
-            return;
-        }
-        // Create the base schema
-        this.db.exec(`
+   */
+  initializeSchema() {
+    if (!this.db) {
+      console.error('Database not initialized');
+      return;
+    }
+    // Create the base schema
+    this.db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         id TEXT PRIMARY KEY,
         swarm_id TEXT NOT NULL,
@@ -118,189 +148,247 @@ To enable persistence, see: https://github.com/ruvnet/claude-code-flow/docs/wind
         FOREIGN KEY (session_id) REFERENCES sessions(id)
       );
     `);
-        // Run migrations to add new columns
-        this.runMigrations();
-    }
-    /**
+
+    // Run migrations to add new columns
+    this.runMigrations();
+  }
+
+  /**
    * Run database migrations
-   */ runMigrations() {
-        if (!this.db) {
-            console.error('Database not initialized for migrations');
-            return;
-        }
-        try {
-            // Check if required columns exist
-            const columns = this.db.prepare('PRAGMA table_info(sessions)').all();
-            // Core columns
-            const hasObjective = columns.some((col)=>col.name === 'objective');
-            const hasSwarmName = columns.some((col)=>col.name === 'swarm_name');
-            const hasCheckpointData = columns.some((col)=>col.name === 'checkpoint_data');
-            const hasMetadata = columns.some((col)=>col.name === 'metadata');
-            const hasParentPid = columns.some((col)=>col.name === 'parent_pid');
-            const hasChildPids = columns.some((col)=>col.name === 'child_pids');
-            // Timestamp columns
-            const hasUpdatedAt = columns.some((col)=>col.name === 'updated_at');
-            const hasPausedAt = columns.some((col)=>col.name === 'paused_at');
-            const hasResumedAt = columns.some((col)=>col.name === 'resumed_at');
-            const hasCompletionPercentage = columns.some((col)=>col.name === 'completion_percentage');
-            if (!hasObjective) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN objective TEXT');
-                console.log('Added objective column to sessions table');
-            }
-            if (!hasSwarmName) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN swarm_name TEXT');
-                console.log('Added swarm_name column to sessions table');
-            }
-            if (!hasCheckpointData) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN checkpoint_data TEXT');
-                console.log('Added checkpoint_data column to sessions table');
-            }
-            if (!hasMetadata) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN metadata TEXT');
-                console.log('Added metadata column to sessions table');
-            }
-            if (!hasParentPid) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN parent_pid INTEGER');
-                console.log('Added parent_pid column to sessions table');
-            }
-            if (!hasChildPids) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN child_pids TEXT');
-                console.log('Added child_pids column to sessions table');
-            }
-            if (!hasUpdatedAt) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN updated_at DATETIME DEFAULT CURRENT_TIMESTAMP');
-                console.log('Added updated_at column to sessions table');
-            }
-            if (!hasPausedAt) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN paused_at DATETIME');
-                console.log('Added paused_at column to sessions table');
-            }
-            if (!hasResumedAt) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN resumed_at DATETIME');
-                console.log('Added resumed_at column to sessions table');
-            }
-            if (!hasCompletionPercentage) {
-                this.db.exec('ALTER TABLE sessions ADD COLUMN completion_percentage REAL DEFAULT 0');
-                console.log('Added completion_percentage column to sessions table');
-            }
-        } catch (error) {
-            console.error('Migration error:', error);
-        }
+   */
+  runMigrations() {
+    if (!this.db) {
+      console.error('Database not initialized for migrations');
+      return;
     }
-    /**
+    try {
+      // Check if required columns exist
+      const columns = this.db.prepare('PRAGMA table_info(sessions)').all();
+
+      // Core columns
+      const hasObjective = columns.some((col) => col.name === 'objective');
+      const hasSwarmName = columns.some((col) => col.name === 'swarm_name');
+      const hasCheckpointData = columns.some((col) => col.name === 'checkpoint_data');
+      const hasMetadata = columns.some((col) => col.name === 'metadata');
+      const hasParentPid = columns.some((col) => col.name === 'parent_pid');
+      const hasChildPids = columns.some((col) => col.name === 'child_pids');
+
+      // Timestamp columns
+      const hasUpdatedAt = columns.some((col) => col.name === 'updated_at');
+      const hasPausedAt = columns.some((col) => col.name === 'paused_at');
+      const hasResumedAt = columns.some((col) => col.name === 'resumed_at');
+      const hasCompletionPercentage = columns.some((col) => col.name === 'completion_percentage');
+
+      if (!hasObjective) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN objective TEXT');
+        console.log('Added objective column to sessions table');
+      }
+
+      if (!hasSwarmName) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN swarm_name TEXT');
+        console.log('Added swarm_name column to sessions table');
+      }
+
+      if (!hasCheckpointData) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN checkpoint_data TEXT');
+        console.log('Added checkpoint_data column to sessions table');
+      }
+
+      if (!hasMetadata) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN metadata TEXT');
+        console.log('Added metadata column to sessions table');
+      }
+
+      if (!hasParentPid) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN parent_pid INTEGER');
+        console.log('Added parent_pid column to sessions table');
+      }
+
+      if (!hasChildPids) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN child_pids TEXT');
+        console.log('Added child_pids column to sessions table');
+      }
+
+      if (!hasUpdatedAt) {
+        this.db.exec(
+          'ALTER TABLE sessions ADD COLUMN updated_at DATETIME DEFAULT CURRENT_TIMESTAMP',
+        );
+        console.log('Added updated_at column to sessions table');
+      }
+
+      if (!hasPausedAt) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN paused_at DATETIME');
+        console.log('Added paused_at column to sessions table');
+      }
+
+      if (!hasResumedAt) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN resumed_at DATETIME');
+        console.log('Added resumed_at column to sessions table');
+      }
+
+      if (!hasCompletionPercentage) {
+        this.db.exec('ALTER TABLE sessions ADD COLUMN completion_percentage REAL DEFAULT 0');
+        console.log('Added completion_percentage column to sessions table');
+      }
+    } catch (error) {
+      console.error('Migration error:', error);
+    }
+  }
+
+  /**
    * Create a new session for a swarm
-   */ async createSession(swarmId, swarmName, objective, metadata = {}) {
-        await this.ensureInitialized();
-        const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const sessionData = {
-                id: sessionId,
-                swarm_id: swarmId,
-                swarm_name: swarmName,
-                objective,
-                status: 'active',
-                created_at: new Date().toISOString(),
-                updated_at: new Date().toISOString(),
-                metadata: sessionSerializer.serializeMetadata(metadata),
-                parent_pid: process.pid,
-                child_pids: '[]'
-            };
-            this.memoryStore.sessions.set(sessionId, sessionData);
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async createSession(swarmId, swarmName, objective, metadata = {}) {
+    await this.ensureInitialized();
+
+    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessionData = {
+        id: sessionId,
+        swarm_id: swarmId,
+        swarm_name: swarmName,
+        objective,
+        status: 'active',
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        metadata: sessionSerializer.serializeMetadata(metadata),
+        parent_pid: process.pid,
+        child_pids: '[]',
+      };
+      this.memoryStore.sessions.set(sessionId, sessionData);
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         INSERT INTO sessions (id, swarm_id, swarm_name, objective, metadata, parent_pid)
         VALUES (?, ?, ?, ?, ?, ?)
       `);
-            stmt.run(sessionId, swarmId, swarmName, objective, sessionSerializer.serializeMetadata(metadata), process.pid);
-        }
-        // Log session creation
-        await this.logSessionEvent(sessionId, 'info', 'Session created', null, {
-            swarmId,
-            swarmName,
-            objective,
-            parentPid: process.pid
-        });
-        return sessionId;
-    }
-    /**
+
+      stmt.run(
+        sessionId,
+        swarmId,
+        swarmName,
+        objective,
+        sessionSerializer.serializeMetadata(metadata),
+        process.pid,
+      );
+    }
+
+    // Log session creation
+    await this.logSessionEvent(sessionId, 'info', 'Session created', null, {
+      swarmId,
+      swarmName,
+      objective,
+      parentPid: process.pid,
+    });
+
+    return sessionId;
+  }
+
+  /**
    * Save session checkpoint
-   */ async saveCheckpoint(sessionId, checkpointName, checkpointData) {
-        await this.ensureInitialized();
-        const checkpointId = `checkpoint-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const checkpointEntry = {
-                id: checkpointId,
-                session_id: sessionId,
-                checkpoint_name: checkpointName,
-                checkpoint_data: sessionSerializer.serializeCheckpointData(checkpointData),
-                created_at: new Date().toISOString()
-            };
-            if (!this.memoryStore.checkpoints.has(sessionId)) {
-                this.memoryStore.checkpoints.set(sessionId, []);
-            }
-            this.memoryStore.checkpoints.get(sessionId).push(checkpointEntry);
-            // Update session data
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (session) {
-                session.checkpoint_data = sessionSerializer.serializeCheckpointData(checkpointData);
-                session.updated_at = new Date().toISOString();
-            }
-        } else {
-            // Save to database
-            const stmt = this.db.prepare(`
+   */
+  async saveCheckpoint(sessionId, checkpointName, checkpointData) {
+    await this.ensureInitialized();
+
+    const checkpointId = `checkpoint-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const checkpointEntry = {
+        id: checkpointId,
+        session_id: sessionId,
+        checkpoint_name: checkpointName,
+        checkpoint_data: sessionSerializer.serializeCheckpointData(checkpointData),
+        created_at: new Date().toISOString(),
+      };
+
+      if (!this.memoryStore.checkpoints.has(sessionId)) {
+        this.memoryStore.checkpoints.set(sessionId, []);
+      }
+      this.memoryStore.checkpoints.get(sessionId).push(checkpointEntry);
+
+      // Update session data
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (session) {
+        session.checkpoint_data = sessionSerializer.serializeCheckpointData(checkpointData);
+        session.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Save to database
+      const stmt = this.db.prepare(`
         INSERT INTO session_checkpoints (id, session_id, checkpoint_name, checkpoint_data)
         VALUES (?, ?, ?, ?)
       `);
-            stmt.run(checkpointId, sessionId, checkpointName, sessionSerializer.serializeCheckpointData(checkpointData));
-            // Update session checkpoint data and timestamp
-            const updateStmt = this.db.prepare(`
+
+      stmt.run(
+        checkpointId,
+        sessionId,
+        checkpointName,
+        sessionSerializer.serializeCheckpointData(checkpointData),
+      );
+
+      // Update session checkpoint data and timestamp
+      const updateStmt = this.db.prepare(`
         UPDATE sessions 
         SET checkpoint_data = ?, updated_at = CURRENT_TIMESTAMP
         WHERE id = ?
       `);
-            updateStmt.run(sessionSerializer.serializeCheckpointData(checkpointData), sessionId);
-        }
-        // Save checkpoint file for backup
-        const checkpointFile = path.join(this.sessionsDir, `${sessionId}-${checkpointName}.json`);
-        await writeFile(checkpointFile, sessionSerializer.serializeSessionData({
-            sessionId,
-            checkpointId,
-            checkpointName,
-            timestamp: new Date().toISOString(),
-            data: checkpointData
-        }));
-        await this.logSessionEvent(sessionId, 'info', `Checkpoint saved: ${checkpointName}`, null, {
-            checkpointId
-        });
-        return checkpointId;
-    }
-    /**
+
+      updateStmt.run(sessionSerializer.serializeCheckpointData(checkpointData), sessionId);
+    }
+
+    // Save checkpoint file for backup
+    const checkpointFile = path.join(this.sessionsDir, `${sessionId}-${checkpointName}.json`);
+    await writeFile(
+      checkpointFile,
+      sessionSerializer.serializeSessionData({
+        sessionId,
+        checkpointId,
+        checkpointName,
+        timestamp: new Date().toISOString(),
+        data: checkpointData,
+      }),
+    );
+
+    await this.logSessionEvent(sessionId, 'info', `Checkpoint saved: ${checkpointName}`, null, {
+      checkpointId,
+    });
+
+    return checkpointId;
+  }
+
+  /**
    * Get active sessions
-   */ async getActiveSessions() {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const sessions = [];
-            for (const [sessionId, session] of this.memoryStore.sessions){
-                if (session.status === 'active' || session.status === 'paused') {
-                    sessions.push({
-                        ...session,
-                        metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
-                        checkpoint_data: session.checkpoint_data ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data) : null,
-                        agent_count: 0,
-                        task_count: 0,
-                        completed_tasks: 0,
-                        completion_percentage: 0
-                    });
-                }
-            }
-            return sessions.sort((a, b)=>new Date(b.updated_at) - new Date(a.updated_at));
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async getActiveSessions() {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessions = [];
+      for (const [sessionId, session] of this.memoryStore.sessions) {
+        if (session.status === 'active' || session.status === 'paused') {
+          sessions.push({
+            ...session,
+            metadata: session.metadata
+              ? sessionSerializer.deserializeMetadata(session.metadata)
+              : {},
+            checkpoint_data: session.checkpoint_data
+              ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data)
+              : null,
+            agent_count: 0, // Not tracked in memory mode
+            task_count: 0, // Not tracked in memory mode
+            completed_tasks: 0, // Not tracked in memory mode
+            completion_percentage: 0,
+          });
+        }
+      }
+      return sessions.sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at));
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         SELECT s.*, 
                COUNT(DISTINCT a.id) as agent_count,
                COUNT(DISTINCT t.id) as task_count,
@@ -312,608 +400,824 @@ To enable persistence, see: https://github.com/ruvnet/claude-code-flow/docs/wind
         GROUP BY s.id
         ORDER BY s.updated_at DESC
       `);
-            const sessions = stmt.all();
-            // Parse JSON fields
-            return sessions.map((session)=>({
-                    ...session,
-                    metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
-                    checkpoint_data: session.checkpoint_data ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data) : null,
-                    completion_percentage: session.task_count > 0 ? Math.round(session.completed_tasks / session.task_count * 100) : 0
-                }));
-        }
+
+      const sessions = stmt.all();
+
+      // Parse JSON fields
+      return sessions.map((session) => ({
+        ...session,
+        metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
+        checkpoint_data: session.checkpoint_data
+          ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data)
+          : null,
+        completion_percentage:
+          session.task_count > 0
+            ? Math.round((session.completed_tasks / session.task_count) * 100)
+            : 0,
+      }));
     }
-    /**
+  }
+
+  /**
    * Get session by ID with full details
-   */ async getSession(sessionId) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (!session) {
-                return null;
-            }
-            // Return simplified session data for in-memory mode
-            return {
-                ...session,
-                metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
-                checkpoint_data: session.checkpoint_data ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data) : null,
-                swarm: null,
-                agents: [],
-                tasks: [],
-                checkpoints: this.memoryStore.checkpoints.get(sessionId) || [],
-                recentLogs: this.memoryStore.logs.get(sessionId) || [],
-                statistics: {
-                    totalAgents: 0,
-                    activeAgents: 0,
-                    totalTasks: 0,
-                    completedTasks: 0,
-                    pendingTasks: 0,
-                    inProgressTasks: 0,
-                    completionPercentage: session.completion_percentage || 0
-                }
-            };
-        }
-        const session = this.db.prepare(`
+   */
+  async getSession(sessionId) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (!session) {
+        return null;
+      }
+
+      // Return simplified session data for in-memory mode
+      return {
+        ...session,
+        metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
+        checkpoint_data: session.checkpoint_data
+          ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data)
+          : null,
+        swarm: null, // Not available in memory mode
+        agents: [], // Not available in memory mode
+        tasks: [], // Not available in memory mode
+        checkpoints: this.memoryStore.checkpoints.get(sessionId) || [],
+        recentLogs: this.memoryStore.logs.get(sessionId) || [],
+        statistics: {
+          totalAgents: 0,
+          activeAgents: 0,
+          totalTasks: 0,
+          completedTasks: 0,
+          pendingTasks: 0,
+          inProgressTasks: 0,
+          completionPercentage: session.completion_percentage || 0,
+        },
+      };
+    }
+
+    const session = this.db
+      .prepare(
+        `
       SELECT * FROM sessions WHERE id = ?
-    `).get(sessionId);
-        if (!session) {
-            return null;
-        }
-        // Get associated swarm data
-        const swarm = this.db.prepare(`
+    `,
+      )
+      .get(sessionId);
+
+    if (!session) {
+      return null;
+    }
+
+    // Get associated swarm data
+    const swarm = this.db
+      .prepare(
+        `
       SELECT * FROM swarms WHERE id = ?
-    `).get(session.swarm_id);
-        // Get agents
-        const agents = this.db.prepare(`
+    `,
+      )
+      .get(session.swarm_id);
+
+    // Get agents
+    const agents = this.db
+      .prepare(
+        `
       SELECT * FROM agents WHERE swarm_id = ?
-    `).all(session.swarm_id);
-        // Get tasks
-        const tasks = this.db.prepare(`
+    `,
+      )
+      .all(session.swarm_id);
+
+    // Get tasks
+    const tasks = this.db
+      .prepare(
+        `
       SELECT * FROM tasks WHERE swarm_id = ?
-    `).all(session.swarm_id);
-        // Get checkpoints
-        const checkpoints = this.db.prepare(`
+    `,
+      )
+      .all(session.swarm_id);
+
+    // Get checkpoints
+    const checkpoints = this.db
+      .prepare(
+        `
       SELECT * FROM session_checkpoints 
       WHERE session_id = ? 
       ORDER BY created_at DESC
-    `).all(sessionId);
-        // Get recent logs
-        const recentLogs = this.db.prepare(`
+    `,
+      )
+      .all(sessionId);
+
+    // Get recent logs
+    const recentLogs = this.db
+      .prepare(
+        `
       SELECT * FROM session_logs 
       WHERE session_id = ? 
       ORDER BY timestamp DESC 
       LIMIT 50
-    `).all(sessionId);
-        return {
-            ...session,
-            metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
-            checkpoint_data: session.checkpoint_data ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data) : null,
-            swarm,
-            agents,
-            tasks,
-            checkpoints: checkpoints.map((cp)=>({
-                    ...cp,
-                    checkpoint_data: sessionSerializer.deserializeCheckpointData(cp.checkpoint_data)
-                })),
-            recentLogs,
-            statistics: {
-                totalAgents: agents.length,
-                activeAgents: agents.filter((a)=>a.status === 'active' || a.status === 'busy').length,
-                totalTasks: tasks.length,
-                completedTasks: tasks.filter((t)=>t.status === 'completed').length,
-                pendingTasks: tasks.filter((t)=>t.status === 'pending').length,
-                inProgressTasks: tasks.filter((t)=>t.status === 'in_progress').length,
-                completionPercentage: tasks.length > 0 ? Math.round(tasks.filter((t)=>t.status === 'completed').length / tasks.length * 100) : 0
-            }
-        };
-    }
-    /**
+    `,
+      )
+      .all(sessionId);
+
+    return {
+      ...session,
+      metadata: session.metadata ? sessionSerializer.deserializeMetadata(session.metadata) : {},
+      checkpoint_data: session.checkpoint_data
+        ? sessionSerializer.deserializeCheckpointData(session.checkpoint_data)
+        : null,
+      swarm,
+      agents,
+      tasks,
+      checkpoints: checkpoints.map((cp) => ({
+        ...cp,
+        checkpoint_data: sessionSerializer.deserializeCheckpointData(cp.checkpoint_data),
+      })),
+      recentLogs,
+      statistics: {
+        totalAgents: agents.length,
+        activeAgents: agents.filter((a) => a.status === 'active' || a.status === 'busy').length,
+        totalTasks: tasks.length,
+        completedTasks: tasks.filter((t) => t.status === 'completed').length,
+        pendingTasks: tasks.filter((t) => t.status === 'pending').length,
+        inProgressTasks: tasks.filter((t) => t.status === 'in_progress').length,
+        completionPercentage:
+          tasks.length > 0
+            ? Math.round(
+                (tasks.filter((t) => t.status === 'completed').length / tasks.length) * 100,
+              )
+            : 0,
+      },
+    };
+  }
+
+  /**
    * Pause a session
-   */ async pauseSession(sessionId) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (session) {
-                session.status = 'paused';
-                session.paused_at = new Date().toISOString();
-                session.updated_at = new Date().toISOString();
-                await this.logSessionEvent(sessionId, 'info', 'Session paused');
-                return true;
-            }
-            return false;
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async pauseSession(sessionId) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (session) {
+        session.status = 'paused';
+        session.paused_at = new Date().toISOString();
+        session.updated_at = new Date().toISOString();
+
+        await this.logSessionEvent(sessionId, 'info', 'Session paused');
+        return true;
+      }
+      return false;
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         UPDATE sessions 
         SET status = 'paused', paused_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
         WHERE id = ?
       `);
-            const result = stmt.run(sessionId);
-            if (result.changes > 0) {
-                await this.logSessionEvent(sessionId, 'info', 'Session paused');
-                // Update swarm status
-                const session = this.db.prepare('SELECT swarm_id FROM sessions WHERE id = ?').get(sessionId);
-                if (session) {
-                    this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('paused', session.swarm_id);
-                }
-            }
-            return result.changes > 0;
+
+      const result = stmt.run(sessionId);
+
+      if (result.changes > 0) {
+        await this.logSessionEvent(sessionId, 'info', 'Session paused');
+
+        // Update swarm status
+        const session = this.db
+          .prepare('SELECT swarm_id FROM sessions WHERE id = ?')
+          .get(sessionId);
+        if (session) {
+          this.db
+            .prepare('UPDATE swarms SET status = ? WHERE id = ?')
+            .run('paused', session.swarm_id);
         }
+      }
+
+      return result.changes > 0;
     }
-    /**
+  }
+
+  /**
    * Resume any previous session (paused, stopped, or inactive)
-   */ async resumeSession(sessionId) {
-        const session = await this.getSession(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        // Allow resuming any session regardless of status
-        console.log(`Resuming session ${sessionId} from status: ${session.status}`);
-        // If session was stopped, log that we're restarting it
-        if (session.status === 'stopped') {
-            await this.logSessionEvent(sessionId, 'info', `Restarting stopped session with original configuration`);
-        }
-        // Update session status
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const sessionData = this.memoryStore.sessions.get(sessionId);
-            if (sessionData) {
-                sessionData.status = 'active';
-                sessionData.resumed_at = new Date().toISOString();
-                sessionData.updated_at = new Date().toISOString();
-            }
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async resumeSession(sessionId) {
+    const session = await this.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    // Allow resuming any session regardless of status
+    console.log(`Resuming session ${sessionId} from status: ${session.status}`);
+
+    // If session was stopped, log that we're restarting it
+    if (session.status === 'stopped') {
+      await this.logSessionEvent(
+        sessionId,
+        'info',
+        `Restarting stopped session with original configuration`,
+      );
+    }
+
+    // Update session status
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessionData = this.memoryStore.sessions.get(sessionId);
+      if (sessionData) {
+        sessionData.status = 'active';
+        sessionData.resumed_at = new Date().toISOString();
+        sessionData.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         UPDATE sessions 
         SET status = 'active', resumed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
         WHERE id = ?
       `);
-            stmt.run(sessionId);
-            // Update swarm status
-            this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('active', session.swarm_id);
-            // Update agent statuses
-            this.db.prepare(`
+
+      stmt.run(sessionId);
+
+      // Update swarm status
+      this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('active', session.swarm_id);
+
+      // Update agent statuses
+      this.db
+        .prepare(
+          `
         UPDATE agents 
         SET status = CASE 
           WHEN role = 'queen' THEN 'active'
           ELSE 'idle'
         END
         WHERE swarm_id = ?
-      `).run(session.swarm_id);
-        }
-        await this.logSessionEvent(sessionId, 'info', 'Session resumed', null, {
-            pausedDuration: session.paused_at ? new Date() - new Date(session.paused_at) : null
-        });
-        return session;
+      `,
+        )
+        .run(session.swarm_id);
     }
-    /**
+
+    await this.logSessionEvent(sessionId, 'info', 'Session resumed', null, {
+      pausedDuration: session.paused_at ? new Date() - new Date(session.paused_at) : null,
+    });
+
+    return session;
+  }
+
+  /**
    * Mark session as completed
-   */ async completeSession(sessionId) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (session) {
-                session.status = 'completed';
-                session.updated_at = new Date().toISOString();
-                session.completion_percentage = 100;
-                await this.logSessionEvent(sessionId, 'info', 'Session completed');
-                return true;
-            }
-            return false;
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async completeSession(sessionId) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (session) {
+        session.status = 'completed';
+        session.updated_at = new Date().toISOString();
+        session.completion_percentage = 100;
+
+        await this.logSessionEvent(sessionId, 'info', 'Session completed');
+        return true;
+      }
+      return false;
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         UPDATE sessions 
         SET status = 'completed', updated_at = CURRENT_TIMESTAMP, completion_percentage = 100
         WHERE id = ?
       `);
-            const result = stmt.run(sessionId);
-            if (result.changes > 0) {
-                await this.logSessionEvent(sessionId, 'info', 'Session completed');
-                // Update swarm status
-                const session = this.db.prepare('SELECT swarm_id FROM sessions WHERE id = ?').get(sessionId);
-                if (session) {
-                    this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('completed', session.swarm_id);
-                }
-            }
-            return result.changes > 0;
+
+      const result = stmt.run(sessionId);
+
+      if (result.changes > 0) {
+        await this.logSessionEvent(sessionId, 'info', 'Session completed');
+
+        // Update swarm status
+        const session = this.db
+          .prepare('SELECT swarm_id FROM sessions WHERE id = ?')
+          .get(sessionId);
+        if (session) {
+          this.db
+            .prepare('UPDATE swarms SET status = ? WHERE id = ?')
+            .run('completed', session.swarm_id);
         }
+      }
+
+      return result.changes > 0;
     }
-    /**
+  }
+
+  /**
    * Archive old sessions
-   */ async archiveSessions(daysOld = 30) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // In-memory mode doesn't support archiving
-            console.warn('Session archiving not supported in in-memory mode');
-            return 0;
-        }
-        const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - daysOld);
-        const sessionsToArchive = this.db.prepare(`
+   */
+  async archiveSessions(daysOld = 30) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // In-memory mode doesn't support archiving
+      console.warn('Session archiving not supported in in-memory mode');
+      return 0;
+    }
+
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+
+    const sessionsToArchive = this.db
+      .prepare(
+        `
       SELECT * FROM sessions 
       WHERE status = 'completed' AND updated_at < ?
-    `).all(cutoffDate.toISOString());
-        const archiveDir = path.join(this.sessionsDir, 'archive');
-        if (!existsSync(archiveDir)) {
-            mkdirSync(archiveDir, {
-                recursive: true
-            });
-        }
-        for (const session of sessionsToArchive){
-            const sessionData = await this.getSession(session.id);
-            const archiveFile = path.join(archiveDir, `${session.id}-archive.json`);
-            await writeFile(archiveFile, sessionSerializer.serializeSessionData(sessionData));
-            // Remove from database
-            this.db.prepare('DELETE FROM session_logs WHERE session_id = ?').run(session.id);
-            this.db.prepare('DELETE FROM session_checkpoints WHERE session_id = ?').run(session.id);
-            this.db.prepare('DELETE FROM sessions WHERE id = ?').run(session.id);
-        }
-        return sessionsToArchive.length;
+    `,
+      )
+      .all(cutoffDate.toISOString());
+
+    const archiveDir = path.join(this.sessionsDir, 'archive');
+    if (!existsSync(archiveDir)) {
+      mkdirSync(archiveDir, { recursive: true });
     }
-    /**
+
+    for (const session of sessionsToArchive) {
+      const sessionData = await this.getSession(session.id);
+      const archiveFile = path.join(archiveDir, `${session.id}-archive.json`);
+
+      await writeFile(archiveFile, sessionSerializer.serializeSessionData(sessionData));
+
+      // Remove from database
+      this.db.prepare('DELETE FROM session_logs WHERE session_id = ?').run(session.id);
+      this.db.prepare('DELETE FROM session_checkpoints WHERE session_id = ?').run(session.id);
+      this.db.prepare('DELETE FROM sessions WHERE id = ?').run(session.id);
+    }
+
+    return sessionsToArchive.length;
+  }
+
+  /**
    * Log session event
-   */ async logSessionEvent(sessionId, logLevel, message, agentId = null, data = null) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage for logs
-            const logId = `log-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-            const logEntry = {
-                id: logId,
-                session_id: sessionId,
-                timestamp: new Date().toISOString(),
-                log_level: logLevel,
-                message,
-                agent_id: agentId,
-                data: data ? sessionSerializer.serializeLogData(data) : null
-            };
-            if (!this.memoryStore.logs.has(sessionId)) {
-                this.memoryStore.logs.set(sessionId, []);
-            }
-            this.memoryStore.logs.get(sessionId).push(logEntry);
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async logSessionEvent(sessionId, logLevel, message, agentId = null, data = null) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage for logs
+      const logId = `log-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+      const logEntry = {
+        id: logId,
+        session_id: sessionId,
+        timestamp: new Date().toISOString(),
+        log_level: logLevel,
+        message,
+        agent_id: agentId,
+        data: data ? sessionSerializer.serializeLogData(data) : null,
+      };
+
+      if (!this.memoryStore.logs.has(sessionId)) {
+        this.memoryStore.logs.set(sessionId, []);
+      }
+      this.memoryStore.logs.get(sessionId).push(logEntry);
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         INSERT INTO session_logs (session_id, log_level, message, agent_id, data)
         VALUES (?, ?, ?, ?, ?)
       `);
-            stmt.run(sessionId, logLevel, message, agentId, data ? sessionSerializer.serializeLogData(data) : null);
-        }
+
+      stmt.run(
+        sessionId,
+        logLevel,
+        message,
+        agentId,
+        data ? sessionSerializer.serializeLogData(data) : null,
+      );
     }
-    /**
+  }
+
+  /**
    * Get session logs
-   */ async getSessionLogs(sessionId, limit = 100, offset = 0) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const logs = this.memoryStore.logs.get(sessionId) || [];
-            return logs.slice(offset, offset + limit).map((log)=>({
-                    ...log,
-                    data: log.data ? sessionSerializer.deserializeLogData(log.data) : null
-                }));
-        }
-        const stmt = this.db.prepare(`
+   */
+  async getSessionLogs(sessionId, limit = 100, offset = 0) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const logs = this.memoryStore.logs.get(sessionId) || [];
+      return logs.slice(offset, offset + limit).map((log) => ({
+        ...log,
+        data: log.data ? sessionSerializer.deserializeLogData(log.data) : null,
+      }));
+    }
+
+    const stmt = this.db.prepare(`
       SELECT * FROM session_logs 
       WHERE session_id = ? 
       ORDER BY timestamp DESC 
       LIMIT ? OFFSET ?
     `);
-        const logs = stmt.all(sessionId, limit, offset);
-        return logs.map((log)=>({
-                ...log,
-                data: log.data ? sessionSerializer.deserializeLogData(log.data) : null
-            }));
-    }
-    /**
+
+    const logs = stmt.all(sessionId, limit, offset);
+
+    return logs.map((log) => ({
+      ...log,
+      data: log.data ? sessionSerializer.deserializeLogData(log.data) : null,
+    }));
+  }
+
+  /**
    * Update session progress
-   */ async updateSessionProgress(sessionId, completionPercentage) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (session) {
-                session.completion_percentage = completionPercentage;
-                session.updated_at = new Date().toISOString();
-            }
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async updateSessionProgress(sessionId, completionPercentage) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (session) {
+        session.completion_percentage = completionPercentage;
+        session.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         UPDATE sessions 
         SET completion_percentage = ?, updated_at = CURRENT_TIMESTAMP
         WHERE id = ?
       `);
-            stmt.run(completionPercentage, sessionId);
-        }
+
+      stmt.run(completionPercentage, sessionId);
     }
-    /**
+  }
+
+  /**
    * Generate session summary
-   */ async generateSessionSummary(sessionId) {
-        const session = await this.getSession(sessionId);
-        if (!session) {
-            return null;
-        }
-        const duration = session.paused_at && session.resumed_at ? new Date(session.updated_at) - new Date(session.created_at) - (new Date(session.resumed_at) - new Date(session.paused_at)) : new Date(session.updated_at) - new Date(session.created_at);
-        const tasksByType = session.agents.reduce((acc, agent)=>{
-            const agentTasks = session.tasks.filter((t)=>t.agent_id === agent.id);
-            if (!acc[agent.type]) {
-                acc[agent.type] = {
-                    total: 0,
-                    completed: 0,
-                    inProgress: 0,
-                    pending: 0
-                };
-            }
-            acc[agent.type].total += agentTasks.length;
-            acc[agent.type].completed += agentTasks.filter((t)=>t.status === 'completed').length;
-            acc[agent.type].inProgress += agentTasks.filter((t)=>t.status === 'in_progress').length;
-            acc[agent.type].pending += agentTasks.filter((t)=>t.status === 'pending').length;
-            return acc;
-        }, {});
-        return {
-            sessionId: session.id,
-            swarmName: session.swarm_name,
-            objective: session.objective,
-            status: session.status,
-            duration: Math.round(duration / 1000 / 60),
-            statistics: session.statistics,
-            tasksByType,
-            checkpointCount: session.checkpoints.length,
-            lastCheckpoint: session.checkpoints[0] || null,
-            timeline: {
-                created: session.created_at,
-                lastUpdated: session.updated_at,
-                paused: session.paused_at,
-                resumed: session.resumed_at
-            }
-        };
+   */
+  async generateSessionSummary(sessionId) {
+    const session = await this.getSession(sessionId);
+
+    if (!session) {
+      return null;
     }
-    /**
+
+    const duration =
+      session.paused_at && session.resumed_at
+        ? new Date(session.updated_at) -
+          new Date(session.created_at) -
+          (new Date(session.resumed_at) - new Date(session.paused_at))
+        : new Date(session.updated_at) - new Date(session.created_at);
+
+    const tasksByType = session.agents.reduce((acc, agent) => {
+      const agentTasks = session.tasks.filter((t) => t.agent_id === agent.id);
+      if (!acc[agent.type]) {
+        acc[agent.type] = {
+          total: 0,
+          completed: 0,
+          inProgress: 0,
+          pending: 0,
+        };
+      }
+      acc[agent.type].total += agentTasks.length;
+      acc[agent.type].completed += agentTasks.filter((t) => t.status === 'completed').length;
+      acc[agent.type].inProgress += agentTasks.filter((t) => t.status === 'in_progress').length;
+      acc[agent.type].pending += agentTasks.filter((t) => t.status === 'pending').length;
+      return acc;
+    }, {});
+
+    return {
+      sessionId: session.id,
+      swarmName: session.swarm_name,
+      objective: session.objective,
+      status: session.status,
+      duration: Math.round(duration / 1000 / 60), // minutes
+      statistics: session.statistics,
+      tasksByType,
+      checkpointCount: session.checkpoints.length,
+      lastCheckpoint: session.checkpoints[0] || null,
+      timeline: {
+        created: session.created_at,
+        lastUpdated: session.updated_at,
+        paused: session.paused_at,
+        resumed: session.resumed_at,
+      },
+    };
+  }
+
+  /**
    * Export session data
-   */ async exportSession(sessionId, exportPath = null) {
-        const session = await this.getSession(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        const exportFile = exportPath || path.join(this.sessionsDir, `${sessionId}-export.json`);
-        await writeFile(exportFile, sessionSerializer.serializeSessionData(session));
-        return exportFile;
+   */
+  async exportSession(sessionId, exportPath = null) {
+    const session = await this.getSession(sessionId);
+
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
     }
-    /**
+
+    const exportFile = exportPath || path.join(this.sessionsDir, `${sessionId}-export.json`);
+
+    await writeFile(exportFile, sessionSerializer.serializeSessionData(session));
+
+    return exportFile;
+  }
+
+  /**
    * Import session data
-   */ async importSession(importPath) {
-        const sessionData = sessionSerializer.deserializeSessionData(await readFile(importPath, 'utf8'));
-        // Create new session with imported data
-        const newSessionId = this.createSession(sessionData.swarm_id, sessionData.swarm_name, sessionData.objective, sessionData.metadata);
-        // Import checkpoints
-        for (const checkpoint of sessionData.checkpoints || []){
-            await this.saveCheckpoint(newSessionId, checkpoint.checkpoint_name, checkpoint.checkpoint_data);
-        }
-        // Import logs
-        for (const log of sessionData.recentLogs || []){
-            await this.logSessionEvent(newSessionId, log.log_level, log.message, log.agent_id, log.data ? sessionSerializer.deserializeLogData(log.data) : null);
-        }
-        return newSessionId;
+   */
+  async importSession(importPath) {
+    const sessionData = sessionSerializer.deserializeSessionData(
+      await readFile(importPath, 'utf8'),
+    );
+
+    // Create new session with imported data
+    const newSessionId = this.createSession(
+      sessionData.swarm_id,
+      sessionData.swarm_name,
+      sessionData.objective,
+      sessionData.metadata,
+    );
+
+    // Import checkpoints
+    for (const checkpoint of sessionData.checkpoints || []) {
+      await this.saveCheckpoint(
+        newSessionId,
+        checkpoint.checkpoint_name,
+        checkpoint.checkpoint_data,
+      );
+    }
+
+    // Import logs
+    for (const log of sessionData.recentLogs || []) {
+      await this.logSessionEvent(
+        newSessionId,
+        log.log_level,
+        log.message,
+        log.agent_id,
+        log.data ? sessionSerializer.deserializeLogData(log.data) : null,
+      );
     }
-    /**
+
+    return newSessionId;
+  }
+
+  /**
    * Add a child process PID to session
-   */ async addChildPid(sessionId, pid) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (!session) return false;
-            const childPids = session.child_pids ? sessionSerializer.deserializeLogData(session.child_pids) : [];
-            if (!childPids.includes(pid)) {
-                childPids.push(pid);
-            }
-            session.child_pids = sessionSerializer.serializeLogData(childPids);
-            session.updated_at = new Date().toISOString();
-            await this.logSessionEvent(sessionId, 'info', 'Child process added', null, {
-                pid
-            });
-            return true;
-        }
-        const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
-        if (!session) return false;
-        const childPids = session.child_pids ? sessionSerializer.deserializeLogData(session.child_pids) : [];
-        if (!childPids.includes(pid)) {
-            childPids.push(pid);
-        }
-        const stmt = this.db.prepare(`
+   */
+  async addChildPid(sessionId, pid) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (!session) return false;
+
+      const childPids = session.child_pids
+        ? sessionSerializer.deserializeLogData(session.child_pids)
+        : [];
+      if (!childPids.includes(pid)) {
+        childPids.push(pid);
+      }
+      session.child_pids = sessionSerializer.serializeLogData(childPids);
+      session.updated_at = new Date().toISOString();
+
+      await this.logSessionEvent(sessionId, 'info', 'Child process added', null, { pid });
+      return true;
+    }
+
+    const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
+    if (!session) return false;
+
+    const childPids = session.child_pids
+      ? sessionSerializer.deserializeLogData(session.child_pids)
+      : [];
+    if (!childPids.includes(pid)) {
+      childPids.push(pid);
+    }
+
+    const stmt = this.db.prepare(`
       UPDATE sessions 
       SET child_pids = ?, updated_at = CURRENT_TIMESTAMP
       WHERE id = ?
     `);
-        stmt.run(sessionSerializer.serializeLogData(childPids), sessionId);
-        await this.logSessionEvent(sessionId, 'info', 'Child process added', null, {
-            pid
-        });
-        return true;
-    }
-    /**
+
+    stmt.run(sessionSerializer.serializeLogData(childPids), sessionId);
+
+    await this.logSessionEvent(sessionId, 'info', 'Child process added', null, { pid });
+    return true;
+  }
+
+  /**
    * Remove a child process PID from session
-   */ async removeChildPid(sessionId, pid) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (!session) return false;
-            const childPids = session.child_pids ? sessionSerializer.deserializeLogData(session.child_pids) : [];
-            const index = childPids.indexOf(pid);
-            if (index > -1) {
-                childPids.splice(index, 1);
-            }
-            session.child_pids = sessionSerializer.serializeLogData(childPids);
-            session.updated_at = new Date().toISOString();
-            await this.logSessionEvent(sessionId, 'info', 'Child process removed', null, {
-                pid
-            });
-            return true;
-        }
-        // Check if database connection is still open before operations
-        if (!this.db || !this.db.open) {
-            console.warn('Database connection closed, cannot remove child PID during cleanup');
-            return false;
-        }
-        const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
-        if (!session) return false;
-        const childPids = session.child_pids ? sessionSerializer.deserializeLogData(session.child_pids) : [];
-        const index = childPids.indexOf(pid);
-        if (index > -1) {
-            childPids.splice(index, 1);
-        }
-        const stmt = this.db.prepare(`
+   */
+  async removeChildPid(sessionId, pid) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (!session) return false;
+
+      const childPids = session.child_pids
+        ? sessionSerializer.deserializeLogData(session.child_pids)
+        : [];
+      const index = childPids.indexOf(pid);
+      if (index > -1) {
+        childPids.splice(index, 1);
+      }
+      session.child_pids = sessionSerializer.serializeLogData(childPids);
+      session.updated_at = new Date().toISOString();
+
+      await this.logSessionEvent(sessionId, 'info', 'Child process removed', null, { pid });
+      return true;
+    }
+
+    // Check if database connection is still open before operations
+    if (!this.db || !this.db.open) {
+      console.warn('Database connection closed, cannot remove child PID during cleanup');
+      return false;
+    }
+
+    const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
+    if (!session) return false;
+
+    const childPids = session.child_pids
+      ? sessionSerializer.deserializeLogData(session.child_pids)
+      : [];
+    const index = childPids.indexOf(pid);
+    if (index > -1) {
+      childPids.splice(index, 1);
+    }
+
+    const stmt = this.db.prepare(`
       UPDATE sessions 
       SET child_pids = ?, updated_at = CURRENT_TIMESTAMP
       WHERE id = ?
     `);
-        stmt.run(sessionSerializer.serializeLogData(childPids), sessionId);
-        await this.logSessionEvent(sessionId, 'info', 'Child process removed', null, {
-            pid
-        });
-        return true;
-    }
-    /**
+
+    stmt.run(sessionSerializer.serializeLogData(childPids), sessionId);
+
+    await this.logSessionEvent(sessionId, 'info', 'Child process removed', null, { pid });
+    return true;
+  }
+
+  /**
    * Get all child PIDs for a session
-   */ async getChildPids(sessionId) {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const session = this.memoryStore.sessions.get(sessionId);
-            if (!session || !session.child_pids) return [];
-            return sessionSerializer.deserializeLogData(session.child_pids);
-        } else {
-            // Check if database connection is still open
-            if (!this.db || !this.db.open) {
-                console.warn('Database connection closed, cannot get child PIDs during cleanup');
-                return [];
-            }
-            // Use SQLite
-            const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
-            if (!session || !session.child_pids) return [];
-            return sessionSerializer.deserializeLogData(session.child_pids);
-        }
+   */
+  async getChildPids(sessionId) {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const session = this.memoryStore.sessions.get(sessionId);
+      if (!session || !session.child_pids) return [];
+      return sessionSerializer.deserializeLogData(session.child_pids);
+    } else {
+      // Check if database connection is still open
+      if (!this.db || !this.db.open) {
+        console.warn('Database connection closed, cannot get child PIDs during cleanup');
+        return [];
+      }
+
+      // Use SQLite
+      const session = this.db
+        .prepare('SELECT child_pids FROM sessions WHERE id = ?')
+        .get(sessionId);
+      if (!session || !session.child_pids) return [];
+      return sessionSerializer.deserializeLogData(session.child_pids);
     }
-    /**
+  }
+
+  /**
    * Stop a session and terminate all child processes
-   */ async stopSession(sessionId) {
-        const session = await this.getSession(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        // Get child PIDs
-        const childPids = await this.getChildPids(sessionId);
-        // Terminate child processes
-        for (const pid of childPids){
-            try {
-                process.kill(pid, 'SIGTERM');
-                await this.logSessionEvent(sessionId, 'info', 'Child process terminated', null, {
-                    pid
-                });
-            } catch (err) {
-                // Process might already be dead
-                await this.logSessionEvent(sessionId, 'warning', 'Failed to terminate child process', null, {
-                    pid,
-                    error: err.message
-                });
-            }
-        }
-        // Update session status
-        if (this.isInMemory) {
-            // Use in-memory storage
-            const sessionData = this.memoryStore.sessions.get(sessionId);
-            if (sessionData) {
-                sessionData.status = 'stopped';
-                sessionData.updated_at = new Date().toISOString();
-            }
-        } else {
-            // Use SQLite
-            const stmt = this.db.prepare(`
+   */
+  async stopSession(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    // Get child PIDs
+    const childPids = await this.getChildPids(sessionId);
+
+    // Terminate child processes
+    for (const pid of childPids) {
+      try {
+        process.kill(pid, 'SIGTERM');
+        await this.logSessionEvent(sessionId, 'info', 'Child process terminated', null, { pid });
+      } catch (err) {
+        // Process might already be dead
+        await this.logSessionEvent(
+          sessionId,
+          'warning',
+          'Failed to terminate child process',
+          null,
+          {
+            pid,
+            error: err.message,
+          },
+        );
+      }
+    }
+
+    // Update session status
+    if (this.isInMemory) {
+      // Use in-memory storage
+      const sessionData = this.memoryStore.sessions.get(sessionId);
+      if (sessionData) {
+        sessionData.status = 'stopped';
+        sessionData.updated_at = new Date().toISOString();
+      }
+    } else {
+      // Use SQLite
+      const stmt = this.db.prepare(`
         UPDATE sessions 
         SET status = 'stopped', updated_at = CURRENT_TIMESTAMP
         WHERE id = ?
       `);
-            stmt.run(sessionId);
-            // Update swarm status
-            this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('stopped', session.swarm_id);
-        }
-        await this.logSessionEvent(sessionId, 'info', 'Session stopped');
-        return true;
+
+      stmt.run(sessionId);
+
+      // Update swarm status
+      this.db.prepare('UPDATE swarms SET status = ? WHERE id = ?').run('stopped', session.swarm_id);
     }
-    /**
+
+    await this.logSessionEvent(sessionId, 'info', 'Session stopped');
+
+    return true;
+  }
+
+  /**
    * Get active sessions with process information
-   */ async getActiveSessionsWithProcessInfo() {
-        const sessions = await this.getActiveSessions();
-        // Add process info to each session
-        return sessions.map((session)=>{
-            const childPids = session.child_pids ? sessionSerializer.deserializeLogData(session.child_pids) : [];
-            const aliveChildPids = [];
-            // Check which child processes are still alive
-            for (const pid of childPids){
-                try {
-                    process.kill(pid, 0); // Signal 0 just checks if process exists
-                    aliveChildPids.push(pid);
-                } catch (err) {
-                // Process is dead
-                }
-            }
-            return {
-                ...session,
-                parent_pid: session.parent_pid,
-                child_pids: aliveChildPids,
-                total_processes: 1 + aliveChildPids.length
-            };
-        });
-    }
-    /**
-   * Clean up orphaned processes
-   */ async cleanupOrphanedProcesses() {
-        await this.ensureInitialized();
-        if (this.isInMemory) {
-            // In-memory mode doesn't track orphaned processes
-            return 0;
+   */
+  async getActiveSessionsWithProcessInfo() {
+    const sessions = await this.getActiveSessions();
+
+    // Add process info to each session
+    return sessions.map((session) => {
+      const childPids = session.child_pids
+        ? sessionSerializer.deserializeLogData(session.child_pids)
+        : [];
+      const aliveChildPids = [];
+
+      // Check which child processes are still alive
+      for (const pid of childPids) {
+        try {
+          process.kill(pid, 0); // Signal 0 just checks if process exists
+          aliveChildPids.push(pid);
+        } catch (err) {
+          // Process is dead
         }
-        const sessions = this.db.prepare(`
+      }
+
+      return {
+        ...session,
+        parent_pid: session.parent_pid,
+        child_pids: aliveChildPids,
+        total_processes: 1 + aliveChildPids.length,
+      };
+    });
+  }
+
+  /**
+   * Clean up orphaned processes
+   */
+  async cleanupOrphanedProcesses() {
+    await this.ensureInitialized();
+
+    if (this.isInMemory) {
+      // In-memory mode doesn't track orphaned processes
+      return 0;
+    }
+
+    const sessions = this.db
+      .prepare(
+        `
       SELECT * FROM sessions 
       WHERE status IN ('active', 'paused')
-    `).all();
-        let cleanedCount = 0;
-        for (const session of sessions){
-            // Check if parent process is still alive
-            try {
-                process.kill(session.parent_pid, 0);
-            } catch (err) {
-                // Parent is dead, clean up session
-                await this.stopSession(session.id);
-                cleanedCount++;
-                await this.logSessionEvent(session.id, 'info', 'Orphaned session cleaned up');
-            }
-        }
-        return cleanedCount;
+    `,
+      )
+      .all();
+
+    let cleanedCount = 0;
+
+    for (const session of sessions) {
+      // Check if parent process is still alive
+      try {
+        process.kill(session.parent_pid, 0);
+      } catch (err) {
+        // Parent is dead, clean up session
+        await this.stopSession(session.id);
+        cleanedCount++;
+        await this.logSessionEvent(session.id, 'info', 'Orphaned session cleaned up');
+      }
     }
-    /**
+
+    return cleanedCount;
+  }
+
+  /**
    * Clean up and close database connection
-   */ close() {
-        if (this.db && !this.isInMemory) {
-            this.db.close();
-        }
-    }
-    constructor(hiveMindDir = null){
-        this.hiveMindDir = hiveMindDir || path.join(cwd(), '.hive-mind');
-        this.sessionsDir = path.join(this.hiveMindDir, 'sessions');
-        this.dbPath = path.join(this.hiveMindDir, 'hive.db');
-        this.db = null;
-        this.isInMemory = false;
-        this.memoryStore = null;
-        this.initializationPromise = null;
-        // Ensure directories exist
-        this.ensureDirectories();
-        // Initialize database connection (store promise for later)
-        this.initializationPromise = this.initializeDatabase();
+   */
+  close() {
+    if (this.db && !this.isInMemory) {
+      this.db.close();
     }
+  }
 }
+
 // Export for use in other modules
 export default HiveMindSessionManager;