@winspan/claude-forge 8.28.2 → 8.33.0

package/dist/core/storage/sqlite.js

@@ -27,6 +27,7 @@ export class SQLiteStorage extends EventEmitter {
         this.db.pragma(`cache_size = ${DATABASE.CACHE_SIZE}`);
         this.db.pragma(`busy_timeout = ${DATABASE.BUSY_TIMEOUT}`);
         this.initSchema();
+        this.runMigrations();
     }
     initSchema() {
         const thisDir = dirname(fileURLToPath(import.meta.url));
@@ -52,6 +53,284 @@ export class SQLiteStorage extends EventEmitter {
       `);
         }
     }
+    hasColumn(table, column) {
+        try {
+            const rows = this.db.prepare(`PRAGMA table_info(${table})`).all();
+            return rows.some(r => r.name === column);
+        }
+        catch {
+            return false;
+        }
+    }
+    addColumnIfMissing(table, column, definition) {
+        if (!this.hasColumn(table, column)) {
+            try {
+                this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+                logger.info(`[SQLiteStorage] migration: added ${table}.${column}`);
+            }
+            catch (err) {
+                logger.warn(`[SQLiteStorage] migration: ALTER ${table} ADD ${column} failed: ${err}`);
+            }
+        }
+    }
+    /**
+     * Incremental schema migrations. Kept idempotent so daemon restarts are safe.
+     * New columns since the base schema.sql go here.
+     */
+    runMigrations() {
+        // methodology_executions: mode / worker_pid / worker_session_id / last_progress_at
+        this.addColumnIfMissing('methodology_executions', 'mode', "TEXT NOT NULL DEFAULT 'foreground'");
+        this.addColumnIfMissing('methodology_executions', 'worker_pid', 'INTEGER');
+        this.addColumnIfMissing('methodology_executions', 'worker_session_id', 'TEXT');
+        this.addColumnIfMissing('methodology_executions', 'last_progress_at', 'INTEGER');
+        // methodology_executions: retry_count / original_plan_json (failure feedback loop)
+        this.addColumnIfMissing('methodology_executions', 'retry_count', 'INTEGER DEFAULT 0');
+        this.addColumnIfMissing('methodology_executions', 'original_plan_json', 'TEXT');
+        // methodology_executions: trigger_type (idle trigger support)
+        this.addColumnIfMissing('methodology_executions', 'trigger_type', "TEXT DEFAULT 'manual'");
+        // sessions: first_prompt — 避免 querySessions 再对 events 表做 O(sessions × events)
+        // 的相关子查询；新增列后若库里已有 sessions 但无 first_prompt，后续 backfill 会补齐。
+        this.addColumnIfMissing('sessions', 'first_prompt', 'TEXT');
+        // phase_executions: output_text / error_message / stream_log_path
+        this.addColumnIfMissing('phase_executions', 'output_text', 'TEXT');
+        this.addColumnIfMissing('phase_executions', 'error_message', 'TEXT');
+        this.addColumnIfMissing('phase_executions', 'stream_log_path', 'TEXT');
+        // phase_executions.status: 升级 CHECK 约束以支持 'cancelled'
+        this.rebuildPhaseExecutionsIfNeeded();
+        // methodology_executions.status: 升级 CHECK 约束以支持 'stale'
+        this.rebuildMethodologyExecutionsIfNeeded();
+        // sessions 聚合表性能索引（幂等）：start_time 用于 querySessions 的 ORDER BY
+        try {
+            this.db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_start_time ON sessions(start_time DESC)');
+        }
+        catch (err) {
+            logger.warn(`[SQLiteStorage] migration: create idx_sessions_start_time failed: ${err}`);
+        }
+        // 一次性回填 sessions 聚合表（仅在 sessions 尚未对齐时触发）
+        this.backfillSessionsIfNeeded();
+    }
+    /**
+     * 将 events 表按 session_id 聚合回填到 sessions 表，仅在 sessions 尚未对齐
+     * （没有任何一行带 first_prompt）时触发。旧库升级场景：引入 sessions 聚合表 +
+     * upsert 写入路径后，历史 events 不会自动同步到 sessions，必须通过一次性回填补齐。
+     *
+     * 幂等策略：检测到已有 first_prompt 非空的聚合行就跳过；避免覆盖已被新写路径
+     * upsert 过的数据。
+     */
+    backfillSessionsIfNeeded() {
+        const eventsExists = this.db
+            .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='events'`)
+            .get();
+        if (!eventsExists)
+            return;
+        const aggRow = this.db
+            .prepare(`SELECT COUNT(*) AS total, COUNT(first_prompt) AS with_prompt FROM sessions`)
+            .get();
+        if (aggRow.with_prompt > 0)
+            return;
+        logger.info('[SQLiteStorage] backfilling sessions aggregate from events...');
+        try {
+            const backfill = this.db.transaction(() => {
+                this.db.exec(`
+          INSERT INTO sessions (
+            session_id, project_path, status, first_prompt,
+            start_time, end_time, last_event_time, event_count
+          )
+          SELECT
+            e.session_id,
+            e.project_path,
+            'active' AS status,
+            (SELECT substr(COALESCE(e2.user_prompt, json_extract(e2.tool_input, '$.user_prompt')), 1, 200)
+             FROM events e2
+             WHERE e2.session_id = e.session_id
+               AND e2.hook_type = 'UserPromptSubmit'
+               AND (e2.user_prompt IS NOT NULL OR json_extract(e2.tool_input, '$.user_prompt') IS NOT NULL)
+             ORDER BY e2.timestamp ASC LIMIT 1) AS first_prompt,
+            MIN(e.timestamp) AS start_time,
+            MAX(e.timestamp) AS end_time,
+            MAX(e.timestamp) AS last_event_time,
+            COUNT(*) AS event_count
+          FROM events e
+          GROUP BY e.session_id, e.project_path
+          ON CONFLICT(session_id) DO UPDATE SET
+            first_prompt = COALESCE(sessions.first_prompt, excluded.first_prompt),
+            end_time = MAX(COALESCE(sessions.end_time, ''), excluded.end_time),
+            last_event_time = MAX(COALESCE(sessions.last_event_time, ''), excluded.last_event_time),
+            event_count = excluded.event_count,
+            updated_at = datetime('now')
+        `);
+            });
+            backfill();
+            const migrated = this.db.prepare('SELECT COUNT(*) AS c FROM sessions').get();
+            logger.info(`[SQLiteStorage] backfilled ${migrated.c} sessions from events`);
+        }
+        catch (err) {
+            logger.warn(`[SQLiteStorage] backfillSessionsIfNeeded failed: ${err}`);
+        }
+    }
+    /**
+     * SQLite 无法直接修改 CHECK 约束。若旧库的 phase_executions.status CHECK
+     * 还没有 'cancelled'，走经典的"新表 + 拷数据 + 重命名"路径升级。
+     *
+     * 幂等：检测到当前 CREATE TABLE 语句里已有 'cancelled' 就跳过。fresh install
+     * 的库会直接命中 schema.sql 里的新定义，这里也直接跳过。
+     */
+    rebuildPhaseExecutionsIfNeeded() {
+        const row = this.db
+            .prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='phase_executions'`)
+            .get();
+        if (!row || typeof row.sql !== 'string')
+            return;
+        if (row.sql.includes(`'cancelled'`))
+            return;
+        // 兜底列齐校验：rebuild 的新表定义必须覆盖所有期望列；如果前面 addColumnIfMissing
+        // 漏补，这里最后再补一次，避免"列在旧表不存在 → 拷数据 SELECT 报 no such column"。
+        const expectedPhaseColumns = [
+            ['output_text', 'TEXT'],
+            ['error_message', 'TEXT'],
+            ['stream_log_path', 'TEXT'],
+        ];
+        for (const [col, def] of expectedPhaseColumns) {
+            this.addColumnIfMissing('phase_executions', col, def);
+        }
+        logger.info('[SQLiteStorage] migration: rebuilding phase_executions to extend status CHECK with cancelled');
+        // 列列表来自最新 schema —— 新增过的列（output_text / error_message / stream_log_path）
+        // 在前面的 addColumnIfMissing 已经补齐，这里可以安全地全量拷贝。
+        const migrate = this.db.transaction(() => {
+            this.db.exec(`
+        CREATE TABLE phase_executions_new (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          methodology_execution_id INTEGER NOT NULL,
+          phase_id TEXT NOT NULL,
+          phase_index INTEGER NOT NULL,
+          agent_name TEXT NOT NULL,
+          prompt TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'running', 'completed', 'failed', 'cancelled')),
+          started_at INTEGER,
+          completed_at INTEGER,
+          duration_ms INTEGER,
+          artifacts_json TEXT,
+          output_text TEXT,
+          error_message TEXT,
+          stream_log_path TEXT,
+          created_at TEXT DEFAULT (datetime('now')),
+          FOREIGN KEY (methodology_execution_id) REFERENCES methodology_executions(id)
+        );
+      `);
+            this.db.exec(`
+        INSERT INTO phase_executions_new (
+          id, methodology_execution_id, phase_id, phase_index, agent_name, prompt,
+          status, started_at, completed_at, duration_ms, artifacts_json,
+          output_text, error_message, stream_log_path, created_at
+        )
+        SELECT
+          id, methodology_execution_id, phase_id, phase_index, agent_name, prompt,
+          status, started_at, completed_at, duration_ms, artifacts_json,
+          output_text, error_message, stream_log_path, created_at
+        FROM phase_executions;
+      `);
+            this.db.exec(`DROP TABLE phase_executions;`);
+            this.db.exec(`ALTER TABLE phase_executions_new RENAME TO phase_executions;`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_phase_exec_methodology ON phase_executions(methodology_execution_id);`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_phase_exec_status ON phase_executions(status);`);
+        });
+        try {
+            migrate();
+            logger.info('[SQLiteStorage] migration: phase_executions rebuild complete');
+        }
+        catch (err) {
+            logger.warn(`[SQLiteStorage] migration: phase_executions rebuild failed: ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * methodology_executions.status CHECK 升级：加入 'stale' 枚举值。
+     * 幂等：CREATE TABLE 语句里已含 'stale' 则跳过；fresh install 会命中 schema.sql
+     * 的新定义，这里也跳过。
+     *
+     * 注意：必须在 addColumnIfMissing('last_progress_at' / 'retry_count' /
+     * 'original_plan_json' / 'trigger_type', ...) 之后执行，重建表时才能把它们一起
+     * 拷贝过去。重建方法内部再做一次兜底 addColumnIfMissing，避免未来新列漏同步。
+     */
+    rebuildMethodologyExecutionsIfNeeded() {
+        const row = this.db
+            .prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='methodology_executions'`)
+            .get();
+        if (!row || typeof row.sql !== 'string')
+            return;
+        if (row.sql.includes(`'stale'`))
+            return;
+        // 兜底列齐校验：重建涉及到 INSERT ... SELECT，任何漏列都会让旧列被丢弃或
+        // 新列 SELECT 报 `no such column`。所有期望列这里再确认一次。
+        const expectedMethodologyColumns = [
+            ['mode', "TEXT NOT NULL DEFAULT 'foreground'"],
+            ['worker_pid', 'INTEGER'],
+            ['worker_session_id', 'TEXT'],
+            ['last_progress_at', 'INTEGER'],
+            ['retry_count', 'INTEGER DEFAULT 0'],
+            ['original_plan_json', 'TEXT'],
+            ['trigger_type', "TEXT DEFAULT 'manual'"],
+        ];
+        for (const [col, def] of expectedMethodologyColumns) {
+            this.addColumnIfMissing('methodology_executions', col, def);
+        }
+        logger.info('[SQLiteStorage] migration: rebuilding methodology_executions to extend status CHECK with stale');
+        // 重建母表会触发依赖它的外键（phase_executions.methodology_execution_id）。
+        // PRAGMA foreign_keys 不能在事务内改，所以在事务外临时关闭，完成后恢复。
+        const fkBefore = this.db.pragma('foreign_keys', { simple: true });
+        if (fkBefore)
+            this.db.pragma('foreign_keys = OFF');
+        const migrate = this.db.transaction(() => {
+            this.db.exec(`
+        CREATE TABLE methodology_executions_new (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          methodology_id TEXT NOT NULL,
+          plan_json TEXT NOT NULL,
+          current_phase_index INTEGER DEFAULT 0,
+          status TEXT NOT NULL DEFAULT 'running' CHECK(status IN ('running', 'completed', 'failed', 'cancelled', 'stale')),
+          started_at INTEGER NOT NULL,
+          completed_at INTEGER,
+          mode TEXT NOT NULL DEFAULT 'foreground',
+          worker_pid INTEGER,
+          worker_session_id TEXT,
+          last_progress_at INTEGER,
+          retry_count INTEGER DEFAULT 0,
+          original_plan_json TEXT,
+          trigger_type TEXT DEFAULT 'manual',
+          created_at TEXT DEFAULT (datetime('now'))
+        );
+      `);
+            this.db.exec(`
+        INSERT INTO methodology_executions_new (
+          id, session_id, methodology_id, plan_json, current_phase_index,
+          status, started_at, completed_at, mode, worker_pid, worker_session_id,
+          last_progress_at, retry_count, original_plan_json, trigger_type, created_at
+        )
+        SELECT
+          id, session_id, methodology_id, plan_json, current_phase_index,
+          status, started_at, completed_at, mode, worker_pid, worker_session_id,
+          last_progress_at, retry_count, original_plan_json, trigger_type, created_at
+        FROM methodology_executions;
+      `);
+            this.db.exec(`DROP TABLE methodology_executions;`);
+            this.db.exec(`ALTER TABLE methodology_executions_new RENAME TO methodology_executions;`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_methodology_exec_session ON methodology_executions(session_id);`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_methodology_exec_status ON methodology_executions(status);`);
+        });
+        try {
+            migrate();
+            logger.info('[SQLiteStorage] migration: methodology_executions rebuild complete');
+        }
+        catch (err) {
+            logger.warn(`[SQLiteStorage] migration: methodology_executions rebuild failed: ${err}`);
+            throw err;
+        }
+        finally {
+            if (fkBefore)
+                this.db.pragma('foreign_keys = ON');
+        }
+    }
     getDatabase() {
         return this.db;
     }
@@ -67,8 +346,52 @@ export class SQLiteStorage extends EventEmitter {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
     `);
         stmt.run(eventId, event.session_id, event.project_path, event.timestamp, event.hook_type, event.tool_name ?? null, event.tool_input ? JSON.stringify(event.tool_input) : null, event.tool_output ? JSON.stringify(event.tool_output) : null, event.user_prompt ?? null, event.ai_response ?? null);
