claude-flow 2.0.0-alpha.63 → 2.0.0-alpha.65

package/dist/cli/simple-commands/hive-mind/session-manager.d.ts

@@ -0,0 +1,139 @@
+export class HiveMindSessionManager {
+    constructor(hiveMindDir?: null);
+    hiveMindDir: string;
+    sessionsDir: string;
+    dbPath: string;
+    db: any;
+    isInMemory: boolean;
+    memoryStore: {
+        sessions: Map<any, any>;
+        checkpoints: Map<any, any>;
+        logs: Map<any, any>;
+    } | null;
+    /**
+     * Initialize database with fallback support
+     */
+    initializeDatabase(): Promise<void>;
+    /**
+     * Ensure database is initialized before use
+     */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Initialize in-memory fallback for session storage
+     */
+    initializeInMemoryFallback(): void;
+    /**
+     * Ensure required directories exist
+     */
+    ensureDirectories(): void;
+    /**
+     * Initialize database schema for sessions
+     */
+    initializeSchema(): void;
+    /**
+     * Run database migrations
+     */
+    runMigrations(): void;
+    /**
+     * Create a new session for a swarm
+     */
+    createSession(swarmId: any, swarmName: any, objective: any, metadata?: {}): Promise<string>;
+    /**
+     * Save session checkpoint
+     */
+    saveCheckpoint(sessionId: any, checkpointName: any, checkpointData: any): Promise<string>;
+    /**
+     * Get active sessions
+     */
+    getActiveSessions(): Promise<any>;
+    /**
+     * Get session by ID with full details
+     */
+    getSession(sessionId: any): Promise<any>;
+    /**
+     * Pause a session
+     */
+    pauseSession(sessionId: any): Promise<boolean>;
+    /**
+     * Resume any previous session (paused, stopped, or inactive)
+     */
+    resumeSession(sessionId: any): Promise<any>;
+    /**
+     * Mark session as completed
+     */
+    completeSession(sessionId: any): boolean;
+    /**
+     * Archive old sessions
+     */
+    archiveSessions(daysOld?: number): Promise<any>;
+    /**
+     * Log session event
+     */
+    logSessionEvent(sessionId: any, logLevel: any, message: any, agentId?: null, data?: null): Promise<void>;
+    /**
+     * Get session logs
+     */
+    getSessionLogs(sessionId: any, limit?: number, offset?: number): any;
+    /**
+     * Update session progress
+     */
+    updateSessionProgress(sessionId: any, completionPercentage: any): Promise<void>;
+    /**
+     * Generate session summary
+     */
+    generateSessionSummary(sessionId: any): {
+        sessionId: any;
+        swarmName: any;
+        objective: any;
+        status: any;
+        duration: number;
+        statistics: any;
+        tasksByType: any;
+        checkpointCount: any;
+        lastCheckpoint: any;
+        timeline: {
+            created: any;
+            lastUpdated: any;
+            paused: any;
+            resumed: any;
+        };
+    } | null;
+    /**
+     * Export session data
+     */
+    exportSession(sessionId: any, exportPath?: null): Promise<string>;
+    /**
+     * Import session data
+     */
+    importSession(importPath: any): Promise<string>;
+    /**
+     * Add a child process PID to session
+     */
+    addChildPid(sessionId: any, pid: any): boolean;
+    /**
+     * Remove a child process PID from session
+     */
+    removeChildPid(sessionId: any, pid: any): boolean;
+    /**
+     * Get all child PIDs for a session
+     */
+    getChildPids(sessionId: any): Promise<any>;
+    /**
+     * Stop a session and terminate all child processes
+     */
+    stopSession(sessionId: any): Promise<boolean>;
+    /**
+     * Get active sessions with process information
+     */
+    getActiveSessionsWithProcessInfo(): any;
+    /**
+     * Clean up orphaned processes
+     */
+    cleanupOrphanedProcesses(): number;
+    /**
+     * Clean up and close database connection
+     */
+    close(): void;
+}
+export default HiveMindSessionManager;
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/cli/simple-commands/hive-mind/session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/hive-mind/session-manager.js"],"names":[],"mappings":"AAYA;IACE,gCAaC;IAZC,oBAAgE;IAChE,oBAA0D;IAC1D,eAAoD;IACpD,QAAc;IACd,oBAAuB;IACvB;;;;aAAuB;IASzB;;OAEG;IACH,oCAiBC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,mCAcC;IAED;;OAEG;IACH,0BAOC;IAED;;OAEG;IACH,yBA0CC;IAED;;OAEG;IACH,sBAmBC;IAED;;OAEG;IACH,4FAuCC;IAED;;OAEG;IACH,0FAmEC;IAED;;OAEG;IACH,kCAgDC;IAED;;OAEG;IACH,yCAyHC;IAED;;OAEG;IACH,+CAuCC;IAED;;OAEG;IACH,4CAkDC;IAED;;OAEG;IACH,yCAsBC;IAED;;OAEG;IACH,gDA+BC;IAED;;OAEG;IACH,yGA6BC;IAED;;OAEG;IACH,qEAcC;IAED;;OAEG;IACH,gFAoBC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;aAgDC;IAED;;OAEG;IACH,kEAYC;IAED;;OAEG;IACH,gDAgCC;IAED;;OAEG;IACH,+CAmBC;IAED;;OAEG;IACH,kDAoBC;IAED;;OAEG;IACH,2CAcC;IAED;;OAEG;IACH,8CAgDC;IAED;;OAEG;IACH,wCAyBC;IAED;;OAEG;IACH,mCAyBC;IAED;;OAEG;IACH,cAIC;CACF"}

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

