@winspan/claude-forge 8.41.0 → 8.51.0

package/src/core/storage/sessions.ts

@@ -0,0 +1,168 @@
+/**
+ * SessionOperations — sessions 聚合表读写
+ *
+ * 拆分自 sqlite.ts。负责：
+ * - upsertSession：每次 writeEvent 后被调用，更新 sessions 聚合
+ * - querySessions：直接读聚合表，O(sessions) 而非 O(sessions × events)
+ */
+
+import type Database from 'better-sqlite3';
+import type { ForgeEvent } from '../types.js';
+
+export interface SessionSummary {
+  session_id: string;
+  first_prompt: string;
+  event_count: number;
+  start_time: string;
+  end_time: string;
+}
+
+export class SessionOperations {
+  constructor(private db: Database.Database) {}
+
+  /**
+   * 将事件聚合到 sessions 表，供 querySessions 直接读取。
+   *
+   * 语义：
+   * - 首次出现 session_id → 插入一行
+   * - 已存在 → event_count += 1，end/last_event_time 取更晚的，first_prompt 只在
+   *   原值为 NULL 时才被 UserPromptSubmit 的前 200 字填充
+   */
+  upsertSession(event: ForgeEvent): void {
+    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,
+    );
+  }
+
+  querySessions(filter: {
+    project_path?: string;
+    limit?: number;
+  } = {}): SessionSummary[] {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (filter.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;
+
+    const sql = `
+      SELECT
+        session_id,
+        first_prompt,
+        event_count,
+        start_time,
+        COALESCE(end_time, last_event_time, start_time) AS end_time
+      FROM sessions
+      ${where}
+      ORDER BY start_time DESC
+      LIMIT ?
+    `;
+
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
+    return rows.map(r => ({
+      session_id: r.session_id as string,
+      first_prompt: (r.first_prompt as string) || '',
+      event_count: (r.event_count as number) ?? 0,
+      start_time: r.start_time as string,
+      end_time: r.end_time as string,
+    }));
+  }
+
+  // ── H2: 聚合 / 计数方法 ───────────────────────────────────────────────
+
+  /** Total session row count. */
+  countAllSessions(): number {
+    const row = this.db.prepare('SELECT COUNT(*) as cnt FROM sessions').get() as { cnt: number };
+    return row.cnt;
+  }
+
+  /** Per-day session counts (date(start_time) → count) within [since, until). */
+  aggregateDailySessionCounts(opts: { since: string; until?: string }): Array<{ date: string; count: number }> {
+    const conditions: string[] = ['start_time >= ?'];
+    const params: unknown[] = [opts.since];
+    if (opts.until !== undefined) {
+      conditions.push('start_time < ?');
+      params.push(opts.until);
+    }
+    const sql = `SELECT date(start_time) as date, COUNT(*) as count FROM sessions
+                 WHERE ${conditions.join(' AND ')}
+                 GROUP BY date ORDER BY date`;
+    return this.db.prepare(sql).all(...params) as Array<{ date: string; count: number }>;
+  }
+
+  /** Sessions with start_time in [since, until?), ordered by start_time DESC. */
+  querySessionsByTimeRange(opts: { since: string; until?: string }): SessionSummary[] {
+    const conditions: string[] = ['start_time >= ?'];
+    const params: unknown[] = [opts.since];
+    if (opts.until !== undefined) {
+      conditions.push('start_time < ?');
+      params.push(opts.until);
+    }
+    const sql = `
+      SELECT
+        session_id,
+        first_prompt,
+        event_count,
+        start_time,
+        COALESCE(end_time, last_event_time, start_time) AS end_time
+      FROM sessions
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY start_time DESC
+    `;
+    const rows = this.db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
+    return rows.map(r => ({
+      session_id: r.session_id as string,
+      first_prompt: (r.first_prompt as string) || '',
+      event_count: (r.event_count as number) ?? 0,
+      start_time: r.start_time as string,
+      end_time: r.end_time as string,
+    }));
+  }
+
+  /** Count of sessions with start_time in [since, until?). */
+  countSessionsByRange(opts: { since: string; until?: string }): number {
+    const conditions: string[] = ['start_time >= ?'];
+    const params: unknown[] = [opts.since];
+    if (opts.until !== undefined) {
+      conditions.push('start_time < ?');
+      params.push(opts.until);
+    }
+    const sql = `SELECT COUNT(*) as cnt FROM sessions WHERE ${conditions.join(' AND ')}`;
+    const row = this.db.prepare(sql).get(...params) as { cnt: number } | undefined;
+    return row?.cnt ?? 0;
+  }
+}

