@morlay/session-rdb 0.0.21-alpha.2 → 0.0.21-alpha.4

package/src/sqlite.ts

@@ -11,12 +11,21 @@ import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistenc
 import {
   type Backend,
   type BackendTx,
+  type EventCountBucket,
   type EventInsert,
   type EventRow,
   type SessionRow,
 } from "./backend.ts";
 import { sessionConflictRow, sessionInsertRow, titleOfEventData, usageRowOf } from "./log.ts";
-import type { UsageAggregate, UsageTotals } from "./usage.ts";
+import {
+  COUNTED_EVENT_TYPES,
+  addActivityCount,
+  addTokenTotals,
+  addTotals,
+  emptyTotals,
+  localDayKey,
+} from "./usage.ts";
+import type { UsageActivityTotals, UsageAggregate, UsageTokenTotals } from "./usage.ts";
 import {
   DEFAULT_BUSY_TIMEOUT_MS,
   SCHEMA_VERSION,
@@ -39,12 +48,11 @@ import type { StorageRepository } from "./storage-takeover/types.ts";
 type SqliteDb = NodeSQLiteDatabase & { $client: DatabaseSync };
 
 /** 用量聚合的原始行（列名是 SQL 别名）。 */
-interface RawUsageRow {
+interface RawBucketRow {
   day: string;
   provider: string | null;
   model: string | null;
   subagent: number;
-  events: number;
   input_tokens: number | null;
   output_tokens: number | null;
   cache_read_tokens: number | null;
@@ -52,6 +60,55 @@ interface RawUsageRow {
   total_tokens: number | null;
 }
 
+/** 活动计数行（派生表按事件类型存，读的时候折成四项）。 */
+interface RawCountRow {
+  f_type: string;
+  n: number | null;
+}
+
+/** 「是否子代理」两组的 token 合计行。 */
+interface RawScopeRow extends RawBucketRow {}
+
+/** 按会话的行：token 一条查询、活动一条查询，按 session_id 合并。 */
+interface RawSessionTokenRow extends RawBucketRow {
+  session_id: string;
+  title: string | null;
+  archived: number;
+}
+
+interface RawSessionCountRow extends RawCountRow {
+  session_id: string;
+}
+
+/** 活动计数的派生表：可销毁重建（不在 drizzle schema / 迁移里，建表幂等）。 */
+function ensureEventCountsTable(db: DatabaseSync): void {
+  db.exec(`CREATE TABLE IF NOT EXISTS t_event_counts (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_session_id TEXT NOT NULL,
+      f_day TEXT NOT NULL,
+      f_type TEXT NOT NULL,
+      f_count INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS uq_event_counts_session_day_type
+      ON t_event_counts(f_session_id, f_day, f_type);
+    CREATE INDEX IF NOT EXISTS idx_event_counts_day ON t_event_counts(f_day);`);
+}
+
+/** 一次性回填活动计数（表为空时从事件表重算；幂等）。 */
+function backfillEventCounts(db: DatabaseSync): void {
+  const pending = db.prepare("SELECT count(*) AS n FROM t_event_counts").get() as { n: number };
+  if (pending.n > 0) return;
+  db.exec(`INSERT OR IGNORE INTO t_event_counts (f_session_id, f_day, f_type, f_count)
+    SELECT b.f_session_id,
+           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+           e.f_type,
+           count(*)
+      FROM t_session_events b
+      JOIN t_events e ON e.f_event_id = b.f_event_id
+     WHERE e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
+     GROUP BY 1, 2, 3`);
+}
+
 /**
  * 一次性回填：旧库的用量从未写过 `t_event_usage`，建表后按事件行补一次（幂等：表非空即跳过）。
  */
@@ -83,9 +140,14 @@ function backfillEventUsage(db: DatabaseSync): void {
 }
 
 /** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
-function totalsOf(row: RawUsageRow): UsageTotals {
+function tokenTotalsOf(row: {
+  input_tokens: number | null;
+  output_tokens: number | null;
+  cache_read_tokens: number | null;
+  reasoning_tokens: number | null;
+  total_tokens: number | null;
+}): UsageTokenTotals {
   return {
-    events: row.events,
     inputTokens: row.input_tokens ?? 0,
     outputTokens: row.output_tokens ?? 0,
     cacheReadTokens: row.cache_read_tokens ?? 0,
@@ -94,6 +156,25 @@ function totalsOf(row: RawUsageRow): UsageTotals {
   };
 }
 
+/** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+function emptyActivity(): UsageActivityTotals {
+  return { turns: 0, steps: 0, userInputs: 0, toolCalls: 0 };
+}
+
+/** 有 token 用量的会话：活动计数与列表都限定在这一批会话里，口径一致。 */
+function hasUsageSession(column: string): string {
+  return `EXISTS (SELECT 1 FROM t_session_events ub
+                    JOIN t_event_usage uu ON uu.f_event_id = ub.f_event_id
+                   WHERE ub.f_session_id = ${column})`;
+}
+
+const SUBAGENT_OF_EVENT = `EXISTS (SELECT 1 FROM t_session_events sb
+                                     JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
+                                    WHERE sb.f_event_id = %EVENT% AND ss.f_origin = 'subagent')`;
+
+/** `IN (...)` 用的类型字面量（与 `COUNTED_EVENT_TYPES` 同源）。 */
+const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
+
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
 
 const sqliteTxQueues = new Map<string, Promise<void>>();
@@ -138,6 +219,8 @@ export async function openDatabase(
       await baselineV2(db);
     }
     migrate(dbx, { migrationsFolder: sqliteMigrationsDir });
+    ensureEventCountsTable(db);
+    backfillEventCounts(db);
     backfillEventUsage(db);
 
     dbx
@@ -358,8 +441,12 @@ export class SqliteBackend implements Backend {
     return scoped.orderBy(tSessionEvents.fSequence).all() as unknown as EventRow[];
   }
 
+  // 只取类型：rewind 的边界 / 窗口探测不该把整个事件 JSON（f_data）拖回来。
   async getEventTypeAt(id: SessionId, sequence: number): Promise<string | undefined> {
-    const row = this.eventRows()
+    const row = this.db
+      .select({ fType: tEvents.fType })
+      .from(tSessionEvents)
+      .innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId))
       .where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence)))
       .get() as { fType?: string } | undefined;
     return row?.fType;
