claudia-orchestrator 0.1.0

package/dist/services/session-info-service.js

@@ -0,0 +1,920 @@
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { CONFIG_DIR, CONFIG_DIR_NAME } from '../utils/constants.js';
+import { createLogger } from './logger.js';
+/**
+ * SessionInfoService manages session information using SQLite backend
+ * Stores session metadata including custom names in ~/.cui/session-info.db
+ * Provides fast lookups and updates for session-specific data
+ */
+export class SessionInfoService {
+    static instance;
+    logger;
+    dbPath;
+    configDir;
+    isInitialized = false;
+    db;
+    getSessionStmt;
+    insertSessionStmt;
+    updateSessionStmt;
+    deleteSessionStmt;
+    getAllStmt;
+    countStmt;
+    archiveAllStmt;
+    setMetadataStmt;
+    getMetadataStmt;
+    // Insights statements
+    getInsightsStmt;
+    upsertInsightsStmt;
+    getAllInsightsStmt;
+    markInsightsStaleStmt;
+    getStaleInsightsStmt;
+    constructor(customConfigDir) {
+        this.logger = createLogger('SessionInfoService');
+        this.initializePaths(customConfigDir);
+    }
+    static getInstance() {
+        if (!SessionInfoService.instance) {
+            SessionInfoService.instance = new SessionInfoService();
+        }
+        return SessionInfoService.instance;
+    }
+    static resetInstance() {
+        if (SessionInfoService.instance) {
+            SessionInfoService.instance.isInitialized = false;
+        }
+        SessionInfoService.instance = null;
+    }
+    initializePaths(customConfigDir) {
+        if (customConfigDir) {
+            if (customConfigDir === ':memory:') {
+                this.configDir = ':memory:';
+                this.dbPath = ':memory:';
+                return;
+            }
+            this.configDir = path.join(customConfigDir, CONFIG_DIR_NAME);
+        }
+        else {
+            this.configDir = CONFIG_DIR;
+        }
+        this.dbPath = path.join(this.configDir, 'session-info.db');
+        this.logger.debug('Initializing paths', {
+            configDir: this.configDir,
+            dbPath: this.dbPath
+        });
+    }
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        try {
+            if (this.dbPath !== ':memory:' && !fs.existsSync(this.configDir)) {
+                fs.mkdirSync(this.configDir, { recursive: true });
+                this.logger.debug('Created config directory', { dir: this.configDir });
+            }
+            this.db = new Database(this.dbPath);
+            this.db.pragma('journal_mode = WAL');
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS sessions (
+          session_id TEXT PRIMARY KEY,
+          custom_name TEXT NOT NULL DEFAULT '',
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          version INTEGER NOT NULL,
+          pinned INTEGER NOT NULL DEFAULT 0,
+          archived INTEGER NOT NULL DEFAULT 0,
+          continuation_session_id TEXT NOT NULL DEFAULT '',
+          initial_commit_head TEXT NOT NULL DEFAULT '',
+          permission_mode TEXT NOT NULL DEFAULT 'default'
+        );
+        CREATE TABLE IF NOT EXISTS metadata (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS session_insights (
+          session_id TEXT PRIMARY KEY,
+          description TEXT,
+          purposes TEXT NOT NULL DEFAULT '[]',
+          milestones TEXT NOT NULL DEFAULT '[]',
+          recent_actions TEXT NOT NULL DEFAULT '[]',
+          progress_completed INTEGER NOT NULL DEFAULT 0,
+          progress_total INTEGER NOT NULL DEFAULT 0,
+          outstanding_tasks TEXT NOT NULL DEFAULT '[]',
+          completed_tasks TEXT NOT NULL DEFAULT '[]',
+          current_task TEXT,
+          theme TEXT,
+          computed_at TEXT NOT NULL,
+          stale INTEGER NOT NULL DEFAULT 0
+        );
+      `);
+            // Migration: Add new columns if they don't exist (for existing databases)
+            this.migrateSessionsColumns();
+            this.migrateInsightsColumns();
+            this.prepareStatements();
+            this.ensureMetadata();
+            this.isInitialized = true;
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize session info database', error);
+            throw new Error(`Session info database initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    migrateSessionsColumns() {
+        // Check if new columns exist on sessions table and add them if not
+        try {
+            const tableInfo = this.db.pragma('table_info(sessions)');
+            const columnNames = tableInfo.map(col => col.name);
+            if (!columnNames.includes('identity_image')) {
+                this.db.exec("ALTER TABLE sessions ADD COLUMN identity_image TEXT DEFAULT NULL");
+                this.logger.info('Added identity_image column to sessions');
+            }
+        }
+        catch (error) {
+            this.logger.debug('Sessions migration check failed', { error });
+        }
+    }
+    migrateInsightsColumns() {
+        // Check if new columns exist and add them if not
+        try {
+            const tableInfo = this.db.pragma('table_info(session_insights)');
+            const columnNames = tableInfo.map(col => col.name);
+            if (!columnNames.includes('purposes')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN purposes TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added purposes column to session_insights');
+            }
+            if (!columnNames.includes('milestones')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN milestones TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added milestones column to session_insights');
+            }
+            if (!columnNames.includes('recent_actions')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN recent_actions TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added recent_actions column to session_insights');
+            }
+            // New ontology columns
+            if (!columnNames.includes('context')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN context TEXT DEFAULT NULL");
+                this.logger.info('Added context column to session_insights');
+            }
+            if (!columnNames.includes('notable')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN notable TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added notable column to session_insights');
+            }
+            if (!columnNames.includes('tags')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN tags TEXT DEFAULT NULL");
+                this.logger.info('Added tags column to session_insights');
+            }
+            if (!columnNames.includes('panels')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN panels TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added panels column to session_insights');
+            }
+            // Delta detection metadata columns
+            if (!columnNames.includes('message_count')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN message_count INTEGER DEFAULT NULL");
+                this.logger.info('Added message_count column to session_insights');
+            }
+            if (!columnNames.includes('last_delta_check_at')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN last_delta_check_at TEXT DEFAULT NULL");
+                this.logger.info('Added last_delta_check_at column to session_insights');
+            }
+            if (!columnNames.includes('patched_at')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN patched_at TEXT DEFAULT NULL");
+                this.logger.info('Added patched_at column to session_insights');
+            }
+            if (!columnNames.includes('current_state')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN current_state TEXT DEFAULT NULL");
+                this.logger.info('Added current_state column to session_insights');
+            }
+            if (!columnNames.includes('last_patch_trace_id')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN last_patch_trace_id TEXT DEFAULT NULL");
+                this.logger.info('Added last_patch_trace_id column to session_insights');
+            }
+        }
+        catch (error) {
+            this.logger.debug('Migration check failed (table may not exist yet)', { error });
+        }
+    }
+    prepareStatements() {
+        this.getSessionStmt = this.db.prepare('SELECT * FROM sessions WHERE session_id = ?');
+        this.insertSessionStmt = this.db.prepare(`
+      INSERT INTO sessions (
+        session_id,
+        custom_name,
+        created_at,
+        updated_at,
+        version,
+        pinned,
+        archived,
+        continuation_session_id,
+        initial_commit_head,
+        permission_mode
+      ) VALUES (
+        @session_id,
+        @custom_name,
+        @created_at,
+        @updated_at,
+        @version,
+        @pinned,
+        @archived,
+        @continuation_session_id,
+        @initial_commit_head,
+        @permission_mode
+      )
+    `);
+        this.updateSessionStmt = this.db.prepare(`
+      UPDATE sessions SET
+        custom_name=@custom_name,
+        updated_at=@updated_at,
+        pinned=@pinned,
+        archived=@archived,
+        continuation_session_id=@continuation_session_id,
+        initial_commit_head=@initial_commit_head,
+        permission_mode=@permission_mode,
+        version=@version
+      WHERE session_id=@session_id
+    `);
+        this.deleteSessionStmt = this.db.prepare('DELETE FROM sessions WHERE session_id = ?');
+        this.getAllStmt = this.db.prepare('SELECT * FROM sessions');
+        this.countStmt = this.db.prepare('SELECT COUNT(*) as count FROM sessions');
+        this.archiveAllStmt = this.db.prepare('UPDATE sessions SET archived=1, updated_at=@updated_at WHERE archived=0');
+        this.setMetadataStmt = this.db.prepare('INSERT INTO metadata (key, value) VALUES (@key, @value) ON CONFLICT(key) DO UPDATE SET value=excluded.value');
+        this.getMetadataStmt = this.db.prepare('SELECT value FROM metadata WHERE key = ?');
+        // Insights statements
+        this.getInsightsStmt = this.db.prepare('SELECT * FROM session_insights WHERE session_id = ?');
+        this.upsertInsightsStmt = this.db.prepare(`
+      INSERT INTO session_insights (
+        session_id, description, context, current_state, last_patch_trace_id, purposes, milestones, notable, tags, recent_actions, panels,
+        progress_completed, progress_total,
+        outstanding_tasks, completed_tasks, current_task, theme, computed_at, stale,
+        message_count, last_delta_check_at, patched_at
+      ) VALUES (
+        @session_id, @description, @context, @current_state, @last_patch_trace_id, @purposes, @milestones, @notable, @tags, @recent_actions, @panels,
+        @progress_completed, @progress_total,
+        @outstanding_tasks, @completed_tasks, @current_task, @theme, @computed_at, @stale,
+        @message_count, @last_delta_check_at, @patched_at
+      ) ON CONFLICT(session_id) DO UPDATE SET
+        description=excluded.description,
+        context=excluded.context,
+        current_state=excluded.current_state,
+        last_patch_trace_id=excluded.last_patch_trace_id,
+        purposes=excluded.purposes,
+        milestones=excluded.milestones,
+        notable=excluded.notable,
+        tags=excluded.tags,
+        recent_actions=excluded.recent_actions,
+        panels=excluded.panels,
+        progress_completed=excluded.progress_completed,
+        progress_total=excluded.progress_total,
+        outstanding_tasks=excluded.outstanding_tasks,
+        completed_tasks=excluded.completed_tasks,
+        current_task=excluded.current_task,
+        theme=excluded.theme,
+        computed_at=excluded.computed_at,
+        stale=excluded.stale,
+        message_count=excluded.message_count,
+        last_delta_check_at=excluded.last_delta_check_at,
+        patched_at=excluded.patched_at
+    `);
+        this.getAllInsightsStmt = this.db.prepare('SELECT * FROM session_insights');
+        this.markInsightsStaleStmt = this.db.prepare('UPDATE session_insights SET stale=1 WHERE session_id = ?');
+        this.getStaleInsightsStmt = this.db.prepare('SELECT session_id FROM session_insights WHERE stale = 1');
+    }
+    ensureMetadata() {
+        const now = new Date().toISOString();
+        const schema = this.getMetadataStmt.get('schema_version');
+        if (!schema) {
+            this.setMetadataStmt.run({ key: 'schema_version', value: '3' });
+            this.setMetadataStmt.run({ key: 'created_at', value: now });
+            this.setMetadataStmt.run({ key: 'last_updated', value: now });
+        }
+    }
+    mapRow(row) {
+        return {
+            custom_name: row.custom_name,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            version: row.version,
+            pinned: !!row.pinned,
+            archived: !!row.archived,
+            continuation_session_id: row.continuation_session_id,
+            initial_commit_head: row.initial_commit_head,
+            permission_mode: row.permission_mode,
+            identity_image: row.identity_image ?? undefined
+        };
+    }
+    async getSessionInfo(sessionId) {
+        try {
+            const row = this.getSessionStmt.get(sessionId);
+            if (row) {
+                return this.mapRow(row);
+            }
+            const now = new Date().toISOString();
+            const defaultSession = {
+                custom_name: '',
+                created_at: now,
+                updated_at: now,
+                version: 3,
+                pinned: false,
+                archived: false,
+                continuation_session_id: '',
+                initial_commit_head: '',
+                permission_mode: 'default'
+            };
+            this.insertSessionStmt.run({
+                session_id: sessionId,
+                custom_name: '',
+                created_at: now,
+                updated_at: now,
+                version: 3,
+                pinned: 0,
+                archived: 0,
+                continuation_session_id: '',
+                initial_commit_head: '',
+                permission_mode: 'default'
+            });
+            this.setMetadataStmt.run({ key: 'last_updated', value: now });
+            return defaultSession;
+        }
+        catch (error) {
+            this.logger.error('Failed to get session info', { sessionId, error });
+            const now = new Date().toISOString();
+            return {
+                custom_name: '',
+                created_at: now,
+                updated_at: now,
+                version: 3,
+                pinned: false,
+                archived: false,
+                continuation_session_id: '',
+                initial_commit_head: '',
+                permission_mode: 'default'
+            };
+        }
+    }
+    async updateSessionInfo(sessionId, updates) {
+        try {
+            const existingRow = this.getSessionStmt.get(sessionId);
+            const now = new Date().toISOString();
+            if (existingRow) {
+                const updatedSession = {
+                    ...this.mapRow(existingRow),
+                    ...updates,
+                    updated_at: now
+                };
+                this.updateSessionStmt.run({
+                    session_id: sessionId,
+                    custom_name: updatedSession.custom_name,
+                    updated_at: updatedSession.updated_at,
+                    pinned: updatedSession.pinned ? 1 : 0,
+                    archived: updatedSession.archived ? 1 : 0,
+                    continuation_session_id: updatedSession.continuation_session_id,
+                    initial_commit_head: updatedSession.initial_commit_head,
+                    permission_mode: updatedSession.permission_mode,
+                    version: updatedSession.version
+                });
+                this.setMetadataStmt.run({ key: 'last_updated', value: now });
+                return updatedSession;
+            }
+            else {
+                const newSession = {
+                    custom_name: '',
+                    created_at: now,
+                    updated_at: now,
+                    version: 3,
+                    pinned: false,
+                    archived: false,
+                    continuation_session_id: '',
+                    initial_commit_head: '',
+                    permission_mode: 'default',
+                    ...updates
+                };
+                this.insertSessionStmt.run({
+                    session_id: sessionId,
+                    custom_name: newSession.custom_name,
+                    created_at: newSession.created_at,
+                    updated_at: newSession.updated_at,
+                    version: newSession.version,
+                    pinned: newSession.pinned ? 1 : 0,
+                    archived: newSession.archived ? 1 : 0,
+                    continuation_session_id: newSession.continuation_session_id,
+                    initial_commit_head: newSession.initial_commit_head,
+                    permission_mode: newSession.permission_mode
+                });
+                this.setMetadataStmt.run({ key: 'last_updated', value: now });
+                return newSession;
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to update session info', { sessionId, updates, error });
+            throw new Error(`Failed to update session info: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async updateCustomName(sessionId, customName) {
+        await this.updateSessionInfo(sessionId, { custom_name: customName });
+    }
+    /**
+     * Set the identity image for a session. This is a one-time operation
+     * that doesn't update the session's updated_at timestamp.
+     */
+    async setIdentityImage(sessionId, imageData) {
+        try {
+            const stmt = this.db.prepare('UPDATE sessions SET identity_image = ? WHERE session_id = ?');
+            stmt.run(imageData, sessionId);
+            this.logger.debug('Identity image set for session', { sessionId });
+        }
+        catch (error) {
+            this.logger.error('Failed to set identity image', { sessionId, error });
+            throw new Error(`Failed to set identity image: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Check if a session already has an identity image.
+     */
+    async hasIdentityImage(sessionId) {
+        try {
+            const row = this.getSessionStmt.get(sessionId);
+            return row?.identity_image != null;
+        }
+        catch (error) {
+            this.logger.error('Failed to check identity image', { sessionId, error });
+            return false;
+        }
+    }
+    async deleteSession(sessionId) {
+        this.logger.info('Deleting session info', { sessionId });
+        try {
+            const result = this.deleteSessionStmt.run(sessionId);
+            if (result.changes > 0) {
+                const now = new Date().toISOString();
+                this.setMetadataStmt.run({ key: 'last_updated', value: now });
+                this.logger.info('Session info deleted successfully', { sessionId });
+            }
+            else {
+                this.logger.debug('Session info not found for deletion', { sessionId });
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to delete session info', { sessionId, error });
+            throw new Error(`Failed to delete session info: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async getAllSessionInfo() {
+        this.logger.debug('Getting all session info');
+        try {
+            const rows = this.getAllStmt.all();
+            const result = {};
+            for (const row of rows) {
+                result[row.session_id] = this.mapRow(row);
+            }
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Failed to get all session info', error);
+            return {};
+        }
+    }
+    async getStats() {
+        try {
+            const countRow = this.countStmt.get();
+            let dbSize = 0;
+            if (this.dbPath !== ':memory:') {
+                try {
+                    const stats = fs.statSync(this.dbPath);
+                    dbSize = stats.size;
+                }
+                catch {
+                    dbSize = 0;
+                }
+            }
+            const lastUpdatedRow = this.getMetadataStmt.get('last_updated');
+            return {
+                sessionCount: countRow.count,
+                dbSize,
+                lastUpdated: lastUpdatedRow?.value || new Date().toISOString()
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get database stats', error);
+            return {
+                sessionCount: 0,
+                dbSize: 0,
+                lastUpdated: new Date().toISOString()
+            };
+        }
+    }
+    reinitializePaths(customConfigDir) {
+        this.initializePaths(customConfigDir);
+    }
+    getDbPath() {
+        return this.dbPath;
+    }
+    getConfigDir() {
+        return this.configDir;
+    }
+    async archiveAllSessions() {
+        this.logger.info('Archiving all sessions');
+        try {
+            const now = new Date().toISOString();
+            const transaction = this.db.transaction(() => {
+                const info = this.archiveAllStmt.run({ updated_at: now });
+                if (info.changes > 0) {
+                    this.setMetadataStmt.run({ key: 'last_updated', value: now });
+                }
+                return info.changes;
+            });
+            const archivedCount = transaction();
+            this.logger.info('Sessions archived successfully', { archivedCount });
+            return archivedCount;
+        }
+        catch (error) {
+            this.logger.error('Failed to archive all sessions', error);
+            throw new Error(`Failed to archive all sessions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async syncMissingSessions(sessionIds) {
+        try {
+            const now = new Date().toISOString();
+            const insert = this.db.prepare(`
+        INSERT OR IGNORE INTO sessions (
+          session_id,
+          custom_name,
+          created_at,
+          updated_at,
+          version,
+          pinned,
+          archived,
+          continuation_session_id,
+          initial_commit_head,
+          permission_mode
+        ) VALUES (
+          @session_id,
+          '',
+          @now,
+          @now,
+          3,
+          0,
+          0,
+          '',
+          '',
+          'default'
+        )
+      `);
+            const transaction = this.db.transaction((ids) => {
+                let inserted = 0;
+                for (const id of ids) {
+                    const info = insert.run({ session_id: id, now });
+                    if (info.changes > 0)
+                        inserted++;
+                }
+                if (inserted > 0) {
+                    this.setMetadataStmt.run({ key: 'last_updated', value: now });
+                }
+                return inserted;
+            });
+            return transaction(sessionIds);
+        }
+        catch (error) {
+            this.logger.error('Failed to sync missing sessions', error);
+            throw new Error(`Failed to sync missing sessions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // ==================== INSIGHTS METHODS ====================
+    mapInsightsRow(row) {
+        return {
+            session_id: row.session_id,
+            description: row.description,
+            context: row.context ? JSON.parse(row.context) : null,
+            current_state: row.current_state ? JSON.parse(row.current_state) : null,
+            last_patch_trace_id: row.last_patch_trace_id ?? null,
+            purposes: JSON.parse(row.purposes || '[]'),
+            milestones: JSON.parse(row.milestones || '[]'),
+            notable: JSON.parse(row.notable || '[]'),
+            tags: row.tags ? JSON.parse(row.tags) : null,
+            recent_actions: JSON.parse(row.recent_actions || '[]'),
+            panels: JSON.parse(row.panels || '[]'),
+            progress_completed: row.progress_completed,
+            progress_total: row.progress_total,
+            outstanding_tasks: JSON.parse(row.outstanding_tasks || '[]'),
+            completed_tasks: JSON.parse(row.completed_tasks || '[]'),
+            current_task: row.current_task,
+            theme: row.theme,
+            computed_at: row.computed_at,
+            stale: !!row.stale,
+            message_count: row.message_count ?? undefined,
+            last_delta_check_at: row.last_delta_check_at ?? undefined,
+            patched_at: row.patched_at ?? undefined
+        };
+    }
+    async getInsights(sessionId) {
+        try {
+            const row = this.getInsightsStmt.get(sessionId);
+            if (row) {
+                return this.mapInsightsRow(row);
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error('Failed to get insights', { sessionId, error });
+            return null;
+        }
+    }
+    async setInsights(insights) {
+        try {
+            this.upsertInsightsStmt.run({
+                session_id: insights.session_id,
+                description: insights.description,
+                context: insights.context ? JSON.stringify(insights.context) : null,
+                current_state: insights.current_state ? JSON.stringify(insights.current_state) : null,
+                last_patch_trace_id: insights.last_patch_trace_id ?? null,
+                purposes: JSON.stringify(insights.purposes || []),
+                milestones: JSON.stringify(insights.milestones || []),
+                notable: JSON.stringify(insights.notable || []),
+                tags: insights.tags ? JSON.stringify(insights.tags) : null,
+                recent_actions: JSON.stringify(insights.recent_actions || []),
+                panels: JSON.stringify(insights.panels || []),
+                progress_completed: insights.progress_completed,
+                progress_total: insights.progress_total,
+                outstanding_tasks: JSON.stringify(insights.outstanding_tasks),
+                completed_tasks: JSON.stringify(insights.completed_tasks),
+                current_task: insights.current_task,
+                theme: insights.theme,
+                computed_at: insights.computed_at,
+                stale: insights.stale ? 1 : 0,
+                message_count: insights.message_count ?? null,
+                last_delta_check_at: insights.last_delta_check_at ?? null,
+                patched_at: insights.patched_at ?? null
+            });
+            this.logger.debug('Insights cached', { sessionId: insights.session_id });
+        }
+        catch (error) {
+            this.logger.error('Failed to set insights', { sessionId: insights.session_id, error });
+            throw error;
+        }
+    }
+    async getAllInsights() {
+        try {
+            const rows = this.getAllInsightsStmt.all();
+            const result = new Map();
+            for (const row of rows) {
+                result.set(row.session_id, this.mapInsightsRow(row));
+            }
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Failed to get all insights', error);
+            return new Map();
+        }
+    }
+    async markInsightsStale(sessionId) {
+        try {
+            this.markInsightsStaleStmt.run(sessionId);
+        }
+        catch (error) {
+            this.logger.error('Failed to mark insights stale', { sessionId, error });
+        }
+    }
+    async getStaleSessionIds() {
+        try {
+            const rows = this.getStaleInsightsStmt.all();
+            return rows.map(r => r.session_id);
+        }
+        catch (error) {
+            this.logger.error('Failed to get stale session IDs', error);
+            return [];
+        }
+    }
+    async getMissingInsightsSessionIds(sessionIds) {
+        try {
+            const existing = await this.getAllInsights();
+            return sessionIds.filter(id => !existing.has(id));
+        }
+        catch (error) {
+            this.logger.error('Failed to get missing insights session IDs', error);
+            return sessionIds;
+        }
+    }
+    /**
+     * Get all non-archived session IDs (for refresh operations)
+     */
+    getNonArchivedSessionIds() {
+        try {
+            const rows = this.db.prepare('SELECT session_id FROM sessions WHERE archived = 0').all();
+            return rows.map(r => r.session_id);
+        }
+        catch (error) {
+            this.logger.error('Failed to get non-archived session IDs', error);
+            return [];
+        }
+    }
+    /**
+     * Audit insight regeneration for debugging (legacy method)
+     */
+    auditRegeneration(params) {
+        try {
+            // Ensure audit table exists
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS insight_audit (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          action TEXT NOT NULL,
+          reason TEXT,
+          old_mission TEXT,
+          new_mission TEXT,
+          old_theme TEXT,
+          new_theme TEXT,
+          message_count INTEGER,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            this.db.prepare(`
+        INSERT INTO insight_audit (session_id, action, reason, old_mission, new_mission, old_theme, new_theme, message_count)
+        VALUES (@sessionId, @action, @reason, @oldMission, @newMission, @oldTheme, @newTheme, @messageCount)
+      `).run({
+                sessionId: params.sessionId,
+                action: params.action,
+                reason: params.reason,
+                oldMission: params.oldMission || null,
+                newMission: params.newMission || null,
+                oldTheme: params.oldTheme || null,
+                newTheme: params.newTheme || null,
+                messageCount: params.messageCount || null
+            });
+        }
+        catch (error) {
+            this.logger.debug('Failed to audit regeneration', { error });
+        }
+    }
+    /**
+     * Audit event-driven insight operations with full context for debugging.
+     * This captures trace IDs, action content, and before/after state snapshots.
+     */
+    auditEventInsight(params) {
+        try {
+            // Ensure extended audit table exists with new columns
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS insight_event_audit (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          trace_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          trigger TEXT NOT NULL,
+          action_content TEXT,
+          before_state TEXT,
+          after_state TEXT,
+          llm_response TEXT,
+          patched_fields TEXT,
+          duration_ms INTEGER,
+          skipped_reason TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            // Create index on trace_id for fast lookups
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_insight_event_audit_trace_id ON insight_event_audit(trace_id)
+      `);
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_insight_event_audit_session_id ON insight_event_audit(session_id)
+      `);
+            this.db.prepare(`
+        INSERT INTO insight_event_audit (
+          trace_id, session_id, event_type, trigger,
+          action_content, before_state, after_state,
+          llm_response, patched_fields, duration_ms, skipped_reason
+        ) VALUES (
+          @traceId, @sessionId, @eventType, @trigger,
+          @actionContent, @beforeState, @afterState,
+          @llmResponse, @patchedFields, @durationMs, @skippedReason
+        )
+      `).run({
+                traceId: params.traceId,
+                sessionId: params.sessionId,
+                eventType: params.eventType,
+                trigger: params.trigger,
+                actionContent: params.actionContent ? JSON.stringify(params.actionContent) : null,
+                beforeState: params.beforeState ? JSON.stringify(params.beforeState) : null,
+                afterState: params.afterState ? JSON.stringify(params.afterState) : null,
+                llmResponse: params.llmResponse || null,
+                patchedFields: params.patchedFields ? JSON.stringify(params.patchedFields) : null,
+                durationMs: params.durationMs || null,
+                skippedReason: params.skippedReason || null
+            });
+        }
+        catch (error) {
+            this.logger.debug('Failed to audit event insight', { error });
+        }
+    }
+    /**
+     * Get event audit history by trace ID (for debugging a specific event chain)
+     */
+    getEventAuditByTraceId(traceId) {
+        try {
+            const rows = this.db.prepare(`
+        SELECT * FROM insight_event_audit
+        WHERE trace_id = ?
+        ORDER BY created_at ASC
+      `).all(traceId);
+            return rows.map(r => ({
+                traceId: r.trace_id,
+                sessionId: r.session_id,
+                eventType: r.event_type,
+                trigger: r.trigger,
+                actionContent: r.action_content ? JSON.parse(r.action_content) : null,
+                beforeState: r.before_state ? JSON.parse(r.before_state) : null,
+                afterState: r.after_state ? JSON.parse(r.after_state) : null,
+                llmResponse: r.llm_response,
+                patchedFields: r.patched_fields ? JSON.parse(r.patched_fields) : null,
+                durationMs: r.duration_ms,
+                skippedReason: r.skipped_reason,
+                createdAt: r.created_at
+            }));
+        }
+        catch (error) {
+            this.logger.debug('Failed to get event audit by trace ID', { error });
+            return [];
+        }
+    }
+    /**
+     * Get recent event audit history for a session
+     */
+    getRecentEventAudit(sessionId, limit = 50) {
+        try {
+            const rows = this.db.prepare(`
+        SELECT trace_id, event_type, trigger, patched_fields, duration_ms, skipped_reason, created_at
+        FROM insight_event_audit
+        WHERE session_id = ?
+        ORDER BY created_at DESC
+        LIMIT ?
+      `).all(sessionId, limit);
+            return rows.map(r => ({
+                traceId: r.trace_id,
+                eventType: r.event_type,
+                trigger: r.trigger,
+                patchedFields: r.patched_fields ? JSON.parse(r.patched_fields) : null,
+                durationMs: r.duration_ms,
+                skippedReason: r.skipped_reason,
+                createdAt: r.created_at
+            }));
+        }
+        catch (error) {
+            this.logger.debug('Failed to get recent event audit', { error });
+            return [];
+        }
+    }
+    /**
+     * Get all audit history across all sessions
+     */
+    getAllAuditHistory(limit = 100) {
+        try {
+            const rows = this.db.prepare(`
+        SELECT session_id, action, reason, old_mission, new_mission, old_theme, new_theme, message_count, created_at
+        FROM insight_audit
+        ORDER BY created_at DESC
+        LIMIT ?
+      `).all(limit);
+            return rows.map(r => ({
+                sessionId: r.session_id,
+                action: r.action,
+                reason: r.reason,
+                oldMission: r.old_mission,
+                newMission: r.new_mission,
+                oldTheme: r.old_theme,
+                newTheme: r.new_theme,
+                messageCount: r.message_count,
+                createdAt: r.created_at
+            }));
+        }
+        catch (error) {
+            this.logger.debug('Failed to get all audit history', { error });
+            return [];
+        }
+    }
+    /**
+     * Get audit history for a session
+     */
+    getAuditHistory(sessionId, limit = 50) {
+        try {
+            const rows = this.db.prepare(`
+        SELECT action, reason, old_mission, new_mission, old_theme, new_theme, message_count, created_at
+        FROM insight_audit
+        WHERE session_id = ?
+        ORDER BY created_at DESC
+        LIMIT ?
+      `).all(sessionId, limit);
+            return rows.map(r => ({
+                action: r.action,
+                reason: r.reason,
+                oldMission: r.old_mission,
+                newMission: r.new_mission,
+                oldTheme: r.old_theme,
+                newTheme: r.new_theme,
+                messageCount: r.message_count,
+                createdAt: r.created_at
+            }));
+        }
+        catch (error) {
+            this.logger.debug('Failed to get audit history', { error });
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=session-info-service.js.map