@winspan/claude-forge 8.50.6 → 8.51.1

package/src/core/storage/events.ts

@@ -16,10 +16,6 @@ import { z } from 'zod';
 import type { ForgeEvent } from '../types.js';
 import { logger } from '../utils/logger.js';
 
-interface UpsertCapableEmitter extends EventEmitter {
-  upsertSession(event: ForgeEvent): void;
-}
-
 // Zod schema for runtime validation
 const ForgeEventSchema = z.object({
   event_id: z.string().uuid().optional(),
@@ -218,6 +214,189 @@ export class EventOperations {
     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 {

package/src/core/storage/routing.ts

@@ -127,7 +127,7 @@ export class RoutingOperations {
   }
 
   /** Pending events with NULL obeyed within the last N seconds; used by daemon restart recovery. */
-  findPendingRoutingEvents(ageMs: number): RoutingEventRow[] {
+  queryPendingRoutingEvents(ageMs: number): RoutingEventRow[] {
     const cutoff = Date.now() - ageMs;
     return this.db.prepare(
       `SELECT * FROM routing_events WHERE obeyed IS NULL AND ts >= ? ORDER BY ts DESC`
@@ -145,6 +145,30 @@ export class RoutingOperations {
     return row ?? null;
   }
 
+  /**
+   * Get the most recent PENDING routing_event for a session (obeyed IS NULL).
+   *
+   * Used by PostToolUseHandler to associate Agent invocations with the
+   * still-unfilled routing_event from the current user prompt. Returning only
+   * pending rows prevents the handler from re-overwriting an already-completed
+   * event (e.g. when 2+ Agents fire within the same prompt, or when an old
+   * obeyed=1 row leaks past a missed UserPromptSubmit).
+   *
+   * Trade-off: in the "same-prompt multi-Agent" case, the 2nd+ Agent will not
+   * find a pending row and will be silently skipped. Recording every Agent
+   * call is M7 out-of-scope (would require INSERT in PostToolUse rather than
+   * UPDATE).
+   */
+  getRecentPendingRoutingEvent(sessionId: string): { id: number } | null {
+    const row = this.db.prepare(`
+      SELECT id FROM routing_events
+      WHERE session_id = ? AND obeyed IS NULL
+      ORDER BY ts DESC
+      LIMIT 1
+    `).get(sessionId) as { id: number } | undefined;
+    return row ?? null;
+  }
+
   // ── Experiment Assignments ──────────────────────────────────────────────
 
   getExperimentAssignment(sessionId: string, experimentId: string): string | null {
@@ -161,6 +185,110 @@ export class RoutingOperations {
     ).run(sessionId, experimentId, groupId);
   }
 
+  // ── Aggregates (H1: SQL-side GROUP BY for routes/rules/skill-stats) ───
+  //
+  // 这些 aggregate* 方法把原本 routes 层做的"全表 SELECT + JS reduce"下沉到
+  // SQL 端，避免单进程内存放大。命名约定（spec H1 固化）：
+  //   - aggregate* —— SQL 端 GROUP BY / COUNT，返回小结果
+  //   - query*     —— 原始行返回（保留旧 API）
+  //
+  // 注意：所有方法都用 `ts > 0` 兜底，防止 strftime 在 ts<=0 时返回 NULL。
+
+  /**
+   * 一次性返回 rules + skill-stats 共用的 routing 汇总（4 个独立聚合，
+   * 各走自己的索引）。不走 UNION ALL（SQLite 无 GROUPING SETS）。
+   */
+  aggregateRoutingStats(filter: { since_ts: number; project_path?: string }): {
+    total: number;
+    obeyed: number;
+    refused: number;
+    unknown: number;
+    by_type: Array<{ type: 'agent' | 'skill' | 'none'; count: number }>;
+    by_agent: Array<{ agent: string; count: number }>;
+    by_skill_routed: Array<{ skill: string; count: number }>;
+  } {
+    const projectCond = filter.project_path ? 'AND project_path = @project' : '';
+    const params = {
+      since: filter.since_ts,
+      project: filter.project_path ?? null,
+    };
+
+    const totalRow = this.db.prepare(`
+      SELECT COUNT(*) AS total,
+             SUM(CASE WHEN obeyed=1 THEN 1 ELSE 0 END) AS obeyed,
+             SUM(CASE WHEN obeyed=0 THEN 1 ELSE 0 END) AS refused,
+             SUM(CASE WHEN obeyed IS NULL THEN 1 ELSE 0 END) AS unknown
+      FROM routing_events
+      WHERE ts > 0 AND ts >= @since ${projectCond}
+    `).get(params) as {
+      total: number | null;
+      obeyed: number | null;
+      refused: number | null;
+      unknown: number | null;
+    };
+
+    const byTypeRows = this.db.prepare(`
+      SELECT COALESCE(routed_to_type, 'none') AS type, COUNT(*) AS count
+      FROM routing_events
+      WHERE ts > 0 AND ts >= @since ${projectCond}
+      GROUP BY COALESCE(routed_to_type, 'none')
+      ORDER BY count DESC
+    `).all(params) as Array<{ type: 'agent' | 'skill' | 'none'; count: number }>;
+
+    const byAgentRows = this.db.prepare(`
+      SELECT routed_to_name AS agent, COUNT(*) AS count
+      FROM routing_events
+      WHERE ts > 0 AND ts >= @since AND obeyed = 1 AND routed_to_name IS NOT NULL ${projectCond}
+      GROUP BY routed_to_name
+      ORDER BY count DESC
+    `).all(params) as Array<{ agent: string; count: number }>;
+
+    const bySkillRoutedRows = this.db.prepare(`
+      SELECT routed_to_name AS skill, COUNT(*) AS count
+      FROM routing_events
+      WHERE ts > 0 AND ts >= @since AND routed_to_type = 'skill' AND routed_to_name IS NOT NULL ${projectCond}
+      GROUP BY routed_to_name
+      ORDER BY count DESC
+    `).all(params) as Array<{ skill: string; count: number }>;
+
+    return {
+      total: totalRow.total ?? 0,
+      obeyed: totalRow.obeyed ?? 0,
+      refused: totalRow.refused ?? 0,
+      unknown: totalRow.unknown ?? 0,
+      by_type: byTypeRows,
+      by_agent: byAgentRows,
+      by_skill_routed: bySkillRoutedRows,
+    };
+  }
+
+  /**
+   * 按天聚合 routing 事件，用于 skill-stats trend chart。
+   * 时区固定 UTC（strftime + unixepoch），与旧实现的 `new Date(ts).toISOString().split('T')[0]` 一致。
+   */
+  aggregateRoutingTrendByDay(filter: { since_ts: number }): Array<{
+    day: string;
+    total: number;
+    skill: number;
+  }> {
+    const rows = this.db.prepare(`
+      SELECT strftime('%Y-%m-%d', ts / 1000, 'unixepoch') AS day,
+             COUNT(*) AS total,
+             SUM(CASE WHEN routed_to_type = 'skill' THEN 1 ELSE 0 END) AS skill
+      FROM routing_events
+      WHERE ts > 0 AND ts >= @since
+      GROUP BY day
+      ORDER BY day ASC
+    `).all({ since: filter.since_ts }) as Array<{
+      day: string | null;
+      total: number;
+      skill: number | null;
+    }>;
+    return rows
+      .filter(r => r.day !== null)
+      .map(r => ({ day: r.day as string, total: r.total, skill: r.skill ?? 0 }));
+  }
+
   queryExperimentStats(experimentId: string): Array<{
     group_id: string;
     total: number;

package/src/core/storage/schema.sql

@@ -17,7 +17,10 @@
 --   └─ 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:
+-- token_usage (LLM token accounting)
+--   └─ token_usage.session_id     → events.session_id (logical, no FK)
+--
+-- Why no FK on routing_events / skill_invocations / token_usage:
 --   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
@@ -152,7 +155,7 @@ CREATE INDEX IF NOT EXISTS idx_routing_events_experiment ON routing_events(exper
 
 CREATE TABLE IF NOT EXISTS token_usage (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,  -- logical ref → events.session_id; no FK due to write-order race (sessions is aggregate, may lag)
     timestamp INTEGER NOT NULL,
     input_tokens INTEGER NOT NULL,
     output_tokens INTEGER NOT NULL,
@@ -212,3 +215,10 @@ CREATE INDEX IF NOT EXISTS idx_events_session_hook ON events(session_id, hook_ty
 
 -- injections: optimize session + handler composite queries
 CREATE INDEX IF NOT EXISTS idx_injections_session_handler ON injections(session_id, source_handler);
+
+-- routing_events: optimize routed_to_type distribution (H1 aggregate path)
+CREATE INDEX IF NOT EXISTS idx_routing_events_type_ts ON routing_events(routed_to_type, ts DESC);
+
+-- skill_invocations: optimize workflow/phase and feature_slug queries (H4 dedup: previously migration-only)
+CREATE INDEX IF NOT EXISTS idx_skill_invocations_workflow ON skill_invocations(workflow, phase);
+CREATE INDEX IF NOT EXISTS idx_skill_invocations_feature ON skill_invocations(feature_slug);

package/src/core/storage/sessions.ts

@@ -101,4 +101,68 @@ export class SessionOperations {
       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

@@ -70,6 +70,43 @@ export class SkillOperations {
     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 聚合工作流进度。
    *
@@ -161,4 +198,36 @@ export class SkillOperations {
       };
     });
   }
+
+  // ── 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);
+  }
 }