@winspan/claude-forge 3.7.8 → 4.1.0

package/dist/storage/schema/migration-manager.js

@@ -1,1000 +1,32 @@
 /**
- * MigrationManager - 数据库迁移管理器
+ * MigrationManager - 数据库迁移管理器（v1 基线版本）
  *
- * 从 sqlite.ts 提取，负责管理 schema 版本迁移。
- * 包含所有增量迁移函数和迁移执行逻辑。
+ * schema.sql 包含完整的表定义，不再依赖增量迁移。
+ * 检测到旧版本数据库时，备份后删库重建。
  */
 import { logger } from '../../utils/logger.js';
-export const SCHEMA_VERSION = 27;
-/** 增量迁移函数表：key 为目标版本号，value 为迁移函数 */
-export const MIGRATIONS = {
-    2: (db) => {
-        db.exec(`
-        CREATE VIRTUAL TABLE IF NOT EXISTS events_fts
-        USING fts5(
-          event_id UNINDEXED,
-          session_id,
-          project_path,
-          tool_name,
-          tool_input,
-          user_prompt,
-          content=events,
-          tokenize='unicode61'
-        )
-      `);
-    },
-    // v3: 任务复盘分析器 — task_sessions, failure_signals, task_patterns
-    3: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS task_sessions (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          pipeline_id TEXT,
-          requirement TEXT NOT NULL,
-          task_type TEXT NOT NULL DEFAULT 'other',
-          complexity TEXT NOT NULL DEFAULT 'moderate',
-          total_rounds INTEGER NOT NULL DEFAULT 0,
-          total_tool_calls INTEGER NOT NULL DEFAULT 0,
-          write_edit_count INTEGER NOT NULL DEFAULT 0,
-          fix_attempt_count INTEGER NOT NULL DEFAULT 0,
-          quality_fail_count INTEGER NOT NULL DEFAULT 0,
-          quality_pass_count INTEGER NOT NULL DEFAULT 0,
-          failure_signal_count INTEGER NOT NULL DEFAULT 0,
-          phase_distribution TEXT,
-          outcome TEXT NOT NULL DEFAULT 'in_progress',
-          duration_ms INTEGER,
-          started_at TEXT NOT NULL,
-          ended_at TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_ts_session ON task_sessions(session_id);
-        CREATE INDEX IF NOT EXISTS idx_ts_project ON task_sessions(project_path);
-        CREATE INDEX IF NOT EXISTS idx_ts_task_type ON task_sessions(task_type);
-
-        CREATE TABLE IF NOT EXISTS failure_signals (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          task_session_id TEXT,
-          signal_type TEXT NOT NULL,
-          raw_prompt TEXT NOT NULL,
-          matched_pattern TEXT,
-          context_phase TEXT,
-          is_iteration INTEGER NOT NULL DEFAULT 0,
-          preceding_tool_count INTEGER NOT NULL DEFAULT 0,
-          timestamp TEXT NOT NULL,
-          created_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_fs_session ON failure_signals(session_id);
-        CREATE INDEX IF NOT EXISTS idx_fs_project ON failure_signals(project_path);
-
-        CREATE TABLE IF NOT EXISTS task_patterns (
-          id TEXT PRIMARY KEY,
-          task_type TEXT NOT NULL,
-          failure_pattern TEXT NOT NULL,
-          prevention_strategy TEXT NOT NULL,
-          confidence_score REAL NOT NULL DEFAULT 0.0,
-          sample_count INTEGER NOT NULL DEFAULT 0,
-          last_updated TEXT NOT NULL DEFAULT (datetime('now')),
-          created_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_tp_task_type ON task_patterns(task_type);
-      `);
-    },
-    // v4: 可观测性 — api_usage 表，task_sessions/task_patterns 效果追踪字段
-    4: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS api_usage (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          label TEXT NOT NULL,
-          model TEXT NOT NULL DEFAULT '',
-          tokens_in INTEGER NOT NULL DEFAULT 0,
-          tokens_out INTEGER NOT NULL DEFAULT 0,
-          cost_usd REAL NOT NULL DEFAULT 0.0,
-          latency_ms INTEGER NOT NULL DEFAULT 0,
-          timestamp TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_au_session ON api_usage(session_id);
-        CREATE INDEX IF NOT EXISTS idx_au_label ON api_usage(label);
-      `);
-        // ALTER TABLE 需单独执行（SQLite 不支持在同一 exec 中混用 DDL）
-        try {
-            db.exec(`ALTER TABLE task_sessions ADD COLUMN satisfaction_score REAL DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE task_patterns ADD COLUMN adoption_count INTEGER NOT NULL DEFAULT 0`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE task_patterns ADD COLUMN effectiveness_score REAL NOT NULL DEFAULT 0.5`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE task_patterns ADD COLUMN last_used TEXT DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-    },
-    // v5: 学习系统修复 — pattern_executions 关联 task_session，质量门禁持久化，Pattern 进化追踪
-    5: (db) => {
-        // 学习闭环：pattern_executions 关联 task_session
-        try {
-            db.exec(`ALTER TABLE pattern_executions ADD COLUMN task_session_id TEXT DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE pattern_executions ADD COLUMN outcome TEXT DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_pe_task_session ON pattern_executions(task_session_id)`);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_pe_outcome ON pattern_executions(outcome)`);
-        // 质量门禁持久化
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS quality_gate_suppressions (
-          id TEXT PRIMARY KEY,
-          category TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          suppression_count INTEGER NOT NULL DEFAULT 1,
-          first_suppressed_at TEXT NOT NULL,
-          last_suppressed_at TEXT NOT NULL,
-          expires_at TEXT DEFAULT NULL,
-          created_at TEXT DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_qgs_category ON quality_gate_suppressions(category, project_path);
-        CREATE INDEX IF NOT EXISTS idx_qgs_expires ON quality_gate_suppressions(expires_at);
-
-        CREATE TABLE IF NOT EXISTS quality_gate_history (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          file_path TEXT NOT NULL,
-          category TEXT NOT NULL,
-          level TEXT NOT NULL,
-          message TEXT NOT NULL,
-          resolved INTEGER DEFAULT 0,
-          resolved_at TEXT DEFAULT NULL,
-          created_at TEXT DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_qgh_session ON quality_gate_history(session_id, project_path);
-        CREATE INDEX IF NOT EXISTS idx_qgh_file ON quality_gate_history(file_path, resolved);
-      `);
-        // Pattern 进化追踪
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS pattern_evolution_history (
-          id TEXT PRIMARY KEY,
-          pattern_id TEXT NOT NULL,
-          old_version TEXT NOT NULL,
-          new_version TEXT NOT NULL,
-          old_yaml TEXT NOT NULL,
-          new_yaml TEXT NOT NULL,
-          validation_status TEXT DEFAULT 'pending',
-          test_success_rate REAL DEFAULT NULL,
-          evolved_at TEXT NOT NULL,
-          validated_at TEXT DEFAULT NULL,
-          created_at TEXT DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_peh_pattern ON pattern_evolution_history(pattern_id);
-        CREATE INDEX IF NOT EXISTS idx_peh_status ON pattern_evolution_history(validation_status);
-      `);
-    },
-    // v6: Pipeline 任务类型区分 — 新增 task_type 字段（已废弃，pipelines 表已迁移至 dynamic_pipelines）
-    6: (db) => {
-        const tableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipelines'`).get();
-        if (tableExists) {
-            try {
-                db.exec(`ALTER TABLE pipelines ADD COLUMN task_type TEXT DEFAULT 'feature'`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-        }
-    },
-    // v7: Pipeline 智能编排 — 新增 complexity, planned_phases, phase_artifacts, reasoning 字段（已废弃，pipelines 表已迁移至 dynamic_pipelines）
-    7: (db) => {
-        const tableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipelines'`).get();
-        if (tableExists) {
-            try {
-                db.exec(`ALTER TABLE pipelines ADD COLUMN complexity TEXT DEFAULT 'moderate'`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-            try {
-                db.exec(`ALTER TABLE pipelines ADD COLUMN planned_phases TEXT DEFAULT NULL`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-            try {
-                db.exec(`ALTER TABLE pipelines ADD COLUMN phase_artifacts TEXT DEFAULT NULL`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-            try {
-                db.exec(`ALTER TABLE pipelines ADD COLUMN reasoning TEXT DEFAULT NULL`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-        }
-    },
-    // v8: 升维 — 端到端延迟追踪、离线规则库、知识图谱、满意度信号
-    8: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS latency_traces (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          trace_type TEXT NOT NULL,
-          engine_name TEXT NOT NULL,
-          duration_ms INTEGER NOT NULL,
-          metadata TEXT,
-          timestamp TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_lt_session ON latency_traces(session_id);
-        CREATE INDEX IF NOT EXISTS idx_lt_type ON latency_traces(trace_type, timestamp DESC);
-
-        CREATE TABLE IF NOT EXISTS intent_rules (
-          id TEXT PRIMARY KEY,
-          rule_type TEXT NOT NULL,
-          pattern TEXT NOT NULL,
-          confidence REAL NOT NULL DEFAULT 0.8,
-          hit_count INTEGER NOT NULL DEFAULT 0,
-          miss_count INTEGER NOT NULL DEFAULT 0,
-          source TEXT NOT NULL DEFAULT 'distilled',
-          last_hit_at TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_ir_type ON intent_rules(rule_type, confidence DESC);
-
-        CREATE TABLE IF NOT EXISTS knowledge_nodes (
-          id TEXT PRIMARY KEY,
-          project_path TEXT NOT NULL,
-          node_type TEXT NOT NULL,
-          title TEXT NOT NULL,
-          content TEXT NOT NULL,
-          tags TEXT,
-          embedding_hint TEXT,
-          archived INTEGER NOT NULL DEFAULT 0,
-          last_accessed_at TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_kn_project ON knowledge_nodes(project_path, node_type);
-        CREATE INDEX IF NOT EXISTS idx_kn_archived ON knowledge_nodes(archived, last_accessed_at);
-
-        CREATE TABLE IF NOT EXISTS knowledge_edges (
-          id TEXT PRIMARY KEY,
-          from_node_id TEXT NOT NULL,
-          to_node_id TEXT NOT NULL,
-          edge_type TEXT NOT NULL,
-          weight REAL NOT NULL DEFAULT 1.0,
-          metadata TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_ke_from ON knowledge_edges(from_node_id);
-        CREATE INDEX IF NOT EXISTS idx_ke_to ON knowledge_edges(to_node_id);
-
-        CREATE TABLE IF NOT EXISTS satisfaction_signals (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          task_session_id TEXT,
-          signal_type TEXT NOT NULL,
-          signal_value REAL NOT NULL,
-          weight REAL NOT NULL DEFAULT 1.0,
-          raw_data TEXT,
-          timestamp TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_ss_session ON satisfaction_signals(session_id);
-        CREATE INDEX IF NOT EXISTS idx_ss_task ON satisfaction_signals(task_session_id);
-        CREATE INDEX IF NOT EXISTS idx_ss_project ON satisfaction_signals(project_path, timestamp DESC);
-      `);
-        // FTS 虚拟表单独执行
-        try {
-            db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_nodes_fts
-          USING fts5(id UNINDEXED, project_path, title, content, embedding_hint,
-                     content=knowledge_nodes, tokenize='unicode61')
-        `);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('already exists')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE api_usage ADD COLUMN engine_name TEXT DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-    },
-    // v9: Daemon 状态持久化 — daemon_state 表
-    9: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS daemon_state (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL,
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-      `);
-    },
-    // v10: 查询性能优化 — 高频查询复合索引
-    10: (db) => {
-        // events 表：project_path + distilled + timestamp 复合索引（消除 ORDER BY 临时 B-Tree）
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_events_project_distilled_ts ON events(project_path, distilled, timestamp DESC)`);
-        // events 表：session_id + distilled 复合索引（getUndistilledEvents 高频路径）
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_events_session_distilled ON events(session_id, distilled, timestamp DESC)`);
-        // knowledge_nodes 表：project_path + node_type + archived 复合索引
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_kn_project_type_archived ON knowledge_nodes(project_path, node_type, archived, last_accessed_at DESC)`);
-        // latency_traces 表：project_path + trace_type + timestamp 复合索引
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_lt_project_type_ts ON latency_traces(project_path, trace_type, timestamp DESC)`);
-        // task_sessions 表：project_path + outcome + ended_at 复合索引（getLastCompletedTaskSession）
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_ts_project_outcome_ts ON task_sessions(project_path, outcome, ended_at DESC)`);
-        // api_usage 表：timestamp 索引（成本趋势查询）
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_au_timestamp ON api_usage(timestamp DESC)`);
-    },
-    // v11: pipeline_tasks 新增 source 字段（任务来源规范标记）（已废弃，pipeline_tasks 表已迁移至 dynamic_nodes）
-    11: (db) => {
-        const tableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipeline_tasks'`).get();
-        if (tableExists) {
-            try {
-                db.exec(`ALTER TABLE pipeline_tasks ADD COLUMN source TEXT DEFAULT NULL`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-        }
-    },
-    // v12: pipeline_tasks 补全 updated_at 字段（新安装 schema.sql 已有，旧库需迁移）（已废弃，pipeline_tasks 表已迁移至 dynamic_nodes）
-    12: (db) => {
-        const tableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipeline_tasks'`).get();
-        if (tableExists) {
-            try {
-                db.exec(`ALTER TABLE pipeline_tasks ADD COLUMN updated_at TEXT DEFAULT NULL`);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                    throw err;
-            }
-            // 回填已有记录的 updated_at（用 created_at 兜底，无 created_at 则用当前时间）
-            db.exec(`UPDATE pipeline_tasks SET updated_at = datetime('now') WHERE updated_at IS NULL`);
-        }
-    },
-    // v13: quality_gate_history 新增 resolved_type 字段（区分 resolved/dismissed）
-    13: (db) => {
-        try {
-            db.exec(`ALTER TABLE quality_gate_history ADD COLUMN resolved_type TEXT DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-    },
-    // v14: 配置版本历史表
-    14: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS config_history (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          snapshot TEXT NOT NULL,
-          saved_at TEXT NOT NULL DEFAULT (datetime('now'))
-        )
-      `);
-    },
-    // v15: 动态节点系统 — dynamic_pipelines, dynamic_nodes, dynamic_pipeline_templates
-    15: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS dynamic_pipelines (
-          id TEXT PRIMARY KEY,
-          requirement TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          session_id TEXT NOT NULL,
-          template_id TEXT,
-          convention_id TEXT,
-          complexity TEXT,
-          reasoning TEXT,
-          status TEXT NOT NULL DEFAULT 'in_progress',
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_dp_session ON dynamic_pipelines(session_id);
-        CREATE INDEX IF NOT EXISTS idx_dp_project ON dynamic_pipelines(project_path);
-        CREATE INDEX IF NOT EXISTS idx_dp_status ON dynamic_pipelines(status);
-
-        CREATE TABLE IF NOT EXISTS dynamic_nodes (
-          id TEXT PRIMARY KEY,
-          pipeline_id TEXT NOT NULL,
-          node_type_id TEXT NOT NULL,
-          status TEXT NOT NULL DEFAULT 'pending',
-          dependencies TEXT NOT NULL DEFAULT '[]',
-          bound_skill_name TEXT,
-          config_override TEXT,
-          output TEXT,
-          started_at TEXT,
-          completed_at TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-          FOREIGN KEY (pipeline_id) REFERENCES dynamic_pipelines(id) ON DELETE CASCADE
-        );
-        CREATE INDEX IF NOT EXISTS idx_dn_pipeline ON dynamic_nodes(pipeline_id);
-        CREATE INDEX IF NOT EXISTS idx_dn_status ON dynamic_nodes(status);
-
-        CREATE TABLE IF NOT EXISTS dynamic_pipeline_templates (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL,
-          description TEXT NOT NULL,
-          source TEXT NOT NULL DEFAULT 'builtin',
-          convention_id TEXT,
-          convention_name TEXT,
-          trigger TEXT NOT NULL,
-          nodes TEXT NOT NULL,
-          quality_standards TEXT,
-          version TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_dpt_source ON dynamic_pipeline_templates(source);
-        CREATE INDEX IF NOT EXISTS idx_dpt_convention ON dynamic_pipeline_templates(convention_id);
-      `);
-    },
-    // v16: Legacy Pipeline 数据迁移到 Dynamic Pipeline
-    16: (db) => {
-        const pipelinesExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipelines'`).get();
-        const tasksExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipeline_tasks'`).get();
-        if (!pipelinesExists && !tasksExists) {
-            logger.info('[SQLite] v16: Legacy Pipeline 表不存在，跳过迁移');
-            return;
-        }
-        logger.info('[SQLite] 开始迁移 Legacy Pipeline 数据到 Dynamic Pipeline...');
-        // 1. 迁移 pipelines → dynamic_pipelines
-        if (pipelinesExists) {
-            const pipelinesMigrated = db.prepare(`
-          INSERT INTO dynamic_pipelines (
-            id, requirement, project_path, session_id,
-            template_id, convention_id, complexity, reasoning,
-            status, created_at, updated_at
-          )
-          SELECT
-            id, requirement, project_path, session_id,
-            NULL as template_id,
-            NULL as convention_id,
-            COALESCE(complexity, 'moderate') as complexity,
-            reasoning,
-            CASE WHEN phase = 'done' THEN 'completed' ELSE 'in_progress' END as status,
-            created_at, updated_at
-          FROM pipelines
-          WHERE id NOT IN (SELECT id FROM dynamic_pipelines)
-        `).run();
-            logger.info(`[SQLite] 迁移了 ${pipelinesMigrated.changes} 个 Legacy Pipelines`);
-        }
-        // 2. 迁移 pipeline_tasks → dynamic_nodes
-        if (tasksExists) {
-            const tasksMigrated = db.prepare(`
-          INSERT INTO dynamic_nodes (
-            id, pipeline_id, node_type_id, status,
-            dependencies, bound_skill_name, output,
-            started_at, completed_at, created_at, updated_at
-          )
-          SELECT
-            id, pipeline_id, phase as node_type_id,
-            CASE
-              WHEN status = 'completed' THEN 'completed'
-              WHEN status = 'in_progress' THEN 'in_progress'
-              WHEN status = 'failed' THEN 'failed'
-              ELSE 'pending'
-            END as status,
-            COALESCE(dependencies, '[]') as dependencies,
-            NULL as bound_skill_name,
-            output,
-            NULL as started_at,
-            NULL as completed_at,
-            datetime('now') as created_at,
-            COALESCE(updated_at, datetime('now')) as updated_at
-          FROM pipeline_tasks
-          WHERE id NOT IN (SELECT id FROM dynamic_nodes)
-        `).run();
-            logger.info(`[SQLite] 迁移了 ${tasksMigrated.changes} 个 Legacy Tasks`);
-        }
-        // 3. 转换 pipeline_events 事件类型
-        if (pipelinesExists) {
-            const eventsConverted = db.prepare(`
-          UPDATE pipeline_events
-          SET type = CASE
-            WHEN type = 'pipeline.created' THEN 'dynamic_pipeline.created'
-            WHEN type = 'task.created' THEN 'dynamic_node.created'
-            WHEN type = 'task.started' THEN 'dynamic_node.started'
-            WHEN type = 'task.completed' THEN 'dynamic_node.completed'
-            WHEN type = 'task.failed' THEN 'dynamic_node.failed'
-            WHEN type = 'phase.advanced' THEN 'dynamic_node.advanced'
-            WHEN type = 'pipeline.closed' THEN 'dynamic_pipeline.completed'
-            ELSE type
-          END
-          WHERE pipeline_id IN (SELECT id FROM pipelines)
-            AND type NOT LIKE 'dynamic_%'
-        `).run();
-            logger.info(`[SQLite] 转换了 ${eventsConverted.changes} 个事件类型`);
-        }
-        logger.info('[SQLite] Legacy Pipeline 数据迁移完成');
-    },
-    // v17: 删除已迁移的 Legacy Pipeline 表（pipelines、pipeline_tasks）
-    17: (db) => {
-        db.exec(`
-        DROP TABLE IF EXISTS pipeline_tasks;
-        DROP TABLE IF EXISTS pipelines;
-      `);
-        logger.info('[SQLite] 已删除 Legacy Pipeline 表（pipelines、pipeline_tasks）');
-    },
-    // v18: 补充迁移 pipeline_events 中未同步到 dynamic_pipelines 的 Pipeline
-    // v16 只迁移了 pipelines 表，但事件溯源系统创建的 Pipeline 只写入 pipeline_events，未写入 pipelines 表
-    18: (db) => {
-        const eventsTableExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='pipeline_events'`).get();
-        if (!eventsTableExists) {
-            logger.info('[SQLite] v18: pipeline_events 表不存在，跳过补充迁移');
-            return;
-        }
-        logger.info('[SQLite] v18: 补充迁移 pipeline_events 中未同步的 Pipeline...');
-        // 找出有 pipeline.created 事件但不在 dynamic_pipelines 里的 pipeline IDs
-        const unmigrated = db.prepare(`
-        SELECT DISTINCT pipeline_id
-        FROM pipeline_events
-        WHERE type = 'pipeline.created'
-          AND pipeline_id NOT IN (SELECT id FROM dynamic_pipelines)
-      `).all();
-        if (unmigrated.length === 0) {
-            logger.info('[SQLite] v18: 无需补充迁移');
-            return;
-        }
-        logger.info(`[SQLite] v18: 发现 ${unmigrated.length} 个未迁移的 Pipeline`);
-        const insertPipeline = db.prepare(`
-        INSERT OR IGNORE INTO dynamic_pipelines
-          (id, requirement, project_path, session_id, complexity, reasoning, status, created_at, updated_at)
-        SELECT
-          pe.pipeline_id,
-          json_extract(pe.payload, '$.requirement'),
-          json_extract(pe.payload, '$.projectPath'),
-          json_extract(pe.payload, '$.sessionId'),
-          COALESCE(json_extract(pe.payload, '$.complexity'), 'moderate'),
-          json_extract(pe.payload, '$.reasoning'),
-          CASE
-            WHEN EXISTS (
-              SELECT 1 FROM pipeline_events pe2
-              WHERE pe2.pipeline_id = pe.pipeline_id
-                AND pe2.type IN ('pipeline.closed', 'dynamic_pipeline.completed')
-            ) THEN 'completed'
-            ELSE 'in_progress'
-          END,
-          pe.created_at,
-          pe.created_at
-        FROM pipeline_events pe
-        WHERE pe.pipeline_id = ? AND pe.type = 'pipeline.created'
-        LIMIT 1
-      `);
-        const insertNodes = db.prepare(`
-        INSERT OR IGNORE INTO dynamic_nodes
-          (id, pipeline_id, node_type_id, status, dependencies, created_at, updated_at)
-        SELECT
-          json_extract(pe.payload, '$.taskId'),
-          pe.pipeline_id,
-          json_extract(pe.payload, '$.phase'),
-          CASE
-            WHEN EXISTS (
-              SELECT 1 FROM pipeline_events pe2
-              WHERE pe2.pipeline_id = pe.pipeline_id
-                AND pe2.type = 'task.completed'
-                AND json_extract(pe2.payload, '$.taskId') = json_extract(pe.payload, '$.taskId')
-            ) THEN 'completed'
-            WHEN EXISTS (
-              SELECT 1 FROM pipeline_events pe2
-              WHERE pe2.pipeline_id = pe.pipeline_id
-                AND pe2.type = 'task.started'
-                AND json_extract(pe2.payload, '$.taskId') = json_extract(pe.payload, '$.taskId')
-            ) THEN 'in_progress'
-            ELSE 'pending'
-          END,
-          COALESCE(json_extract(pe.payload, '$.dependencies'), '[]'),
-          pe.created_at,
-          pe.created_at
-        FROM pipeline_events pe
-        WHERE pe.pipeline_id = ? AND pe.type = 'task.created'
-          AND json_extract(pe.payload, '$.taskId') NOT IN (SELECT id FROM dynamic_nodes)
-      `);
-        const convertEvents = db.prepare(`
-        UPDATE pipeline_events
-        SET type = CASE
-          WHEN type = 'pipeline.created' THEN 'dynamic_pipeline.created'
-          WHEN type = 'task.created'     THEN 'dynamic_node.created'
-          WHEN type = 'task.started'     THEN 'dynamic_node.started'
-          WHEN type = 'task.completed'   THEN 'dynamic_node.completed'
-          WHEN type = 'task.failed'      THEN 'dynamic_node.failed'
-          WHEN type = 'phase.advanced'   THEN 'dynamic_node.advanced'
-          WHEN type = 'pipeline.closed'  THEN 'dynamic_pipeline.completed'
-          ELSE type
-        END
-        WHERE pipeline_id = ? AND type NOT LIKE 'dynamic_%'
-      `);
-        let pipelineCount = 0;
-        let nodeCount = 0;
-        for (const { pipeline_id } of unmigrated) {
-            insertPipeline.run(pipeline_id);
-            const nodeResult = insertNodes.run(pipeline_id);
-            nodeCount += nodeResult.changes;
-            convertEvents.run(pipeline_id);
-            pipelineCount++;
-        }
-        logger.info(`[SQLite] v18: 补充迁移完成 — ${pipelineCount} 个 Pipeline，${nodeCount} 个节点`);
-    },
-    // v19: 节点类型持久化 — node_types 表
-    19: (db) => {
-        logger.info('[SQLite] v19: 创建 node_types 表...');
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS node_types (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL,
-          description TEXT,
-          semantic_category TEXT,
-          completion_config TEXT NOT NULL,
-          activity_threshold TEXT NOT NULL,
-          default_skills TEXT,
-          source TEXT NOT NULL DEFAULT 'builtin' CHECK(source IN ('builtin', 'convention')),
-          convention_id TEXT,
-          created_at TEXT DEFAULT (datetime('now')),
-          updated_at TEXT DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_node_types_source ON node_types(source);
-        CREATE INDEX IF NOT EXISTS idx_node_types_convention ON node_types(convention_id);
-        CREATE INDEX IF NOT EXISTS idx_node_types_category ON node_types(semantic_category);
-      `);
-        logger.info('[SQLite] v19: node_types 表创建完成');
-    },
-    20: (db) => {
-        logger.info('[SQLite] v20: 升级意图分类系统（统一分类器）...');
-        // 1. 升级 intent_rules 表：添加质量追踪字段
-        db.exec(`
-        ALTER TABLE intent_rules ADD COLUMN priority TEXT DEFAULT 'learned' CHECK(priority IN ('ground_truth', 'learned'));
-        ALTER TABLE intent_rules ADD COLUMN success_count INTEGER DEFAULT 0;
-        ALTER TABLE intent_rules ADD COLUMN failure_count INTEGER DEFAULT 0;
-        ALTER TABLE intent_rules ADD COLUMN avg_satisfaction REAL DEFAULT 0.0;
-        ALTER TABLE intent_rules ADD COLUMN is_active INTEGER DEFAULT 1 CHECK(is_active IN (0, 1));
-        ALTER TABLE intent_rules ADD COLUMN conflicts_with TEXT;
-        ALTER TABLE intent_rules ADD COLUMN last_quality_update_at TEXT;
-      `);
-        // 2. 创建索引
-        db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_intent_rules_priority_active ON intent_rules(priority, is_active);
-        CREATE INDEX IF NOT EXISTS idx_intent_rules_confidence_active ON intent_rules(confidence DESC, is_active);
-      `);
-        // 3. 新建 intent_decisions 表（决策审计日志）
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS intent_decisions (
-          id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          requirement TEXT NOT NULL,
-          predicted_complexity TEXT NOT NULL CHECK(predicted_complexity IN ('simple', 'moderate', 'complex')),
-          matched_rule_id TEXT,
-          matched_layer TEXT NOT NULL CHECK(matched_layer IN ('ground_truth', 'learned', 'ai_fallback')),
-          confidence REAL NOT NULL,
-          actual_outcome TEXT CHECK(actual_outcome IN ('success', 'partial', 'failure', NULL)),
-          satisfaction_score REAL,
-          feedback_recorded_at TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          FOREIGN KEY (session_id) REFERENCES task_sessions(session_id) ON DELETE CASCADE
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_intent_decisions_session ON intent_decisions(session_id);
-        CREATE INDEX IF NOT EXISTS idx_intent_decisions_rule ON intent_decisions(matched_rule_id);
-        CREATE INDEX IF NOT EXISTS idx_intent_decisions_created ON intent_decisions(created_at DESC);
-      `);
-        // 4. 创建质量监控视图
-        db.exec(`
-        CREATE VIEW IF NOT EXISTS intent_rules_quality AS
-        SELECT
-          id, rule_type, pattern, priority, confidence,
-          hit_count, miss_count, success_count, failure_count, avg_satisfaction, is_active,
-          CASE
-            WHEN (success_count + failure_count) > 0
-            THEN CAST(success_count AS REAL) / (success_count + failure_count)
-            ELSE 0.0
-          END AS accuracy,
-          CASE
-            WHEN (hit_count + miss_count) > 0
-            THEN CAST(hit_count AS REAL) / (hit_count + miss_count)
-            ELSE 0.0
-          END AS hit_rate,
-          CASE
-            WHEN (success_count + failure_count) > 0 AND (hit_count + miss_count) > 0
-            THEN (
-              CAST(success_count AS REAL) / (success_count + failure_count) *
-              CAST(hit_count AS REAL) / (hit_count + miss_count) *
-              avg_satisfaction
-            )
-            ELSE 0.0
-          END AS quality_score,
-          conflicts_with, last_quality_update_at, created_at, updated_at
-        FROM intent_rules
-        ORDER BY quality_score DESC, confidence DESC;
-      `);
-        logger.info('[SQLite] v20: 意图分类系统升级完成');
-    },
-    21: (db) => {
-        logger.info('[SQLite] v21: 添加 pipeline_id 到 events 和 quality_gate_history 表...');
-        // 为 events 表添加 pipeline_id
-        db.exec(`
-        ALTER TABLE events ADD COLUMN pipeline_id TEXT;
-        CREATE INDEX IF NOT EXISTS idx_events_pipeline ON events(pipeline_id);
-      `);
-        // 为 quality_gate_history 表添加 pipeline_id
-        db.exec(`
-        ALTER TABLE quality_gate_history ADD COLUMN pipeline_id TEXT;
-        CREATE INDEX IF NOT EXISTS idx_qgh_pipeline ON quality_gate_history(pipeline_id);
-      `);
-        logger.info('[SQLite] v21: pipeline_id 字段添加完成');
-    },
-    22: (db) => {
-        // 添加复合索引，优化常见查询
-        db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_sessions_project_status ON sessions(project_path, status);
-        CREATE INDEX IF NOT EXISTS idx_events_project_tool ON events(project_path, tool_name);
-        CREATE INDEX IF NOT EXISTS idx_events_project_date ON events(project_path, DATE(timestamp));
-      `);
-        logger.info('[SQLite] v22: 复合索引添加完成');
-    },
-    23: (db) => {
-        logger.info('[SQLite] v23: 添加 Step 分步驱动支持...');
-        // 1. 扩展 dynamic_nodes 表，添加 Step 状态字段
-        db.exec(`
-        ALTER TABLE dynamic_nodes ADD COLUMN current_step_id TEXT;
-        ALTER TABLE dynamic_nodes ADD COLUMN completed_steps TEXT DEFAULT '[]';
-        ALTER TABLE dynamic_nodes ADD COLUMN failed_steps TEXT DEFAULT '[]';
-        ALTER TABLE dynamic_nodes ADD COLUMN step_executions TEXT DEFAULT '[]';
-      `);
-        // 2. 创建 step_executions 表（持久化 Step 执行状态）
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS step_executions (
-          id TEXT PRIMARY KEY,
-          pipeline_id TEXT NOT NULL,
-          node_id TEXT NOT NULL,
-          step_definition_id TEXT NOT NULL,
-          status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'running', 'validating', 'passed', 'failed', 'need_human')),
-          attempts INTEGER DEFAULT 0,
-          outputs TEXT DEFAULT '{}',
-          validation_results TEXT,
-          failure_reason TEXT,
-          started_at TEXT,
-          completed_at TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-          FOREIGN KEY (pipeline_id) REFERENCES dynamic_pipelines(id) ON DELETE CASCADE,
-          FOREIGN KEY (node_id) REFERENCES dynamic_nodes(id) ON DELETE CASCADE
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_step_executions_pipeline ON step_executions(pipeline_id);
-        CREATE INDEX IF NOT EXISTS idx_step_executions_node ON step_executions(node_id);
-        CREATE INDEX IF NOT EXISTS idx_step_executions_status ON step_executions(status);
-      `);
-        logger.info('[SQLite] v23: Step 分步驱动支持添加完成');
-    },
-    // v24: 性能优化 — 添加缺失的复合索引
-    24: (db) => {
-        // events 表：按 pipeline_id + timestamp 查询优化
-        db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_events_pipeline_ts
-        ON events(pipeline_id, timestamp DESC)
-      `);
-        // quality_gate_history 表：按 pipeline_id + status 查询优化
-        try {
-            db.exec(`
-          CREATE INDEX IF NOT EXISTS idx_qgh_pipeline_status
-          ON quality_gate_history(pipeline_id, status)
-        `);
-        }
-        catch { /* pipeline_id 列可能不存在 */ }
-        // step_executions 表：按 pipeline_id + status + created_at 查询优化
-        db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_step_exec_pipeline_status_created
-        ON step_executions(pipeline_id, status, created_at DESC)
-      `);
-        // dynamic_pipelines 表：按 project_path + status + created_at 复合索引
-        db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_dp_project_status_created
-        ON dynamic_pipelines(project_path, status, created_at DESC)
-      `);
-        logger.info('[SQLite] v24: 性能优化索引添加完成');
-    },
-    // v25: knowledge_nodes FTS5 同步触发器 — 保持全文索引与主表实时一致
-    25: (db) => {
-        // 先重建 FTS 表（确保 content table 模式正确）
-        try {
-            db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_nodes_fts
-          USING fts5(id UNINDEXED, project_path, title, content, embedding_hint,
-                     content=knowledge_nodes, tokenize='unicode61')
-        `);
-        }
-        catch { /* 已存在则跳过 */ }
-        // INSERT 触发器
-        db.exec(`
-        CREATE TRIGGER IF NOT EXISTS knowledge_nodes_fts_insert
-        AFTER INSERT ON knowledge_nodes BEGIN
-          INSERT INTO knowledge_nodes_fts(rowid, id, project_path, title, content, embedding_hint)
-          VALUES (new.rowid, new.id, new.project_path, new.title, new.content, new.embedding_hint);
-        END
-      `);
-        // UPDATE 触发器（先删旧记录再插新记录）
-        db.exec(`
-        CREATE TRIGGER IF NOT EXISTS knowledge_nodes_fts_update
-        AFTER UPDATE ON knowledge_nodes BEGIN
-          INSERT INTO knowledge_nodes_fts(knowledge_nodes_fts, rowid, id, project_path, title, content, embedding_hint)
-          VALUES ('delete', old.rowid, old.id, old.project_path, old.title, old.content, old.embedding_hint);
-          INSERT INTO knowledge_nodes_fts(rowid, id, project_path, title, content, embedding_hint)
-          VALUES (new.rowid, new.id, new.project_path, new.title, new.content, new.embedding_hint);
-        END
-      `);
-        // DELETE 触发器
-        db.exec(`
-        CREATE TRIGGER IF NOT EXISTS knowledge_nodes_fts_delete
-        AFTER DELETE ON knowledge_nodes BEGIN
-          INSERT INTO knowledge_nodes_fts(knowledge_nodes_fts, rowid, id, project_path, title, content, embedding_hint)
-          VALUES ('delete', old.rowid, old.id, old.project_path, old.title, old.content, old.embedding_hint);
-        END
-      `);
-        // 全量重建 FTS 索引（同步历史数据）
-        try {
-            db.exec(`INSERT INTO knowledge_nodes_fts(knowledge_nodes_fts) VALUES ('rebuild')`);
-        }
-        catch { /* 忽略重建失败 */ }
-        logger.info('[SQLite] v25: knowledge_nodes FTS5 触发器创建完成，索引已重建');
-    },
-    // v26: 会话标签/备注/归档 — sessions 表新增 tags, notes, archived 字段
-    26: (db) => {
-        try {
-            db.exec(`ALTER TABLE sessions ADD COLUMN tags TEXT DEFAULT '[]'`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE sessions ADD COLUMN notes TEXT DEFAULT NULL`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        try {
-            db.exec(`ALTER TABLE sessions ADD COLUMN archived INTEGER NOT NULL DEFAULT 0`);
-        }
-        catch (err) {
-            if (!(err instanceof Error && err.message.includes('duplicate column name')))
-                throw err;
-        }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_archived ON sessions(archived)`);
-        logger.info('[SQLite] v26: sessions 表新增 tags/notes/archived 字段完成');
-    },
-    // v27: Plan Service 支持 — pipeline_plans, plan_nodes, template_versions, template_evolution_events
-    27: (db) => {
-        db.exec(`
-        CREATE TABLE IF NOT EXISTS pipeline_plans (
-          plan_id TEXT PRIMARY KEY,
-          template_id TEXT NOT NULL,
-          template_version TEXT NOT NULL,
-          goal TEXT NOT NULL,
-          project_path TEXT NOT NULL,
-          session_id TEXT NOT NULL,
-          params TEXT,
-          status TEXT NOT NULL DEFAULT 'draft',
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_pipeline_plans_project ON pipeline_plans(project_path);
-        CREATE INDEX IF NOT EXISTS idx_pipeline_plans_status ON pipeline_plans(status);
-
-        CREATE TABLE IF NOT EXISTS plan_nodes (
-          node_id TEXT PRIMARY KEY,
-          plan_id TEXT NOT NULL REFERENCES pipeline_plans(plan_id),
-          phase TEXT NOT NULL,
-          title TEXT NOT NULL,
-          instruction TEXT NOT NULL,
-          completion_rules TEXT NOT NULL DEFAULT '[]',
-          strategy_pool TEXT NOT NULL DEFAULT '[]',
-          retry_policy TEXT NOT NULL DEFAULT '{"max_retries":3}',
-          timeout_sec INTEGER NOT NULL DEFAULT 300,
-          dependencies TEXT,
-          status TEXT NOT NULL DEFAULT 'pending',
-          current_strategy_id TEXT,
-          attempt_count INTEGER NOT NULL DEFAULT 0,
-          created_at TEXT NOT NULL DEFAULT (datetime('now')),
-          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_plan_nodes_plan ON plan_nodes(plan_id);
-
-        CREATE TABLE IF NOT EXISTS template_versions (
-          version_id TEXT PRIMARY KEY,
-          template_id TEXT NOT NULL,
-          version TEXT NOT NULL,
-          content TEXT NOT NULL,
-          evolved_from TEXT,
-          evolution_reason TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_template_versions_template ON template_versions(template_id);
-
-        CREATE TABLE IF NOT EXISTS template_evolution_events (
-          event_id TEXT PRIMARY KEY,
-          template_id TEXT NOT NULL,
-          plan_id TEXT NOT NULL,
-          signal_type TEXT NOT NULL,
-          evidence TEXT NOT NULL DEFAULT '{}',
-          action TEXT NOT NULL,
-          new_version_id TEXT,
-          created_at TEXT NOT NULL DEFAULT (datetime('now'))
-        );
-        CREATE INDEX IF NOT EXISTS idx_tee_template ON template_evolution_events(template_id);
-      `);
-        logger.info('[SQLite] v27: pipeline_plans / plan_nodes / template_versions / template_evolution_events 创建完成');
-    },
-}; // end MIGRATIONS
-/**
- * 执行数据库迁移
- */
+import fs from 'fs';
+export const SCHEMA_VERSION = 1;
 export function runMigrations(db) {
-    // 确保 schema_version 表存在
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_version (
-      version INTEGER NOT NULL,
-      applied_at TEXT DEFAULT (datetime('now'))
-    )
-  `);
-    const row = db.prepare('SELECT MAX(version) as v FROM schema_version').get();
-    const currentVersion = row?.v ?? 0;
-    if (currentVersion < SCHEMA_VERSION) {
-        const migrate = db.transaction(() => {
-            for (let v = currentVersion + 1; v <= SCHEMA_VERSION; v++) {
-                const fn = MIGRATIONS[v];
-                if (fn)
-                    fn(db);
-                db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(v);
-                logger.info(`[SQLite] 迁移完成：v${v}`);
-            }
-        });
-        migrate();
-        // 基线版本无迁移函数时也要记录
-        if (currentVersion === 0) {
-            const exists = db.prepare('SELECT 1 FROM schema_version WHERE version = 1').get();
-            if (!exists) {
-                db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
-            }
-        }
-        logger.info(`[SQLite] Schema 版本：v${SCHEMA_VERSION}`);
+    const hasVersionTable = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
+    let currentVersion = 0;
+    if (hasVersionTable) {
+        const row = db.prepare('SELECT MAX(version) as v FROM schema_version').get();
+        currentVersion = row?.v ?? 0;
+    }
+    if (currentVersion > SCHEMA_VERSION) {
+        const dbPath = db.name;
+        const backupPath = `${dbPath}.backup-${Date.now()}`;
+        logger.warn(`[SQLite] 检测到旧版本数据库 (v${currentVersion})，备份到 ${backupPath} 后重建`);
+        db.close();
+        fs.copyFileSync(dbPath, backupPath);
+        fs.unlinkSync(dbPath);
+        throw new Error(`DB_REBUILD_NEEDED:${dbPath}`);
+    }
+    if (currentVersion === 0) {
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        logger.info(`[SQLite] 新数据库初始化完成：v${SCHEMA_VERSION}`);
     }
+    logger.info(`[SQLite] Schema 版本：v${SCHEMA_VERSION}`);
 }
 //# sourceMappingURL=migration-manager.js.map