claude-flow-novice 2.0.3 → 2.0.4

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

@@ -1,115 +1,85 @@
 /**
  * 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 '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';
-
+ */ 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";
 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,
@@ -148,247 +118,189 @@ 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 database migrations
-   */
-  runMigrations() {
-    if (!this.db) {
-      console.error('Database not initialized for migrations');
-      return;
+        // Run migrations to add new columns
+        this.runMigrations();
     }
-    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);
+    /**
+   * 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);
+        }
     }
-  }
-
-  /**
+    /**
    * 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;
-  }
-
-  /**
-   * 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, // Not tracked in memory mode
-            task_count: 0, // Not tracked in memory mode
-            completed_tasks: 0, // Not tracked in memory mode
-            completion_percentage: 0,
-          });
+            updateStmt.run(sessionSerializer.serializeCheckpointData(checkpointData), sessionId);
         }
-      }
-      return sessions.sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at));
-    } else {
-      // Use SQLite
-      const stmt = this.db.prepare(`
+        // 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(`
         SELECT s.*, 
                COUNT(DISTINCT a.id) as agent_count,
                COUNT(DISTINCT t.id) as task_count,
@@ -400,824 +312,608 @@ 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, // 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(
-        `
+   */ 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(`
       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);
+            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;
         }
-      }
-
-      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);
+      `).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;
     }
-
-    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);
+            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;
         }
-      }
-
-      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);
+    `).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;
     }
-
-    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,
+   */ 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
+            }
         };
-      }
-      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`);
+   */ 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;
     }
-
-    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,
-      );
+   */ 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;
     }
-
-    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;
-  }
-
-  /**
-   * 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);
+        stmt.run(sessionSerializer.serializeLogData(childPids), sessionId);
+        await this.logSessionEvent(sessionId, 'info', 'Child process added', null, {
+            pid
+        });
+        return true;
     }
-
-    const stmt = this.db.prepare(`
+    /**
+   * 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(`
       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);
+            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;
     }
-
-    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,
-      };
-    });
-  }
-
-  /**
+   */ 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;
-    }
-
-    const sessions = this.db
-      .prepare(
-        `
+   */ 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');
-      }
+    `).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;
     }
-
-    return cleanedCount;
-  }
-
-  /**
+    /**
    * Clean up and close database connection
-   */
-  close() {
-    if (this.db && !this.isInMemory) {
-      this.db.close();
+   */ 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();
     }
-  }
 }
-
 // Export for use in other modules
 export default HiveMindSessionManager;