create-walle 0.1.0

package/template/claude-task-manager/db.js

@@ -0,0 +1,1721 @@
+// --- SQLite Database Layer (WAL mode, better-sqlite3) ---
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+
+const DATA_DIR = process.env.CTM_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
+const DEFAULT_DB_PATH = path.join(DATA_DIR, 'task-manager.db');
+const DEFAULT_IMAGES_DIR = path.join(DATA_DIR, 'images');
+const BACKUP_DIR = path.join(DATA_DIR, 'backups');
+
+let db = null;
+let currentDbPath = null;
+let backupIntervalId = null;
+
+function getDb() {
+  if (db) return db;
+  throw new Error('Database not initialized. Call initDb() first.');
+}
+
+function initDb(dbPath) {
+  dbPath = dbPath || DEFAULT_DB_PATH;
+  currentDbPath = dbPath;
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(DEFAULT_IMAGES_DIR)) fs.mkdirSync(DEFAULT_IMAGES_DIR, { recursive: true });
+  if (!fs.existsSync(BACKUP_DIR)) fs.mkdirSync(BACKUP_DIR, { recursive: true });
+
+  db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('busy_timeout = 5000');
+  db.pragma('foreign_keys = ON');
+
+  createTables();
+  runMigrations();
+  return db;
+}
+
+function createTables() {
+  db.exec(`
+    -- Settings (key-value store)
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT,
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Folders for organizing prompts
+    CREATE TABLE IF NOT EXISTS folders (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      parent_id INTEGER REFERENCES folders(id) ON DELETE SET NULL,
+      color TEXT DEFAULT '#7aa2f7',
+      sort_order INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Prompts
+    CREATE TABLE IF NOT EXISTS prompts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      content_html TEXT NOT NULL DEFAULT '',
+      folder_id INTEGER REFERENCES folders(id) ON DELETE SET NULL,
+      context_type TEXT DEFAULT 'general',
+      tags TEXT DEFAULT '[]',
+      is_template INTEGER DEFAULT 0,
+      template_vars TEXT DEFAULT '[]',
+      starred INTEGER DEFAULT 0,
+      sort_order INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Prompt versions (history)
+    CREATE TABLE IF NOT EXISTS prompt_versions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt_id INTEGER NOT NULL REFERENCES prompts(id) ON DELETE CASCADE,
+      version INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      content_html TEXT NOT NULL DEFAULT '',
+      tags TEXT DEFAULT '[]',
+      created_at TEXT DEFAULT (datetime('now')),
+      message TEXT DEFAULT ''
+    );
+
+    -- Images (stored as blobs or file references)
+    CREATE TABLE IF NOT EXISTS images (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt_id INTEGER REFERENCES prompts(id) ON DELETE CASCADE,
+      filename TEXT NOT NULL,
+      mime_type TEXT DEFAULT 'image/png',
+      file_path TEXT NOT NULL,
+      annotations TEXT DEFAULT '[]',
+      width INTEGER,
+      height INTEGER,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Prompt chains
+    CREATE TABLE IF NOT EXISTS chains (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Chain nodes (steps in a chain)
+    CREATE TABLE IF NOT EXISTS chain_nodes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      chain_id INTEGER NOT NULL REFERENCES chains(id) ON DELETE CASCADE,
+      prompt_id INTEGER REFERENCES prompts(id) ON DELETE SET NULL,
+      node_type TEXT DEFAULT 'prompt',
+      position_x REAL DEFAULT 0,
+      position_y REAL DEFAULT 0,
+      config TEXT DEFAULT '{}',
+      sort_order INTEGER DEFAULT 0
+    );
+
+    -- Chain edges (connections between nodes)
+    CREATE TABLE IF NOT EXISTS chain_edges (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      chain_id INTEGER NOT NULL REFERENCES chains(id) ON DELETE CASCADE,
+      from_node_id INTEGER NOT NULL REFERENCES chain_nodes(id) ON DELETE CASCADE,
+      to_node_id INTEGER NOT NULL REFERENCES chain_nodes(id) ON DELETE CASCADE,
+      condition TEXT DEFAULT '',
+      label TEXT DEFAULT ''
+    );
+
+    -- Prompt usage tracking
+    CREATE TABLE IF NOT EXISTS prompt_usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt_id INTEGER NOT NULL REFERENCES prompts(id) ON DELETE CASCADE,
+      session_id TEXT,
+      used_at TEXT DEFAULT (datetime('now')),
+      result TEXT DEFAULT '',
+      effectiveness_score REAL
+    );
+
+    -- Permission rules
+    CREATE TABLE IF NOT EXISTS permission_rules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_name TEXT NOT NULL,
+      pattern TEXT DEFAULT '*',
+      action TEXT DEFAULT 'ask',
+      project_path TEXT DEFAULT '*',
+      created_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(tool_name, pattern, project_path)
+    );
+
+    -- Permission audit log (from session parsing)
+    CREATE TABLE IF NOT EXISTS permission_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      tool_name TEXT NOT NULL,
+      action_taken TEXT,
+      details TEXT DEFAULT '',
+      timestamp TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Session conversations (imported from JSONL)
+    CREATE TABLE IF NOT EXISTS session_conversations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      project_path TEXT,
+      messages TEXT NOT NULL DEFAULT '[]',
+      user_msg_count INTEGER DEFAULT 0,
+      assistant_msg_count INTEGER DEFAULT 0,
+      title TEXT,
+      first_message TEXT,
+      git_branch TEXT,
+      file_size INTEGER DEFAULT 0,
+      session_created_at TEXT,
+      imported_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(session_id)
+    );
+
+    -- Prompt templates
+    CREATE TABLE IF NOT EXISTS templates (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      content TEXT NOT NULL DEFAULT '',
+      content_html TEXT NOT NULL DEFAULT '',
+      variables TEXT DEFAULT '[]',
+      category TEXT DEFAULT 'general',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Create indexes
+    CREATE INDEX IF NOT EXISTS idx_prompts_folder ON prompts(folder_id);
+    CREATE INDEX IF NOT EXISTS idx_prompts_context ON prompts(context_type);
+    CREATE INDEX IF NOT EXISTS idx_prompts_updated ON prompts(updated_at);
+    CREATE INDEX IF NOT EXISTS idx_prompt_versions_prompt ON prompt_versions(prompt_id);
+    CREATE INDEX IF NOT EXISTS idx_images_prompt ON images(prompt_id);
+    CREATE INDEX IF NOT EXISTS idx_chain_nodes_chain ON chain_nodes(chain_id);
+    CREATE INDEX IF NOT EXISTS idx_chain_edges_chain ON chain_edges(chain_id);
+    CREATE INDEX IF NOT EXISTS idx_prompt_usage_prompt ON prompt_usage(prompt_id);
+    CREATE INDEX IF NOT EXISTS idx_session_conversations_session ON session_conversations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_permission_log_session ON permission_log(session_id);
+  `);
+}
+
+function runMigrations() {
+  // Add pinned column to prompts if not exists
+  const cols = getDb().prepare("PRAGMA table_info(prompts)").all();
+  if (!cols.find(c => c.name === 'pinned')) {
+    getDb().exec('ALTER TABLE prompts ADD COLUMN pinned INTEGER DEFAULT 0');
+  }
+
+  // Add session_titles table for AI-generated titles
+  const hasTitles = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_titles'").get();
+  if (!hasTitles) {
+    getDb().exec(`
+      CREATE TABLE session_titles (
+        session_id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        user_renamed INTEGER DEFAULT 0,
+        generated_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+  } else {
+    // Migration: add user_renamed column if missing
+    const cols = getDb().prepare("PRAGMA table_info(session_titles)").all();
+    if (!cols.find(c => c.name === 'user_renamed')) {
+      getDb().exec("ALTER TABLE session_titles ADD COLUMN user_renamed INTEGER DEFAULT 0");
+    }
+  }
+
+  // Add session_folders table for user-overridden project folders
+  const hasFolders = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_folders'").get();
+  if (!hasFolders) {
+    getDb().exec(`
+      CREATE TABLE session_folders (
+        session_id TEXT PRIMARY KEY,
+        folder TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+  }
+
+  // Add prompt_queues table
+  const hasQueues = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='prompt_queues'").get();
+  if (!hasQueues) {
+    getDb().exec(`
+      CREATE TABLE prompt_queues (
+        session_id TEXT PRIMARY KEY,
+        mode TEXT DEFAULT 'manual',
+        status TEXT DEFAULT 'idle',
+        current_index INTEGER DEFAULT -1,
+        idle_timeout_ms INTEGER DEFAULT 10000,
+        items TEXT DEFAULT '[]',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+  }
+
+  // Add perm_rules table (source of truth for all permission rules)
+  const hasPermRules = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='perm_rules'").get();
+  if (!hasPermRules) {
+    getDb().exec(`
+      CREATE TABLE perm_rules (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        rule TEXT NOT NULL,
+        list_type TEXT NOT NULL DEFAULT 'allow',
+        scope TEXT NOT NULL DEFAULT 'global',
+        project TEXT NOT NULL DEFAULT '__global__',
+        created_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(rule, list_type, project)
+      );
+      CREATE INDEX IF NOT EXISTS idx_perm_rules_project ON perm_rules(project);
+      CREATE INDEX IF NOT EXISTS idx_perm_rules_type ON perm_rules(list_type);
+    `);
+  }
+
+  // Add always_ask column to perm_rules (migration)
+  const hasAlwaysAsk = getDb().prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='perm_rules'").get();
+  if (hasAlwaysAsk && !hasAlwaysAsk.sql.includes('always_ask')) {
+    getDb().exec('ALTER TABLE perm_rules ADD COLUMN always_ask INTEGER DEFAULT 0');
+  }
+
+  // Migrate tool_permissions_cache data into perm_rules
+  const hasTPC = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tool_permissions_cache'").get();
+  if (hasTPC) {
+    const rows = getDb().prepare('SELECT * FROM tool_permissions_cache').all();
+    if (rows.length > 0) {
+      const ins = getDb().prepare(
+        `INSERT OR IGNORE INTO perm_rules (rule, list_type, scope, project, always_ask)
+         VALUES (?, 'allow', ?, ?, ?)`
+      );
+      for (const r of rows) {
+        if (r.project_path === '__always_ask__') {
+          // always_ask flag — update existing rule or insert
+          getDb().prepare(
+            `UPDATE perm_rules SET always_ask = 1 WHERE rule = ? AND list_type = 'allow'`
+          ).run(r.tool_name);
+          // If no row was updated (rule doesn't exist as broad rule), insert it as global
+          ins.run(r.tool_name, 'global', '__global__', 1);
+        } else {
+          const scope = r.project_path === '__global__' ? 'global' : 'project';
+          ins.run(r.tool_name, scope, r.project_path, 0);
+        }
+      }
+      console.log(`  Migrated ${rows.length} entries from tool_permissions_cache → perm_rules`);
+    }
+    getDb().exec('DROP TABLE tool_permissions_cache');
+    console.log('  Dropped tool_permissions_cache table');
+  }
+
+  // Add parent_id column to prompts for tree grouping
+  const promptsSql = getDb().prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='prompts'").get();
+  if (promptsSql && !promptsSql.sql.includes('parent_id')) {
+    getDb().exec('ALTER TABLE prompts ADD COLUMN parent_id INTEGER REFERENCES prompts(id) ON DELETE SET NULL');
+    getDb().exec('CREATE INDEX IF NOT EXISTS idx_prompts_parent ON prompts(parent_id)');
+    console.log('  Added parent_id column to prompts table');
+  }
+
+  // Add auto_approvals table
+  const hasAutoApprovals = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='auto_approvals'").get();
+  if (!hasAutoApprovals) {
+    getDb().exec(`
+      CREATE TABLE auto_approvals (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        pattern TEXT NOT NULL,
+        response TEXT NOT NULL DEFAULT 'yes',
+        label TEXT NOT NULL DEFAULT '',
+        category TEXT NOT NULL DEFAULT '',
+        enabled INTEGER DEFAULT 1,
+        occurrences INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(pattern)
+      );
+    `);
+  }
+
+  // Add approval_rules table (learned rules from AI agent)
+  const hasApprovalRules = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='approval_rules'").get();
+  if (!hasApprovalRules) {
+    getDb().exec(`
+      CREATE TABLE approval_rules (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        pattern TEXT NOT NULL,
+        label TEXT NOT NULL DEFAULT '',
+        description TEXT DEFAULT '',
+        category TEXT DEFAULT '',
+        risk_level TEXT DEFAULT 'low',
+        enabled INTEGER DEFAULT 1,
+        times_matched INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(pattern)
+      );
+    `);
+  }
+
+  // Rename generic "Local dev operations" rules with descriptive labels
+  {
+    const labelMap = [
+      { pattern: 'echo\\s+.*>\\s*\\/tmp\\/', label: 'Write to /tmp', desc: 'Echo output to temp files' },
+      { pattern: 'cat\\s', label: 'Read file contents', desc: 'View file contents with cat' },
+      { pattern: 'ls\\s', label: 'List directory', desc: 'List files and directories' },
+      { pattern: 'pwd', label: 'Print working directory', desc: 'Show current directory path' },
+      { pattern: 'git\\s+(status|log|diff|branch|show)', label: 'Git read operations', desc: 'Read-only git commands' },
+      { pattern: 'node\\s+-e', label: 'Node one-liner', desc: 'Run inline Node.js expression' },
+      { pattern: 'python3?\\s+-c', label: 'Python one-liner', desc: 'Run inline Python expression' },
+      { pattern: 'npm\\s+(run|test|start)', label: 'npm script', desc: 'Run npm scripts (run, test, start)' },
+      { pattern: 'mkdir\\s+-?p?\\s', label: 'Create directory', desc: 'Create directories with mkdir' },
+      { pattern: '>\\s*\\/tmp\\/', label: 'Write to /tmp', desc: 'Redirect output to temp files' },
+      { pattern: 'touch\\s', label: 'Create empty file', desc: 'Create or update file timestamps' },
+      { pattern: 'cp\\s', label: 'Copy files', desc: 'Copy files or directories' },
+      { pattern: 'mv\\s', label: 'Move/rename files', desc: 'Move or rename files' },
+    ];
+    const stmt = getDb().prepare(
+      `UPDATE approval_rules SET label = ?, description = ? WHERE pattern = ? AND label = 'Local dev operations'`
+    );
+    for (const { pattern, label, desc } of labelMap) {
+      stmt.run(label, desc, pattern);
+    }
+  }
+
+  // Add approval_decisions table (audit log of all decisions)
+  const hasApprovalDecisions = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='approval_decisions'").get();
+  if (!hasApprovalDecisions) {
+    getDb().exec(`
+      CREATE TABLE approval_decisions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        tool_name TEXT DEFAULT '',
+        command_summary TEXT NOT NULL DEFAULT '',
+        full_context TEXT DEFAULT '',
+        warning_text TEXT DEFAULT '',
+        decision TEXT NOT NULL DEFAULT 'escalated',
+        reasoning TEXT DEFAULT '',
+        decided_by TEXT DEFAULT 'ai',
+        rule_id INTEGER,
+        risk_level TEXT DEFAULT 'low',
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_approval_decisions_session ON approval_decisions(session_id);
+      CREATE INDEX IF NOT EXISTS idx_approval_decisions_created ON approval_decisions(created_at);
+    `);
+  }
+
+  // Add code_reviews tables
+  const hasCodeReviews = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='code_reviews'").get();
+  if (!hasCodeReviews) {
+    getDb().exec(`
+      CREATE TABLE code_reviews (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT,
+        project_path TEXT NOT NULL,
+        base_ref TEXT DEFAULT '',
+        status TEXT DEFAULT 'draft',
+        summary TEXT DEFAULT '',
+        file_count INTEGER DEFAULT 0,
+        comment_count INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        submitted_at TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_code_reviews_session ON code_reviews(session_id);
+      CREATE INDEX IF NOT EXISTS idx_code_reviews_project ON code_reviews(project_path);
+
+      CREATE TABLE review_comments (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        review_id INTEGER NOT NULL REFERENCES code_reviews(id) ON DELETE CASCADE,
+        file_path TEXT NOT NULL,
+        line_start INTEGER NOT NULL,
+        line_end INTEGER,
+        side TEXT DEFAULT 'new',
+        body TEXT NOT NULL,
+        severity TEXT DEFAULT 'comment',
+        status TEXT DEFAULT 'open',
+        ai_generated INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_review_comments_review ON review_comments(review_id);
+    `);
+  }
+
+  // Add insights tables (session analysis, groups, skills, recommendations)
+  const hasSessionAnalyses = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_analyses'").get();
+  if (!hasSessionAnalyses) {
+    getDb().exec(`
+      CREATE TABLE session_analyses (
+        session_id TEXT PRIMARY KEY,
+        project TEXT,
+        title TEXT,
+        category TEXT,
+        topics TEXT DEFAULT '[]',
+        skills_used TEXT DEFAULT '[]',
+        complexity TEXT,
+        summary TEXT,
+        pattern TEXT,
+        first_message TEXT,
+        session_modified_at TEXT,
+        analyzed_at TEXT DEFAULT (datetime('now')),
+        token_count INTEGER DEFAULT 0,
+        message_count INTEGER DEFAULT 0,
+        prompt_efficiency TEXT DEFAULT '{}'
+      );
+      CREATE INDEX IF NOT EXISTS idx_session_analyses_category ON session_analyses(category);
+      CREATE INDEX IF NOT EXISTS idx_session_analyses_analyzed ON session_analyses(analyzed_at);
+
+      CREATE TABLE insight_groups (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        description TEXT,
+        category TEXT,
+        is_internal INTEGER DEFAULT 0,
+        session_ids TEXT DEFAULT '[]',
+        session_count INTEGER DEFAULT 0,
+        generated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE insight_skills (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        title TEXT,
+        description TEXT,
+        trigger_pattern TEXT,
+        category TEXT,
+        is_internal INTEGER DEFAULT 0,
+        based_on TEXT DEFAULT '[]',
+        priority TEXT DEFAULT 'low',
+        example_sessions TEXT DEFAULT '[]',
+        generated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE insight_recommendations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        category TEXT,
+        title TEXT NOT NULL,
+        description TEXT,
+        evidence TEXT DEFAULT '{}',
+        impact TEXT DEFAULT 'medium',
+        actionable TEXT,
+        generated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE analysis_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        started_at TEXT DEFAULT (datetime('now')),
+        completed_at TEXT,
+        sessions_analyzed INTEGER DEFAULT 0,
+        sessions_skipped INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'running'
+      );
+    `);
+  }
+
+  // Add prompt_executions table (harvested session messages)
+  const hasPromptExecs = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='prompt_executions'").get();
+  if (!hasPromptExecs) {
+    getDb().exec(`
+      CREATE TABLE prompt_executions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        message_text TEXT NOT NULL,
+        message_index INTEGER DEFAULT 0,
+        role TEXT DEFAULT 'user',
+        tool_uses TEXT DEFAULT '[]',
+        image_refs TEXT DEFAULT '[]',
+        project_path TEXT DEFAULT '',
+        cwd TEXT DEFAULT '',
+        source TEXT DEFAULT 'harvested',
+        outcome TEXT,
+        outcome_notes TEXT,
+        executed_at TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(session_id, message_index)
+      );
+      CREATE INDEX IF NOT EXISTS idx_pe_session ON prompt_executions(session_id);
+      CREATE INDEX IF NOT EXISTS idx_pe_role ON prompt_executions(role);
+      CREATE INDEX IF NOT EXISTS idx_pe_project ON prompt_executions(project_path);
+      CREATE INDEX IF NOT EXISTS idx_pe_executed ON prompt_executions(executed_at);
+    `);
+  }
+
+  // Add prompt_patterns table (detected reusable patterns)
+  const hasPromptPatterns = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='prompt_patterns'").get();
+  if (!hasPromptPatterns) {
+    getDb().exec(`
+      CREATE TABLE prompt_patterns (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        normalized_text TEXT NOT NULL,
+        frequency INTEGER DEFAULT 1,
+        example_text TEXT,
+        sessions TEXT DEFAULT '[]',
+        projects TEXT DEFAULT '[]',
+        last_used_at TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(normalized_text)
+      );
+    `);
+  }
+
+  // Add harvest_state table (singleton watermark for incremental scanning)
+  const hasHarvestState = getDb().prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='harvest_state'").get();
+  if (!hasHarvestState) {
+    getDb().exec(`
+      CREATE TABLE harvest_state (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        last_scan_at TEXT,
+        files_scanned INTEGER DEFAULT 0,
+        prompts_harvested INTEGER DEFAULT 0
+      );
+    `);
+  }
+
+  // Add lifecycle_status column to prompts for prompt lifecycle
+  const promptsCols2 = getDb().prepare("PRAGMA table_info(prompts)").all();
+  if (!promptsCols2.find(c => c.name === 'lifecycle_status')) {
+    getDb().exec("ALTER TABLE prompts ADD COLUMN lifecycle_status TEXT DEFAULT 'draft'");
+  }
+
+  // Rename lifecycle statuses: tested→used, proven→frequent
+  getDb().exec("UPDATE prompts SET lifecycle_status = 'used' WHERE lifecycle_status = 'tested'");
+  getDb().exec("UPDATE prompts SET lifecycle_status = 'frequent' WHERE lifecycle_status = 'proven'");
+
+  // Add last_lifecycle_refresh_at column to harvest_state
+  const hsCols = getDb().prepare("PRAGMA table_info(harvest_state)").all();
+  if (!hsCols.find(c => c.name === 'last_lifecycle_refresh_at')) {
+    getDb().exec("ALTER TABLE harvest_state ADD COLUMN last_lifecycle_refresh_at TEXT");
+  }
+}
+
+// --- Settings CRUD ---
+function getSetting(key, defaultValue) {
+  const row = getDb().prepare('SELECT value FROM settings WHERE key = ?').get(key);
+  return row ? JSON.parse(row.value) : defaultValue;
+}
+
+function getSettingsByPrefix(prefix) {
+  return getDb().prepare('SELECT key, value FROM settings WHERE key LIKE ?').all(prefix + '%').map(row => ({
+    key: row.key,
+    value: JSON.parse(row.value),
+  }));
+}
+
+function setSetting(key, value) {
+  getDb().prepare(
+    "INSERT INTO settings (key, value, updated_at) VALUES (?, ?, datetime('now')) ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at"
+  ).run(key, JSON.stringify(value));
+}
+
+// --- Prompts CRUD ---
+function createPrompt({ title, content, content_html, folder_id, context_type, tags, is_template, template_vars, starred, parent_id }) {
+  const result = getDb().prepare(
+    `INSERT INTO prompts (title, content, content_html, folder_id, context_type, tags, is_template, template_vars, starred, parent_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    title, content || '', content_html || '', folder_id || null,
+    context_type || 'general', JSON.stringify(tags || []),
+    is_template ? 1 : 0, JSON.stringify(template_vars || []),
+    starred ? 1 : 0, parent_id || null
+  );
+  // Create initial version
+  getDb().prepare(
+    `INSERT INTO prompt_versions (prompt_id, version, title, content, content_html, tags, message)
+     VALUES (?, 1, ?, ?, ?, ?, 'Initial version')`
+  ).run(result.lastInsertRowid, title, content || '', content_html || '', JSON.stringify(tags || []));
+  return result.lastInsertRowid;
+}
+
+function updatePrompt(id, { title, content, content_html, folder_id, context_type, tags, is_template, template_vars, starred, pinned, sort_order, parent_id, version_message, lifecycle_status }) {
+  const existing = getDb().prepare('SELECT * FROM prompts WHERE id = ?').get(id);
+  if (!existing) throw new Error('Prompt not found');
+
+  getDb().prepare(
+    `UPDATE prompts SET title=?, content=?, content_html=?, folder_id=?, context_type=?, tags=?,
+     is_template=?, template_vars=?, starred=?, pinned=?, sort_order=?, parent_id=?, lifecycle_status=?, updated_at=datetime('now') WHERE id=?`
+  ).run(
+    title ?? existing.title, content ?? existing.content, content_html ?? existing.content_html,
+    folder_id !== undefined ? folder_id : existing.folder_id,
+    context_type ?? existing.context_type, tags ? JSON.stringify(tags) : existing.tags,
+    is_template !== undefined ? (is_template ? 1 : 0) : existing.is_template,
+    template_vars ? JSON.stringify(template_vars) : existing.template_vars,
+    starred !== undefined ? (starred ? 1 : 0) : existing.starred,
+    pinned !== undefined ? (pinned ? 1 : 0) : (existing.pinned || 0),
+    sort_order !== undefined ? sort_order : (existing.sort_order || 0),
+    parent_id !== undefined ? parent_id : (existing.parent_id || null),
+    lifecycle_status ?? (existing.lifecycle_status || 'draft'),
+    id
+  );
+
+  // Create new version
+  const lastVersion = getDb().prepare(
+    'SELECT MAX(version) as v FROM prompt_versions WHERE prompt_id = ?'
+  ).get(id);
+  getDb().prepare(
+    `INSERT INTO prompt_versions (prompt_id, version, title, content, content_html, tags, message)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id, (lastVersion?.v || 0) + 1, title ?? existing.title,
+    content ?? existing.content, content_html ?? existing.content_html,
+    tags ? JSON.stringify(tags) : existing.tags, version_message || ''
+  );
+}
+
+function getPrompt(id) {
+  return getDb().prepare('SELECT p.*, (SELECT COUNT(*) FROM prompts c WHERE c.parent_id = p.id) as child_count FROM prompts p WHERE p.id = ?').get(id);
+}
+
+function listPrompts({ folder_id, context_type, search, starred, limit, offset, include_children, lifecycle_status } = {}) {
+  let sql = `SELECT p.*, (SELECT COUNT(*) FROM prompts c WHERE c.parent_id = p.id) as child_count FROM prompts p WHERE 1=1`;
+  const params = [];
+
+  // By default, only show top-level prompts (parent_id IS NULL)
+  // When searching, show all matches regardless of nesting
+  if (!search && !include_children) {
+    sql += ' AND p.parent_id IS NULL';
+  }
+
+  if (folder_id !== undefined) { sql += ' AND p.folder_id = ?'; params.push(folder_id); }
+  if (context_type) { sql += ' AND p.context_type = ?'; params.push(context_type); }
+  if (lifecycle_status) { sql += ' AND (p.lifecycle_status = ? OR (? = \'draft\' AND p.lifecycle_status IS NULL))'; params.push(lifecycle_status, lifecycle_status); }
+  if (starred) { sql += ' AND p.starred = 1'; }
+  if (search) {
+    sql += ' AND (p.title LIKE ? OR p.content LIKE ? OR p.tags LIKE ?)';
+    const q = `%${search}%`;
+    params.push(q, q, q);
+  }
+
+  sql += ' ORDER BY p.pinned DESC, p.sort_order ASC, p.updated_at DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  if (offset) { sql += ' OFFSET ?'; params.push(offset); }
+
+  return getDb().prepare(sql).all(...params);
+}
+
+function listChildPrompts(parentId) {
+  return getDb().prepare(
+    'SELECT * FROM prompts WHERE parent_id = ? ORDER BY sort_order ASC, updated_at DESC'
+  ).all(parentId);
+}
+
+function setPromptParent(id, parentId) {
+  // Prevent circular: can't set parent to self or to own child
+  if (parentId === id) throw new Error('Cannot parent to self');
+  if (parentId) {
+    const target = getDb().prepare('SELECT parent_id FROM prompts WHERE id = ?').get(parentId);
+    if (target && target.parent_id) throw new Error('Cannot nest more than 1 level deep');
+    // If the dragged prompt has children, prevent it from becoming a child
+    const childCount = getDb().prepare('SELECT COUNT(*) as n FROM prompts WHERE parent_id = ?').get(id);
+    if (childCount.n > 0) throw new Error('Cannot nest a group inside another group');
+  }
+  getDb().prepare('UPDATE prompts SET parent_id = ?, updated_at = datetime(\'now\') WHERE id = ?').run(parentId || null, id);
+}
+
+function createGroupFromPrompts(promptIds, { title, content, contentHtml } = {}) {
+  if (!promptIds || promptIds.length < 2) throw new Error('Need at least 2 prompts to create a group');
+  const prompts = promptIds.map(id => {
+    const p = getDb().prepare('SELECT * FROM prompts WHERE id = ?').get(id);
+    if (!p) throw new Error(`Prompt ${id} not found`);
+    if (p.parent_id) throw new Error(`Prompt "${p.title}" is already in a group`);
+    const childCount = getDb().prepare('SELECT COUNT(*) as n FROM prompts WHERE parent_id = ?').get(id);
+    if (childCount.n > 0) throw new Error(`Prompt "${p.title}" is already a group parent`);
+    return p;
+  });
+
+  // Fallback if no AI-generated title/content provided
+  if (!title) {
+    title = prompts.map(p => p.title || 'Untitled').join(' + ');
+  }
+  if (!content) {
+    const summaryLines = prompts.map(p => `- ${p.title || 'Untitled'}`).join('\n');
+    content = `Group of ${prompts.length} prompts:\n${summaryLines}`;
+  }
+  if (!contentHtml) {
+    contentHtml = `<p>${content.replace(/\n/g, '<br>')}</p>`;
+  }
+
+  const folderId = prompts[0].folder_id;
+  const contextType = prompts[0].context_type || 'general';
+  const sortOrder = prompts[0].sort_order || 0;
+
+  const txn = getDb().transaction(() => {
+    const result = getDb().prepare(
+      `INSERT INTO prompts (title, content, content_html, folder_id, context_type, tags, sort_order)
+       VALUES (?, ?, ?, ?, ?, '[]', ?)`
+    ).run(title, content, contentHtml, folderId, contextType, sortOrder);
+    const groupId = result.lastInsertRowid;
+
+    getDb().prepare(
+      `INSERT INTO prompt_versions (prompt_id, version, title, content, content_html, tags, message)
+       VALUES (?, 1, ?, ?, ?, '[]', 'Group created')`
+    ).run(groupId, title, content, contentHtml);
+
+    const setParent = getDb().prepare('UPDATE prompts SET parent_id = ?, updated_at = datetime(\'now\') WHERE id = ?');
+    for (const p of prompts) {
+      setParent.run(groupId, p.id);
+    }
+
+    return groupId;
+  });
+
+  return txn();
+}
+
+function deletePrompt(id) {
+  // Delete children first (group sub-prompts), then the prompt itself
+  getDb().prepare('DELETE FROM prompts WHERE parent_id = ?').run(id);
+  getDb().prepare('DELETE FROM prompts WHERE id = ?').run(id);
+}
+
+function duplicatePrompt(id) {
+  const existing = getDb().prepare('SELECT * FROM prompts WHERE id = ?').get(id);
+  if (!existing) throw new Error('Prompt not found');
+
+  const insertStmt = getDb().prepare(
+    `INSERT INTO prompts (title, content, content_html, folder_id, context_type, tags, is_template, template_vars, starred, pinned, sort_order, parent_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+
+  const txn = getDb().transaction(() => {
+    const result = insertStmt.run(
+      existing.title + ' (copy)', existing.content, existing.content_html,
+      existing.folder_id, existing.context_type, existing.tags,
+      existing.is_template, existing.template_vars, 0, 0, 0,
+      existing.parent_id || null
+    );
+    const newId = result.lastInsertRowid;
+
+    // Recursively duplicate children
+    const children = listChildPrompts(id);
+    for (const child of children) {
+      insertStmt.run(
+        child.title, child.content, child.content_html,
+        child.folder_id, child.context_type, child.tags,
+        child.is_template, child.template_vars, 0, 0, child.sort_order,
+        newId
+      );
+    }
+
+    return newId;
+  });
+
+  return txn();
+}
+
+function reorderPrompts(orderedIds) {
+  const stmt = getDb().prepare('UPDATE prompts SET sort_order = ? WHERE id = ?');
+  const txn = getDb().transaction(() => {
+    for (let i = 0; i < orderedIds.length; i++) {
+      stmt.run(i, orderedIds[i]);
+    }
+  });
+  txn();
+}
+
+function reorderFolders(orderedIds) {
+  const stmt = getDb().prepare('UPDATE folders SET sort_order = ? WHERE id = ?');
+  const txn = getDb().transaction(() => {
+    for (let i = 0; i < orderedIds.length; i++) {
+      stmt.run(i, orderedIds[i]);
+    }
+  });
+  txn();
+}
+
+function getPromptVersions(promptId) {
+  return getDb().prepare('SELECT * FROM prompt_versions WHERE prompt_id = ? ORDER BY version DESC').all(promptId);
+}
+
+function restorePromptVersion(promptId, versionId) {
+  const version = getDb().prepare('SELECT * FROM prompt_versions WHERE id = ? AND prompt_id = ?').get(versionId, promptId);
+  if (!version) throw new Error('Version not found');
+  updatePrompt(promptId, {
+    title: version.title, content: version.content, content_html: version.content_html,
+    tags: JSON.parse(version.tags || '[]'), version_message: `Restored from v${version.version}`
+  });
+}
+
+// --- Folders CRUD ---
+function createFolder({ name, parent_id, color }) {
+  const result = getDb().prepare(
+    'INSERT INTO folders (name, parent_id, color) VALUES (?, ?, ?)'
+  ).run(name, parent_id || null, color || '#7aa2f7');
+  return result.lastInsertRowid;
+}
+
+function listFolders() {
+  return getDb().prepare('SELECT * FROM folders ORDER BY sort_order, name').all();
+}
+
+function updateFolder(id, { name, parent_id, color, sort_order }) {
+  const existing = getDb().prepare('SELECT * FROM folders WHERE id = ?').get(id);
+  if (!existing) throw new Error('Folder not found');
+  getDb().prepare('UPDATE folders SET name=?, parent_id=?, color=?, sort_order=? WHERE id=?')
+    .run(name ?? existing.name, parent_id !== undefined ? parent_id : existing.parent_id,
+      color ?? existing.color, sort_order ?? existing.sort_order, id);
+}
+
+function deleteFolder(id) {
+  getDb().prepare('DELETE FROM folders WHERE id = ?').run(id);
+}
+
+// --- Images ---
+function saveImage(promptId, buffer, filename, mimeType) {
+  const ext = path.extname(filename) || '.png';
+  const hash = crypto.createHash('md5').update(buffer).digest('hex');
+  const storedFilename = `${hash}${ext}`;
+  const filePath = path.join(DEFAULT_IMAGES_DIR, storedFilename);
+
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, buffer);
+  }
+
+  // Use NULL for prompt_id=0 (queue panel images not tied to a prompt) to avoid FK constraint
+  const pid = promptId && promptId > 0 ? promptId : null;
+  const result = getDb().prepare(
+    'INSERT INTO images (prompt_id, filename, mime_type, file_path) VALUES (?, ?, ?, ?)'
+  ).run(pid, filename, mimeType || 'image/png', filePath);
+  return { id: result.lastInsertRowid, filename: storedFilename, path: filePath };
+}
+
+function getImage(id) {
+  return getDb().prepare('SELECT * FROM images WHERE id = ?').get(id);
+}
+
+function updateImageAnnotations(id, annotations) {
+  getDb().prepare('UPDATE images SET annotations = ? WHERE id = ?').run(JSON.stringify(annotations), id);
+}
+
+function listImages(promptId) {
+  return getDb().prepare('SELECT * FROM images WHERE prompt_id = ? ORDER BY created_at').all(promptId);
+}
+
+function deleteImage(id) {
+  const img = getDb().prepare('SELECT * FROM images WHERE id = ?').get(id);
+  if (img) {
+    try { fs.unlinkSync(img.file_path); } catch {}
+    getDb().prepare('DELETE FROM images WHERE id = ?').run(id);
+  }
+}
+
+// --- Chains ---
+function createChain({ name, description }) {
+  const result = getDb().prepare('INSERT INTO chains (name, description) VALUES (?, ?)').run(name, description || '');
+  return result.lastInsertRowid;
+}
+
+function getChain(id) {
+  const chain = getDb().prepare('SELECT * FROM chains WHERE id = ?').get(id);
+  if (!chain) return null;
+  chain.nodes = getDb().prepare('SELECT * FROM chain_nodes WHERE chain_id = ? ORDER BY sort_order').all(id);
+  chain.edges = getDb().prepare('SELECT * FROM chain_edges WHERE chain_id = ?').all(id);
+  return chain;
+}
+
+function listChains() {
+  return getDb().prepare('SELECT * FROM chains ORDER BY updated_at DESC').all();
+}
+
+function updateChain(id, { name, description, nodes, edges }) {
+  getDb().prepare('UPDATE chains SET name=?, description=?, updated_at=datetime("now") WHERE id=?')
+    .run(name, description || '', id);
+
+  if (nodes) {
+    getDb().prepare('DELETE FROM chain_nodes WHERE chain_id = ?').run(id);
+    const insertNode = getDb().prepare(
+      'INSERT INTO chain_nodes (chain_id, prompt_id, node_type, position_x, position_y, config, sort_order) VALUES (?, ?, ?, ?, ?, ?, ?)'
+    );
+    for (const n of nodes) {
+      insertNode.run(id, n.prompt_id || null, n.node_type || 'prompt', n.position_x || 0, n.position_y || 0, JSON.stringify(n.config || {}), n.sort_order || 0);
+    }
+  }
+
+  if (edges) {
+    getDb().prepare('DELETE FROM chain_edges WHERE chain_id = ?').run(id);
+    const insertEdge = getDb().prepare(
+      'INSERT INTO chain_edges (chain_id, from_node_id, to_node_id, condition, label) VALUES (?, ?, ?, ?, ?)'
+    );
+    for (const e of edges) {
+      insertEdge.run(id, e.from_node_id, e.to_node_id, e.condition || '', e.label || '');
+    }
+  }
+}
+
+function deleteChain(id) {
+  getDb().prepare('DELETE FROM chains WHERE id = ?').run(id);
+}
+
+// --- Perm Rules (source of truth for Claude Code permissions) ---
+function listPermRules({ project, listType } = {}) {
+  let sql = 'SELECT * FROM perm_rules WHERE 1=1';
+  const params = [];
+  if (project) { sql += ' AND project = ?'; params.push(project); }
+  if (listType) { sql += ' AND list_type = ?'; params.push(listType); }
+  sql += ' ORDER BY project, rule';
+  return getDb().prepare(sql).all(...params);
+}
+
+function addPermRule({ rule, listType, scope, project }) {
+  getDb().prepare(
+    `INSERT OR IGNORE INTO perm_rules (rule, list_type, scope, project)
+     VALUES (?, ?, ?, ?)`
+  ).run(rule, listType || 'allow', scope || 'global', project || '__global__');
+}
+
+function removePermRule({ rule, listType, project }) {
+  getDb().prepare(
+    'DELETE FROM perm_rules WHERE rule = ? AND list_type = ? AND project = ?'
+  ).run(rule, listType || 'allow', project || '__global__');
+}
+
+function bulkSetPermRules(rules) {
+  // rules: [{ rule, listType, scope, project }]
+  const txn = getDb().transaction(() => {
+    getDb().exec('DELETE FROM perm_rules');
+    const ins = getDb().prepare(
+      'INSERT OR IGNORE INTO perm_rules (rule, list_type, scope, project) VALUES (?, ?, ?, ?)'
+    );
+    for (const r of rules) {
+      ins.run(r.rule, r.listType || 'allow', r.scope || 'global', r.project || '__global__');
+    }
+  });
+  txn();
+}
+
+function getPermRulesByProject() {
+  const rows = getDb().prepare('SELECT * FROM perm_rules ORDER BY project, list_type, rule').all();
+  const result = {};
+  for (const r of rows) {
+    if (!result[r.project]) result[r.project] = { allow: [], deny: [] };
+    result[r.project][r.list_type].push(r.rule);
+  }
+  return result;
+}
+
+// --- Legacy Permission Rules (old table, kept for backwards compat) ---
+function listPermissionRules() {
+  return getDb().prepare('SELECT * FROM permission_rules ORDER BY tool_name, pattern').all();
+}
+
+function upsertPermissionRule({ tool_name, pattern, action, project_path }) {
+  getDb().prepare(
+    `INSERT INTO permission_rules (tool_name, pattern, action, project_path)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(tool_name, pattern, project_path) DO UPDATE SET action = excluded.action`
+  ).run(tool_name, pattern || '*', action || 'ask', project_path || '*');
+}
+
+function deletePermissionRule(id) {
+  getDb().prepare('DELETE FROM permission_rules WHERE id = ?').run(id);
+}
+
+function listPermissionLog({ session_id, tool_name, limit } = {}) {
+  let sql = 'SELECT * FROM permission_log WHERE 1=1';
+  const params = [];
+  if (session_id) { sql += ' AND session_id = ?'; params.push(session_id); }
+  if (tool_name) { sql += ' AND tool_name = ?'; params.push(tool_name); }
+  sql += ' ORDER BY timestamp DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  return getDb().prepare(sql).all(...params);
+}
+
+function addPermissionLog({ session_id, tool_name, action_taken, details }) {
+  getDb().prepare(
+    'INSERT INTO permission_log (session_id, tool_name, action_taken, details) VALUES (?, ?, ?, ?)'
+  ).run(session_id || '', tool_name, action_taken || '', details || '');
+}
+
+// --- Session Titles ---
+function getSessionTitle(sessionId) {
+  const row = getDb().prepare('SELECT title, user_renamed FROM session_titles WHERE session_id = ?').get(sessionId);
+  return row || null;
+}
+
+function setSessionTitle(sessionId, title, userRenamed = false) {
+  getDb().prepare(
+    `INSERT INTO session_titles (session_id, title, user_renamed) VALUES (?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       title = CASE WHEN session_titles.user_renamed AND NOT excluded.user_renamed THEN session_titles.title ELSE excluded.title END,
+       user_renamed = CASE WHEN excluded.user_renamed THEN 1 ELSE session_titles.user_renamed END,
+       generated_at = datetime('now')`
+  ).run(sessionId, title, userRenamed ? 1 : 0);
+}
+
+function isSessionUserRenamed(sessionId) {
+  const row = getDb().prepare('SELECT user_renamed FROM session_titles WHERE session_id = ?').get(sessionId);
+  return row ? !!row.user_renamed : false;
+}
+
+function getAllSessionTitles() {
+  const rows = getDb().prepare('SELECT session_id, title, user_renamed FROM session_titles').all();
+  const map = {};
+  for (const r of rows) map[r.session_id] = { title: r.title, userRenamed: !!r.user_renamed };
+  return map;
+}
+
+
+// --- Always Ask (uses perm_rules.always_ask column) ---
+function getAlwaysAskTools() {
+  return getDb().prepare('SELECT DISTINCT rule FROM perm_rules WHERE always_ask = 1').all()
+    .map(r => r.rule);
+}
+
+function setAlwaysAsk(toolName, alwaysAsk) {
+  if (alwaysAsk) {
+    // Set always_ask=1 on all matching rules across all projects
+    const updated = getDb().prepare(
+      `UPDATE perm_rules SET always_ask = 1 WHERE rule = ?`
+    ).run(toolName);
+    // If no matching rule exists, insert as global allow with always_ask
+    if (updated.changes === 0) {
+      getDb().prepare(
+        `INSERT OR IGNORE INTO perm_rules (rule, list_type, scope, project, always_ask)
+         VALUES (?, 'allow', 'global', '__global__', 1)`
+      ).run(toolName);
+    }
+  } else {
+    getDb().prepare(
+      `UPDATE perm_rules SET always_ask = 0 WHERE rule = ?`
+    ).run(toolName);
+  }
+}
+
+// --- Session Conversations ---
+function importSessionConversation({ session_id, project_path, messages, user_msg_count, assistant_msg_count, title, first_message, git_branch, file_size, session_created_at }) {
+  getDb().prepare(
+    `INSERT INTO session_conversations (session_id, project_path, messages, user_msg_count, assistant_msg_count, title, first_message, git_branch, file_size, session_created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       messages=excluded.messages, user_msg_count=excluded.user_msg_count,
+       assistant_msg_count=excluded.assistant_msg_count, title=excluded.title,
+       first_message=excluded.first_message, git_branch=excluded.git_branch,
+       file_size=excluded.file_size, imported_at=datetime('now')`
+  ).run(
+    session_id, project_path || '', JSON.stringify(messages || []),
+    user_msg_count || 0, assistant_msg_count || 0, title || '',
+    first_message || '', git_branch || '', file_size || 0, session_created_at || ''
+  );
+}
+
+function listSessionConversations({ search, limit, offset } = {}) {
+  let sql = 'SELECT id, session_id, project_path, user_msg_count, assistant_msg_count, title, first_message, git_branch, file_size, session_created_at, imported_at FROM session_conversations WHERE 1=1';
+  const params = [];
+  if (search) {
+    sql += ' AND (title LIKE ? OR first_message LIKE ? OR project_path LIKE ?)';
+    const q = `%${search}%`;
+    params.push(q, q, q);
+  }
+  sql += ' ORDER BY imported_at DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  if (offset) { sql += ' OFFSET ?'; params.push(offset); }
+  return getDb().prepare(sql).all(...params);
+}
+
+function getSessionConversation(sessionId) {
+  return getDb().prepare('SELECT * FROM session_conversations WHERE session_id = ?').get(sessionId);
+}
+
+// --- Templates ---
+function createTemplate({ name, description, content, content_html, variables, category }) {
+  const result = getDb().prepare(
+    'INSERT INTO templates (name, description, content, content_html, variables, category) VALUES (?, ?, ?, ?, ?, ?)'
+  ).run(name, description || '', content || '', content_html || '', JSON.stringify(variables || []), category || 'general');
+  return result.lastInsertRowid;
+}
+
+function listTemplates() {
+  return getDb().prepare('SELECT * FROM templates ORDER BY category, name').all();
+}
+
+function getTemplate(id) {
+  return getDb().prepare('SELECT * FROM templates WHERE id = ?').get(id);
+}
+
+function deleteTemplate(id) {
+  getDb().prepare('DELETE FROM templates WHERE id = ?').run(id);
+}
+
+// --- Prompt Usage ---
+function trackPromptUsage({ prompt_id, session_id, result, effectiveness_score }) {
+  getDb().prepare(
+    'INSERT INTO prompt_usage (prompt_id, session_id, result, effectiveness_score) VALUES (?, ?, ?, ?)'
+  ).run(prompt_id, session_id || '', result || '', effectiveness_score || null);
+}
+
+function getPromptUsageStats(promptId) {
+  return getDb().prepare(
+    `SELECT COUNT(*) as use_count, AVG(effectiveness_score) as avg_score,
+     MAX(used_at) as last_used FROM prompt_usage WHERE prompt_id = ?`
+  ).get(promptId);
+}
+
+// --- Backup & Recovery ---
+function checkpointWal() {
+  if (!db) return;
+  try {
+    db.pragma('wal_checkpoint(TRUNCATE)');
+  } catch {}
+}
+
+function createBackup(label) {
+  if (!db || !currentDbPath) throw new Error('Database not initialized');
+  checkpointWal();
+
+  const now = new Date();
+  const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const tag = label ? `-${label.replace(/[^a-zA-Z0-9_-]/g, '')}` : '';
+  const backupName = `task-manager-${ts}${tag}.db`;
+  const backupPath = path.join(BACKUP_DIR, backupName);
+
+  // Use SQLite backup API via better-sqlite3
+  db.backup(backupPath).then(() => {}).catch(() => {
+    // Fallback: file copy
+    fs.copyFileSync(currentDbPath, backupPath);
+  });
+
+  // Also copy images dir as a tarball if it has content
+  const imagesBackup = path.join(BACKUP_DIR, `images-${ts}${tag}.tar.gz`);
+  try {
+
+    const imageFiles = fs.readdirSync(DEFAULT_IMAGES_DIR);
+    if (imageFiles.length > 0) {
+      require('child_process').spawnSync('tar', ['-czf', imagesBackup, '-C', path.dirname(DEFAULT_IMAGES_DIR), path.basename(DEFAULT_IMAGES_DIR)], { timeout: 30000 });
+    }
+  } catch {}
+
+  cleanOldBackups();
+  return { backupName, backupPath, timestamp: now.toISOString() };
+}
+
+function createBackupSync(label) {
+  if (!db || !currentDbPath) throw new Error('Database not initialized');
+  checkpointWal();
+
+  const now = new Date();
+  const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const tag = label ? `-${label.replace(/[^a-zA-Z0-9_-]/g, '')}` : '';
+  const backupName = `task-manager-${ts}${tag}.db`;
+  const backupPath = path.join(BACKUP_DIR, backupName);
+
+  fs.copyFileSync(currentDbPath, backupPath);
+
+  // Also copy images
+  const imagesBackup = path.join(BACKUP_DIR, `images-${ts}${tag}.tar.gz`);
+  try {
+
+    const imageFiles = fs.readdirSync(DEFAULT_IMAGES_DIR);
+    if (imageFiles.length > 0) {
+      require('child_process').spawnSync('tar', ['-czf', imagesBackup, '-C', path.dirname(DEFAULT_IMAGES_DIR), path.basename(DEFAULT_IMAGES_DIR)], { timeout: 30000 });
+    }
+  } catch {}
+
+  cleanOldBackups();
+  return { backupName, backupPath, timestamp: now.toISOString() };
+}
+
+function listBackups() {
+  if (!fs.existsSync(BACKUP_DIR)) return [];
+  const files = fs.readdirSync(BACKUP_DIR)
+    .filter(f => f.startsWith('task-manager-') && f.endsWith('.db'))
+    .sort()
+    .reverse();
+
+  return files.map(f => {
+    const stat = fs.statSync(path.join(BACKUP_DIR, f));
+    // Check for matching images archive
+    const imagesFile = f.replace('task-manager-', 'images-').replace('.db', '.tar.gz');
+    const hasImages = fs.existsSync(path.join(BACKUP_DIR, imagesFile));
+    return {
+      name: f,
+      path: path.join(BACKUP_DIR, f),
+      size: stat.size,
+      createdAt: stat.mtime.toISOString(),
+      hasImages,
+      imagesFile: hasImages ? imagesFile : null,
+    };
+  });
+}
+
+function restoreBackup(backupName) {
+  const backupPath = path.join(BACKUP_DIR, path.basename(backupName));
+  if (!fs.existsSync(backupPath)) throw new Error('Backup not found');
+  if (!backupName.endsWith('.db')) throw new Error('Invalid backup file');
+
+  // Create a safety backup of current state before restoring
+  createBackupSync('pre-restore');
+
+  // Close current DB
+  checkpointWal();
+  if (db) { db.close(); db = null; }
+
+  // Copy backup over current DB
+  fs.copyFileSync(backupPath, currentDbPath);
+
+  // Restore images if archive exists
+  const imagesFile = backupName.replace('task-manager-', 'images-').replace('.db', '.tar.gz');
+  const imagesArchive = path.join(BACKUP_DIR, imagesFile);
+  if (fs.existsSync(imagesArchive)) {
+    try {
+      require('child_process').spawnSync('tar', ['-xzf', imagesArchive, '-C', path.dirname(DEFAULT_IMAGES_DIR)], { timeout: 30000 });
+    } catch {}
+  }
+
+  // Re-open DB
+  db = new Database(currentDbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('busy_timeout = 5000');
+  db.pragma('foreign_keys = ON');
+
+  return { ok: true, restored: backupName };
+}
+
+function deleteBackup(backupName) {
+  const backupPath = path.join(BACKUP_DIR, path.basename(backupName));
+  if (fs.existsSync(backupPath)) fs.unlinkSync(backupPath);
+  // Also delete images archive
+  const imagesFile = backupName.replace('task-manager-', 'images-').replace('.db', '.tar.gz');
+  const imagesPath = path.join(BACKUP_DIR, imagesFile);
+  if (fs.existsSync(imagesPath)) fs.unlinkSync(imagesPath);
+}
+
+function cleanOldBackups(maxAge = 30) {
+  // Keep backups for maxAge days, but always keep at least 5
+  const backups = listBackups();
+  if (backups.length <= 5) return;
+
+  const cutoff = Date.now() - (maxAge * 24 * 60 * 60 * 1000);
+  const toDelete = backups.slice(5).filter(b => new Date(b.createdAt).getTime() < cutoff);
+  for (const b of toDelete) {
+    deleteBackup(b.name);
+  }
+}
+
+function startDailyBackup() {
+  // Run backup immediately if none today
+  const backups = listBackups();
+  const today = new Date().toISOString().slice(0, 10);
+  const hasToday = backups.some(b => b.createdAt.startsWith(today));
+  if (!hasToday && db) {
+    try { createBackupSync('daily'); } catch (e) { console.error('Daily backup failed:', e.message); }
+  }
+
+  // Schedule daily check every hour
+  backupIntervalId = setInterval(() => {
+    const bks = listBackups();
+    const day = new Date().toISOString().slice(0, 10);
+    const hasBk = bks.some(b => b.createdAt.startsWith(day));
+    if (!hasBk && db) {
+      try { createBackupSync('daily'); } catch (e) { console.error('Daily backup failed:', e.message); }
+    }
+  }, 60 * 60 * 1000); // check every hour
+}
+
+function closeDb() {
+  if (backupIntervalId) { clearInterval(backupIntervalId); backupIntervalId = null; }
+  if (db) {
+    checkpointWal();
+    db.close();
+    db = null;
+  }
+}
+
+// --- Prompt Queues CRUD ---
+
+function saveQueue(sessionId, { mode, status, currentIndex, items, idleTimeoutMs }) {
+  getDb().prepare(
+    `INSERT INTO prompt_queues (session_id, mode, status, current_index, idle_timeout_ms, items, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+     ON CONFLICT(session_id) DO UPDATE SET
+       mode = excluded.mode, status = excluded.status, current_index = excluded.current_index,
+       idle_timeout_ms = excluded.idle_timeout_ms, items = excluded.items, updated_at = excluded.updated_at`
+  ).run(sessionId, mode, status, currentIndex, idleTimeoutMs, JSON.stringify(items));
+}
+
+function loadQueue(sessionId) {
+  const row = getDb().prepare('SELECT * FROM prompt_queues WHERE session_id = ?').get(sessionId);
+  if (!row) return null;
+  return {
+    sessionId: row.session_id,
+    mode: row.mode,
+    status: row.status,
+    currentIndex: row.current_index,
+    items: JSON.parse(row.items || '[]'),
+    idleTimeoutMs: row.idle_timeout_ms,
+  };
+}
+
+function loadAllQueues() {
+  const rows = getDb().prepare('SELECT * FROM prompt_queues WHERE status != ?').all('done');
+  return rows.map(row => ({
+    sessionId: row.session_id,
+    mode: row.mode,
+    status: row.status,
+    currentIndex: row.current_index,
+    items: JSON.parse(row.items || '[]'),
+    idleTimeoutMs: row.idle_timeout_ms,
+  }));
+}
+
+function deleteQueueDb(sessionId) {
+  getDb().prepare('DELETE FROM prompt_queues WHERE session_id = ?').run(sessionId);
+}
+
+// --- Auto Approvals ---
+function listAutoApprovals() {
+  return getDb().prepare('SELECT * FROM auto_approvals ORDER BY category, label').all();
+}
+
+function upsertAutoApproval({ pattern, response, label, category, enabled, occurrences }) {
+  getDb().prepare(
+    `INSERT INTO auto_approvals (pattern, response, label, category, enabled, occurrences)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(pattern) DO UPDATE SET
+       response = excluded.response,
+       label = excluded.label,
+       category = excluded.category,
+       enabled = CASE WHEN excluded.enabled IS NOT NULL THEN excluded.enabled ELSE auto_approvals.enabled END,
+       occurrences = CASE WHEN excluded.occurrences > 0 THEN excluded.occurrences ELSE auto_approvals.occurrences END`
+  ).run(pattern, response || 'yes', label || '', category || '', enabled ?? 1, occurrences || 0);
+}
+
+function toggleAutoApproval(id, enabled) {
+  getDb().prepare('UPDATE auto_approvals SET enabled = ? WHERE id = ?').run(enabled ? 1 : 0, id);
+}
+
+function deleteAutoApproval(id) {
+  getDb().prepare('DELETE FROM auto_approvals WHERE id = ?').run(id);
+}
+
+function getEnabledAutoApprovals() {
+  return getDb().prepare('SELECT * FROM auto_approvals WHERE enabled = 1').all();
+}
+
+// --- Approval Rules (learned by AI agent) ---
+function listApprovalRules() {
+  return getDb().prepare('SELECT * FROM approval_rules ORDER BY times_matched DESC, label').all();
+}
+
+function upsertApprovalRule({ pattern, label, description, category, riskLevel, enabled }) {
+  getDb().prepare(
+    `INSERT INTO approval_rules (pattern, label, description, category, risk_level, enabled)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(pattern) DO UPDATE SET
+       label = excluded.label,
+       description = CASE WHEN excluded.description != '' THEN excluded.description ELSE approval_rules.description END,
+       category = CASE WHEN excluded.category != '' THEN excluded.category ELSE approval_rules.category END,
+       risk_level = excluded.risk_level,
+       times_matched = approval_rules.times_matched + 1,
+       updated_at = datetime('now')`
+  ).run(pattern, label || '', description || '', category || '', riskLevel || 'low', enabled ? 1 : 0);
+}
+
+function toggleApprovalRule(id, enabled) {
+  getDb().prepare('UPDATE approval_rules SET enabled = ?, updated_at = datetime("now") WHERE id = ?').run(enabled ? 1 : 0, id);
+}
+
+function deleteApprovalRule(id) {
+  getDb().prepare('DELETE FROM approval_rules WHERE id = ?').run(id);
+}
+
+function incrementApprovalRuleMatch(id) {
+  getDb().prepare('UPDATE approval_rules SET times_matched = times_matched + 1, updated_at = datetime("now") WHERE id = ?').run(id);
+}
+
+// --- Approval Decisions (audit log) ---
+function addApprovalDecision({ sessionId, toolName, commandSummary, fullContext, warning, decision, reasoning, decidedBy, ruleId, riskLevel }) {
+  const result = getDb().prepare(
+    `INSERT INTO approval_decisions (session_id, tool_name, command_summary, full_context, warning_text, decision, reasoning, decided_by, rule_id, risk_level)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(sessionId || '', toolName || '', commandSummary || '', fullContext || '', warning || '', decision, reasoning || '', decidedBy || 'ai', ruleId || null, riskLevel || 'low');
+  return result.lastInsertRowid;
+}
+
+function listApprovalDecisions({ limit, sessionId } = {}) {
+  let sql = 'SELECT * FROM approval_decisions WHERE 1=1';
+  const params = [];
+  if (sessionId) { sql += ' AND session_id = ?'; params.push(sessionId); }
+  sql += ' ORDER BY created_at DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  return getDb().prepare(sql).all(...params);
+}
+
+function resolveApprovalDecision(id, decision) {
+  getDb().prepare('UPDATE approval_decisions SET decision = ?, decided_by = ? WHERE id = ?')
+    .run(decision, 'user', id);
+}
+
+function getPendingEscalations(sessionId) {
+  let sql = "SELECT * FROM approval_decisions WHERE decision = 'escalated'";
+  const params = [];
+  if (sessionId) { sql += ' AND session_id = ?'; params.push(sessionId); }
+  sql += ' ORDER BY created_at DESC';
+  return getDb().prepare(sql).all(...params);
+}
+
+// --- Code Reviews CRUD ---
+function createReview({ session_id, project_path, base_ref }) {
+  const result = getDb().prepare(
+    `INSERT INTO code_reviews (session_id, project_path, base_ref) VALUES (?, ?, ?)`
+  ).run(session_id || null, project_path, base_ref || '');
+  return result.lastInsertRowid;
+}
+
+function getReview(id) {
+  const review = getDb().prepare('SELECT * FROM code_reviews WHERE id = ?').get(id);
+  if (!review) return null;
+  review.comments = getDb().prepare('SELECT * FROM review_comments WHERE review_id = ? ORDER BY file_path, line_start').all(id);
+  return review;
+}
+
+function listReviews({ project_path, session_id, limit = 50 } = {}) {
+  let sql = 'SELECT * FROM code_reviews WHERE 1=1';
+  const params = [];
+  if (project_path) { sql += ' AND project_path = ?'; params.push(project_path); }
+  if (session_id) { sql += ' AND session_id = ?'; params.push(session_id); }
+  sql += ' ORDER BY created_at DESC LIMIT ?';
+  params.push(limit);
+  return getDb().prepare(sql).all(...params);
+}
+
+function updateReview(id, { status, summary, file_count, base_ref }) {
+  const sets = ["updated_at = datetime('now')"];
+  const params = [];
+  if (status !== undefined) {
+    sets.push('status = ?'); params.push(status);
+    if (status === 'submitted') { sets.push("submitted_at = datetime('now')"); }
+  }
+  if (summary !== undefined) { sets.push('summary = ?'); params.push(summary); }
+  if (file_count !== undefined) { sets.push('file_count = ?'); params.push(file_count); }
+  if (base_ref !== undefined) { sets.push('base_ref = ?'); params.push(base_ref); }
+  params.push(id);
+  getDb().prepare(`UPDATE code_reviews SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+}
+
+function deleteReview(id) {
+  getDb().prepare('DELETE FROM code_reviews WHERE id = ?').run(id);
+}
+
+function addReviewComment({ review_id, file_path, line_start, line_end, side, body, severity, ai_generated }) {
+  const result = getDb().prepare(
+    `INSERT INTO review_comments (review_id, file_path, line_start, line_end, side, body, severity, ai_generated)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(review_id, file_path, line_start, line_end || line_start, side || 'new', body, severity || 'comment', ai_generated ? 1 : 0);
+  // Update comment count
+  const count = getDb().prepare('SELECT COUNT(*) as n FROM review_comments WHERE review_id = ?').get(review_id);
+  getDb().prepare('UPDATE code_reviews SET comment_count = ? WHERE id = ?').run(count.n, review_id);
+  return result.lastInsertRowid;
+}
+
+function updateReviewComment(id, { body, severity, status }) {
+  const sets = [];
+  const params = [];
+  if (body !== undefined) { sets.push('body = ?'); params.push(body); }
+  if (severity !== undefined) { sets.push('severity = ?'); params.push(severity); }
+  if (status !== undefined) { sets.push('status = ?'); params.push(status); }
+  if (sets.length === 0) return;
+  params.push(id);
+  getDb().prepare(`UPDATE review_comments SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+}
+
+function deleteReviewComment(id) {
+  const comment = getDb().prepare('SELECT review_id FROM review_comments WHERE id = ?').get(id);
+  getDb().prepare('DELETE FROM review_comments WHERE id = ?').run(id);
+  if (comment) {
+    const count = getDb().prepare('SELECT COUNT(*) as n FROM review_comments WHERE review_id = ?').get(comment.review_id);
+    getDb().prepare('UPDATE code_reviews SET comment_count = ? WHERE id = ?').run(count.n, comment.review_id);
+  }
+}
+
+// --- Session Analyses (Insights) ---
+function upsertSessionAnalysis(data) {
+  getDb().prepare(`
+    INSERT INTO session_analyses (session_id, project, title, category, topics, skills_used, complexity, summary, pattern, first_message, session_modified_at, analyzed_at, token_count, message_count, prompt_efficiency)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?, ?, ?)
+    ON CONFLICT(session_id) DO UPDATE SET
+      project=excluded.project, title=excluded.title, category=excluded.category,
+      topics=excluded.topics, skills_used=excluded.skills_used, complexity=excluded.complexity,
+      summary=excluded.summary, pattern=excluded.pattern, first_message=excluded.first_message,
+      session_modified_at=excluded.session_modified_at, analyzed_at=excluded.analyzed_at,
+      token_count=excluded.token_count, message_count=excluded.message_count,
+      prompt_efficiency=excluded.prompt_efficiency
+  `).run(
+    data.session_id, data.project || '', data.title || '', data.category || '',
+    JSON.stringify(data.topics || []), JSON.stringify(data.skills_used || []),
+    data.complexity || '', data.summary || '', data.pattern || '',
+    data.first_message || '', data.session_modified_at || '',
+    data.token_count || 0, data.message_count || 0,
+    JSON.stringify(data.prompt_efficiency || {})
+  );
+}
+
+function getSessionAnalysis(sessionId) {
+  return getDb().prepare('SELECT * FROM session_analyses WHERE session_id = ?').get(sessionId);
+}
+
+function getAllSessionAnalyses() {
+  return getDb().prepare('SELECT * FROM session_analyses ORDER BY analyzed_at DESC').all();
+}
+
+function getSessionAnalysisCount() {
+  return getDb().prepare('SELECT COUNT(*) as count FROM session_analyses').get().count;
+}
+
+function deleteSessionAnalysis(sessionId) {
+  getDb().prepare('DELETE FROM session_analyses WHERE session_id = ?').run(sessionId);
+}
+
+function deleteStaleAnalyses(validSessionIds) {
+  const existing = getDb().prepare('SELECT session_id FROM session_analyses').all().map(r => r.session_id);
+  const validSet = new Set(validSessionIds);
+  let removed = 0;
+  for (const id of existing) {
+    if (!validSet.has(id)) {
+      getDb().prepare('DELETE FROM session_analyses WHERE session_id = ?').run(id);
+      removed++;
+    }
+  }
+  return removed;
+}
+
+// --- Insight Groups ---
+function replaceInsightGroups(groups) {
+  getDb().prepare('DELETE FROM insight_groups').run();
+  const ins = getDb().prepare(`
+    INSERT INTO insight_groups (name, description, category, is_internal, session_ids, session_count, generated_at)
+    VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+  `);
+  for (const g of groups) {
+    ins.run(g.name, g.description || '', g.category || '', g.is_internal ? 1 : 0,
+      JSON.stringify(g.session_ids || []), g.count || g.session_count || 0);
+  }
+}
+
+function listInsightGroups(includeInternal) {
+  if (includeInternal) return getDb().prepare('SELECT * FROM insight_groups ORDER BY session_count DESC').all();
+  return getDb().prepare('SELECT * FROM insight_groups WHERE is_internal = 0 ORDER BY session_count DESC').all();
+}
+
+// --- Insight Skills ---
+function replaceInsightSkills(skills) {
+  getDb().prepare('DELETE FROM insight_skills').run();
+  const ins = getDb().prepare(`
+    INSERT INTO insight_skills (name, title, description, trigger_pattern, category, is_internal, based_on, priority, example_sessions, generated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+  `);
+  for (const s of skills) {
+    ins.run(s.name, s.title || '', s.description || '', s.trigger || s.trigger_pattern || '',
+      s.category || '', s.is_internal ? 1 : 0, JSON.stringify(s.based_on || []),
+      s.priority || 'low', JSON.stringify(s.example_sessions || []));
+  }
+}
+
+function listInsightSkills(includeInternal) {
+  if (includeInternal) return getDb().prepare('SELECT * FROM insight_skills ORDER BY priority DESC').all();
+  return getDb().prepare('SELECT * FROM insight_skills WHERE is_internal = 0 ORDER BY priority DESC').all();
+}
+
+// --- Insight Recommendations ---
+function replaceInsightRecommendations(recs) {
+  getDb().prepare('DELETE FROM insight_recommendations').run();
+  const ins = getDb().prepare(`
+    INSERT INTO insight_recommendations (type, category, title, description, evidence, impact, actionable, generated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+  `);
+  for (const r of recs) {
+    ins.run(r.type, r.category || '', r.title, r.description || '',
+      JSON.stringify(r.evidence || {}), r.impact || 'medium', r.actionable || '');
+  }
+}
+
+function listInsightRecommendations() {
+  return getDb().prepare('SELECT * FROM insight_recommendations ORDER BY impact DESC').all();
+}
+
+// --- Analysis Runs ---
+function startAnalysisRun() {
+  return getDb().prepare(`INSERT INTO analysis_runs (status) VALUES ('running')`).run().lastInsertRowid;
+}
+
+function completeAnalysisRun(id, { sessions_analyzed, sessions_skipped, status }) {
+  getDb().prepare(`UPDATE analysis_runs SET completed_at = datetime('now'), sessions_analyzed = ?, sessions_skipped = ?, status = ? WHERE id = ?`)
+    .run(sessions_analyzed || 0, sessions_skipped || 0, status || 'completed', id);
+}
+
+function getLastAnalysisRun() {
+  return getDb().prepare('SELECT * FROM analysis_runs ORDER BY id DESC LIMIT 1').get();
+}
+
+// --- Full Insights Data (for API) ---
+function getInsightsData(includeInternal) {
+  const groups = listInsightGroups(includeInternal).map(g => ({
+    ...g, session_ids: JSON.parse(g.session_ids || '[]'),
+    topics: undefined, is_internal: !!g.is_internal,
+  }));
+  const skills = listInsightSkills(includeInternal).map(s => ({
+    ...s, based_on: JSON.parse(s.based_on || '[]'),
+    example_sessions: JSON.parse(s.example_sessions || '[]'),
+    is_internal: !!s.is_internal,
+  }));
+  const recommendations = listInsightRecommendations().map(r => ({
+    ...r, evidence: JSON.parse(r.evidence || '{}'),
+  }));
+  const sessionCount = getSessionAnalysisCount();
+  const lastRun = getLastAnalysisRun();
+
+  // Compute summary stats
+  const analyses = getAllSessionAnalyses();
+  const totalMessages = analyses.reduce((sum, a) => sum + (a.message_count || 0), 0);
+  const avgMessages = sessionCount > 0 ? (totalMessages / sessionCount).toFixed(1) : 0;
+  const categories = {};
+  for (const a of analyses) {
+    categories[a.category] = (categories[a.category] || 0) + 1;
+  }
+  const topCategory = Object.entries(categories).sort((a, b) => b[1] - a[1])[0];
+
+  return {
+    sessionCount,
+    stats: {
+      avgMessages: parseFloat(avgMessages),
+      totalMessages,
+      topCategory: topCategory ? { name: topCategory[0], count: topCategory[1] } : null,
+    },
+    groups, skills, recommendations,
+    updatedAt: lastRun?.completed_at || null,
+    lastRunStatus: lastRun?.status || null,
+  };
+}
+
+module.exports = {
+  initDb, getDb, closeDb, getDbPath: () => currentDbPath,
+  getSetting, getSettingsByPrefix, setSetting,
+  createPrompt, updatePrompt, getPrompt, listPrompts, listChildPrompts, setPromptParent, createGroupFromPrompts, deletePrompt, duplicatePrompt, reorderPrompts,
+  getPromptVersions, restorePromptVersion,
+  createFolder, listFolders, updateFolder, deleteFolder, reorderFolders,
+  saveImage, getImage, updateImageAnnotations, listImages, deleteImage,
+  createChain, getChain, listChains, updateChain, deleteChain,
+  listPermissionRules, upsertPermissionRule, deletePermissionRule,
+  listPermissionLog, addPermissionLog,
+  getAlwaysAskTools, setAlwaysAsk,
+  importSessionConversation, listSessionConversations, getSessionConversation,
+  getSessionTitle, setSessionTitle, isSessionUserRenamed, getAllSessionTitles,
+  createTemplate, listTemplates, getTemplate, deleteTemplate,
+  trackPromptUsage, getPromptUsageStats,
+  checkpointWal, createBackup, createBackupSync, listBackups, restoreBackup, deleteBackup, startDailyBackup,
+  saveQueue, loadQueue, loadAllQueues, deleteQueueDb,
+  listPermRules, addPermRule, removePermRule, bulkSetPermRules, getPermRulesByProject,
+  listAutoApprovals, upsertAutoApproval, toggleAutoApproval, deleteAutoApproval, getEnabledAutoApprovals,
+  listApprovalRules, upsertApprovalRule, toggleApprovalRule, deleteApprovalRule, incrementApprovalRuleMatch,
+  addApprovalDecision, listApprovalDecisions, resolveApprovalDecision, getPendingEscalations,
+  createReview, getReview, listReviews, updateReview, deleteReview,
+  addReviewComment, updateReviewComment, deleteReviewComment,
+  upsertSessionAnalysis, getSessionAnalysis, getAllSessionAnalyses, getSessionAnalysisCount,
+  deleteSessionAnalysis, deleteStaleAnalyses,
+  replaceInsightGroups, listInsightGroups,
+  replaceInsightSkills, listInsightSkills,
+  replaceInsightRecommendations, listInsightRecommendations,
+  startAnalysisRun, completeAnalysisRun, getLastAnalysisRun,
+  getInsightsData,
+  DEFAULT_IMAGES_DIR, BACKUP_DIR,
+};