package/src/core/storage/skills.ts

@@ -0,0 +1,233 @@
+/**
+ * SkillOperations — skill_invocations 表读写 + 工作流聚合查询
+ *
+ * 拆分自 sqlite.ts。
+ */
+
+import type Database from 'better-sqlite3';
+import type { SkillInvocationRow } from './rows.js';
+
+export class SkillOperations {
+  constructor(private db: Database.Database) {}
+
+  writeSkillInvocation(row: Omit<SkillInvocationRow, 'created_at'>): void {
+    const sql = `INSERT INTO skill_invocations
+      (id, route_request_id, session_id, agent_id, skill_id, invocation_type,
+       reason, workflow, phase, feature_slug, artifact_path,
+       depth, success, error, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+    this.db.prepare(sql).run(
+      row.id,
+      row.route_request_id,
+      row.session_id,
+      row.agent_id,
+      row.skill_id,
+      row.invocation_type,
+      row.reason,
+      row.workflow,
+      row.phase,
+      row.feature_slug,
+      row.artifact_path,
+      row.depth,
+      row.success,
+      row.error,
+      row.timestamp,
+    );
+  }
+
+  querySkillInvocations(filter: {
+    route_request_id?: string;
+    session_id?: string;
+    skill_id?: string;
+    since?: number;
+    limit?: number;
+  } = {}): SkillInvocationRow[] {
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (filter.route_request_id) {
+      conditions.push('route_request_id = ?');
+      params.push(filter.route_request_id);
+    }
+    if (filter.session_id) {
+      conditions.push('session_id = ?');
+      params.push(filter.session_id);
+    }
+    if (filter.skill_id) {
+      conditions.push('skill_id = ?');
+      params.push(filter.skill_id);
+    }
+    if (filter.since !== undefined) {
+      conditions.push('timestamp >= ?');
+      params.push(filter.since);
+    }
+
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filter.limit ?? 100;
+    const sql = `SELECT * FROM skill_invocations ${where} ORDER BY timestamp DESC LIMIT ?`;
+
+    params.push(limit);
+    return this.db.prepare(sql).all(...params) as SkillInvocationRow[];
+  }
+
+  /**
+   * H1: 按 skill_id 聚合调用总数 / 成功 / 失败。
+   *
+   * 取代 routes 层的"全表 querySkillInvocations + JS reduce"。
+   * 走 `idx_skill_invocations_timestamp`。
+   */
+  aggregateSkillInvocationsBySkill(filter: { since: number; limit?: number }): Array<{
+    skill_id: string;
+    total: number;
+    success: number;
+    failed: number;
+  }> {
+    const limit = filter.limit ?? 1000;
+    const rows = this.db.prepare(`
+      SELECT skill_id,
+             COUNT(*) AS total,
+             SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) AS success,
+             SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) AS failed
+      FROM skill_invocations
+      WHERE timestamp >= ?
+      GROUP BY skill_id
+      ORDER BY total DESC
+      LIMIT ?
+    `).all(filter.since, limit) as Array<{
+      skill_id: string;
+      total: number;
+      success: number | null;
+      failed: number | null;
+    }>;
+    return rows.map(r => ({
+      skill_id: r.skill_id,
+      total: r.total,
+      success: r.success ?? 0,
+      failed: r.failed ?? 0,
+    }));
+  }
+
+  /**
+   * 按 route_request_id 聚合工作流进度。
+   *
+   * 用途：Web UI 展示「某次路由 / 某个 session 走完了哪些 phase」。仅聚合
+   * `workflow IS NOT NULL` 的调用（工作流型 reason），普通调用不会被纳入。
+   */
+  queryWorkflowProgress(filter: {
+    session_id?: string;
+    workflow?: string;
+    limit?: number;
+  } = {}): Array<{
+    route_request_id: string;
+    workflow: string;
+    phases_completed: string[];
+    feature_slug: string | null;
+    total_invocations: number;
+    success_count: number;
+    first_at: number;
+    last_at: number;
+  }> {
+    const conditions: string[] = ['workflow IS NOT NULL', 'route_request_id IS NOT NULL'];
+    const params: unknown[] = [];
+
+    if (filter.session_id) {
+      conditions.push('session_id = ?');
+      params.push(filter.session_id);
+    }
+    if (filter.workflow) {
+      conditions.push('workflow = ?');
+      params.push(filter.workflow);
+    }
+
+    const where = `WHERE ${conditions.join(' AND ')}`;
+    const limit = filter.limit ?? 100;
+
+    const sql = `
+      SELECT
+        route_request_id,
+        workflow,
+        GROUP_CONCAT(phase, '||') AS phases_raw,
+        MIN(feature_slug) AS feature_slug,
+        COUNT(*) AS total_invocations,
+        SUM(success) AS success_count,
+        MIN(timestamp) AS first_at,
+        MAX(timestamp) AS last_at
+      FROM (
+        SELECT * FROM skill_invocations
+        ${where}
+        ORDER BY timestamp ASC
+      )
+      GROUP BY route_request_id, workflow
+      ORDER BY last_at DESC
+      LIMIT ?
+    `;
+
+    type AggRow = {
+      route_request_id: string;
+      workflow: string;
+      phases_raw: string | null;
+      feature_slug: string | null;
+      total_invocations: number;
+      success_count: number | null;
+      first_at: number;
+      last_at: number;
+    };
+
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params) as AggRow[];
+
+    return rows.map(r => {
+      const phases = r.phases_raw ? r.phases_raw.split('||').filter(Boolean) : [];
+      const seen = new Set<string>();
+      const phases_completed: string[] = [];
+      for (const p of phases) {
+        if (!seen.has(p)) {
+          seen.add(p);
+          phases_completed.push(p);
+        }
+      }
+      return {
+        route_request_id: r.route_request_id,
+        workflow: r.workflow,
+        phases_completed,
+        feature_slug: r.feature_slug,
+        total_invocations: r.total_invocations,
+        success_count: r.success_count ?? 0,
+        first_at: r.first_at,
+        last_at: r.last_at,
+      };
+    });
+  }
+
+  // ── H2: 计数 / 列表方法 ──────────────────────────────────────────────
+
+  /** Total skill_invocations row count. */
+  countAllSkillInvocations(): number {
+    const row = this.db.prepare('SELECT COUNT(*) as cnt FROM skill_invocations').get() as { cnt: number };
+    return row.cnt;
+  }
+
+  /** Skill invocation count for a single session. */
+  countSkillInvocationsBySession(session_id: string): number {
+    const row = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM skill_invocations WHERE session_id = ?`
+    ).get(session_id) as { cnt: number } | undefined;
+    return row?.cnt ?? 0;
+  }
+
+  /** Distinct skill_id count since `since_ms` (unix ms). */
+  countDistinctSkillsSince(since_ms: number): number {
+    const row = this.db.prepare(
+      `SELECT COUNT(DISTINCT skill_id) as cnt FROM skill_invocations WHERE timestamp >= ?`
+    ).get(since_ms) as { cnt: number } | undefined;
+    return row?.cnt ?? 0;
+  }
+
+  /** Distinct skill_id values for a single session. */
+  queryDistinctSkillIdsBySession(session_id: string): string[] {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT skill_id FROM skill_invocations WHERE session_id = ?`
+    ).all(session_id) as Array<{ skill_id: string }>;
+    return rows.map(r => r.skill_id);
+  }
+}

package/src/core/storage/sqlite.ts

@@ -0,0 +1,293 @@
+/**
+ * SQLiteStorage — 装配入口（facade）
+ *
+ * 历史上这是一个 1000+ 行的单文件实现。重构后职责拆分到独立的 *Operations 类，
+ * 此文件保留为：
+ *   - 组合 db 实例 + 各个 Operations
+ *   - 保持原有 API 完全向后兼容（方法签名 / EventEmitter 行为 / 类型 re-export）
+ *
+ * 职责矩阵：
+ *   base.ts          — 数据库连接、schema、迁移
+ *   events.ts        — events 表读写
+ *   sessions.ts      — sessions 聚合表
+ *   tasks.ts         — tasks / task_events
+ *   injections.ts    — injections
+ *   routing.ts       — routing_events + experiment_assignments
+ *   skills.ts        — skill_invocations + workflow 聚合
+ *   token-usage.ts   — token_usage
+ *   maintenance.ts   — 清理 / VACUUM
+ */
+
+import { EventEmitter } from 'node:events';
+import type Database from 'better-sqlite3';
+import type { ForgeEvent } from '../types.js';
+import { SQLiteBase } from './base.js';
+import { EventOperations } from './events.js';
+import { SessionOperations } from './sessions.js';
+import { TaskOperations } from './tasks.js';
+import { InjectionOperations } from './injections.js';
+import { RoutingOperations } from './routing.js';
+import { SkillOperations } from './skills.js';
+import { TokenUsageOperations } from './token-usage.js';
+import { MaintenanceOperations } from './maintenance.js';
+import { logger } from '../utils/logger.js';
+import type { SkillInvocationRow } from './rows.js';
+import type {
+  RoutingEventRecord,
+  RoutingEventRow,
+} from './routing.js';
+import type { SessionSummary } from './sessions.js';
+import type { Injection } from './injections.js';
+import type { TaskRecord } from './tasks.js';
+
+// Re-export row types so existing consumers can import from './sqlite.js'.
+export type {
+  EventRow,
+  SessionRow,
+  InjectionRow,
+  TaskRow,
+  TokenUsageRow,
+  SkillInvocationRow,
+} from './rows.js';
+
+// Re-export operation-level types from their new homes (向后兼容)
+export type { SessionSummary } from './sessions.js';
+export type { Injection } from './injections.js';
+export type { TaskRecord, TaskFilter, TaskPage } from './tasks.js';
+export type { RoutingEventRecord, RoutingEventRow } from './routing.js';
+
+export class SQLiteStorage extends EventEmitter {
+  private base: SQLiteBase;
+  private events: EventOperations;
+  private sessions: SessionOperations;
+  private tasks: TaskOperations;
+  private injections: InjectionOperations;
+  private routing: RoutingOperations;
+  private skills: SkillOperations;
+  private tokenUsage: TokenUsageOperations;
+  private maintenance: MaintenanceOperations;
+
+  constructor(dbPath: string) {
+    super();
+    this.base = new SQLiteBase(dbPath);
+
+    const db = this.base.getDatabase();
+    this.sessions = new SessionOperations(db);
+    this.events = new EventOperations(db, this);
+    this.tasks = new TaskOperations(db);
+    this.injections = new InjectionOperations(db);
+    this.routing = new RoutingOperations(db);
+    this.skills = new SkillOperations(db);
+    this.tokenUsage = new TokenUsageOperations(db);
+    this.maintenance = new MaintenanceOperations(db, dbPath);
+  }
+
+  // ── Database accessors ─────────────────────────────────────────────────
+  /** @internal 见 SQLiteBase.getDatabase 注释。Routes/Handlers/Analytics 禁止调用。 */
+  getDatabase(): Database.Database { return this.base.getDatabase(); }
+  getDbPath(): string { return this.base.getDbPath(); }
+
+  // ── Event operations ────────────────────────────────────────────────────
+  writeEvent(event: ForgeEvent): void { this.events.writeEvent(event); }
+  queryEvents(filter: Parameters<EventOperations['queryEvents']>[0]): ForgeEvent[] {
+    return this.events.queryEvents(filter);
+  }
+  countEvents(filter?: Parameters<EventOperations['countEvents']>[0]): number { return this.events.countEvents(filter); }
+  searchEvents(filter: Parameters<EventOperations['searchEvents']>[0]): ForgeEvent[] {
+    return this.events.searchEvents(filter);
+  }
+
+  // ── H2: Event aggregates (前 routes/handlers/analytics 越权 SQL) ──
+  countAllEvents(): number { return this.events.countAllEvents(); }
+  aggregateToolUsage(opts?: Parameters<EventOperations['aggregateToolUsage']>[0]): ReturnType<EventOperations['aggregateToolUsage']> {
+    return this.events.aggregateToolUsage(opts);
+  }
+  aggregateDailyEventCounts(opts: Parameters<EventOperations['aggregateDailyEventCounts']>[0]): ReturnType<EventOperations['aggregateDailyEventCounts']> {
+    return this.events.aggregateDailyEventCounts(opts);
+  }
+  aggregateHookTypeBySession(session_id: string): ReturnType<EventOperations['aggregateHookTypeBySession']> {
+    return this.events.aggregateHookTypeBySession(session_id);
+  }
+  aggregateAgentTypeBySession(session_id: string): ReturnType<EventOperations['aggregateAgentTypeBySession']> {
+    return this.events.aggregateAgentTypeBySession(session_id);
+  }
+  aggregateToolUsageBySession(session_id: string): ReturnType<EventOperations['aggregateToolUsageBySession']> {
+    return this.events.aggregateToolUsageBySession(session_id);
+  }
+  countActiveDays(opts: Parameters<EventOperations['countActiveDays']>[0]): number {
+    return this.events.countActiveDays(opts);
+  }
+  aggregateOverviewByRange(opts: Parameters<EventOperations['aggregateOverviewByRange']>[0]): ReturnType<EventOperations['aggregateOverviewByRange']> {
+    return this.events.aggregateOverviewByRange(opts);
+  }
+  queryDistinctProjects(opts: Parameters<EventOperations['queryDistinctProjects']>[0]): string[] {
+    return this.events.queryDistinctProjects(opts);
+  }
+  aggregateToolFailureRate(opts: Parameters<EventOperations['aggregateToolFailureRate']>[0]): ReturnType<EventOperations['aggregateToolFailureRate']> {
+    return this.events.aggregateToolFailureRate(opts);
+  }
+  queryFileEditInputs(opts: Parameters<EventOperations['queryFileEditInputs']>[0]): ReturnType<EventOperations['queryFileEditInputs']> {
+    return this.events.queryFileEditInputs(opts);
+  }
+  queryEventsByTimeRange(opts: Parameters<EventOperations['queryEventsByTimeRange']>[0]): ForgeEvent[] {
+    return this.events.queryEventsByTimeRange(opts);
+  }
+
+  // ── Session operations ─────────────────────────────────────────────────
+  upsertSession(event: ForgeEvent): void { this.sessions.upsertSession(event); }
+  querySessions(filter: Parameters<SessionOperations['querySessions']>[0] = {}): SessionSummary[] {
+    return this.sessions.querySessions(filter);
+  }
+  // ── H2: Session aggregates ──
+  countAllSessions(): number { return this.sessions.countAllSessions(); }
+  aggregateDailySessionCounts(opts: Parameters<SessionOperations['aggregateDailySessionCounts']>[0]): ReturnType<SessionOperations['aggregateDailySessionCounts']> {
+    return this.sessions.aggregateDailySessionCounts(opts);
+  }
+  querySessionsByTimeRange(opts: Parameters<SessionOperations['querySessionsByTimeRange']>[0]): SessionSummary[] {
+    return this.sessions.querySessionsByTimeRange(opts);
+  }
+  countSessionsByRange(opts: Parameters<SessionOperations['countSessionsByRange']>[0]): number {
+    return this.sessions.countSessionsByRange(opts);
+  }
+
+  // ── Injection operations ───────────────────────────────────────────────
+  writeInjection(injection: Injection): void { this.injections.writeInjection(injection); }
+  queryInjections(filter: Parameters<InjectionOperations['queryInjections']>[0] = {}): Injection[] {
+    return this.injections.queryInjections(filter);
+  }
+
+  // ── Task operations ─────────────────────────────────────────────────
+  writeTask(task: { id: string; session_id: string; title: string; start_time: string }): void {
+    this.tasks.writeTask(task);
+  }
+  updateTask(taskId: string, updates: { end_time?: string; status?: string; event_count?: number; title?: string }): void {
+    this.tasks.updateTask(taskId, updates);
+  }
+  linkEventToTask(taskId: string, eventId: string): void {
+    this.tasks.linkEventToTask(taskId, eventId);
+  }
+  queryTasks(filter: Parameters<TaskOperations['queryTasks']>[0] = {}): TaskRecord[] {
+    return this.tasks.queryTasks(filter);
+  }
+  queryTasksFiltered(filter: Parameters<TaskOperations['queryTasksFiltered']>[0] = {}): import('./tasks.js').TaskPage {
+    return this.tasks.queryTasksFiltered(filter);
+  }
+  queryTaskProjects(): string[] {
+    return this.tasks.queryTaskProjects();
+  }
+  // ── H2: Task counts ──
+  countTasksByRange(opts: Parameters<TaskOperations['countTasksByRange']>[0]): number {
+    return this.tasks.countTasksByRange(opts);
+  }
+  getTaskEventIds(taskId: string): string[] { return this.tasks.getTaskEventIds(taskId); }
+  completeStaleActiveTasks(idleMinutes: number): number {
+    return this.tasks.completeStaleActiveTasks(idleMinutes);
+  }
+  getTask(taskId: string): TaskRecord | null {
+    return this.tasks.getTask(taskId);
+  }
+  queryEventsByTaskId(taskId: string, opts?: Parameters<TaskOperations['queryEventsByTaskId']>[1]): ForgeEvent[] {
+    return this.tasks.queryEventsByTaskId(taskId, opts);
+  }
+  queryInjectionsByTaskId(taskId: string): Injection[] {
+    return this.tasks.queryInjectionsByTaskId(taskId);
+  }
+  querySkillInvocationsByTaskWindow(
+    taskId: string,
+    opts?: Parameters<TaskOperations['querySkillInvocationsByTaskWindow']>[1],
+  ): SkillInvocationRow[] {
+    return this.tasks.querySkillInvocationsByTaskWindow(taskId, opts);
+  }
+
+  // ── Routing events ─────────────────────────────────────────────────────
+  writeRoutingEvent(record: RoutingEventRecord): number {
+    return this.routing.writeRoutingEvent(record);
+  }
+  updateRoutingEvent(id: number, patch: Partial<RoutingEventRecord>): void {
+    this.routing.updateRoutingEvent(id, patch);
+  }
+  queryRoutingEvents(filter: Parameters<RoutingOperations['queryRoutingEvents']>[0] = {}): RoutingEventRow[] {
+    return this.routing.queryRoutingEvents(filter);
+  }
+  aggregateRoutingStats(
+    filter: Parameters<RoutingOperations['aggregateRoutingStats']>[0],
+  ): ReturnType<RoutingOperations['aggregateRoutingStats']> {
+    return this.routing.aggregateRoutingStats(filter);
+  }
+  aggregateRoutingTrendByDay(
+    filter: Parameters<RoutingOperations['aggregateRoutingTrendByDay']>[0],
+  ): ReturnType<RoutingOperations['aggregateRoutingTrendByDay']> {
+    return this.routing.aggregateRoutingTrendByDay(filter);
+  }
+  queryPendingRoutingEvents(ageMs: number): RoutingEventRow[] {
+    return this.routing.queryPendingRoutingEvents(ageMs);
+  }
+  getRecentRoutingEvent(sessionId: string): { id: number } | null {
+    return this.routing.getRecentRoutingEvent(sessionId);
+  }
+  getRecentPendingRoutingEvent(sessionId: string): { id: number } | null {
+    return this.routing.getRecentPendingRoutingEvent(sessionId);
+  }
+
+  // ── Experiment assignments ─────────────────────────────────────────────
+  getExperimentAssignment(sessionId: string, experimentId: string): string | null {
+    return this.routing.getExperimentAssignment(sessionId, experimentId);
+  }
+  setExperimentAssignment(sessionId: string, experimentId: string, groupId: string): void {
+    this.routing.setExperimentAssignment(sessionId, experimentId, groupId);
+  }
+  queryExperimentStats(experimentId: string): ReturnType<RoutingOperations['queryExperimentStats']> {
+    return this.routing.queryExperimentStats(experimentId);
+  }
+
+  // ── Token usage ────────────────────────────────────────────────────────
+  writeTokenUsage(params: Parameters<TokenUsageOperations['writeTokenUsage']>[0]): void {
+    this.tokenUsage.writeTokenUsage(params);
+  }
+  getTokenUsageBySession(session_id: string): ReturnType<TokenUsageOperations['getTokenUsageBySession']> {
+    return this.tokenUsage.getTokenUsageBySession(session_id);
+  }
+  listTokenUsage(filter: Parameters<TokenUsageOperations['listTokenUsage']>[0] = {}): ReturnType<TokenUsageOperations['listTokenUsage']> {
+    return this.tokenUsage.listTokenUsage(filter);
+  }
+
+  // ── Skill invocations ──────────────────────────────────────────────────
+  writeSkillInvocation(row: Omit<SkillInvocationRow, 'created_at'>): void {
+    this.skills.writeSkillInvocation(row);
+  }
+  querySkillInvocations(filter: Parameters<SkillOperations['querySkillInvocations']>[0] = {}): SkillInvocationRow[] {
+    return this.skills.querySkillInvocations(filter);
+  }
+  aggregateSkillInvocationsBySkill(
+    filter: Parameters<SkillOperations['aggregateSkillInvocationsBySkill']>[0],
+  ): ReturnType<SkillOperations['aggregateSkillInvocationsBySkill']> {
+    return this.skills.aggregateSkillInvocationsBySkill(filter);
+  }
+  queryWorkflowProgress(filter: Parameters<SkillOperations['queryWorkflowProgress']>[0] = {}): ReturnType<SkillOperations['queryWorkflowProgress']> {
+    return this.skills.queryWorkflowProgress(filter);
+  }
+  // ── H2: Skill counts ──
+  countAllSkillInvocations(): number { return this.skills.countAllSkillInvocations(); }
+  countSkillInvocationsBySession(session_id: string): number {
+    return this.skills.countSkillInvocationsBySession(session_id);
+  }
+  countDistinctSkillsSince(since_ms: number): number {
+    return this.skills.countDistinctSkillsSince(since_ms);
+  }
+  queryDistinctSkillIdsBySession(session_id: string): string[] {
+    return this.skills.queryDistinctSkillIdsBySession(session_id);
+  }
+
+  // ── Maintenance ────────────────────────────────────────────────────────
+  cleanOldEvents(daysToKeep: number = 30): number { return this.maintenance.cleanOldEvents(daysToKeep); }
+  runMaintenance(maxSizeMb: number): void { this.maintenance.runMaintenance(maxSizeMb); }
+  vacuum(): void { this.maintenance.vacuum(); }
+
+  close(): void {
+    try {
+      this.base.getDatabase().close();
+    } catch (err) {
+      logger.warn(`Failed to close database: ${err}`);
+    }
+  }
+}