@winspan/claude-forge 8.53.2 → 8.54.4

package/src/core/storage/events.ts

@@ -1,434 +0,0 @@
-/**
- * EventOperations — 事件读写
- *
- * 拆分自 sqlite.ts。负责 events 表 + 触发 sessions 聚合 upsert。
- *
- * 注意：
- * - writeEvent 会 emit 'event' 事件，因此构造时需要传入 EventEmitter 实例
- * - upsertSession 通过 emitter（即 SQLiteStorage facade）调用，以保持原版本
- *   "monkey-patch storage.upsertSession 能拦截 writeEvent 内部调用"的行为
- */
-
-import type Database from 'better-sqlite3';
-import { randomUUID } from 'node:crypto';
-import type { EventEmitter } from 'node:events';
-import { z } from 'zod';
-import type { ForgeEvent } from '../types.js';
-import { logger } from '../utils/logger.js';
-
-// Zod schema for runtime validation
-const ForgeEventSchema = z.object({
-  event_id: z.string().uuid().optional(),
-  session_id: z.string().min(1),
-  project_path: z.string().min(1),
-  timestamp: z.string().min(1),
-  hook_type: z.enum([
-    'UserPromptSubmit',
-    'PreToolUse',
-    'PostToolUse',
-    'Stop',
-    'Notification',
-    'HistoryExport',
-  ]),
-  tool_name: z.string().optional(),
-  tool_input: z.unknown().optional(),
-  tool_output: z.unknown().optional(),
-  user_prompt: z.string().optional(),
-  ai_response: z.string().optional(),
-});
-
-const DatabaseRowSchema = z.object({
-  event_id: z.string(),
-  session_id: z.string(),
-  project_path: z.string(),
-  timestamp: z.string(),
-  hook_type: z.string(),
-  tool_name: z.union([z.string(), z.null()]),
-  tool_input: z.union([z.string(), z.null()]),
-  tool_output: z.union([z.string(), z.null()]),
-  user_prompt: z.union([z.string(), z.null()]),
-  ai_response: z.union([z.string(), z.null()]),
-});
-
-interface UpsertCapableEmitter extends EventEmitter {
-  upsertSession(event: ForgeEvent): void;
-}
-
-export class EventOperations {
-  constructor(
-    private db: Database.Database,
-    private emitter: UpsertCapableEmitter,
-  ) {}
-
-  writeEvent(event: ForgeEvent): void {
-    // Runtime validation
-    try {
-      ForgeEventSchema.parse(event);
-    } catch (err) {
-      logger.error(`[EventOperations] Invalid event data: ${err}`);
-      throw new Error(`Invalid event data: ${err instanceof Error ? err.message : String(err)}`);
-    }
-
-    const eventId = event.event_id || randomUUID();
-    const stmt = this.db.prepare(`
-      INSERT INTO events (event_id, session_id, project_path, timestamp, hook_type,
-                          tool_name, tool_input, tool_output, user_prompt, ai_response, distilled)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
-    `);
-
-    try {
-      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,
-      );
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (msg.includes('UNIQUE constraint failed')) {
-        // Duplicate event_id — expected during queue replay. Caller decides how to handle.
-        logger.debug(`[EventOperations] Duplicate event_id ${eventId} (UNIQUE constraint)`);
-      } else {
-        logger.error(`[EventOperations] Failed to write event: ${err}`);
-      }
-      throw new Error(`Failed to write event: ${msg}`);
-    }
-
-    // 聚合到 sessions 表。单独 try/catch：一旦聚合失败，不能影响原事件持久化。
-    // 通过 facade 调用以保持 monkey-patch 兼容性。
-    try {
-      this.emitter.upsertSession(event);
-    } catch (err) {
-      logger.warn(`[SQLiteStorage] upsertSession failed (event still written): ${err}`);
-    }
-
-    this.emitter.emit('event', { ...event, event_id: eventId });
-  }
-
-  queryEvents(filter: {
-    session_id?: string;
-    project_path?: string;
-    hook_type?: string;
-    limit?: number;
-    offset?: number;
-  }): ForgeEvent[] {
-    const conditions: string[] = [];
-    const params: unknown[] = [];
-
-    if (filter.session_id) {
-      conditions.push('session_id = ?');
-      params.push(filter.session_id);
-    }
-    if (filter.project_path) {
-      conditions.push('project_path = ?');
-      params.push(filter.project_path);
-    }
-    if (filter.hook_type) {
-      conditions.push('hook_type = ?');
-      params.push(filter.hook_type);
-    }
-
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-    const limit = filter.limit ?? 1000;
-    const offset = filter.offset ?? 0;
-    const sql = `SELECT * FROM events ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`;
-
-    params.push(limit, offset);
-    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
-    return rows.map((row) => this.rowToEvent(row));
-  }
-
-  countEvents(filter?: {
-    session_id?: string;
-    project_path?: string;
-    hook_type?: string;
-  }): number {
-    if (!filter || (!filter.session_id && !filter.project_path && !filter.hook_type)) {
-      const result = this.db.prepare('SELECT COUNT(*) as count FROM events').get() as { count: number };
-      return result.count;
-    }
-
-    const conditions: string[] = [];
-    const params: unknown[] = [];
-
-    if (filter.session_id) {
-      conditions.push('session_id = ?');
-      params.push(filter.session_id);
-    }
-    if (filter.project_path) {
-      conditions.push('project_path = ?');
-      params.push(filter.project_path);
-    }
-    if (filter.hook_type) {
-      conditions.push('hook_type = ?');
-      params.push(filter.hook_type);
-    }
-
-    const where = `WHERE ${conditions.join(' AND ')}`;
-    const sql = `SELECT COUNT(*) as count FROM events ${where}`;
-    const result = this.db.prepare(sql).all(...params)[0] as { count: number };
-    return result.count;
-  }
-
-  /**
-   * Server-side event search with filtering.
-   * Reduces data transfer by filtering events before sending to client.
-   */
-  searchEvents(filter: {
-    session_id: string;
-    query?: string;
-    tool_name?: string;
-    hook_type?: string;
-    limit?: number;
-    offset?: number;
-  }): ForgeEvent[] {
-    const conditions: string[] = ['session_id = ?'];
-    const params: unknown[] = [filter.session_id];
-
-    if (filter.query) {
-      conditions.push('(user_prompt LIKE ? OR ai_response LIKE ? OR tool_input LIKE ?)');
-      const pattern = `%${filter.query}%`;
-      params.push(pattern, pattern, pattern);
-    }
-    if (filter.tool_name) {
-      conditions.push('tool_name = ?');
-      params.push(filter.tool_name);
-    }
-    if (filter.hook_type) {
-      conditions.push('hook_type = ?');
-      params.push(filter.hook_type);
-    }
-
-    const limit = filter.limit ?? 100;
-    const offset = filter.offset ?? 0;
-
-    const sql = `SELECT * FROM events WHERE ${conditions.join(' AND ')} ORDER BY timestamp DESC LIMIT ? OFFSET ?`;
-    params.push(limit, offset);
-    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
-    return rows.map((row) => this.rowToEvent(row));
-  }
-
-  // ── H2: 聚合 / 计数方法（消除 routes / handlers / analytics 越权 SQL）─────
-
-  /** Total event row count. */
-  countAllEvents(): number {
-    const row = this.db.prepare('SELECT COUNT(*) as cnt FROM events').get() as { cnt: number };
-    return row.cnt;
-  }
-
-  /**
-   * Tool usage distribution (tool_name → count).
-   *
-   * - `since`: ISO timestamp, inclusive lower bound on `timestamp`. Omit for all-time.
-   * - `hook_type`: filter on hook_type (e.g. 'PreToolUse') — used by weekly-report.
-   * - `limit`: max distinct tools returned (default 100).
-   */
-  aggregateToolUsage(opts: {
-    since?: string;
-    limit?: number;
-    hook_type?: 'PreToolUse' | 'PostToolUse';
-  } = {}): Array<{ tool_name: string; count: number }> {
-    const conditions: string[] = [`tool_name IS NOT NULL`, `tool_name != ''`];
-    const params: unknown[] = [];
-    if (opts.since !== undefined) {
-      conditions.push('timestamp >= ?');
-      params.push(opts.since);
-    }
-    if (opts.hook_type) {
-      conditions.push('hook_type = ?');
-      params.push(opts.hook_type);
-    }
-    const limit = opts.limit ?? 100;
-    const sql = `SELECT tool_name, COUNT(*) as count FROM events
-                 WHERE ${conditions.join(' AND ')}
-                 GROUP BY tool_name ORDER BY count DESC LIMIT ?`;
-    params.push(limit);
-    return this.db.prepare(sql).all(...params) as Array<{ tool_name: string; count: number }>;
-  }
-
-  /** Per-day event counts (date(timestamp) → count) within [since, until). */
-  aggregateDailyEventCounts(opts: { since: string; until?: string }): Array<{ date: string; count: number }> {
-    const conditions: string[] = ['timestamp >= ?'];
-    const params: unknown[] = [opts.since];
-    if (opts.until !== undefined) {
-      conditions.push('timestamp < ?');
-      params.push(opts.until);
-    }
-    const sql = `SELECT date(timestamp) as date, COUNT(*) as count FROM events
-                 WHERE ${conditions.join(' AND ')}
-                 GROUP BY date ORDER BY date`;
-    return this.db.prepare(sql).all(...params) as Array<{ date: string; count: number }>;
-  }
-
-  /** Hook type distribution for a single session. */
-  aggregateHookTypeBySession(session_id: string): Array<{ hook_type: string; count: number }> {
-    return this.db.prepare(
-      `SELECT hook_type, COUNT(*) as count FROM events
-       WHERE session_id = ? GROUP BY hook_type`
-    ).all(session_id) as Array<{ hook_type: string; count: number }>;
-  }
-
-  /** Agent/Task subagent_type distribution for a single session (json_extract from tool_input). */
-  aggregateAgentTypeBySession(session_id: string): Array<{ agent_type: string | null; count: number }> {
-    return this.db.prepare(
-      `SELECT json_extract(tool_input, '$.subagent_type') as agent_type, COUNT(*) as count
-       FROM events
-       WHERE session_id = ? AND tool_name IN ('Agent', 'Task') AND tool_input IS NOT NULL
-       GROUP BY agent_type`
-    ).all(session_id) as Array<{ agent_type: string | null; count: number }>;
-  }
-
-  /** Tool usage distribution for a single session (non-null tool_name only). */
-  aggregateToolUsageBySession(session_id: string): Array<{ tool_name: string; count: number }> {
-    return this.db.prepare(
-      `SELECT tool_name, COUNT(*) as count FROM events
-       WHERE session_id = ? AND tool_name IS NOT NULL
-       GROUP BY tool_name ORDER BY count DESC`
-    ).all(session_id) as Array<{ tool_name: string; count: number }>;
-  }
-
-  /** Count of distinct active days (date(timestamp)) in [since, until). */
-  countActiveDays(opts: { since: string; until?: string }): number {
-    const conditions: string[] = ['timestamp >= ?'];
-    const params: unknown[] = [opts.since];
-    if (opts.until !== undefined) {
-      conditions.push('timestamp < ?');
-      params.push(opts.until);
-    }
-    const sql = `SELECT COUNT(DISTINCT date(timestamp)) as cnt FROM events
-                 WHERE ${conditions.join(' AND ')}`;
-    const row = this.db.prepare(sql).get(...params) as { cnt: number } | undefined;
-    return row?.cnt ?? 0;
-  }
-
-  /** Composite overview within [since, until): event count + distinct session count + distinct day count. */
-  aggregateOverviewByRange(opts: { since: string; until: string }): {
-    event_count: number;
-    session_count: number;
-    day_count: number;
-  } {
-    const row = this.db.prepare(
-      `SELECT COUNT(*) as cnt, COUNT(DISTINCT session_id) as sessionCount,
-              COUNT(DISTINCT date(timestamp)) as dayCount
-       FROM events
-       WHERE timestamp >= ? AND timestamp < ?`
-    ).get(opts.since, opts.until) as { cnt: number; sessionCount: number; dayCount: number } | undefined;
-    return {
-      event_count: row?.cnt ?? 0,
-      session_count: row?.sessionCount ?? 0,
-      day_count: row?.dayCount ?? 0,
-    };
-  }
-
-  /** Distinct, non-empty project_path values within [since, until). */
-  queryDistinctProjects(opts: { since: string; until: string }): string[] {
-    const rows = this.db.prepare(
-      `SELECT DISTINCT project_path FROM events
-       WHERE timestamp >= ? AND timestamp < ?
-         AND project_path IS NOT NULL AND project_path != ''`
-    ).all(opts.since, opts.until) as Array<{ project_path: string }>;
-    return rows.map(r => r.project_path);
-  }
-
-  /**
-   * PostToolUse failure rate within [since, until).
-   *
-   * Failure detection uses three LIKE branches on tool_output (preserved from
-   * weekly-report.ts original SQL):
-   *   - '%"error"%'
-   *   - '%"is_error":true%'
-   *   - '%"isError":true%'
-   */
-  aggregateToolFailureRate(opts: { since: string; until: string }): { post_total: number; failed: number } {
-    const totalRow = this.db.prepare(
-      `SELECT COUNT(*) as total FROM events
-       WHERE timestamp >= ? AND timestamp < ?
-         AND hook_type = 'PostToolUse'`
-    ).get(opts.since, opts.until) as { total: number } | undefined;
-
-    const failRow = this.db.prepare(
-      `SELECT COUNT(*) as failed FROM events
-       WHERE timestamp >= ? AND timestamp < ?
-         AND hook_type = 'PostToolUse'
-         AND tool_output IS NOT NULL
-         AND (tool_output LIKE '%"error"%'
-           OR tool_output LIKE '%"is_error":true%'
-           OR tool_output LIKE '%"isError":true%')`
-    ).get(opts.since, opts.until) as { failed: number } | undefined;
-
-    return {
-      post_total: totalRow?.total ?? 0,
-      failed: failRow?.failed ?? 0,
-    };
-  }
-
-  /**
-   * Raw tool_input JSON strings for file-edit tools within [since, until).
-   * Caller is responsible for JSON.parse / file_path extraction.
-   * Internal IN-list expansion of `tool_names`.
-   */
-  queryFileEditInputs(opts: { since: string; until: string; tool_names: string[] }): Array<{ tool_input: string }> {
-    if (opts.tool_names.length === 0) return [];
-    const placeholders = opts.tool_names.map(() => '?').join(',');
-    const sql = `SELECT tool_input FROM events
-                 WHERE timestamp >= ? AND timestamp < ?
-                   AND hook_type = 'PreToolUse'
-                   AND tool_name IN (${placeholders})
-                   AND tool_input IS NOT NULL`;
-    return this.db.prepare(sql).all(opts.since, opts.until, ...opts.tool_names) as Array<{ tool_input: string }>;
-  }
-
-  /** Full events in [since, until?), ascending by timestamp (used by anti-pattern-detector). */
-  queryEventsByTimeRange(opts: { since: string; until?: string }): ForgeEvent[] {
-    const conditions: string[] = ['timestamp >= ?'];
-    const params: unknown[] = [opts.since];
-    if (opts.until !== undefined) {
-      conditions.push('timestamp < ?');
-      params.push(opts.until);
-    }
-    const sql = `SELECT * FROM events WHERE ${conditions.join(' AND ')} ORDER BY timestamp ASC`;
-    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
-    return rows.map(r => this.rowToEvent(r));
-  }
-
-  rowToEvent(row: Record<string, unknown>): ForgeEvent {
-    // Runtime validation of database row
-    try {
-      const validatedRow = DatabaseRowSchema.parse(row);
-
-      return {
-        event_id: validatedRow.event_id,
-        session_id: validatedRow.session_id,
-        project_path: validatedRow.project_path,
-        timestamp: validatedRow.timestamp,
-        hook_type: validatedRow.hook_type as ForgeEvent['hook_type'],
-        tool_name: validatedRow.tool_name || undefined,
-        tool_input: validatedRow.tool_input ? JSON.parse(validatedRow.tool_input) : undefined,
-        tool_output: validatedRow.tool_output ? JSON.parse(validatedRow.tool_output) : undefined,
-        user_prompt: validatedRow.user_prompt || undefined,
-        ai_response: validatedRow.ai_response || undefined,
-      };
-    } catch (err) {
-      logger.error(`[EventOperations] Invalid database row: ${err}`);
-      // Return a safe fallback instead of throwing to prevent query failures
-      return {
-        event_id: String(row.event_id || 'unknown'),
-        session_id: String(row.session_id || 'unknown'),
-        project_path: String(row.project_path || ''),
-        timestamp: String(row.timestamp || new Date().toISOString()),
-        hook_type: 'UserPromptSubmit', // Safe default
-        tool_name: undefined,
-        tool_input: undefined,
-        tool_output: undefined,
-        user_prompt: undefined,
-        ai_response: undefined,
-      };
-    }
-  }
-}