@@ -370,7 +457,10 @@ export class SqliteBackend implements Backend {
     beforeSequence: number,
     limit: number,
   ): Promise<Array<Pick<EventRow, "fSequence" | "fType">>> {
-    return this.eventRows()
+    return this.db
+      .select({ fSequence: tSessionEvents.fSequence, fType: tEvents.fType })
+      .from(tSessionEvents)
+      .innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId))
       .where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence)))
       .orderBy(desc(tSessionEvents.fSequence))
       .limit(limit)
@@ -597,36 +687,65 @@ export class SqliteBackend implements Backend {
     return Number(info.changes);
   }
 
-  /** 用量聚合：只读 `t_event_usage`；可选只算 `sinceMs` 之后的事件行。 */
+  /**
+   * 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
+   * 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
+   * `f_created_at`（同一时刻写入，口径一致）。
+   */
   async usageReport(sinceMs?: number): Promise<UsageAggregate> {
-    const sinceClause = sinceMs === undefined ? "" : " AND u.f_created_at >= ?";
-    const sinceParams = sinceMs === undefined ? [] : [sinceMs];
+    const usageSince = sinceMs === undefined ? "" : " AND u.f_created_at >= ?";
+    const params = sinceMs === undefined ? [] : [sinceMs];
+    // 活动计数走派生表的「本地日」列（与桶的 localtime 口径一致）。
+    const daySince = sinceMs === undefined ? "" : " AND c.f_day >= ?";
+    const dayParams = sinceMs === undefined ? [] : [localDayKey(sinceMs)];
+    const subagentOfUsage = SUBAGENT_OF_EVENT.replace("%EVENT%", "u.f_event_id");
+
     const buckets = this.db.$client
       .prepare(
         `SELECT date(u.f_created_at / 1000, 'unixepoch', 'localtime') AS day,
                 u.f_provider AS provider,
                 u.f_model AS model,
-                EXISTS (SELECT 1 FROM t_session_events sb
-                          JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
-                         WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
-                count(*) AS events,
+                ${subagentOfUsage} AS subagent,
                 sum(u.f_input_tokens) AS input_tokens,
                 sum(u.f_output_tokens) AS output_tokens,
                 sum(u.f_cache_read_tokens) AS cache_read_tokens,
                 sum(u.f_reasoning_tokens) AS reasoning_tokens,
                 sum(u.f_total_tokens) AS total_tokens
            FROM t_event_usage u
-          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
           GROUP BY day, provider, model, subagent`,
       )
-      .all(...sinceParams) as unknown as RawUsageRow[];
-    const sessions = this.db.$client
+      .all(...params) as unknown as RawBucketRow[];
+    const tokenScope = this.db.$client
+      .prepare(
+        `SELECT ${subagentOfUsage} AS subagent,
+                sum(u.f_input_tokens) AS input_tokens,
+                sum(u.f_output_tokens) AS output_tokens,
+                sum(u.f_cache_read_tokens) AS cache_read_tokens,
+                sum(u.f_reasoning_tokens) AS reasoning_tokens,
+                sum(u.f_total_tokens) AS total_tokens
+           FROM t_event_usage u
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+          GROUP BY subagent`,
+      )
+      .all(...params) as unknown as RawScopeRow[];
+    const activityScope = this.db.$client
+      .prepare(
+        `SELECT (s.f_origin = 'subagent') AS subagent,
+                c.f_type AS f_type,
+                sum(c.f_count) AS n
+           FROM t_event_counts c
+           JOIN t_sessions s ON s.f_session_id = c.f_session_id
+          WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+          GROUP BY subagent, c.f_type`,
+      )
+      .all(...dayParams) as unknown as Array<RawCountRow & { subagent: number }>;
+    const tokenSessions = this.db.$client
       .prepare(
         `SELECT b.f_session_id AS session_id,
                 s.f_title AS title,
                 (s.f_origin = 'subagent') AS subagent,
                 (s.f_archived_at IS NOT NULL) AS archived,
-                count(*) AS events,
                 sum(u.f_input_tokens) AS input_tokens,
                 sum(u.f_output_tokens) AS output_tokens,
                 sum(u.f_cache_read_tokens) AS cache_read_tokens,
@@ -635,30 +754,90 @@ export class SqliteBackend implements Backend {
            FROM t_session_events b
            JOIN t_event_usage u ON u.f_event_id = b.f_event_id
            JOIN t_sessions s ON s.f_session_id = b.f_session_id
-          WHERE 1 = 1${sinceClause}
+          WHERE 1 = 1${usageSince}
           GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at`,
       )
-      .all(...sinceParams) as unknown as Array<
-      RawUsageRow & { session_id: string; title: string | null; archived: number }
-    >;
+      .all(...params) as unknown as RawSessionTokenRow[];
+    const activitySessions = this.db.$client
+      .prepare(
+        `SELECT c.f_session_id AS session_id,
+                c.f_type AS f_type,
+                sum(c.f_count) AS n
+           FROM t_event_counts c
+          WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+          GROUP BY c.f_session_id, c.f_type`,
+      )
+      .all(...dayParams) as unknown as RawSessionCountRow[];
+    const human = emptyTotals();
+    const subagent = emptyTotals();
+    for (const row of tokenScope) {
+      addTokenTotals(row.subagent === 1 ? subagent : human, tokenTotalsOf(row));
+    }
+    for (const row of activityScope) {
+      addActivityCount(row.subagent === 1 ? subagent : human, row.f_type, row.n ?? 0);
+    }
+    const totals = addTotals(addTotals(emptyTotals(), human), subagent);
+
+    const activityBySession = new Map<string, UsageActivityTotals>();
+    for (const row of activitySessions) {
+      const target = activityBySession.get(row.session_id) ?? emptyActivity();
+      addActivityCount(target, row.f_type, row.n ?? 0);
+      activityBySession.set(row.session_id, target);
+    }
     return {
+      totals,
+      subagent,
+      human,
       buckets: buckets.map((row) => ({
         day: row.day,
         provider: row.provider,
         model: row.model,
         subagent: row.subagent === 1,
-        ...totalsOf(row),
+        ...tokenTotalsOf(row),
       })),
-      sessions: sessions.map((row) => ({
+      sessions: tokenSessions.map((row) => ({
         sessionId: row.session_id,
         title: row.title,
         subagent: row.subagent === 1,
         archived: row.archived === 1,
-        ...totalsOf(row),
+        ...tokenTotalsOf(row),
+        ...(activityBySession.get(row.session_id) ?? emptyActivity()),
       })),
     };
   }
 
+  /** 活动计数旁路累加：派生表 `t_event_counts`，不在写事务里（失败可丢，表可销毁重建）。 */
+  async incrementEventCounts(id: SessionId, buckets: readonly EventCountBucket[]): Promise<void> {
+    if (buckets.length === 0) return;
+    const statement = this.db.$client.prepare(
+      `INSERT INTO t_event_counts (f_session_id, f_day, f_type, f_count) VALUES (?, ?, ?, ?)
+       ON CONFLICT(f_session_id, f_day, f_type) DO UPDATE SET f_count = f_count + excluded.f_count`,
+    );
+    for (const bucket of buckets) statement.run(id, bucket.day, bucket.type, bucket.count);
+  }
+
+  /** 按会话重算活动计数（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+  async rebuildEventCounts(id: SessionId): Promise<void> {
+    this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+    this.db.$client
+      .prepare(
+        `INSERT INTO t_event_counts (f_session_id, f_day, f_type, f_count)
+         SELECT b.f_session_id,
+                date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+                e.f_type,
+                count(*)
+           FROM t_session_events b
+           JOIN t_events e ON e.f_event_id = b.f_event_id
+          WHERE b.f_session_id = ? AND e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
+          GROUP BY 1, 2, 3`,
+      )
+      .run(id);
+  }
+
+  async deleteEventCounts(id: SessionId): Promise<void> {
+    this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+  }
+
   async vacuum(): Promise<void> {
     await enqueueSqliteTx(this.dbPath, async () => {
       this.db.$client.exec("VACUUM");

package/src/usage.ts

@@ -48,9 +48,8 @@ function parseUsageRange(value: unknown): UsageRangeKey {
     : "all";
 }
 
-/** 一段用量合计（token 字段直接取事件里模型报的 usage）。 */
-export interface UsageTotals {
-  events: number;
+/** 一段 token 用量（字段直接取事件里模型报的 usage）。 */
+export interface UsageTokenTotals {
   inputTokens: number;
   outputTokens: number;
   cacheReadTokens: number;
@@ -58,8 +57,25 @@ export interface UsageTotals {
   totalTokens: number;
 }
 
-/** 一天 × 一个模型 × 是否子代理 的用量桶：总览、按天、按模型都由它折叠。 */
-export interface UsageBucket extends UsageTotals {
+/**
+ * 活动计数：与 token 用量同一时间范围、同一去重口径（只算被会话引用的事件行），
+ * 按事件类型数出来——「轮次 / 步骤 / 用户输入 / 工具调用」比「事件行数」有信息量。
+ */
+export interface UsageActivityTotals {
+  turns: number;
+  steps: number;
+  userInputs: number;
+  toolCalls: number;
+}
+
+/** 总量与按会话行用的一整套指标（token + 活动）。 */
+export interface UsageTotals extends UsageTokenTotals, UsageActivityTotals {}
+
+/**
+ * 一天 × 一个模型 × 是否子代理 的用量桶：总览、按天、按模型都由它折叠。
+ * 只有 token 用量——活动计数没有模型归属（一个轮次可能跨模型），挂在总量与按会话行上。
+ */
+export interface UsageBucket extends UsageTokenTotals {
   day: string;
   provider: string | null;
   model: string | null;
@@ -74,25 +90,63 @@ export interface UsageSessionRow extends UsageTotals {
   archived: boolean;
 }
 
-/** 后端的原始聚合结果。 */
+/** 后端的原始聚合结果（总量 / 其中子代理 / 人类、按天×模型的桶、按会话的行）。 */
 export interface UsageAggregate {
-  buckets: UsageBucket[];
-  sessions: UsageSessionRow[];
-}
-
-/** 一次统计请求的完整回报。 */
-export interface SessionUsageReport {
   totals: UsageTotals;
   subagent: UsageTotals;
-  /** 只被人类会话引用的部分（`totals − subagent`）。 */
   human: UsageTotals;
   buckets: UsageBucket[];
   sessions: UsageSessionRow[];
 }
 
-function emptyTotals(): UsageTotals {
+/** 一次统计请求的完整回报。 */
+export type SessionUsageReport = UsageAggregate;
+
+/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+export const COUNTED_EVENT_TYPES = [
+  "turn/start",
+  "step/start",
+  "user/message",
+  "tool/call",
+] as const;
+
+/** 按事件类型把计数累加到活动指标上（表里按类型存，读的时候折成四项）。 */
+export function addActivityCount(
+  target: UsageActivityTotals,
+  type: string,
+  count: number,
+): UsageActivityTotals {
+  switch (type) {
+    case "turn/start":
+      target.turns += count;
+      return target;
+    case "step/start":
+      target.steps += count;
+      return target;
+    case "user/message":
+      target.userInputs += count;
+      return target;
+    case "tool/call":
+      target.toolCalls += count;
+      return target;
+    default:
+      return target;
+  }
+}
+
+/** 毫秒时间戳 → host 本地日（`YYYY-MM-DD`，与 SQL 的 localtime 口径一致）。 */
+export function localDayKey(ms: number): string {
+  const date = new Date(ms);
+  const pad = (value: number): string => String(value).padStart(2, "0");
+  return `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+export function emptyTotals(): UsageTotals {
   return {
-    events: 0,
+    turns: 0,
+    steps: 0,
+    userInputs: 0,
+    toolCalls: 0,
     inputTokens: 0,
     outputTokens: 0,
     cacheReadTokens: 0,
@@ -101,18 +155,31 @@ function emptyTotals(): UsageTotals {
   };
 }
 
-/** 折叠一组行（桶或会话行）的用量。 */
-export function sumUsage(rows: readonly UsageTotals[]): UsageTotals {
-  const totals = emptyTotals();
-  for (const row of rows) {
-    totals.events += row.events;
-    totals.inputTokens += row.inputTokens;
-    totals.outputTokens += row.outputTokens;
-    totals.cacheReadTokens += row.cacheReadTokens;
-    totals.reasoningTokens += row.reasoningTokens;
-    totals.totalTokens += row.totalTokens;
-  }
-  return totals;
+export function addTokenTotals(target: UsageTokenTotals, row: UsageTokenTotals): UsageTokenTotals {
+  target.inputTokens += row.inputTokens;
+  target.outputTokens += row.outputTokens;
+  target.cacheReadTokens += row.cacheReadTokens;
+  target.reasoningTokens += row.reasoningTokens;
+  target.totalTokens += row.totalTokens;
+  return target;
+}
+
+export function addActivityTotals(
+  target: UsageActivityTotals,
+  row: UsageActivityTotals,
+): UsageActivityTotals {
+  target.turns += row.turns;
+  target.steps += row.steps;
+  target.userInputs += row.userInputs;
+  target.toolCalls += row.toolCalls;
+  return target;
+}
+
+/** 把一行的整套指标累加进目标（后端合并「是否子代理」两组时用）。 */
+export function addTotals(target: UsageTotals, row: UsageTotals): UsageTotals {
+  addActivityTotals(target, row);
+  addTokenTotals(target, row);
+  return target;
 }
 
 /**
@@ -167,14 +234,11 @@ export function registerSessionUsage(ctx: Context, persistence: SessionPersisten
               }
             }
             try {
-              const aggregate = await persistence.usageReport(
+              const report = await persistence.usageReport(
                 resolveUsageSince(parseUsageRange(envelope.range), Date.now()),
               );
-              const totals = sumUsage(aggregate.buckets);
-              const subagent = sumUsage(aggregate.buckets.filter((bucket) => bucket.subagent));
-              const human = sumUsage(aggregate.buckets.filter((bucket) => !bucket.subagent));
               res.writeHead(200, { "content-type": "application/json" });
-              res.end(JSON.stringify({ totals, subagent, human, ...aggregate }));
+              res.end(JSON.stringify(report));
             } catch (error: unknown) {
               res.writeHead(500, { "content-type": "application/json" });
               res.end(