@winspan/claude-forge 8.41.0 → 8.51.0

package/src/core/storage/events.ts

@@ -0,0 +1,434 @@
+/**
+ * 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

@@ -0,0 +1,78 @@
+/**
+ * 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

@@ -0,0 +1,59 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+-- 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

@@ -0,0 +1,23 @@
+-- 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

@@ -0,0 +1,23 @@
+-- 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);