claude-code-workflow 6.1.3 → 6.2.1

package/src/tools/cli-history-store.ts

@@ -0,0 +1,1195 @@
+/**
+ * CLI History Store - SQLite Storage Backend
+ * Provides persistent storage for CLI execution history with efficient queries
+ */
+
+import Database from 'better-sqlite3';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, rmdirSync } from 'fs';
+import { join } from 'path';
+import { parseSessionFile, formatConversation, extractConversationPairs, type ParsedSession, type ParsedTurn } from './session-content-parser.js';
+import { StoragePaths, ensureStorageDir, getProjectId } from '../config/storage-paths.js';
+
+// Types
+export interface ConversationTurn {
+  turn: number;
+  timestamp: string;
+  prompt: string;
+  duration_ms: number;
+  status: 'success' | 'error' | 'timeout';
+  exit_code: number | null;
+  // NOTE: Naming inconsistency - using prompt/stdout vs tool_args/tool_output in MemoryStore
+  // This reflects CLI-specific semantics (prompt -> execution -> output)
+  output: {
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+  };
+}
+
+// Execution category types
+export type ExecutionCategory = 'user' | 'internal' | 'insight';
+
+export interface ConversationRecord {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  tool: string;
+  model: string;
+  mode: string;
+  category: ExecutionCategory; // user | internal | insight
+  total_duration_ms: number;
+  turn_count: number;
+  latest_status: 'success' | 'error' | 'timeout';
+  turns: ConversationTurn[];
+  parent_execution_id?: string; // For fork/retry scenarios
+}
+
+export interface HistoryQueryOptions {
+  limit?: number;
+  offset?: number;
+  tool?: string | null;
+  status?: string | null;
+  category?: ExecutionCategory | null;
+  search?: string | null;
+  startDate?: string | null;
+  endDate?: string | null;
+}
+
+export interface HistoryIndexEntry {
+  id: string;
+  timestamp: string;
+  updated_at?: string;
+  tool: string;
+  status: string;
+  category?: ExecutionCategory;
+  duration_ms: number;
+  turn_count?: number;
+  prompt_preview: string;
+  sourceDir?: string;
+}
+
+// Native session mapping interface
+export interface NativeSessionMapping {
+  ccw_id: string;              // CCW execution ID (e.g., 1702123456789-gemini)
+  tool: string;                // gemini | qwen | codex
+  native_session_id: string;   // Native UUID
+  native_session_path?: string; // Native file path
+  project_hash?: string;       // Project hash (Gemini/Qwen)
+  created_at: string;
+}
+
+// Review record interface
+export type ReviewStatus = 'pending' | 'approved' | 'rejected' | 'changes_requested';
+
+export interface ReviewRecord {
+  id?: number;
+  execution_id: string;
+  status: ReviewStatus;
+  rating?: number;
+  comments?: string;
+  reviewer?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * CLI History Store using SQLite
+ */
+export class CliHistoryStore {
+  private db: Database.Database;
+  private dbPath: string;
+  private projectPath: string;
+
+  constructor(baseDir: string) {
+    this.projectPath = baseDir;
+
+    // Use centralized storage path
+    const paths = StoragePaths.project(baseDir);
+    const historyDir = paths.cliHistory;
+    ensureStorageDir(historyDir);
+
+    this.dbPath = paths.historyDb;
+    this.db = new Database(this.dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('synchronous = NORMAL');
+
+    this.initSchema();
+    this.migrateFromJson(historyDir);
+  }
+
+  /**
+   * Initialize database schema
+   */
+  private initSchema(): void {
+    this.db.exec(`
+      -- Conversations table (conversation metadata)
+      CREATE TABLE IF NOT EXISTS conversations (
+        id TEXT PRIMARY KEY,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        tool TEXT NOT NULL,
+        model TEXT DEFAULT 'default',
+        mode TEXT DEFAULT 'analysis',
+        category TEXT DEFAULT 'user',
+        total_duration_ms INTEGER DEFAULT 0,
+        turn_count INTEGER DEFAULT 0,
+        latest_status TEXT DEFAULT 'success',
+        prompt_preview TEXT,
+        parent_execution_id TEXT,
+        FOREIGN KEY (parent_execution_id) REFERENCES conversations(id) ON DELETE SET NULL
+      );
+
+      -- Turns table (individual conversation turns)
+      CREATE TABLE IF NOT EXISTS turns (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversation_id TEXT NOT NULL,
+        turn_number INTEGER NOT NULL,
+        timestamp TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        duration_ms INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'success',
+        exit_code INTEGER,
+        stdout TEXT,
+        stderr TEXT,
+        truncated INTEGER DEFAULT 0,
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE,
+        UNIQUE(conversation_id, turn_number)
+      );
+
+      -- Indexes for efficient queries
+      CREATE INDEX IF NOT EXISTS idx_conversations_tool ON conversations(tool);
+      CREATE INDEX IF NOT EXISTS idx_conversations_status ON conversations(latest_status);
+      CREATE INDEX IF NOT EXISTS idx_conversations_category ON conversations(category);
+      CREATE INDEX IF NOT EXISTS idx_conversations_updated ON conversations(updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_conversations_created ON conversations(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_turns_conversation ON turns(conversation_id);
+
+      -- Full-text search for prompts
+      CREATE VIRTUAL TABLE IF NOT EXISTS turns_fts USING fts5(
+        prompt,
+        stdout,
+        content='turns',
+        content_rowid='id'
+      );
+
+      -- Triggers to keep FTS index updated
+      CREATE TRIGGER IF NOT EXISTS turns_ai AFTER INSERT ON turns BEGIN
+        INSERT INTO turns_fts(rowid, prompt, stdout) VALUES (new.id, new.prompt, new.stdout);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS turns_ad AFTER DELETE ON turns BEGIN
+        INSERT INTO turns_fts(turns_fts, rowid, prompt, stdout) VALUES('delete', old.id, old.prompt, old.stdout);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS turns_au AFTER UPDATE ON turns BEGIN
+        INSERT INTO turns_fts(turns_fts, rowid, prompt, stdout) VALUES('delete', old.id, old.prompt, old.stdout);
+        INSERT INTO turns_fts(rowid, prompt, stdout) VALUES (new.id, new.prompt, new.stdout);
+      END;
+
+      -- Native session mapping table (CCW ID <-> Native Session ID)
+      CREATE TABLE IF NOT EXISTS native_session_mapping (
+        ccw_id TEXT PRIMARY KEY,
+        tool TEXT NOT NULL,
+        native_session_id TEXT NOT NULL,
+        native_session_path TEXT,
+        project_hash TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(tool, native_session_id)
+      );
+
+      -- Indexes for native session lookups
+      CREATE INDEX IF NOT EXISTS idx_native_tool_session ON native_session_mapping(tool, native_session_id);
+      CREATE INDEX IF NOT EXISTS idx_native_session_id ON native_session_mapping(native_session_id);
+
+      -- Insights analysis history table
+      CREATE TABLE IF NOT EXISTS insights (
+        id TEXT PRIMARY KEY,
+        created_at TEXT NOT NULL,
+        tool TEXT NOT NULL,
+        prompt_count INTEGER DEFAULT 0,
+        patterns TEXT,
+        suggestions TEXT,
+        raw_output TEXT,
+        execution_id TEXT,
+        lang TEXT DEFAULT 'en'
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_insights_created ON insights(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_insights_tool ON insights(tool);
+
+      -- Reviews table for CLI execution reviews
+      CREATE TABLE IF NOT EXISTS reviews (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        execution_id TEXT NOT NULL UNIQUE,
+        status TEXT NOT NULL DEFAULT 'pending',
+        rating INTEGER,
+        comments TEXT,
+        reviewer TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (execution_id) REFERENCES conversations(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_reviews_execution ON reviews(execution_id);
+      CREATE INDEX IF NOT EXISTS idx_reviews_status ON reviews(status);
+      CREATE INDEX IF NOT EXISTS idx_reviews_created ON reviews(created_at DESC);
+    `);
+
+    // Migration: Add category column if not exists (for existing databases)
+    this.migrateSchema();
+  }
+
+  /**
+   * Migrate schema for existing databases
+   */
+  private migrateSchema(): void {
+    try {
+      // Check if columns exist
+      const tableInfo = this.db.prepare('PRAGMA table_info(conversations)').all() as Array<{ name: string }>;
+      const hasCategory = tableInfo.some(col => col.name === 'category');
+      const hasParentExecutionId = tableInfo.some(col => col.name === 'parent_execution_id');
+      const hasProjectRoot = tableInfo.some(col => col.name === 'project_root');
+      const hasRelativePath = tableInfo.some(col => col.name === 'relative_path');
+
+      if (!hasCategory) {
+        console.log('[CLI History] Migrating database: adding category column...');
+        this.db.exec(`
+          ALTER TABLE conversations ADD COLUMN category TEXT DEFAULT 'user';
+        `);
+        // Create index separately to handle potential errors
+        try {
+          this.db.exec(`CREATE INDEX IF NOT EXISTS idx_conversations_category ON conversations(category);`);
+        } catch (indexErr) {
+          console.warn('[CLI History] Category index creation warning:', (indexErr as Error).message);
+        }
+        console.log('[CLI History] Migration complete: category column added');
+      }
+
+      if (!hasParentExecutionId) {
+        console.log('[CLI History] Migrating database: adding parent_execution_id column...');
+        this.db.exec(`
+          ALTER TABLE conversations ADD COLUMN parent_execution_id TEXT;
+        `);
+        try {
+          this.db.exec(`CREATE INDEX IF NOT EXISTS idx_conversations_parent ON conversations(parent_execution_id);`);
+        } catch (indexErr) {
+          console.warn('[CLI History] Parent execution index creation warning:', (indexErr as Error).message);
+        }
+        console.log('[CLI History] Migration complete: parent_execution_id column added');
+      }
+
+      // Add hierarchical storage support columns
+      if (!hasProjectRoot) {
+        console.log('[CLI History] Migrating database: adding project_root column for hierarchical storage...');
+        this.db.exec(`
+          ALTER TABLE conversations ADD COLUMN project_root TEXT;
+        `);
+        try {
+          this.db.exec(`CREATE INDEX IF NOT EXISTS idx_conversations_project_root ON conversations(project_root);`);
+        } catch (indexErr) {
+          console.warn('[CLI History] Project root index creation warning:', (indexErr as Error).message);
+        }
+        console.log('[CLI History] Migration complete: project_root column added');
+      }
+
+      if (!hasRelativePath) {
+        console.log('[CLI History] Migrating database: adding relative_path column for hierarchical storage...');
+        this.db.exec(`
+          ALTER TABLE conversations ADD COLUMN relative_path TEXT;
+        `);
+        console.log('[CLI History] Migration complete: relative_path column added');
+      }
+
+      // Add missing timestamp index for turns table (for time-based queries)
+      try {
+        const indexExists = this.db.prepare(`
+          SELECT name FROM sqlite_master
+          WHERE type='index' AND name='idx_turns_timestamp'
+        `).get();
+
+        if (!indexExists) {
+          console.log('[CLI History] Adding missing timestamp index to turns table...');
+          this.db.exec(`CREATE INDEX IF NOT EXISTS idx_turns_timestamp ON turns(timestamp DESC);`);
+          console.log('[CLI History] Migration complete: turns timestamp index added');
+        }
+      } catch (indexErr) {
+        console.warn('[CLI History] Turns timestamp index creation warning:', (indexErr as Error).message);
+      }
+    } catch (err) {
+      console.error('[CLI History] Migration error:', (err as Error).message);
+      // Don't throw - allow the store to continue working with existing schema
+    }
+  }
+
+  /**
+   * Migrate existing JSON files to SQLite
+   */
+  private migrateFromJson(historyDir: string): void {
+    const migrationMarker = join(historyDir, '.migrated');
+    if (existsSync(migrationMarker)) {
+      return; // Already migrated
+    }
+
+    // Find all date directories
+    const dateDirs = readdirSync(historyDir).filter(d => {
+      const dirPath = join(historyDir, d);
+      return statSync(dirPath).isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(d);
+    });
+
+    let migratedCount = 0;
+
+    for (const dateDir of dateDirs) {
+      const dirPath = join(historyDir, dateDir);
+      const files = readdirSync(dirPath).filter(f => f.endsWith('.json'));
+
+      for (const file of files) {
+        try {
+          const filePath = join(dirPath, file);
+          const data = JSON.parse(readFileSync(filePath, 'utf8'));
+
+          // Convert to conversation record if legacy format
+          const conversation = this.normalizeRecord(data);
+          this.saveConversation(conversation);
+          migratedCount++;
+
+          // Optionally delete the JSON file after migration
+          // unlinkSync(filePath);
+        } catch (err) {
+          console.error(`Failed to migrate ${file}:`, (err as Error).message);
+        }
+      }
+    }
+
+    // Create migration marker
+    if (migratedCount > 0) {
+      require('fs').writeFileSync(migrationMarker, new Date().toISOString());
+      console.log(`[CLI History] Migrated ${migratedCount} records to SQLite`);
+    }
+  }
+
+  /**
+   * Normalize legacy record to ConversationRecord format
+   */
+  private normalizeRecord(data: any): ConversationRecord {
+    if (data.turns && Array.isArray(data.turns)) {
+      return data as ConversationRecord;
+    }
+
+    // Legacy single execution format
+    return {
+      id: data.id,
+      created_at: data.timestamp,
+      updated_at: data.timestamp,
+      tool: data.tool,
+      model: data.model || 'default',
+      mode: data.mode || 'analysis',
+      category: data.category || 'user',
+      total_duration_ms: data.duration_ms || 0,
+      turn_count: 1,
+      latest_status: data.status || 'success',
+      turns: [{
+        turn: 1,
+        timestamp: data.timestamp,
+        prompt: data.prompt,
+        duration_ms: data.duration_ms || 0,
+        status: data.status || 'success',
+        exit_code: data.exit_code,
+        output: data.output || { stdout: '', stderr: '', truncated: false }
+      }]
+    };
+  }
+
+  /**
+   * Save or update a conversation
+   */
+  saveConversation(conversation: ConversationRecord): void {
+    const promptPreview = conversation.turns.length > 0
+      ? conversation.turns[conversation.turns.length - 1].prompt.substring(0, 100)
+      : '';
+
+    const upsertConversation = this.db.prepare(`
+      INSERT INTO conversations (id, created_at, updated_at, tool, model, mode, category, total_duration_ms, turn_count, latest_status, prompt_preview, parent_execution_id, project_root, relative_path)
+      VALUES (@id, @created_at, @updated_at, @tool, @model, @mode, @category, @total_duration_ms, @turn_count, @latest_status, @prompt_preview, @parent_execution_id, @project_root, @relative_path)
+      ON CONFLICT(id) DO UPDATE SET
+        updated_at = @updated_at,
+        total_duration_ms = @total_duration_ms,
+        turn_count = @turn_count,
+        latest_status = @latest_status,
+        prompt_preview = @prompt_preview,
+        project_root = @project_root,
+        relative_path = @relative_path
+    `);
+
+    const upsertTurn = this.db.prepare(`
+      INSERT INTO turns (conversation_id, turn_number, timestamp, prompt, duration_ms, status, exit_code, stdout, stderr, truncated)
+      VALUES (@conversation_id, @turn_number, @timestamp, @prompt, @duration_ms, @status, @exit_code, @stdout, @stderr, @truncated)
+      ON CONFLICT(conversation_id, turn_number) DO UPDATE SET
+        timestamp = @timestamp,
+        prompt = @prompt,
+        duration_ms = @duration_ms,
+        status = @status,
+        exit_code = @exit_code,
+        stdout = @stdout,
+        stderr = @stderr,
+        truncated = @truncated
+    `);
+
+    const transaction = this.db.transaction(() => {
+      upsertConversation.run({
+        id: conversation.id,
+        created_at: conversation.created_at,
+        updated_at: conversation.updated_at,
+        tool: conversation.tool,
+        model: conversation.model,
+        mode: conversation.mode,
+        category: conversation.category || 'user',
+        total_duration_ms: conversation.total_duration_ms,
+        turn_count: conversation.turn_count,
+        latest_status: conversation.latest_status,
+        prompt_preview: promptPreview,
+        parent_execution_id: conversation.parent_execution_id || null,
+        project_root: this.projectPath,
+        relative_path: null  // For future hierarchical tracking
+      });
+
+      for (const turn of conversation.turns) {
+        upsertTurn.run({
+          conversation_id: conversation.id,
+          turn_number: turn.turn,
+          timestamp: turn.timestamp,
+          prompt: turn.prompt,
+          duration_ms: turn.duration_ms,
+          status: turn.status,
+          exit_code: turn.exit_code,
+          stdout: turn.output.stdout,
+          stderr: turn.output.stderr,
+          truncated: turn.output.truncated ? 1 : 0
+        });
+      }
+    });
+
+    transaction();
+  }
+
+  /**
+   * Get conversation by ID
+   */
+  getConversation(id: string): ConversationRecord | null {
+    const conv = this.db.prepare(`
+      SELECT * FROM conversations WHERE id = ?
+    `).get(id) as any;
+
+    if (!conv) return null;
+
+    const turns = this.db.prepare(`
+      SELECT * FROM turns WHERE conversation_id = ? ORDER BY turn_number ASC
+    `).all(id) as any[];
+
+    return {
+      id: conv.id,
+      created_at: conv.created_at,
+      updated_at: conv.updated_at,
+      tool: conv.tool,
+      model: conv.model,
+      mode: conv.mode,
+      category: conv.category || 'user',
+      total_duration_ms: conv.total_duration_ms,
+      turn_count: conv.turn_count,
+      latest_status: conv.latest_status,
+      parent_execution_id: conv.parent_execution_id || undefined,
+      turns: turns.map(t => ({
+        turn: t.turn_number,
+        timestamp: t.timestamp,
+        prompt: t.prompt,
+        duration_ms: t.duration_ms,
+        status: t.status,
+        exit_code: t.exit_code,
+        output: {
+          stdout: t.stdout || '',
+          stderr: t.stderr || '',
+          truncated: !!t.truncated
+        }
+      }))
+    };
+  }
+
+  /**
+   * Get conversation with native session info
+   */
+  getConversationWithNativeInfo(id: string): (ConversationRecord & {
+    hasNativeSession: boolean;
+    nativeSessionId?: string;
+    nativeSessionPath?: string;
+  }) | null {
+    const conv = this.getConversation(id);
+    if (!conv) return null;
+
+    const mapping = this.getNativeSessionMapping(id);
+    return {
+      ...conv,
+      hasNativeSession: !!mapping,
+      nativeSessionId: mapping?.native_session_id,
+      nativeSessionPath: mapping?.native_session_path
+    };
+  }
+
+  /**
+   * Query execution history
+   */
+  getHistory(options: HistoryQueryOptions = {}): {
+    total: number;
+    count: number;
+    executions: HistoryIndexEntry[];
+  } {
+    const { limit = 50, offset = 0, tool, status, category, search, startDate, endDate } = options;
+
+    let whereClause = '1=1';
+    const params: any = {};
+
+    if (tool) {
+      whereClause += ' AND tool = @tool';
+      params.tool = tool;
+    }
+
+    if (status) {
+      whereClause += ' AND latest_status = @status';
+      params.status = status;
+    }
+
+    if (category) {
+      whereClause += ' AND category = @category';
+      params.category = category;
+    }
+
+    if (startDate) {
+      whereClause += ' AND created_at >= @startDate';
+      params.startDate = startDate;
+    }
+
+    if (endDate) {
+      whereClause += ' AND created_at <= @endDate';
+      params.endDate = endDate;
+    }
+
+    // Full-text search
+    let joinClause = '';
+    if (search) {
+      joinClause = `
+        INNER JOIN (
+          SELECT DISTINCT conversation_id FROM turns t
+          INNER JOIN turns_fts ON turns_fts.rowid = t.id
+          WHERE turns_fts MATCH @search
+        ) AS matched ON c.id = matched.conversation_id
+      `;
+      params.search = search;
+    }
+
+    const countQuery = this.db.prepare(`
+      SELECT COUNT(*) as count FROM conversations c ${joinClause} WHERE ${whereClause}
+    `);
+    const total = (countQuery.get(params) as any).count;
+
+    const dataQuery = this.db.prepare(`
+      SELECT c.* FROM conversations c ${joinClause}
+      WHERE ${whereClause}
+      ORDER BY c.updated_at DESC
+      LIMIT @limit OFFSET @offset
+    `);
+
+    const rows = dataQuery.all({ ...params, limit, offset }) as any[];
+
+    return {
+      total,
+      count: rows.length,
+      executions: rows.map(r => ({
+        id: r.id,
+        timestamp: r.created_at,
+        updated_at: r.updated_at,
+        tool: r.tool,
+        status: r.latest_status,
+        category: r.category || 'user',
+        duration_ms: r.total_duration_ms,
+        turn_count: r.turn_count,
+        prompt_preview: r.prompt_preview || ''
+      }))
+    };
+  }
+
+  /**
+   * Delete a conversation
+   */
+  deleteConversation(id: string): { success: boolean; error?: string } {
+    try {
+      const result = this.db.prepare('DELETE FROM conversations WHERE id = ?').run(id);
+      return { success: result.changes > 0 };
+    } catch (err) {
+      return { success: false, error: (err as Error).message };
+    }
+  }
+
+  /**
+   * Batch delete conversations
+   */
+  batchDelete(ids: string[]): { success: boolean; deleted: number; errors?: string[] } {
+    const deleteStmt = this.db.prepare('DELETE FROM conversations WHERE id = ?');
+    const errors: string[] = [];
+    let deleted = 0;
+
+    const transaction = this.db.transaction(() => {
+      for (const id of ids) {
+        try {
+          const result = deleteStmt.run(id);
+          if (result.changes > 0) deleted++;
+        } catch (err) {
+          errors.push(`${id}: ${(err as Error).message}`);
+        }
+      }
+    });
+
+    transaction();
+
+    return {
+      success: true,
+      deleted,
+      errors: errors.length > 0 ? errors : undefined
+    };
+  }
+
+  /**
+   * Delete conversations by tool
+   */
+  deleteByTool(tool: string): { success: boolean; deleted: number } {
+    const result = this.db.prepare('DELETE FROM conversations WHERE tool = ?').run(tool);
+    return { success: true, deleted: result.changes };
+  }
+
+  /**
+   * Delete all conversations
+   */
+  deleteAll(): { success: boolean; deleted: number } {
+    const count = (this.db.prepare('SELECT COUNT(*) as c FROM conversations').get() as any).c;
+    this.db.prepare('DELETE FROM conversations').run();
+    return { success: true, deleted: count };
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    total: number;
+    byTool: Record<string, number>;
+    byStatus: Record<string, number>;
+    totalDuration: number;
+  } {
+    const total = (this.db.prepare('SELECT COUNT(*) as c FROM conversations').get() as any).c;
+
+    const byToolRows = this.db.prepare(`
+      SELECT tool, COUNT(*) as count FROM conversations GROUP BY tool
+    `).all() as any[];
+    const byTool: Record<string, number> = {};
+    for (const row of byToolRows) {
+      byTool[row.tool] = row.count;
+    }
+
+    const byStatusRows = this.db.prepare(`
+      SELECT latest_status, COUNT(*) as count FROM conversations GROUP BY latest_status
+    `).all() as any[];
+    const byStatus: Record<string, number> = {};
+    for (const row of byStatusRows) {
+      byStatus[row.latest_status] = row.count;
+    }
+
+    const totalDuration = (this.db.prepare(`
+      SELECT COALESCE(SUM(total_duration_ms), 0) as total FROM conversations
+    `).get() as any).total;
+
+    return { total, byTool, byStatus, totalDuration };
+  }
+
+  // ========== Native Session Mapping Methods ==========
+
+  /**
+   * Save or update native session mapping
+   */
+  saveNativeSessionMapping(mapping: NativeSessionMapping): void {
+    const stmt = this.db.prepare(`
+      INSERT INTO native_session_mapping (ccw_id, tool, native_session_id, native_session_path, project_hash, created_at)
+      VALUES (@ccw_id, @tool, @native_session_id, @native_session_path, @project_hash, @created_at)
+      ON CONFLICT(ccw_id) DO UPDATE SET
+        native_session_id = @native_session_id,
+        native_session_path = @native_session_path,
+        project_hash = @project_hash
+    `);
+
+    stmt.run({
+      ccw_id: mapping.ccw_id,
+      tool: mapping.tool,
+      native_session_id: mapping.native_session_id,
+      native_session_path: mapping.native_session_path || null,
+      project_hash: mapping.project_hash || null,
+      created_at: mapping.created_at || new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get native session ID by CCW ID
+   */
+  getNativeSessionId(ccwId: string): string | null {
+    const row = this.db.prepare(`
+      SELECT native_session_id FROM native_session_mapping WHERE ccw_id = ?
+    `).get(ccwId) as any;
+    return row?.native_session_id || null;
+  }
+
+  /**
+   * Get CCW ID by native session ID
+   */
+  getCcwIdByNativeSession(tool: string, nativeSessionId: string): string | null {
+    const row = this.db.prepare(`
+      SELECT ccw_id FROM native_session_mapping WHERE tool = ? AND native_session_id = ?
+    `).get(tool, nativeSessionId) as any;
+    return row?.ccw_id || null;
+  }
+
+  /**
+   * Get full mapping by CCW ID
+   */
+  getNativeSessionMapping(ccwId: string): NativeSessionMapping | null {
+    const row = this.db.prepare(`
+      SELECT * FROM native_session_mapping WHERE ccw_id = ?
+    `).get(ccwId) as any;
+
+    if (!row) return null;
+
+    return {
+      ccw_id: row.ccw_id,
+      tool: row.tool,
+      native_session_id: row.native_session_id,
+      native_session_path: row.native_session_path,
+      project_hash: row.project_hash,
+      created_at: row.created_at
+    };
+  }
+
+  /**
+   * Get latest native session mapping for a tool
+   */
+  getLatestNativeMapping(tool: string): NativeSessionMapping | null {
+    const row = this.db.prepare(`
+      SELECT * FROM native_session_mapping 
+      WHERE tool = ? 
+      ORDER BY created_at DESC 
+      LIMIT 1
+    `).get(tool) as any;
+
+    if (!row) return null;
+
+    return {
+      ccw_id: row.ccw_id,
+      tool: row.tool,
+      native_session_id: row.native_session_id,
+      native_session_path: row.native_session_path,
+      project_hash: row.project_hash,
+      created_at: row.created_at
+    };
+  }
+
+  /**
+   * Delete native session mapping
+   */
+  deleteNativeSessionMapping(ccwId: string): boolean {
+    const result = this.db.prepare('DELETE FROM native_session_mapping WHERE ccw_id = ?').run(ccwId);
+    return result.changes > 0;
+  }
+
+  /**
+   * Check if CCW ID has native session mapping
+   */
+  hasNativeSession(ccwId: string): boolean {
+    const row = this.db.prepare(`
+      SELECT 1 FROM native_session_mapping WHERE ccw_id = ? LIMIT 1
+    `).get(ccwId);
+    return !!row;
+  }
+
+  // ========== Native Session Content Methods ==========
+
+  /**
+   * Get parsed native session content by CCW ID
+   * Returns full conversation with all turns from native session file
+   */
+  getNativeSessionContent(ccwId: string): ParsedSession | null {
+    const mapping = this.getNativeSessionMapping(ccwId);
+    if (!mapping || !mapping.native_session_path) {
+      return null;
+    }
+
+    return parseSessionFile(mapping.native_session_path, mapping.tool);
+  }
+
+  /**
+   * Get formatted conversation text from native session
+   */
+  getFormattedNativeConversation(ccwId: string, options?: {
+    includeThoughts?: boolean;
+    includeToolCalls?: boolean;
+    includeTokens?: boolean;
+    maxContentLength?: number;
+  }): string | null {
+    const session = this.getNativeSessionContent(ccwId);
+    if (!session) {
+      return null;
+    }
+    return formatConversation(session, options);
+  }
+
+  /**
+   * Get conversation pairs (user prompt + assistant response) from native session
+   */
+  getNativeConversationPairs(ccwId: string): Array<{
+    turn: number;
+    userPrompt: string;
+    assistantResponse: string;
+    timestamp: string;
+  }> | null {
+    const session = this.getNativeSessionContent(ccwId);
+    if (!session) {
+      return null;
+    }
+    return extractConversationPairs(session);
+  }
+
+  /**
+   * Get conversation with enriched native session data
+   * Merges CCW history with native session content
+   */
+  getEnrichedConversation(ccwId: string): {
+    ccw: ConversationRecord | null;
+    native: ParsedSession | null;
+    merged: Array<{
+      turn: number;
+      timestamp: string;
+      ccwPrompt?: string;
+      ccwOutput?: string;
+      nativeUserContent?: string;
+      nativeAssistantContent?: string;
+      nativeThoughts?: string[];
+      nativeToolCalls?: Array<{ name: string; arguments?: string; output?: string }>;
+    }>;
+  } | null {
+    const ccwConv = this.getConversation(ccwId);
+    const nativeSession = this.getNativeSessionContent(ccwId);
+
+    if (!ccwConv && !nativeSession) {
+      return null;
+    }
+
+    const merged: Array<{
+      turn: number;
+      timestamp: string;
+      ccwPrompt?: string;
+      ccwOutput?: string;
+      nativeUserContent?: string;
+      nativeAssistantContent?: string;
+      nativeThoughts?: string[];
+      nativeToolCalls?: Array<{ name: string; arguments?: string; output?: string }>;
+    }> = [];
+
+    // Determine max turn count
+    const maxTurns = Math.max(
+      ccwConv?.turn_count || 0,
+      nativeSession?.turns.filter(t => t.role === 'user').length || 0
+    );
+
+    for (let i = 1; i <= maxTurns; i++) {
+      const ccwTurn = ccwConv?.turns.find(t => t.turn === i);
+      const nativeUserTurn = nativeSession?.turns.find(t => t.turnNumber === i && t.role === 'user');
+      const nativeAssistantTurn = nativeSession?.turns.find(t => t.turnNumber === i && t.role === 'assistant');
+
+      merged.push({
+        turn: i,
+        timestamp: ccwTurn?.timestamp || nativeUserTurn?.timestamp || '',
+        ccwPrompt: ccwTurn?.prompt,
+        ccwOutput: ccwTurn?.output.stdout,
+        nativeUserContent: nativeUserTurn?.content,
+        nativeAssistantContent: nativeAssistantTurn?.content,
+        nativeThoughts: nativeAssistantTurn?.thoughts,
+        nativeToolCalls: nativeAssistantTurn?.toolCalls
+      });
+    }
+
+    return { ccw: ccwConv, native: nativeSession, merged };
+  }
+
+  /**
+   * List all conversations with native session info
+   */
+  getHistoryWithNativeInfo(options: HistoryQueryOptions = {}): {
+    total: number;
+    count: number;
+    executions: Array<HistoryIndexEntry & {
+      hasNativeSession: boolean;
+      nativeSessionId?: string;
+      nativeSessionPath?: string;
+    }>;
+  } {
+    const history = this.getHistory(options);
+
+    const enrichedExecutions = history.executions.map(exec => {
+      const mapping = this.getNativeSessionMapping(exec.id);
+      return {
+        ...exec,
+        hasNativeSession: !!mapping,
+        nativeSessionId: mapping?.native_session_id,
+        nativeSessionPath: mapping?.native_session_path
+      };
+    });
+
+    return {
+      total: history.total,
+      count: history.count,
+      executions: enrichedExecutions
+    };
+  }
+
+  // ========== Insights Methods ==========
+
+  /**
+   * Save an insights analysis result
+   */
+  saveInsight(insight: {
+    id: string;
+    tool: string;
+    promptCount: number;
+    patterns: any[];
+    suggestions: any[];
+    rawOutput?: string;
+    executionId?: string;
+    lang?: string;
+  }): void {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO insights (id, created_at, tool, prompt_count, patterns, suggestions, raw_output, execution_id, lang)
+      VALUES (@id, @created_at, @tool, @prompt_count, @patterns, @suggestions, @raw_output, @execution_id, @lang)
+    `);
+
+    stmt.run({
+      id: insight.id,
+      created_at: new Date().toISOString(),
+      tool: insight.tool,
+      prompt_count: insight.promptCount,
+      patterns: JSON.stringify(insight.patterns || []),
+      suggestions: JSON.stringify(insight.suggestions || []),
+      raw_output: insight.rawOutput || null,
+      execution_id: insight.executionId || null,
+      lang: insight.lang || 'en'
+    });
+  }
+
+  /**
+   * Get insights history
+   */
+  getInsights(options: { limit?: number; tool?: string } = {}): {
+    id: string;
+    created_at: string;
+    tool: string;
+    prompt_count: number;
+    patterns: any[];
+    suggestions: any[];
+    execution_id: string | null;
+    lang: string;
+  }[] {
+    const { limit = 20, tool } = options;
+
+    let sql = 'SELECT id, created_at, tool, prompt_count, patterns, suggestions, execution_id, lang FROM insights';
+    const params: any = {};
+
+    if (tool) {
+      sql += ' WHERE tool = @tool';
+      params.tool = tool;
+    }
+
+    sql += ' ORDER BY created_at DESC LIMIT @limit';
+    params.limit = limit;
+
+    const rows = this.db.prepare(sql).all(params) as any[];
+
+    return rows.map(row => ({
+      ...row,
+      patterns: JSON.parse(row.patterns || '[]'),
+      suggestions: JSON.parse(row.suggestions || '[]')
+    }));
+  }
+
+  /**
+   * Get a single insight by ID
+   */
+  getInsight(id: string): {
+    id: string;
+    created_at: string;
+    tool: string;
+    prompt_count: number;
+    patterns: any[];
+    suggestions: any[];
+    raw_output: string | null;
+    execution_id: string | null;
+    lang: string;
+  } | null {
+    const row = this.db.prepare(
+      'SELECT * FROM insights WHERE id = ?'
+    ).get(id) as any;
+
+    if (!row) return null;
+
+    return {
+      ...row,
+      patterns: JSON.parse(row.patterns || '[]'),
+      suggestions: JSON.parse(row.suggestions || '[]')
+    };
+  }
+
+  /**
+   * Delete an insight
+   */
+  deleteInsight(id: string): boolean {
+    const result = this.db.prepare('DELETE FROM insights WHERE id = ?').run(id);
+    return result.changes > 0;
+  }
+
+  /**
+   * Save or update a review for an execution
+   */
+  saveReview(review: Omit<ReviewRecord, 'id' | 'created_at' | 'updated_at'> & { created_at?: string; updated_at?: string }): ReviewRecord {
+    const now = new Date().toISOString();
+    const created_at = review.created_at || now;
+    const updated_at = review.updated_at || now;
+
+    const stmt = this.db.prepare(`
+      INSERT INTO reviews (execution_id, status, rating, comments, reviewer, created_at, updated_at)
+      VALUES (@execution_id, @status, @rating, @comments, @reviewer, @created_at, @updated_at)
+      ON CONFLICT(execution_id) DO UPDATE SET
+        status = @status,
+        rating = @rating,
+        comments = @comments,
+        reviewer = @reviewer,
+        updated_at = @updated_at
+    `);
+
+    const result = stmt.run({
+      execution_id: review.execution_id,
+      status: review.status,
+      rating: review.rating ?? null,
+      comments: review.comments ?? null,
+      reviewer: review.reviewer ?? null,
+      created_at,
+      updated_at
+    });
+
+    return {
+      id: result.lastInsertRowid as number,
+      execution_id: review.execution_id,
+      status: review.status,
+      rating: review.rating,
+      comments: review.comments,
+      reviewer: review.reviewer,
+      created_at,
+      updated_at
+    };
+  }
+
+  /**
+   * Get review for an execution
+   */
+  getReview(executionId: string): ReviewRecord | null {
+    const row = this.db.prepare(
+      'SELECT * FROM reviews WHERE execution_id = ?'
+    ).get(executionId) as any;
+
+    if (!row) return null;
+
+    return {
+      id: row.id,
+      execution_id: row.execution_id,
+      status: row.status as ReviewStatus,
+      rating: row.rating,
+      comments: row.comments,
+      reviewer: row.reviewer,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+
+  /**
+   * Get reviews with optional filtering
+   */
+  getReviews(options: { status?: ReviewStatus; limit?: number } = {}): ReviewRecord[] {
+    const { status, limit = 50 } = options;
+
+    let sql = 'SELECT * FROM reviews';
+    const params: any = { limit };
+
+    if (status) {
+      sql += ' WHERE status = @status';
+      params.status = status;
+    }
+
+    sql += ' ORDER BY updated_at DESC LIMIT @limit';
+
+    const rows = this.db.prepare(sql).all(params) as any[];
+
+    return rows.map(row => ({
+      id: row.id,
+      execution_id: row.execution_id,
+      status: row.status as ReviewStatus,
+      rating: row.rating,
+      comments: row.comments,
+      reviewer: row.reviewer,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    }));
+  }
+
+  /**
+   * Delete a review
+   */
+  deleteReview(executionId: string): boolean {
+    const result = this.db.prepare('DELETE FROM reviews WHERE execution_id = ?').run(executionId);
+    return result.changes > 0;
+  }
+
+  /**
+   * Close database connection
+   */
+  close(): void {
+    this.db.close();
+  }
+}
+
+// Singleton instance cache - keyed by normalized project ID for consistency
+const storeCache = new Map<string, CliHistoryStore>();
+
+/**
+ * Get or create a store instance for a directory
+ * Uses normalized project ID as cache key to handle path casing differences
+ */
+export function getHistoryStore(baseDir: string): CliHistoryStore {
+  // Use getProjectId to normalize path for consistent cache key
+  const cacheKey = getProjectId(baseDir);
+
+  if (!storeCache.has(cacheKey)) {
+    storeCache.set(cacheKey, new CliHistoryStore(baseDir));
+  }
+  return storeCache.get(cacheKey)!;
+}
+
+/**
+ * Close all store instances
+ */
+export function closeAllStores(): void {
+  for (const store of storeCache.values()) {
+    store.close();
+  }
+  storeCache.clear();
+}
+
+// Re-export types from session-content-parser
+export type { ParsedSession, ParsedTurn } from './session-content-parser.js';