package/src/core/storage/injections.ts

@@ -1,78 +0,0 @@
-/**
- * InjectionOperations — injections 表读写
- *
- * 拆分自 sqlite.ts。
- */
-
-import type Database from 'better-sqlite3';
-import { randomUUID } from 'node:crypto';
-
-export interface Injection {
-  id?: string;
-  event_id?: string;
-  session_id: string;
-  timestamp: string;
-  source_handler: string;
-  injection_type: 'systemMessage' | 'additionalContext' | 'reason';
-  content: string;
-}
-
-export class InjectionOperations {
-  constructor(private db: Database.Database) {}
-
-  writeInjection(injection: Injection): void {
-    const id = injection.id || randomUUID();
-    const stmt = this.db.prepare(`
-      INSERT INTO injections (id, event_id, session_id, timestamp, source_handler, injection_type, content)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(
-      id,
-      injection.event_id ?? null,
-      injection.session_id,
-      injection.timestamp,
-      injection.source_handler,
-      injection.injection_type,
-      injection.content,
-    );
-  }
-
-  queryInjections(filter: {
-    session_id?: string;
-    event_id?: string;
-    source_handler?: string;
-    limit?: number;
-  } = {}): Injection[] {
-    const conditions: string[] = [];
-    const params: unknown[] = [];
-
-    if (filter.session_id) {
-      conditions.push('session_id = ?');
-      params.push(filter.session_id);
-    }
-    if (filter.event_id) {
-      conditions.push('event_id = ?');
-      params.push(filter.event_id);
-    }
-    if (filter.source_handler) {
-      conditions.push('source_handler = ?');
-      params.push(filter.source_handler);
-    }
-
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-    const limit = filter.limit ?? 100;
-    const sql = `SELECT * FROM injections ${where} ORDER BY timestamp DESC LIMIT ?`;
-
-    params.push(limit);
-    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
-    return rows.map(r => ({
-      id: r.id as string,
-      event_id: (r.event_id as string) || undefined,
-      session_id: r.session_id as string,
-      timestamp: r.timestamp as string,
-      source_handler: r.source_handler as string,
-      injection_type: r.injection_type as Injection['injection_type'],
-      content: r.content as string,
-    }));
-  }
-}

package/src/core/storage/maintenance.ts

@@ -1,59 +0,0 @@
-/**
- * MaintenanceOperations — 数据清理 / VACUUM / 体积监控
- *
- * 拆分自 sqlite.ts。
- */
-
-import type Database from 'better-sqlite3';
-import { existsSync, statSync } from 'node:fs';
-import { logger } from '../utils/logger.js';
-
-export class MaintenanceOperations {
-  constructor(
-    private db: Database.Database,
-    private dbPath: string,
-  ) {}
-
-  /**
-   * Clean events older than specified days
-   * @param daysToKeep Number of days to keep (default: 30)
-   * @returns Number of events deleted
-   */
-  cleanOldEvents(daysToKeep: number = 30): number {
-    const cutoffDate = new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
-    const cutoff = cutoffDate.toISOString();
-
-    const result = this.db.prepare(`
-      DELETE FROM events WHERE timestamp < ?
-    `).run(cutoff);
-
-    const deleted = result.changes;
-    if (deleted > 0) {
-      logger.info(`[Storage] Cleaned ${deleted} events older than ${daysToKeep} days`);
-    }
-    return deleted;
-  }
-
-  runMaintenance(maxSizeMb: number): void {
-    const sizeMb = this.getDbSizeMb();
-    if (sizeMb < maxSizeMb) {
-      logger.debug(`[Storage] DB size ${sizeMb.toFixed(1)}MB < ${maxSizeMb}MB, skipping maintenance`);
-      return;
-    }
-
-    logger.info(`[Storage] Running maintenance (size: ${sizeMb.toFixed(1)}MB)`);
-
-    this.cleanOldEvents(30);
-    this.vacuum();
-  }
-
-  vacuum(): void {
-    this.db.exec('VACUUM');
-  }
-
-  getDbSizeMb(): number {
-    if (!existsSync(this.dbPath)) return 0;
-    return statSync(this.dbPath).size / (1024 * 1024);
-  }
-}

package/src/core/storage/migrations/002_add_skill_tracking.sql

@@ -1,6 +0,0 @@
--- Migration: 新增 Skill 监控字段
--- Date: 2026-05-11
--- Description: 为 routing_events 表新增 skill_confidence 和 skill_source 字段
-
-ALTER TABLE routing_events ADD COLUMN skill_confidence REAL;
-ALTER TABLE routing_events ADD COLUMN skill_source TEXT;

package/src/core/storage/migrations/003_add_skill_invocations.sql

@@ -1,23 +0,0 @@
--- Migration: 新增 skill_invocations 表
--- Date: 2026-05-11
--- Description: 追踪 Agent 动态调用 Skill 的链路
-
-CREATE TABLE IF NOT EXISTS skill_invocations (
-  id TEXT PRIMARY KEY,                     -- UUID
-  route_request_id TEXT,                   -- 关联外层路由（routing_events.route_request_id）
-  session_id TEXT NOT NULL,
-  agent_id TEXT,                           -- 发起调用的 Agent（可能为 NULL 如果是主 Claude）
-  skill_id TEXT NOT NULL,                  -- 被调用的 Skill ID
-  invocation_type TEXT NOT NULL,           -- 'static'（静态依赖） / 'dynamic'（动态调用） / 'slash_command'
-  reason TEXT,                             -- Agent 提供的调用理由
-  depth INTEGER DEFAULT 0,                 -- 调用嵌套深度
-  success INTEGER DEFAULT 1,               -- 1 成功 / 0 失败
-  error TEXT,                              -- 错误信息（如 skill 不存在）
-  timestamp INTEGER NOT NULL,              -- 调用时间戳（ms）
-  created_at TEXT DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_skill_invocations_route_request ON skill_invocations(route_request_id);
-CREATE INDEX IF NOT EXISTS idx_skill_invocations_session ON skill_invocations(session_id);
-CREATE INDEX IF NOT EXISTS idx_skill_invocations_skill ON skill_invocations(skill_id);
-CREATE INDEX IF NOT EXISTS idx_skill_invocations_timestamp ON skill_invocations(timestamp DESC);

package/src/core/storage/performance-indexes.sql

@@ -1,23 +0,0 @@
--- Performance optimization indexes
--- Add these indexes to improve query performance
-
--- Sessions table optimization
-CREATE INDEX IF NOT EXISTS idx_sessions_start_time ON sessions(start_time DESC);
-CREATE INDEX IF NOT EXISTS idx_sessions_end_time ON sessions(end_time DESC);
-CREATE INDEX IF NOT EXISTS idx_sessions_last_event ON sessions(last_event_time DESC);
-
--- V2 decisions table optimization (timestamp index)
-CREATE INDEX IF NOT EXISTS idx_v2_decisions_timestamp ON v2_decisions(timestamp DESC);
-
--- Injections table optimization
-CREATE INDEX IF NOT EXISTS idx_injections_handler ON injections(source_handler);
-
--- Tasks table optimization
-CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
-CREATE INDEX IF NOT EXISTS idx_tasks_start_time ON tasks(start_time DESC);
-CREATE INDEX IF NOT EXISTS idx_tasks_end_time ON tasks(end_time DESC);
-
--- Composite indexes for common query patterns
-CREATE INDEX IF NOT EXISTS idx_events_session_timestamp ON events(session_id, timestamp DESC);
-CREATE INDEX IF NOT EXISTS idx_events_project_timestamp ON events(project_path, timestamp DESC);
-CREATE INDEX IF NOT EXISTS idx_sessions_project_start ON sessions(project_path, start_time DESC);