lattice-orchestrator 0.7.0

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

@@ -0,0 +1,1640 @@
+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 '../infrastructure/logger.js';
+import { InsightAuditRepository } from '../insights/insight-audit-repository.js';
+import { TurnRepository } from './turn-repository.js';
+import { SessionMarksRepository } from './session-marks-repository.js';
+/**
+ * SessionInfoService manages session information using SQLite backend
+ * Stores session metadata including custom names in ~/.claudia/session-info.db
+ * Provides fast lookups and updates for session-specific data
+ *
+ * EXTRACTED REPOSITORIES (prefer using these directly for new code):
+ * - auditRepository (InsightAuditRepository) - Insight audit logging
+ * - turnRepository (TurnRepository) - Per-turn summaries
+ * - marksRepository (SessionMarksRepository) - User-flagged session marks
+ *
+ * REMAINING SECTIONS (search for "// ==="):
+ * 1. Core Session CRUD - getSessionInfo, updateSessionInfo, deleteSession
+ * 2. Recommendation Management - getPendingRecommendations, acceptRecommendation
+ * 3. Insights Cache - getInsights, setInsights, updateSessionMetadata
+ * 4. Insight Auditing - wrapper methods → auditRepository
+ * 5. Turn Management - wrapper methods → turnRepository
+ * 6+7. Session Marks - wrapper methods → marksRepository
+ * 8. Branch Operations - copyTurnsForBranch, copyMarksForBranch
+ */
+export class SessionInfoService {
+    static instance;
+    logger;
+    dbPath;
+    configDir;
+    isInitialized = false;
+    db;
+    // Extracted repositories (lazy-initialized after db is ready)
+    _auditRepository;
+    _turnRepository;
+    _marksRepository;
+    getSessionStmt;
+    insertSessionStmt;
+    updateSessionStmt;
+    deleteSessionStmt;
+    getAllStmt;
+    countStmt;
+    archiveAllStmt;
+    setMetadataStmt;
+    getMetadataStmt;
+    // Insights statements
+    getInsightsStmt;
+    upsertInsightsStmt;
+    getAllInsightsStmt;
+    markInsightsStaleStmt;
+    getStaleInsightsStmt;
+    updateMetadataFieldsStmt;
+    // File changes statements
+    insertFileChangeStmt;
+    getFileChangesStmt;
+    getFileChangesByFileStmt;
+    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.pragma('busy_timeout = 10000');
+            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
+        );
+        CREATE TABLE IF NOT EXISTS session_turns (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          turn_number INTEGER NOT NULL,
+          timestamp TEXT NOT NULL,
+          headline TEXT NOT NULL,
+          actions TEXT NOT NULL DEFAULT '[]',
+          tag TEXT NOT NULL,
+          icon TEXT NOT NULL,
+          exit_code INTEGER,
+          termination_reason TEXT NOT NULL DEFAULT 'normal_completion',
+          tool_count INTEGER NOT NULL DEFAULT 0,
+          incomplete INTEGER NOT NULL DEFAULT 0,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_turns_session_id ON session_turns(session_id);
+        CREATE INDEX IF NOT EXISTS idx_turns_timestamp ON session_turns(timestamp);
+
+        CREATE TABLE IF NOT EXISTS recommendations (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          category TEXT NOT NULL,
+          friction TEXT NOT NULL,
+          suggestion TEXT NOT NULL,
+          why TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          created_at TEXT NOT NULL,
+          actioned_at TEXT,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_recommendations_session_id ON recommendations(session_id);
+        CREATE INDEX IF NOT EXISTS idx_recommendations_status ON recommendations(status);
+
+        CREATE TABLE IF NOT EXISTS friction_marks (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          message_id TEXT NOT NULL,
+          content_type TEXT NOT NULL,
+          tool_name TEXT,
+          content_preview TEXT NOT NULL,
+          full_content TEXT NOT NULL,
+          marked_at TEXT NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_friction_marks_session ON friction_marks(session_id);
+
+        -- Session marks v2: supports multiple mark types with turn context
+        CREATE TABLE IF NOT EXISTS session_marks (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          message_id TEXT NOT NULL,
+          mark_type TEXT NOT NULL DEFAULT 'friction',
+          content_type TEXT NOT NULL,
+          tool_name TEXT,
+          content_preview TEXT NOT NULL,
+          turn_number INTEGER,
+          turn_context TEXT,
+          marked_at TEXT NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_session_marks_session ON session_marks(session_id);
+        CREATE INDEX IF NOT EXISTS idx_session_marks_type ON session_marks(mark_type);
+
+        -- File changes captured from Edit/Write tool calls for walkthrough generation
+        CREATE TABLE IF NOT EXISTS turn_file_changes (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          turn_number INTEGER NOT NULL,
+          tool_name TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          old_string TEXT,
+          new_string TEXT NOT NULL,
+          timestamp TEXT NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_turn_file_changes_session ON turn_file_changes(session_id);
+        CREATE INDEX IF NOT EXISTS idx_turn_file_changes_file ON turn_file_changes(file_path);
+
+        -- Walkthrough scope analysis cache
+        CREATE TABLE IF NOT EXISTS walkthrough_scope_cache (
+          session_id TEXT PRIMARY KEY,
+          turn_count INTEGER NOT NULL,
+          generated_at TEXT NOT NULL,
+          analysis_json TEXT NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        );
+      `);
+            // Migration: Add new columns if they don't exist (for existing databases)
+            this.migrateSessionsColumns();
+            this.migrateInsightsColumns();
+            this.migrateTurnTags();
+            this.migrateTurnsColumns();
+            this.migrateToSessionMarks();
+            this.prepareStatements();
+            this.ensureMetadata();
+            // Initialize extracted repositories
+            this._auditRepository = new InsightAuditRepository(this.db);
+            this._turnRepository = new TurnRepository(this.db);
+            this._marksRepository = new SessionMarksRepository(this.db, (shortId) => this.resolveSessionId(shortId));
+            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');
+            }
+            if (!columnNames.includes('last_termination_reason')) {
+                this.db.exec("ALTER TABLE sessions ADD COLUMN last_termination_reason TEXT DEFAULT NULL");
+                this.logger.info('Added last_termination_reason column to sessions');
+            }
+            // Branch lineage columns
+            if (!columnNames.includes('branched_from_session_id')) {
+                this.db.exec("ALTER TABLE sessions ADD COLUMN branched_from_session_id TEXT DEFAULT NULL");
+                this.logger.info('Added branched_from_session_id column to sessions');
+            }
+            if (!columnNames.includes('branched_at_turn')) {
+                this.db.exec("ALTER TABLE sessions ADD COLUMN branched_at_turn INTEGER DEFAULT NULL");
+                this.logger.info('Added branched_at_turn 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');
+            }
+            // V9 accumulative fields
+            if (!columnNames.includes('progress_items')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN progress_items TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added progress_items column to session_insights');
+            }
+            if (!columnNames.includes('notable_events')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN notable_events TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added notable_events column to session_insights');
+            }
+            if (!columnNames.includes('recent_actions_v2')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN recent_actions_v2 TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added recent_actions_v2 column to session_insights');
+            }
+            if (!columnNames.includes('progress_summary')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN progress_summary TEXT DEFAULT NULL");
+                this.logger.info('Added progress_summary column to session_insights');
+            }
+            if (!columnNames.includes('purpose')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN purpose TEXT DEFAULT NULL");
+                this.logger.info('Added purpose column to session_insights');
+            }
+            // Accumulated propositions for post-session analysis
+            if (!columnNames.includes('propositions')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN propositions TEXT NOT NULL DEFAULT '[]'");
+                this.logger.info('Added propositions column to session_insights');
+            }
+            // Tool metrics columns (Phase 1 of list endpoint optimization)
+            // These cache ToolMetrics to avoid re-parsing all messages on every list request
+            if (!columnNames.includes('lines_added')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN lines_added INTEGER DEFAULT 0");
+                this.logger.info('Added lines_added column to session_insights');
+            }
+            if (!columnNames.includes('lines_removed')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN lines_removed INTEGER DEFAULT 0");
+                this.logger.info('Added lines_removed column to session_insights');
+            }
+            if (!columnNames.includes('edit_count')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN edit_count INTEGER DEFAULT 0");
+                this.logger.info('Added edit_count column to session_insights');
+            }
+            if (!columnNames.includes('write_count')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN write_count INTEGER DEFAULT 0");
+                this.logger.info('Added write_count column to session_insights');
+            }
+            if (!columnNames.includes('metrics_updated_at')) {
+                this.db.exec("ALTER TABLE session_insights ADD COLUMN metrics_updated_at TEXT DEFAULT NULL");
+                this.logger.info('Added metrics_updated_at column to session_insights');
+            }
+        }
+        catch (error) {
+            this.logger.debug('Migration check failed (table may not exist yet)', { error });
+        }
+    }
+    /**
+     * Clean turn tags that have trailing emojis from the Haiku bug.
+     * Uses metadata key to ensure this only runs once per database.
+     */
+    migrateTurnTags() {
+        try {
+            // Check if migration already ran
+            const migrated = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get('turn_tags_cleaned');
+            if (migrated?.value === 'true') {
+                return;
+            }
+            // Find all turns with emoji in tag field and clean them
+            const turnsWithEmoji = this.db.prepare(`
+        SELECT id, tag FROM session_turns
+        WHERE tag LIKE '%🔍%' OR tag LIKE '%🔧%' OR tag LIKE '%💡%'
+           OR tag LIKE '%🏗%' OR tag LIKE '%♻%' OR tag LIKE '%🐛%'
+           OR tag LIKE '%💬%' OR tag LIKE '%⚖%' OR tag LIKE '%🔄%' OR tag LIKE '%🚧%'
+      `).all();
+            if (turnsWithEmoji.length > 0) {
+                const updateStmt = this.db.prepare('UPDATE session_turns SET tag = ? WHERE id = ?');
+                // Same regex used in turn-capture-service.ts
+                const emojiStrippingRegex = /[\p{Extended_Pictographic}\p{Variation_Selector}\s]+$/u;
+                for (const turn of turnsWithEmoji) {
+                    const cleanTag = turn.tag.replace(emojiStrippingRegex, '').trim() || 'discuss';
+                    updateStmt.run(cleanTag, turn.id);
+                }
+                this.logger.info(`Cleaned ${turnsWithEmoji.length} turn tags with trailing emojis`);
+            }
+            // Mark migration as complete
+            this.db.prepare('INSERT INTO metadata (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value')
+                .run('turn_tags_cleaned', 'true');
+        }
+        catch (error) {
+            this.logger.debug('Turn tag migration failed', { error });
+        }
+    }
+    migrateTurnsColumns() {
+        // Add termination_reason column to session_turns if it doesn't exist
+        try {
+            const tableInfo = this.db.pragma('table_info(session_turns)');
+            const columnNames = tableInfo.map(col => col.name);
+            if (!columnNames.includes('termination_reason')) {
+                this.db.exec("ALTER TABLE session_turns ADD COLUMN termination_reason TEXT NOT NULL DEFAULT 'normal_completion'");
+                this.logger.info('Added termination_reason column to session_turns');
+            }
+        }
+        catch (error) {
+            this.logger.debug('Session turns migration check failed', { error });
+        }
+    }
+    /**
+     * Migrate existing friction_marks to session_marks table.
+     * Runs once, tracked via metadata key.
+     */
+    migrateToSessionMarks() {
+        try {
+            // Check if migration already ran
+            const migrated = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get('session_marks_migrated');
+            if (migrated?.value === 'true') {
+                return;
+            }
+            // Check if there are existing friction_marks to migrate
+            const count = this.db.prepare('SELECT COUNT(*) as count FROM friction_marks').get();
+            if (count.count > 0) {
+                this.logger.info('Migrating friction_marks to session_marks', { count: count.count });
+                // Copy existing friction marks to new table with mark_type='friction'
+                // Note: we don't have turn_context for old marks, they'll work with fallback display
+                this.db.exec(`
+          INSERT INTO session_marks (id, session_id, message_id, mark_type, content_type, tool_name, content_preview, turn_number, turn_context, marked_at)
+          SELECT id, session_id, message_id, 'friction', content_type, tool_name, content_preview, NULL, NULL, marked_at
+          FROM friction_marks
+        `);
+                this.logger.info('Migrated friction_marks to session_marks', { count: count.count });
+            }
+            // Mark migration as complete
+            this.db.prepare('INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)').run('session_marks_migrated', 'true');
+            this.logger.info('Session marks migration complete');
+        }
+        catch (error) {
+            this.logger.error('Failed to migrate to session_marks', { 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,
+        branched_from_session_id,
+        branched_at_turn
+      ) VALUES (
+        @session_id,
+        @custom_name,
+        @created_at,
+        @updated_at,
+        @version,
+        @pinned,
+        @archived,
+        @continuation_session_id,
+        @initial_commit_head,
+        @permission_mode,
+        @branched_from_session_id,
+        @branched_at_turn
+      )
+    `);
+        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,
+        branched_from_session_id=@branched_from_session_id,
+        branched_at_turn=@branched_at_turn
+      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,
+        progress_items, notable_events, recent_actions_v2, progress_summary, purpose, propositions
+      ) 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,
+        @progress_items, @notable_events, @recent_actions_v2, @progress_summary, @purpose, @propositions
+      ) 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,
+        progress_items=excluded.progress_items,
+        notable_events=excluded.notable_events,
+        recent_actions_v2=excluded.recent_actions_v2,
+        progress_summary=excluded.progress_summary,
+        purpose=excluded.purpose,
+        propositions=excluded.propositions
+    `);
+        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');
+        // Lightweight metadata update (purpose/theme/tags only)
+        this.updateMetadataFieldsStmt = this.db.prepare(`
+      UPDATE session_insights SET
+        purpose = COALESCE(@purpose, purpose),
+        theme = COALESCE(@theme, theme),
+        tags = COALESCE(@tags, tags),
+        patched_at = @patched_at
+      WHERE session_id = @session_id
+    `);
+        // File changes statements (for walkthrough generation)
+        this.insertFileChangeStmt = this.db.prepare(`
+      INSERT INTO turn_file_changes (id, session_id, turn_number, tool_name, file_path, old_string, new_string, timestamp)
+      VALUES (@id, @session_id, @turn_number, @tool_name, @file_path, @old_string, @new_string, @timestamp)
+    `);
+        this.getFileChangesStmt = this.db.prepare(`
+      SELECT * FROM turn_file_changes WHERE session_id = ? ORDER BY turn_number, id
+    `);
+        this.getFileChangesByFileStmt = this.db.prepare(`
+      SELECT * FROM turn_file_changes WHERE session_id = ? AND file_path = ? ORDER BY turn_number
+    `);
+    }
+    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,
+            last_termination_reason: row.last_termination_reason ?? undefined,
+            branched_from_session_id: row.branched_from_session_id ?? undefined,
+            branched_at_turn: row.branched_at_turn ?? undefined
+        };
+    }
+    // ===========================================================================
+    // SECTION 1: Core Session CRUD
+    // ===========================================================================
+    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: true, // Sessions discovered outside Claudia start archived
+                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: 1, // Sessions discovered outside Claudia start archived
+                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: true, // Sessions discovered outside Claudia start archived
+                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,
+                    branched_from_session_id: updatedSession.branched_from_session_id || null,
+                    branched_at_turn: updatedSession.branched_at_turn || null
+                });
+                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: true, // Default archived, but updates can override
+                    continuation_session_id: '',
+                    initial_commit_head: '',
+                    permission_mode: 'default',
+                    ...updates
+                };
+                this.logger.info('Inserting new session with branch info', {
+                    sessionId: sessionId.slice(0, 8),
+                    branched_from: newSession.branched_from_session_id?.slice(0, 8),
+                    branched_at_turn: newSession.branched_at_turn,
+                    updates_keys: Object.keys(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,
+                    branched_from_session_id: newSession.branched_from_session_id || null,
+                    branched_at_turn: newSession.branched_at_turn || null
+                });
+                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;
+        }
+    }
+    /**
+     * Update the last termination reason for a session.
+     * Called when a turn is captured to persist why the session ended.
+     */
+    async setLastTerminationReason(sessionId, reason) {
+        try {
+            const stmt = this.db.prepare('UPDATE sessions SET last_termination_reason = ? WHERE session_id = ?');
+            stmt.run(reason, sessionId);
+            this.logger.debug('Last termination reason set for session', { sessionId: sessionId.slice(0, 8), reason });
+        }
+        catch (error) {
+            this.logger.error('Failed to set last termination reason', { sessionId, error });
+            // Don't throw - this is non-critical metadata
+        }
+    }
+    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;
+    }
+    /**
+     * Resolve a short session ID prefix to the full session ID.
+     * Returns null if no matching session is found.
+     */
+    async resolveSessionId(sessionIdPrefix) {
+        // If it's already a full UUID (36 chars), return as-is
+        if (sessionIdPrefix.length === 36) {
+            return sessionIdPrefix;
+        }
+        try {
+            const row = this.db.prepare(`
+        SELECT session_id FROM sessions
+        WHERE session_id LIKE ?
+        LIMIT 1
+      `).get(`${sessionIdPrefix}%`);
+            return row?.session_id || null;
+        }
+        catch (error) {
+            this.logger.debug('Failed to resolve session ID', { error, prefix: sessionIdPrefix });
+            return null;
+        }
+    }
+    // ==========================================================================
+    // Recommendation Management
+    // ==========================================================================
+    /**
+     * Save an accepted recommendation to the database
+     * Note: observation is stored in the 'friction' column for backwards compatibility
+     */
+    async acceptRecommendation(recommendation) {
+        try {
+            // Resolve short session ID to full UUID
+            const fullSessionId = await this.resolveSessionId(recommendation.sessionId);
+            if (!fullSessionId) {
+                throw new Error(`Session not found: ${recommendation.sessionId}`);
+            }
+            const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO recommendations (id, session_id, category, friction, suggestion, why, status, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, 'accepted', ?)
+      `);
+            stmt.run(recommendation.id, fullSessionId, 'general', // No longer using categories
+            recommendation.observation, // Stored in 'friction' column
+            recommendation.suggestion, recommendation.why, new Date().toISOString());
+            this.logger.debug('Recommendation accepted', { id: recommendation.id, sessionId: fullSessionId });
+        }
+        catch (error) {
+            this.logger.error('Failed to accept recommendation', { error, id: recommendation.id });
+            throw error;
+        }
+    }
+    /**
+     * Mark a recommendation as dismissed (won't be shown again)
+     */
+    async dismissRecommendation(recommendationId) {
+        try {
+            const stmt = this.db.prepare(`
+        UPDATE recommendations SET status = 'dismissed', actioned_at = ?
+        WHERE id = ?
+      `);
+            const result = stmt.run(new Date().toISOString(), recommendationId);
+            // If it wasn't in the table, insert it as dismissed
+            if (result.changes === 0) {
+                this.logger.debug('Recommendation not found, cannot dismiss', { id: recommendationId });
+            }
+            else {
+                this.logger.debug('Recommendation dismissed', { id: recommendationId });
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to dismiss recommendation', { error, id: recommendationId });
+            throw error;
+        }
+    }
+    /**
+     * Mark a recommendation as completed (was actioned)
+     */
+    async completeRecommendation(recommendationId) {
+        try {
+            const stmt = this.db.prepare(`
+        UPDATE recommendations SET status = 'completed', actioned_at = ?
+        WHERE id = ?
+      `);
+            stmt.run(new Date().toISOString(), recommendationId);
+            this.logger.debug('Recommendation completed', { id: recommendationId });
+        }
+        catch (error) {
+            this.logger.error('Failed to complete recommendation', { error, id: recommendationId });
+            throw error;
+        }
+    }
+    /**
+     * Get all pending (accepted but not completed) recommendations
+     */
+    async getPendingRecommendations() {
+        try {
+            const stmt = this.db.prepare(`
+        SELECT id, session_id, category, friction, suggestion, why, status, created_at
+        FROM recommendations
+        WHERE status = 'accepted'
+        ORDER BY created_at DESC
+      `);
+            const rows = stmt.all();
+            return rows.map(row => ({
+                id: row.id,
+                sessionId: row.session_id,
+                category: row.category,
+                observation: row.friction, // Map DB 'friction' column to 'observation' field
+                suggestion: row.suggestion,
+                why: row.why,
+                status: row.status,
+                createdAt: row.created_at,
+            }));
+        }
+        catch (error) {
+            this.logger.error('Failed to get pending recommendations', { error });
+            return [];
+        }
+    }
+    /**
+     * Get recommendations for a specific session
+     */
+    async getRecommendationsForSession(sessionId) {
+        try {
+            const stmt = this.db.prepare(`
+        SELECT id, category, friction, suggestion, why, status, created_at
+        FROM recommendations
+        WHERE session_id = ? OR session_id LIKE ?
+        ORDER BY created_at DESC
+      `);
+            const rows = stmt.all(sessionId, `${sessionId}%`);
+            return rows.map(row => ({
+                id: row.id,
+                category: row.category,
+                observation: row.friction, // Map DB 'friction' column to 'observation' field
+                suggestion: row.suggestion,
+                why: row.why,
+                status: row.status,
+                createdAt: row.created_at,
+            }));
+        }
+        catch (error) {
+            this.logger.error('Failed to get recommendations for session', { error, sessionId });
+            return [];
+        }
+    }
+    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();
+            // Default to archived=1 so synced sessions don't clutter the active list.
+            // Sessions started from the dashboard are explicitly unarchived in conversation.routes.ts
+            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,
+          1,
+          '',
+          '',
+          '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,
+            // V9 accumulative fields
+            progress_items: JSON.parse(row.progress_items || '[]'),
+            notable_events: JSON.parse(row.notable_events || '[]'),
+            recent_actions_v2: JSON.parse(row.recent_actions_v2 || '[]'),
+            progress_summary: row.progress_summary ? JSON.parse(row.progress_summary) : null,
+            propositions: JSON.parse(row.propositions || '[]'),
+            // Evolving purpose
+            purpose: row.purpose ?? undefined,
+            // Cached tool metrics
+            lines_added: row.lines_added ?? undefined,
+            lines_removed: row.lines_removed ?? undefined,
+            edit_count: row.edit_count ?? undefined,
+            write_count: row.write_count ?? undefined,
+            metrics_updated_at: row.metrics_updated_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,
+                // V9 accumulative fields
+                progress_items: JSON.stringify(insights.progress_items || []),
+                notable_events: JSON.stringify(insights.notable_events || []),
+                recent_actions_v2: JSON.stringify(insights.recent_actions_v2 || []),
+                progress_summary: insights.progress_summary ? JSON.stringify(insights.progress_summary) : null,
+                propositions: JSON.stringify(insights.propositions || []),
+                // Evolving purpose
+                purpose: insights.purpose ?? 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;
+        }
+    }
+    /**
+     * Lightweight update for session metadata (purpose/theme/tags only).
+     * Called on user message to update session classification without full recompute.
+     * Only updates fields that are provided (null/undefined preserves existing).
+     */
+    async updateSessionMetadata(sessionId, updates) {
+        try {
+            this.updateMetadataFieldsStmt.run({
+                session_id: sessionId,
+                purpose: updates.purpose ?? null,
+                theme: updates.theme ?? null,
+                tags: updates.tags ? JSON.stringify(updates.tags) : null,
+                patched_at: new Date().toISOString()
+            });
+            this.logger.debug('Session metadata updated', {
+                sessionId,
+                fields: Object.keys(updates).filter(k => updates[k] !== undefined)
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to update session metadata', { sessionId, error });
+            throw error;
+        }
+    }
+    /**
+     * Update tool metrics and message count for a session (list endpoint optimization).
+     * Called to cache metrics so list endpoint doesn't need to re-parse messages.
+     * Also updates message_count for use in metadata-only queries.
+     */
+    async updateToolMetrics(sessionId, metrics, messageCount) {
+        try {
+            const stmt = this.db.prepare(`
+        UPDATE session_insights
+        SET lines_added = ?, lines_removed = ?, edit_count = ?, write_count = ?, metrics_updated_at = ?
+            ${messageCount !== undefined ? ', message_count = ?' : ''}
+        WHERE session_id = ?
+      `);
+            const params = [
+                metrics.linesAdded,
+                metrics.linesRemoved,
+                metrics.editCount,
+                metrics.writeCount,
+                new Date().toISOString(),
+                ...(messageCount !== undefined ? [messageCount] : []),
+                sessionId
+            ];
+            const result = stmt.run(...params);
+            if (result.changes > 0) {
+                this.logger.debug('Tool metrics updated', { sessionId, metrics, messageCount });
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to update tool metrics', { sessionId, error });
+            // Don't throw - this is a non-critical optimization
+        }
+    }
+    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 [];
+        }
+    }
+    /**
+     * Fast path for archived sessions - returns session + insights data directly from DB.
+     * This avoids parsing JSONL files which is extremely slow for 1000+ archived sessions.
+     *
+     * @param limit - Maximum number of sessions to return
+     * @param offset - Number of sessions to skip (for pagination)
+     * @returns Array of session data with insights, sorted by updated_at desc
+     */
+    getArchivedSessionsWithInsights(limit, offset) {
+        const startTime = Date.now();
+        try {
+            // Join sessions with insights for archived sessions, sorted by most recent
+            const rows = this.db.prepare(`
+        SELECT
+          s.session_id,
+          s.*,
+          i.purpose, i.description, i.theme, i.current_state, i.progress_summary,
+          i.milestones, i.panels, i.notable_events, i.tags,
+          i.recent_actions_v2, i.progress_items, i.propositions,
+          i.message_count, i.computed_at, i.patched_at, i.stale,
+          i.lines_added, i.lines_removed, i.edit_count, i.write_count, i.metrics_updated_at,
+          i.last_delta_check_at, i.last_patch_trace_id
+        FROM sessions s
+        LEFT JOIN session_insights i ON s.session_id = i.session_id
+        WHERE s.archived = 1
+        ORDER BY s.updated_at DESC
+        LIMIT ? OFFSET ?
+      `).all(limit, offset);
+            const results = rows.map(row => ({
+                sessionId: row.session_id,
+                sessionInfo: this.mapRow(row),
+                insights: row.purpose ? this.mapInsightsRow(row) : null
+            }));
+            this.logger.debug('getArchivedSessionsWithInsights', {
+                limit,
+                offset,
+                returnedCount: results.length,
+                durationMs: Date.now() - startTime
+            });
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Failed to get archived sessions with insights', error);
+            return [];
+        }
+    }
+    /**
+     * Get total count of archived sessions (for pagination)
+     */
+    getArchivedSessionCount() {
+        try {
+            const row = this.db.prepare('SELECT COUNT(*) as count FROM sessions WHERE archived = 1').get();
+            return row.count;
+        }
+        catch (error) {
+            this.logger.error('Failed to get archived session count', error);
+            return 0;
+        }
+    }
+    // ===========================================================================
+    // SECTION 4: Insight Auditing (delegated to InsightAuditRepository)
+    // ===========================================================================
+    /**
+     * Get the audit repository for direct access.
+     * Prefer using the wrapper methods below for compatibility.
+     */
+    get auditRepository() {
+        if (!this._auditRepository) {
+            throw new Error('SessionInfoService not initialized - call initialize() first');
+        }
+        return this._auditRepository;
+    }
+    /**
+     * Audit insight regeneration for debugging (legacy method).
+     * @deprecated Use auditRepository.auditLegacy() directly for new code.
+     */
+    auditRegeneration(params) {
+        this.auditRepository.auditLegacy(params);
+    }
+    /**
+     * Audit event-driven insight operations with full context for debugging.
+     * @deprecated Use auditRepository.auditEvent() directly for new code.
+     */
+    auditEventInsight(params) {
+        this.auditRepository.auditEvent(params);
+    }
+    /**
+     * Get event audit history by trace ID.
+     * @deprecated Use auditRepository.getByTraceId() directly for new code.
+     */
+    getEventAuditByTraceId(traceId) {
+        return this.auditRepository.getByTraceId(traceId);
+    }
+    /**
+     * Get recent event audit history for a session.
+     * @deprecated Use auditRepository.getRecentForSession() directly for new code.
+     */
+    getRecentEventAudit(sessionId, limit = 50) {
+        return this.auditRepository.getRecentForSession(sessionId, limit);
+    }
+    /**
+     * Get all audit history across all sessions.
+     * @deprecated Use auditRepository.getAllLegacyAudit() directly for new code.
+     */
+    getAllAuditHistory(limit = 100) {
+        return this.auditRepository.getAllLegacyAudit(limit);
+    }
+    /**
+     * Get audit history for a session.
+     * @deprecated Use auditRepository.getLegacyForSession() directly for new code.
+     */
+    getAuditHistory(sessionId, limit = 50) {
+        return this.auditRepository.getLegacyForSession(sessionId, limit);
+    }
+    // ===========================================================================
+    // SECTION 5: Turn Management (delegated to TurnRepository)
+    // ===========================================================================
+    /**
+     * Get the turn repository for direct access.
+     */
+    get turnRepository() {
+        if (!this._turnRepository) {
+            throw new Error('SessionInfoService not initialized - call initialize() first');
+        }
+        return this._turnRepository;
+    }
+    /**
+     * Save a turn to the database.
+     * @deprecated Use turnRepository.save() directly for new code.
+     */
+    async saveTurn(turn) {
+        return this.turnRepository.save(turn);
+    }
+    /**
+     * Get all turns for a session, ordered by turn number.
+     * @deprecated Use turnRepository.getForSession() directly for new code.
+     */
+    async getTurns(sessionId) {
+        return this.turnRepository.getForSession(sessionId);
+    }
+    /**
+     * Get turn count for a session (without fetching all data).
+     * @deprecated Use turnRepository.getCount() directly for new code.
+     */
+    async getTurnCount(sessionId) {
+        return this.turnRepository.getCount(sessionId);
+    }
+    // ===========================================================================
+    // SECTION 5b: File Changes (for walkthrough generation)
+    // ===========================================================================
+    /**
+     * Record a file change from an Edit or Write tool call.
+     * Called by TurnCaptureService when processing tool calls.
+     */
+    insertFileChange(change) {
+        const id = `${change.sessionId}-${change.turnNumber}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.insertFileChangeStmt.run({
+            id,
+            session_id: change.sessionId,
+            turn_number: change.turnNumber,
+            tool_name: change.toolName,
+            file_path: change.filePath,
+            old_string: change.oldString,
+            new_string: change.newString,
+            timestamp: change.timestamp,
+        });
+    }
+    /**
+     * Get all file changes for a session, ordered by turn number.
+     */
+    getFileChanges(sessionId) {
+        const rows = this.getFileChangesStmt.all(sessionId);
+        return rows.map(row => ({
+            id: row.id,
+            sessionId: row.session_id,
+            turnNumber: row.turn_number,
+            toolName: row.tool_name,
+            filePath: row.file_path,
+            oldString: row.old_string,
+            newString: row.new_string,
+            timestamp: row.timestamp,
+        }));
+    }
+    /**
+     * Get file changes for a specific file in a session.
+     */
+    getFileChangesByFile(sessionId, filePath) {
+        const rows = this.getFileChangesByFileStmt.all(sessionId, filePath);
+        return rows.map(row => ({
+            id: row.id,
+            turnNumber: row.turn_number,
+            toolName: row.tool_name,
+            oldString: row.old_string,
+            newString: row.new_string,
+            timestamp: row.timestamp,
+        }));
+    }
+    // ===========================================================================
+    // SECTION 6+7: Session Marks (delegated to SessionMarksRepository)
+    // ===========================================================================
+    /**
+     * Get the marks repository for direct access.
+     */
+    get marksRepository() {
+        if (!this._marksRepository) {
+            throw new Error('SessionInfoService not initialized - call initialize() first');
+        }
+        return this._marksRepository;
+    }
+    // --- Friction Marks (v1 legacy) ---
+    /** @deprecated Use marksRepository.addFrictionMark() directly */
+    async addFrictionMark(mark) {
+        return this.marksRepository.addFrictionMark(mark);
+    }
+    /** @deprecated Use marksRepository.getFrictionMarksForSession() directly */
+    async getFrictionMarksForSession(sessionId) {
+        return this.marksRepository.getFrictionMarksForSession(sessionId);
+    }
+    /** @deprecated Use marksRepository.deleteFrictionMark() directly */
+    async deleteFrictionMark(id) {
+        await this.marksRepository.deleteFrictionMark(id);
+    }
+    /** @deprecated Use marksRepository.isFrictionMarked() directly */
+    async isFrictionMarked(sessionId, messageId) {
+        return this.marksRepository.isFrictionMarked(sessionId, messageId);
+    }
+    // --- Session Marks v2 ---
+    /** @deprecated Use marksRepository.addSessionMark() directly */
+    async addSessionMark(mark) {
+        return this.marksRepository.addSessionMark(mark);
+    }
+    /** @deprecated Use marksRepository.getSessionMarks() directly */
+    async getSessionMarks(sessionId) {
+        return this.marksRepository.getSessionMarks(sessionId);
+    }
+    /** @deprecated Use marksRepository.deleteSessionMark() directly */
+    async deleteSessionMark(id) {
+        await this.marksRepository.deleteSessionMark(id);
+    }
+    /** @deprecated Use marksRepository.isSessionMarked() directly */
+    async isSessionMarked(sessionId, messageId) {
+        return this.marksRepository.isSessionMarked(sessionId, messageId);
+    }
+    /** @deprecated Use marksRepository.getMarksWithoutTurnContext() directly */
+    async getMarksWithoutTurnContext(sessionId) {
+        return this.marksRepository.getMarksWithoutTurnContext(sessionId);
+    }
+    /** @deprecated Use marksRepository.updateMarkTurnContext() directly */
+    async updateMarkTurnContext(markId, turnNumber, turnContext) {
+        return this.marksRepository.updateMarkTurnContext(markId, turnNumber, turnContext);
+    }
+    // ===========================================================================
+    // SECTION 8: Branch Operations
+    // ===========================================================================
+    /**
+     * Get all sessions that branched from this parent session.
+     * Returns the child session IDs and the turn numbers they branched at.
+     */
+    getBranchChildren(parentSessionId) {
+        try {
+            const rows = this.db.prepare(`
+        SELECT session_id, branched_at_turn
+        FROM sessions
+        WHERE branched_from_session_id = ?
+        ORDER BY branched_at_turn ASC
+      `).all(parentSessionId);
+            return rows
+                .filter(r => r.branched_at_turn != null)
+                .map(r => ({
+                childSessionId: r.session_id,
+                atTurn: r.branched_at_turn,
+            }));
+        }
+        catch (error) {
+            this.logger.debug('Failed to get branch children', { error, parentSessionId });
+            return [];
+        }
+    }
+    /**
+     * Copy session_turns from source session to new branch session.
+     * Only copies turns with turn_number <= afterTurn.
+     * Generates new IDs for the copied turns.
+     * @returns Number of turns copied
+     */
+    copyTurnsForBranch(sourceSessionId, newSessionId, afterTurn) {
+        try {
+            // Get turns to copy
+            const turns = this.db.prepare(`
+        SELECT turn_number, timestamp, headline, actions, tag, icon, exit_code, tool_count, incomplete, termination_reason
+        FROM session_turns
+        WHERE session_id = ? AND turn_number <= ?
+      `).all(sourceSessionId, afterTurn);
+            if (turns.length === 0) {
+                return 0;
+            }
+            // Insert with new session ID and new IDs
+            const insertStmt = this.db.prepare(`
+        INSERT INTO session_turns (id, session_id, turn_number, timestamp, headline, actions, tag, icon, exit_code, tool_count, incomplete, termination_reason)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            for (const turn of turns) {
+                const newId = `${newSessionId}-turn-${turn.turn_number}`;
+                insertStmt.run(newId, newSessionId, turn.turn_number, turn.timestamp, turn.headline, turn.actions, turn.tag, turn.icon, turn.exit_code, turn.tool_count, turn.incomplete, turn.termination_reason);
+            }
+            this.logger.debug('Copied turns for branch', {
+                sourceSession: sourceSessionId.slice(0, 8),
+                newSession: newSessionId.slice(0, 8),
+                count: turns.length,
+            });
+            return turns.length;
+        }
+        catch (error) {
+            this.logger.error('Failed to copy turns for branch', { error, sourceSessionId, newSessionId });
+            throw error;
+        }
+    }
+    /**
+     * Copy session_marks from source session to new branch session.
+     * Only copies marks with turn_number <= afterTurn (or null turn_number).
+     * Generates new IDs for the copied marks.
+     * @returns Number of marks copied
+     */
+    copyMarksForBranch(sourceSessionId, newSessionId, afterTurn) {
+        return this.marksRepository.copyMarksForBranch(sourceSessionId, newSessionId, afterTurn);
+    }
+    // ===========================================================================
+    // SECTION 9: Walkthrough Scope Cache
+    // ===========================================================================
+    /**
+     * Get cached walkthrough scope analysis.
+     * Returns null if not cached.
+     */
+    getWalkthroughScopeCache(sessionId) {
+        try {
+            const row = this.db.prepare(`
+        SELECT turn_count, generated_at, analysis_json
+        FROM walkthrough_scope_cache
+        WHERE session_id = ?
+      `).get(sessionId);
+            if (!row)
+                return null;
+            return {
+                turnCount: row.turn_count,
+                generatedAt: row.generated_at,
+                analysis: JSON.parse(row.analysis_json),
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get walkthrough scope cache', { error, sessionId });
+            return null;
+        }
+    }
+    /**
+     * Save walkthrough scope analysis to cache.
+     */
+    setWalkthroughScopeCache(sessionId, turnCount, analysis) {
+        try {
+            this.db.prepare(`
+        INSERT OR REPLACE INTO walkthrough_scope_cache (session_id, turn_count, generated_at, analysis_json)
+        VALUES (?, ?, ?, ?)
+      `).run(sessionId, turnCount, new Date().toISOString(), JSON.stringify(analysis));
+        }
+        catch (error) {
+            this.logger.error('Failed to set walkthrough scope cache', { error, sessionId });
+        }
+    }
+    /**
+     * Delete walkthrough scope cache for a session.
+     */
+    deleteWalkthroughScopeCache(sessionId) {
+        try {
+            this.db.prepare('DELETE FROM walkthrough_scope_cache WHERE session_id = ?').run(sessionId);
+        }
+        catch (error) {
+            this.logger.error('Failed to delete walkthrough scope cache', { error, sessionId });
+        }
+    }
+}
+//# sourceMappingURL=session-info-service.js.map