+        // 聚合到 sessions 表。单独 try/catch：一旦聚合失败（比如 schema 升级过程中
+        // 的短暂窗口），也不能影响原事件的持久化，上层已经 commit 过 events 了。
+        try {
+            this.upsertSession(event);
+        }
+        catch (err) {
+            logger.warn(`[SQLiteStorage] upsertSession failed (event still written): ${err}`);
+        }
         this.emit('event', { ...event, event_id: eventId });
     }
+    /**
+     * 将事件聚合到 sessions 表，供 querySessions 直接读取，避免对 events 做 O(n²)
+     * 的 GROUP BY + 相关子查询。
+     *
+     * 语义：
+     * - 首次出现 session_id → 插入一行，start/end/last_event_time 都取当前事件时间戳
+     * - 已存在 → event_count += 1，end/last_event_time 取更晚的，first_prompt 只在
+     *   原值为 NULL 时才被 UserPromptSubmit 的前 200 字填充（保留"首条"语义）
+     * - 非 UserPromptSubmit 事件或 user_prompt 为空时 first_prompt 传 NULL，不会
+     *   覆盖已有值
+     */
+    upsertSession(event) {
+        const firstPrompt = event.hook_type === 'UserPromptSubmit' && event.user_prompt
+            ? event.user_prompt.slice(0, 200)
+            : null;
+        const stmt = this.db.prepare(`
+      INSERT INTO sessions (
+        session_id, project_path, status, first_prompt,
+        start_time, end_time, last_event_time, event_count
+      )
+      VALUES (?, ?, 'active', ?, ?, ?, ?, 1)
+      ON CONFLICT(session_id) DO UPDATE SET
+        end_time = CASE
+          WHEN excluded.end_time > COALESCE(sessions.end_time, '') THEN excluded.end_time
+          ELSE sessions.end_time
+        END,
+        last_event_time = CASE
+          WHEN excluded.last_event_time > COALESCE(sessions.last_event_time, '') THEN excluded.last_event_time
+          ELSE sessions.last_event_time
+        END,
+        event_count = COALESCE(sessions.event_count, 0) + 1,
+        first_prompt = COALESCE(sessions.first_prompt, excluded.first_prompt),
+        updated_at = datetime('now')
+    `);
+        stmt.run(event.session_id, event.project_path, firstPrompt, event.timestamp, event.timestamp, event.timestamp);
+    }
     writeToolEvent(event) {
         const stmt = this.db.prepare(`
       INSERT INTO v2_tool_events (session_id, route_request_id, tool, args, result, success, error, timestamp)
@@ -146,33 +469,31 @@ export class SQLiteStorage extends EventEmitter {
         const conditions = [];
         const params = [];
         if (filter.project_path) {
-            conditions.push('e.project_path = ?');
+            conditions.push('project_path = ?');
             params.push(filter.project_path);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
         const limit = filter.limit ?? 10;
+        // 直接读 sessions 聚合表 → O(sessions)。writeEvent 的 upsertSession 路径保证
+        // 每次事件写入都会同步更新此表；旧库在 runMigrations 里由 backfillSessionsIfNeeded
+        // 一次性回填，确保历史 session 也可见。
         const sql = `
       SELECT
-        e.session_id,
-        COUNT(*) as event_count,
-        MIN(e.timestamp) as start_time,
-        MAX(e.timestamp) as end_time,
-        (SELECT COALESCE(e2.user_prompt, json_extract(e2.tool_input, '$.user_prompt'))
-         FROM events e2
-         WHERE e2.session_id = e.session_id AND e2.hook_type = 'UserPromptSubmit'
-         AND (e2.user_prompt IS NOT NULL OR json_extract(e2.tool_input, '$.user_prompt') IS NOT NULL)
-         ORDER BY e2.timestamp ASC LIMIT 1) as first_prompt
-      FROM events e
+        session_id,
+        first_prompt,
+        event_count,
+        start_time,
+        COALESCE(end_time, last_event_time, start_time) AS end_time
+      FROM sessions
       ${where}
-      GROUP BY e.session_id
-      ORDER BY MAX(e.timestamp) DESC
+      ORDER BY start_time DESC
       LIMIT ${limit}
     `;
         const rows = this.db.prepare(sql).all(...params);
         return rows.map(r => ({
             session_id: r.session_id,
             first_prompt: r.first_prompt || '',
-            event_count: r.event_count,
+            event_count: r.event_count ?? 0,
             start_time: r.start_time,
             end_time: r.end_time,
         }));
@@ -506,18 +827,22 @@ export class SQLiteStorage extends EventEmitter {
     }
     // ── Methodology Executions ─────────────────────────────────────────────
     createMethodologyExecution(data) {
+        const mode = data.mode ?? 'foreground';
+        const trigger_type = data.trigger_type ?? 'manual';
+        const now = Date.now();
         const result = this.db.prepare(`
-      INSERT INTO methodology_executions (session_id, methodology_id, plan_json, started_at)
-      VALUES (?, ?, ?, ?)
-    `).run(data.session_id, data.methodology_id, data.plan_json, Date.now());
+      INSERT INTO methodology_executions (session_id, methodology_id, plan_json, original_plan_json, mode, trigger_type, started_at, last_progress_at, retry_count)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `).run(data.session_id, data.methodology_id, data.plan_json, data.plan_json, mode, trigger_type, now, now);
         return result.lastInsertRowid;
     }
     getActiveMethodologyExecution(session_id) {
-        return this.db.prepare(`
+        const row = this.db.prepare(`
       SELECT * FROM methodology_executions
       WHERE session_id = ? AND status = 'running'
       ORDER BY id DESC LIMIT 1
-    `).get(session_id) || null;
+    `).get(session_id);
+        return row ?? null;
     }
     updateMethodologyExecution(id, data) {
         const updates = [];
@@ -534,6 +859,26 @@ export class SQLiteStorage extends EventEmitter {
             updates.push('completed_at = ?');
             values.push(data.completed_at);
         }
+        if (data.worker_pid !== undefined) {
+            updates.push('worker_pid = ?');
+            values.push(data.worker_pid);
+        }
+        if (data.worker_session_id !== undefined) {
+            updates.push('worker_session_id = ?');
+            values.push(data.worker_session_id);
+        }
+        if (data.last_progress_at !== undefined) {
+            updates.push('last_progress_at = ?');
+            values.push(data.last_progress_at);
+        }
+        if (data.plan_json !== undefined) {
+            updates.push('plan_json = ?');
+            values.push(data.plan_json);
+        }
+        if (data.retry_count !== undefined) {
+            updates.push('retry_count = ?');
+            values.push(data.retry_count);
+        }
         if (updates.length > 0) {
             values.push(id);
             this.db.prepare(`
@@ -544,9 +889,34 @@ export class SQLiteStorage extends EventEmitter {
         }
     }
     getMethodologyExecution(id) {
-        return this.db.prepare(`
+        const row = this.db.prepare(`
       SELECT * FROM methodology_executions WHERE id = ?
-    `).get(id) || null;
+    `).get(id);
+        return row ?? null;
+    }
+    /**
+     * List all methodology_executions with status='running' and mode='background'.
+     * Used at daemon startup to detect crashed workers (worker_pid not alive).
+     */
+    listRunningBackgroundExecutions() {
+        return this.db.prepare(`
+      SELECT * FROM methodology_executions
+      WHERE status = 'running' AND mode = 'background'
+      ORDER BY id DESC
+    `).all();
+    }
+    /**
+     * List all methodology_executions with status='running' and mode='foreground'.
+     * Used at daemon startup to sweep stale foreground executions — rows left
+     * behind when the originating Claude session ended without Stop hook firing
+     * (crash / detach / pre-guard legacy data).
+     */
+    listRunningForegroundExecutions() {
+        return this.db.prepare(`
+      SELECT * FROM methodology_executions
+      WHERE status = 'running' AND mode = 'foreground'
+      ORDER BY id DESC
+    `).all();
     }
     // ── Phase Executions ───────────────────────────────────────────────────
     createPhaseExecution(data) {
@@ -568,13 +938,29 @@ export class SQLiteStorage extends EventEmitter {
             updates.push('completed_at = ?');
             values.push(data.completed_at);
             if (data.status === 'completed') {
-                updates.push('duration_ms = completed_at - started_at');
+                // SQLite UPDATE 的 SET 子句里引用列名取的是更新前的值，
+                // 不能写 `duration_ms = completed_at - started_at`（RHS 的 completed_at 仍是 NULL）。
+                // 用参数占位符复写一次 completed_at 的值，减去旧的 started_at。
+                updates.push('duration_ms = ? - started_at');
+                values.push(data.completed_at);
             }
         }
         if (data.artifacts_json) {
             updates.push('artifacts_json = ?');
             values.push(data.artifacts_json);
         }
+        if (data.output_text !== undefined) {
+            updates.push('output_text = ?');
+            values.push(data.output_text);
+        }
+        if (data.error_message !== undefined) {
+            updates.push('error_message = ?');
+            values.push(data.error_message);
+        }
+        if (data.stream_log_path !== undefined) {
+            updates.push('stream_log_path = ?');
+            values.push(data.stream_log_path);
+        }
         if (updates.length > 0) {
             values.push(id);
             this.db.prepare(`
@@ -591,5 +977,77 @@ export class SQLiteStorage extends EventEmitter {
       ORDER BY phase_index ASC
     `).all(methodology_execution_id);
     }
+    /**
+     * 获取指定 session 和 methodology 的最后一次 idle 触发时间
+     */
+    getLastIdleTrigger(session_id, methodology_id) {
+        const row = this.db.prepare(`
+      SELECT MAX(started_at) as last_trigger
+      FROM methodology_executions
+      WHERE session_id = ? AND methodology_id = ? AND trigger_type = 'idle'
+    `).get(session_id, methodology_id);
+        return row?.last_trigger ?? null;
+    }
+    // ── Token Usage ────────────────────────────────────────────────────────
+    recordTokenUsage(params) {
+        const total_tokens = params.input_tokens + params.output_tokens;
+        try {
+            this.db.prepare(`
+        INSERT INTO token_usage (session_id, methodology_execution_id, timestamp,
+                                 input_tokens, output_tokens, total_tokens, model, tool_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(params.session_id, params.methodology_execution_id ?? null, Date.now(), params.input_tokens, params.output_tokens, total_tokens, params.model ?? null, params.tool_name ?? null);
+        }
+        catch (err) {
+            logger.debug(`[Storage] Failed to record token usage: ${err}`);
+        }
+    }
+    getTokenUsageBySession(session_id) {
+        const result = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(input_tokens), 0) as input_tokens,
+        COALESCE(SUM(output_tokens), 0) as output_tokens,
+        COALESCE(SUM(total_tokens), 0) as total_tokens
+      FROM token_usage WHERE session_id = ?
+    `).get(session_id);
+        return result;
+    }
+    getTokenUsageByMethodology(methodology_execution_id) {
+        const result = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(input_tokens), 0) as input_tokens,
+        COALESCE(SUM(output_tokens), 0) as output_tokens,
+        COALESCE(SUM(total_tokens), 0) as total_tokens
+      FROM token_usage WHERE methodology_execution_id = ?
+    `).get(methodology_execution_id);
+        return result;
+    }
+    listTokenUsage(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.session_id) {
+            conditions.push('session_id = ?');
+            params.push(filter.session_id);
+        }
+        if (filter.methodology_execution_id !== undefined) {
+            conditions.push('methodology_execution_id = ?');
+            params.push(filter.methodology_execution_id);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = filter.limit ?? 100;
+        const sql = `SELECT * FROM token_usage ${where} ORDER BY timestamp DESC LIMIT ${limit}`;
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => ({
+            id: r.id,
+            session_id: r.session_id,
+            methodology_execution_id: r.methodology_execution_id || null,
+            timestamp: r.timestamp,
+            input_tokens: r.input_tokens,
+            output_tokens: r.output_tokens,
+            total_tokens: r.total_tokens,
+            model: r.model || null,
+            tool_name: r.tool_name || null,
+        }));
+    }
 }
 //# sourceMappingURL=sqlite.js.map