@@ -2,22 +2,69 @@
  * Hive Mind Session Manager
  * Handles session persistence and resume functionality for swarms
  */
-import Database from 'better-sqlite3';
 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';
 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;
         // Ensure directories exist
         this.ensureDirectories();
         // Initialize database connection
-        this.db = new Database(this.dbPath);
-        this.initializeSchema();
+        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);
+            this.initializeSchema();
+        }
+        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.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(`
+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
@@ -100,15 +147,35 @@ export class HiveMindSessionManager {
     /**
      * Create a new session for a swarm
      */
-    createSession(swarmId, swarmName, objective, metadata = {}) {
+    async createSession(swarmId, swarmName, objective, metadata = {}) {
+        await this.ensureInitialized();
         const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const stmt = this.db.prepare(`
-      INSERT INTO sessions (id, swarm_id, swarm_name, objective, metadata, parent_pid)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(sessionId, swarmId, swarmName, objective, JSON.stringify(metadata), process.pid);
+        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: JSON.stringify(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, JSON.stringify(metadata), process.pid);
+        }
         // Log session creation
-        this.logSessionEvent(sessionId, 'info', 'Session created', null, {
+        await this.logSessionEvent(sessionId, 'info', 'Session created', null, {
             swarmId,
             swarmName,
             objective,
@@ -120,20 +187,43 @@ export class HiveMindSessionManager {
      * Save session checkpoint
      */
     async saveCheckpoint(sessionId, checkpointName, checkpointData) {
+        await this.ensureInitialized();
         const checkpointId = `checkpoint-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        // 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, JSON.stringify(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(JSON.stringify(checkpointData), sessionId);
+        if (this.isInMemory) {
+            // Use in-memory storage
+            const checkpointEntry = {
+                id: checkpointId,
+                session_id: sessionId,
+                checkpoint_name: checkpointName,
+                checkpoint_data: JSON.stringify(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 = JSON.stringify(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, JSON.stringify(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(JSON.stringify(checkpointData), sessionId);
+        }
         // Save checkpoint file for backup
         const checkpointFile = path.join(this.sessionsDir, `${sessionId}-${checkpointName}.json`);
         await writeFile(checkpointFile, JSON.stringify({
@@ -143,7 +233,7 @@ export class HiveMindSessionManager {
             timestamp: new Date().toISOString(),
             data: checkpointData,
         }, null, 2));
-        this.logSessionEvent(sessionId, 'info', `Checkpoint saved: ${checkpointName}`, null, {
+        await this.logSessionEvent(sessionId, 'info', `Checkpoint saved: ${checkpointName}`, null, {
             checkpointId,
         });
         return checkpointId;
@@ -151,34 +241,84 @@ export class HiveMindSessionManager {
     /**
      * Get active sessions
      */
-    getActiveSessions() {
-        const stmt = this.db.prepare(`
-      SELECT s.*, 
-             COUNT(DISTINCT a.id) as agent_count,
-             COUNT(DISTINCT t.id) as task_count,
-             SUM(CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END) as completed_tasks
-      FROM sessions s
-      LEFT JOIN agents a ON s.swarm_id = a.swarm_id
-      LEFT JOIN tasks t ON s.swarm_id = t.swarm_id
-      WHERE s.status = 'active' OR s.status = 'paused'
-      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 ? JSON.parse(session.metadata) : {},
-            checkpoint_data: session.checkpoint_data ? JSON.parse(session.checkpoint_data) : null,
-            completion_percentage: session.task_count > 0
-                ? Math.round((session.completed_tasks / session.task_count) * 100)
-                : 0,
-        }));
+    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 ? JSON.parse(session.metadata) : {},
+                        checkpoint_data: session.checkpoint_data ? JSON.parse(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,
+               SUM(CASE WHEN t.status = 'completed' THEN 1 ELSE 0 END) as completed_tasks
+        FROM sessions s
+        LEFT JOIN agents a ON s.swarm_id = a.swarm_id
+        LEFT JOIN tasks t ON s.swarm_id = t.swarm_id
+        WHERE s.status = 'active' OR s.status = 'paused'
+        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 ? JSON.parse(session.metadata) : {},
+                checkpoint_data: session.checkpoint_data ? JSON.parse(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
      */
-    getSession(sessionId) {
+    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 ? JSON.parse(session.metadata) : {},
+                checkpoint_data: session.checkpoint_data ? JSON.parse(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 = ?
@@ -250,24 +390,40 @@ export class HiveMindSessionManager {
     /**
      * Pause a session
      */
-    pauseSession(sessionId) {
-        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) {
-            this.logSessionEvent(sessionId, 'info', 'Session paused');
-            // Update swarm status
-            const session = this.db.prepare('SELECT swarm_id FROM sessions WHERE id = ?').get(sessionId);
+    async pauseSession(sessionId) {
+        await this.ensureInitialized();
+        if (this.isInMemory) {
+            // Use in-memory storage
+            const session = this.memoryStore.sessions.get(sessionId);
             if (session) {
-                this.db
-                    .prepare('UPDATE swarms SET status = ? WHERE id = ?')
-                    .run('paused', session.swarm_id);
+                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;
         }
-        return result.changes > 0;
     }
     /**
      * Resume any previous session (paused, stopped, or inactive)
@@ -360,12 +516,33 @@ export class HiveMindSessionManager {
     /**
      * Log session event
      */
-    logSessionEvent(sessionId, logLevel, message, agentId = null, data = null) {
-        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 ? JSON.stringify(data) : null);
+    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 ? JSON.stringify(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 ? JSON.stringify(data) : null);
+        }
     }
     /**
      * Get session logs
@@ -386,13 +563,25 @@ export class HiveMindSessionManager {
     /**
      * Update session progress
      */
-    updateSessionProgress(sessionId, completionPercentage) {
-        const stmt = this.db.prepare(`
-      UPDATE sessions 
-      SET completion_percentage = ?, updated_at = CURRENT_TIMESTAMP
-      WHERE id = ?
-    `);
-        stmt.run(completionPercentage, sessionId);
+    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);
+        }
     }
     /**
      * Generate session summary
@@ -514,46 +703,68 @@ export class HiveMindSessionManager {
     /**
      * Get all child PIDs for a session
      */
-    getChildPids(sessionId) {
-        const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
-        if (!session || !session.child_pids)
-            return [];
-        return JSON.parse(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 JSON.parse(session.child_pids);
+        }
+        else {
+            // Use SQLite
+            const session = this.db.prepare('SELECT child_pids FROM sessions WHERE id = ?').get(sessionId);
+            if (!session || !session.child_pids)
+                return [];
+            return JSON.parse(session.child_pids);
+        }
     }
     /**
      * Stop a session and terminate all child processes
      */
     async stopSession(sessionId) {
-        const session = this.getSession(sessionId);
+        const session = await this.getSession(sessionId);
         if (!session) {
             throw new Error(`Session ${sessionId} not found`);
         }
         // Get child PIDs
-        const childPids = this.getChildPids(sessionId);
+        const childPids = await this.getChildPids(sessionId);
         // Terminate child processes
         for (const pid of childPids) {
             try {
                 process.kill(pid, 'SIGTERM');
-                this.logSessionEvent(sessionId, 'info', 'Child process terminated', null, { pid });
+                await this.logSessionEvent(sessionId, 'info', 'Child process terminated', null, { pid });
             }
             catch (err) {
                 // Process might already be dead
-                this.logSessionEvent(sessionId, 'warning', 'Failed to terminate child process', null, {
+                await this.logSessionEvent(sessionId, 'warning', 'Failed to terminate child process', null, {
                     pid,
                     error: err.message,
                 });
             }
         }
         // Update session status
-        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);
-        this.logSessionEvent(sessionId, 'info', 'Session stopped');
+        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;
     }
     /**
@@ -612,7 +823,9 @@ export class HiveMindSessionManager {
      * Clean up and close database connection
      */
     close() {
-        this.db.close();
+        if (this.db && !this.isInMemory) {
+            this.db.close();
+        }
     }
 }
 // Export for use in other modules