@winspan/claude-forge 8.41.0 → 8.50.6

package/src/core/storage/schema.sql

@@ -0,0 +1,214 @@
+-- Claude Forge SQLite Schema (core tables)
+-- Active tables: events, sessions, injections, tasks, task_events,
+-- routing_events, token_usage, skill_invocations
+--
+-- ── Table Relationships ──────────────────────────────────────────────────────
+--
+-- events (core fact table)
+--   └─ sessions.session_id        — aggregated from events (app-layer, no FK)
+--   └─ injections.event_id        — FK ON DELETE CASCADE
+--   └─ task_events.event_id       — FK ON DELETE CASCADE
+--
+-- routing_events (agent routing decisions)
+--   └─ routing_events.session_id  → events.session_id (logical, no FK)
+--   └─ skill_invocations.route_request_id → routing_events.route_request_id (logical, no FK)
+--
+-- skill_invocations (skill execution records)
+--   └─ skill_invocations.session_id       → events.session_id (logical, no FK)
+--   └─ skill_invocations.route_request_id → routing_events.route_request_id (logical, no FK)
+--
+-- Why no FK on routing_events / skill_invocations:
+--   1. routing_events.route_request_id is nullable and not UNIQUE — cannot be FK target
+--   2. Write order is not guaranteed: skill_invocations may be written before routing_events
+--   3. session_id references are maintained by application logic; sessions is an aggregate
+--      table that may lag behind event writes
+--   4. Indexes on join columns provide equivalent query performance to FK indexes
+--
+
+-- ── Events & Sessions ─────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS events (
+    event_id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    project_path TEXT NOT NULL,
+    timestamp TEXT NOT NULL,
+    hook_type TEXT NOT NULL CHECK(hook_type IN ('PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Notification', 'Stop')),
+    tool_name TEXT,
+    tool_input TEXT,
+    tool_output TEXT,
+    user_prompt TEXT,
+    ai_response TEXT,
+    distilled INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+CREATE INDEX IF NOT EXISTS idx_events_project ON events(project_path);
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_events_distilled ON events(distilled);
+CREATE INDEX IF NOT EXISTS idx_events_hook_type ON events(hook_type);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    session_id TEXT PRIMARY KEY,
+    project_path TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'interrupted', 'resumed', 'abandoned')),
+    first_prompt TEXT,
+    start_time TEXT NOT NULL,
+    end_time TEXT,
+    last_event_time TEXT,
+    event_count INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path);
+CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+CREATE INDEX IF NOT EXISTS idx_sessions_start_time ON sessions(start_time DESC);
+
+-- ── Injections ─────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS injections (
+    id TEXT PRIMARY KEY,
+    event_id TEXT,
+    session_id TEXT NOT NULL,
+    timestamp TEXT NOT NULL,
+    source_handler TEXT NOT NULL,
+    injection_type TEXT NOT NULL CHECK(injection_type IN ('systemMessage', 'additionalContext', 'reason')),
+    content TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_injections_session ON injections(session_id);
+CREATE INDEX IF NOT EXISTS idx_injections_event ON injections(event_id);
+CREATE INDEX IF NOT EXISTS idx_injections_timestamp ON injections(timestamp DESC);
+
+-- ── Tasks ──────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    start_time TEXT NOT NULL,
+    end_time TEXT,
+    status TEXT DEFAULT 'active' CHECK(status IN ('active', 'completed', 'abandoned')),
+    event_count INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS task_events (
+    task_id TEXT NOT NULL,
+    event_id TEXT NOT NULL,
+    PRIMARY KEY (task_id, event_id),
+    FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+    FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE
+);
+
+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_task_events_task ON task_events(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_events_event ON task_events(event_id);
+
+-- ── Routing Events (agent routing observability) ─────────────────────────
+
+CREATE TABLE IF NOT EXISTS routing_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    route_request_id TEXT,
+    project_path TEXT NOT NULL,
+    ts INTEGER NOT NULL,
+    prompt TEXT NOT NULL,
+    intent_json TEXT NOT NULL,
+    routed_to_type TEXT,
+    routed_to_name TEXT,
+    is_forced INTEGER DEFAULT 0,
+    obeyed INTEGER,
+    classification_ms INTEGER,
+    fallback_used INTEGER DEFAULT 0,
+    refusal_reason TEXT,
+    first_tool_name TEXT,
+    first_tool_ts INTEGER,
+    completed_ts INTEGER,
+    total_execution_ms INTEGER,
+    completion_reason TEXT,
+    downstream_task_chain TEXT,
+    injection_version TEXT,
+    experiment_id TEXT,
+    experiment_group TEXT,
+    skill_confidence REAL,
+    skill_source TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_routing_events_session ON routing_events(session_id);
+CREATE INDEX IF NOT EXISTS idx_routing_events_route_request ON routing_events(route_request_id);
+CREATE INDEX IF NOT EXISTS idx_routing_events_ts ON routing_events(ts DESC);
+CREATE INDEX IF NOT EXISTS idx_routing_events_agent ON routing_events(routed_to_name, obeyed);
+CREATE INDEX IF NOT EXISTS idx_routing_events_obeyed ON routing_events(obeyed);
+CREATE INDEX IF NOT EXISTS idx_routing_events_experiment ON routing_events(experiment_id, experiment_group);
+
+-- ── Token Usage ──────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS token_usage (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    timestamp INTEGER NOT NULL,
+    input_tokens INTEGER NOT NULL,
+    output_tokens INTEGER NOT NULL,
+    total_tokens INTEGER NOT NULL,
+    model TEXT,
+    tool_name TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_token_usage_session ON token_usage(session_id);
+CREATE INDEX IF NOT EXISTS idx_token_usage_timestamp ON token_usage(timestamp DESC);
+
+-- ── Skill Invocations ─────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS skill_invocations (
+    id TEXT PRIMARY KEY,
+    route_request_id TEXT,
+    session_id TEXT NOT NULL,
+    agent_id TEXT,
+    skill_id TEXT NOT NULL,
+    invocation_type TEXT NOT NULL,
+    reason TEXT,
+    workflow TEXT,
+    phase TEXT,
+    feature_slug TEXT,
+    artifact_path TEXT,
+    depth INTEGER DEFAULT 0,
+    success INTEGER DEFAULT 1,
+    error TEXT,
+    timestamp INTEGER NOT NULL,
+    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);
+
+-- ── Composite Indexes (high-frequency query optimization) ─────────────────────
+-- These cover session-scoped queries that filter by session_id then sort by time.
+-- Existing single-column indexes are retained for other query paths.
+
+CREATE INDEX IF NOT EXISTS idx_events_session_ts ON events(session_id, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_routing_events_session_ts ON routing_events(session_id, ts DESC);
+CREATE INDEX IF NOT EXISTS idx_skill_invocations_session_ts ON skill_invocations(session_id, timestamp DESC);
+
+-- ── Additional Performance Indexes (Phase 1 Refactor) ─────────────────────
+
+-- routing_events: optimize obeyed flag queries with time sorting
+CREATE INDEX IF NOT EXISTS idx_routing_events_obeyed_ts ON routing_events(obeyed, ts DESC);
+
+-- tasks: optimize filter+sort queries (start_time range filter + session join)
+CREATE INDEX IF NOT EXISTS idx_tasks_start_time_session ON tasks(start_time DESC, session_id);
+
+-- events: optimize session + hook_type composite queries
+CREATE INDEX IF NOT EXISTS idx_events_session_hook ON events(session_id, hook_type, timestamp DESC);
+
+-- injections: optimize session + handler composite queries
+CREATE INDEX IF NOT EXISTS idx_injections_session_handler ON injections(session_id, source_handler);

package/src/core/storage/sessions.ts

@@ -0,0 +1,104 @@
+/**
+ * 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,
+    }));
+  }
+}

package/src/core/storage/skills.ts

@@ -0,0 +1,164 @@
+/**
+ * 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[];
+  }
+
+  /**
+   * 按 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,
+      };
+    });
+  }
+}

package/src/core/storage/sqlite.ts

@@ -0,0 +1,194 @@
+/**
+ * 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 ─────────────────────────────────────────────────
+  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);
+  }
+
+  // ── Session operations ─────────────────────────────────────────────────
+  upsertSession(event: ForgeEvent): void { this.sessions.upsertSession(event); }
+  querySessions(filter: Parameters<SessionOperations['querySessions']>[0] = {}): SessionSummary[] {
+    return this.sessions.querySessions(filter);
+  }
+
+  // ── 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();
+  }
+  getTaskEventIds(taskId: string): string[] { return this.tasks.getTaskEventIds(taskId); }
+
+  // ── 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);
+  }
+  findPendingRoutingEvents(ageMs: number): RoutingEventRow[] {
+    return this.routing.findPendingRoutingEvents(ageMs);
+  }
+  getRecentRoutingEvent(sessionId: string): { id: number } | null {
+    return this.routing.getRecentRoutingEvent(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 ────────────────────────────────────────────────────────
+  recordTokenUsage(params: Parameters<TokenUsageOperations['recordTokenUsage']>[0]): void {
+    this.tokenUsage.recordTokenUsage(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);
+  }
+  queryWorkflowProgress(filter: Parameters<SkillOperations['queryWorkflowProgress']>[0] = {}): ReturnType<SkillOperations['queryWorkflowProgress']> {
+    return this.skills.queryWorkflowProgress(filter);
+  }
+
+  // ── 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}`);
+    }
+  }
+}