@cartanova/qgrid-cli 2.6.1 → 2.6.4

package/bundle/src/application/qgrid/token-death.ts

@@ -0,0 +1,96 @@
+/**
+ * 세션 만료(auth-dead) 토큰의 라우팅 제외 지점.
+ *
+ * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 비활성화는
+ * `active=true` 조건부 갱신 1회이고, 그 갱신을 이긴 프로세스만 Slack 알림을 보낸다 —
+ * 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.
+ */
+import { getLogger } from "@logtape/logtape";
+
+import { getRefreshToken } from "../../utils/providers/common/credentials";
+import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { TokenModel } from "../token/token.model";
+
+const logger = getLogger(["qgrid", "token-death"]);
+
+type DeadTokenRef = {
+  id: number;
+  name: string;
+  provider: string;
+};
+
+/**
+ * @param usedRefreshToken 실패한 요청이 실제로 사용한 refresh token.
+ *   refresh token 은 회전 저장되므로, 이미 회전된 옛 토큰으로 늦게 도착한 재시도가
+ *   400 을 받는 것은 정상 레이스다. DB 의 현재 값과 다르면 사망으로 보지 않는다.
+ * @param reasonCode `provider:code` 형태의 내부 코드. provider 응답 본문에는 계정 이메일이나
+ *   토큰 조각이 섞일 수 있어 raw 메시지를 그대로 알림에 싣지 않는다.
+ */
+export async function deactivateAuthDeadToken(
+  token: DeadTokenRef,
+  usedRefreshToken: string,
+  reasonCode: string,
+): Promise<boolean> {
+  const current = await TokenModel.findOne("A", { id: token.id });
+  if (!current) return false;
+
+  const currentRefreshToken = getRefreshToken(current.credentials);
+  if (currentRefreshToken && currentRefreshToken !== usedRefreshToken) {
+    logger.info(
+      `skipping auth-death for ${token.name}(id=${token.id}): refresh token rotated since this attempt`,
+    );
+    return false;
+  }
+
+  const { deactivated, keptAsLastActive } = await TokenModel.deactivateIfActive(token.id);
+  if (!deactivated) {
+    if (keptAsLastActive) notifyLastActiveTokenDying(token, reasonCode);
+    return false;
+  }
+
+  logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);
+  void notifySlack({
+    title: "세션 만료",
+    subject: token.name,
+    context: `${token.provider} · ${reasonCode} · 재로그인이 필요합니다`,
+    color: SLACK_COLOR.bad,
+  });
+  return true;
+}
+
+/**
+ * 마지막 활성 토큰이 죽었을 때의 알림 쿨다운.
+ *
+ * 이 경우 토큰은 비활성화되지 않고 살아남으므로, 뒤따르는 요청마다 같은 실패를 반복해
+ * 알림이 폭주한다. 비활성화 성공 경로가 조건부 UPDATE 로 중복을 막는 것과 달리 여기엔
+ * 상태 변화가 없어 DB 로 억제할 수 없다 — provider 단위로 시간 창을 둔다.
+ */
+const LAST_ACTIVE_ALERT_COOLDOWN_MS = 30 * 60 * 1000;
+const lastActiveAlertAt = new Map<string, number>();
+
+function notifyLastActiveTokenDying(token: DeadTokenRef, reasonCode: string): void {
+  const now = Date.now();
+  const previous = lastActiveAlertAt.get(token.provider);
+  if (previous !== undefined && now - previous < LAST_ACTIVE_ALERT_COOLDOWN_MS) return;
+  lastActiveAlertAt.set(token.provider, now);
+
+  void notifySlack({
+    title: "마지막 토큰 사망",
+    subject: token.name,
+    context:
+      `${token.provider} · ${reasonCode} · 풀이 비지 않도록 유지 중입니다. ` +
+      `전 토큰이 동시에 실패했다면 client_id 취소나 OAuth 계약 변경을 의심하세요`,
+    color: SLACK_COLOR.bad,
+  });
+}
+
+/** 로그인이 완료돼 토큰이 저장됐을 때. 신규·재로그인을 가리지 않는다. */
+export function notifyTokenAdded(name: string, provider: string): void {
+  logger.info(`token added: ${name} (${provider})`);
+  void notifySlack({
+    title: "토큰 추가",
+    subject: name,
+    context: `${provider} · 요청 처리에 사용됩니다`,
+    color: SLACK_COLOR.good,
+  });
+}

package/bundle/src/application/queries.generated.ts

@@ -80,12 +80,15 @@ export namespace QgridService {
   export const stats = (): SSRQuery =>
     createSSRQuery("QgridFrame", "stats", [], ["Qgrid", "stats"]);
 
-  export const totalCost = (tokenName?: string): SSRQuery =>
-    createSSRQuery("QgridFrame", "totalCost", [tokenName], ["Qgrid", "totalCost"]);
+  export const totalCost = (params?: RequestLogListParams): SSRQuery =>
+    createSSRQuery("QgridFrame", "totalCost", [params], ["Qgrid", "totalCost"]);
 
   export const projectNames = (): SSRQuery =>
     createSSRQuery("QgridFrame", "projectNames", [], ["Qgrid", "projectNames"]);
 
+  export const modelNames = (): SSRQuery =>
+    createSSRQuery("QgridFrame", "modelNames", [], ["Qgrid", "modelNames"]);
+
   export const usage = (tokenId?: number): SSRQuery =>
     createSSRQuery("QgridFrame", "usage", [tokenId], ["Qgrid", "usage"]);
 

package/bundle/src/application/request-log/request-log.entity.json

@@ -36,12 +36,7 @@
       "length": 255,
       "nullable": true
     },
-    {
-      "name": "fallback_count",
-      "type": "integer",
-      "nullable": true,
-      "desc": "모델 fallback 횟수"
-    },
+    { "name": "fallback_count", "type": "integer", "nullable": true, "desc": "모델 fallback 횟수" },
     { "name": "user_prompt", "type": "string", "nullable": true, "desc": "사용자 프롬프트" },
     { "name": "system_prompt", "type": "string", "nullable": true, "desc": "시스템 프롬프트" },
     { "name": "response", "desc": "llm 응답 전문", "type": "string", "dbDefault": "\"\"" },
@@ -132,6 +127,18 @@
       "name": "request_logs_project_name_index",
       "columns": [{ "name": "project_name" }],
       "using": "btree"
+    },
+    {
+      "type": "index",
+      "name": "request_logs_project_name_cost_usd_index",
+      "columns": [{ "name": "project_name" }, { "name": "cost_usd" }],
+      "using": "btree"
+    },
+    {
+      "type": "index",
+      "name": "request_logs_model_name_index",
+      "columns": [{ "name": "model_name" }],
+      "using": "btree"
     }
   ],
   "subsets": {
@@ -190,10 +197,42 @@
       "status",
       "tool_call_count",
       "is_image_generation"
+    ],
+    "C": [
+      "id",
+      "token_name",
+      "model_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
+      "cost_usd",
+      "cost_source"
     ]
   },
   "enums": {
-    "RequestLogOrderBy": { "id-desc": "ID최신순" },
+    "RequestLogOrderBy": {
+      "id-desc": "ID최신순",
+      "id-asc": "ID오래된순",
+      "created_at-desc": "등록일시최신순",
+      "created_at-asc": "등록일시오래된순",
+      "ttft_ms-desc": "TTFT긴순",
+      "ttft_ms-asc": "TTFT짧은순",
+      "duration_ms-desc": "소요시간긴순",
+      "duration_ms-asc": "소요시간짧은순",
+      "input_tokens-desc": "입력토큰많은순",
+      "input_tokens-asc": "입력토큰적은순",
+      "output_tokens-desc": "출력토큰많은순",
+      "output_tokens-asc": "출력토큰적은순",
+      "cache_read_tokens-desc": "캐시읽기많은순",
+      "cache_read_tokens-asc": "캐시읽기적은순",
+      "cache_creation_tokens-desc": "캐시생성많은순",
+      "cache_creation_tokens-asc": "캐시생성적은순",
+      "cost_usd-desc": "비용높은순",
+      "cost_usd-asc": "비용낮은순"
+    },
     "RequestLogSearchField": {
       "id": "ID",
       "token_name": "토큰이름",

package/bundle/src/application/request-log/request-log.model.test.ts

@@ -366,59 +366,170 @@ describe("RequestLogModel cost provenance", () => {
     vi.restoreAllMocks();
   });
 
-  it("uses exact stored cost for rows with a cost source", async () => {
-    const chain = {
+  /**
+   * totalCost 는 확정 비용(SQL SUM)과 legacy 재계산(JS) 두 쿼리로 나뉜다.
+   * @param confirmedTotal SUM 쿼리가 돌려줄 micro-USD 합계
+   * @param legacyRows 재계산 대상 row 들
+   */
+  function mockTotalCostQueries(confirmedTotal: number, legacyRows: unknown[]) {
+    // subset qb 는 SELECT 를 비우고(clear) 집계/축소된 컬럼만 다시 얹는다 — 구현과 같은 체인.
+    const sumChain = {
       where: vi.fn(),
-      select: vi.fn(async () => [
-        {
-          model_name: "claude-opus-4-8",
-          input_tokens: 1_000_000,
-          output_tokens: 1_000_000,
-          cache_read_tokens: 0,
-          cache_creation_tokens: 0,
-          cache_creation_5m_tokens: null,
-          cache_creation_1h_tokens: null,
-          cost_usd: 3_000,
-          cost_source: "provider",
-        },
-      ]),
+      whereIn: vi.fn(),
+      whereRaw: vi.fn(),
+      clear: vi.fn(),
+      select: vi.fn(),
+      first: vi.fn(async () => ({ total: confirmedTotal })),
     };
-    chain.where.mockReturnValue(chain);
-    const from = vi.fn(() => chain);
+    sumChain.where.mockReturnValue(sumChain);
+    sumChain.whereIn.mockReturnValue(sumChain);
+    sumChain.whereRaw.mockReturnValue(sumChain);
+    sumChain.clear.mockReturnValue(sumChain);
+    sumChain.select.mockReturnValue(sumChain);
+
+    const legacyChain = {
+      where: vi.fn(),
+      whereIn: vi.fn(),
+      whereRaw: vi.fn(),
+      clear: vi.fn(),
+      select: vi.fn(async () => legacyRows),
+    };
+    legacyChain.where.mockReturnValue(legacyChain);
+    legacyChain.whereIn.mockReturnValue(legacyChain);
+    legacyChain.whereRaw.mockReturnValue(legacyChain);
+    legacyChain.clear.mockReturnValue(legacyChain);
+
+    const getSubsetQueries = vi
+      .fn()
+      .mockReturnValueOnce({ qb: sumChain })
+      .mockReturnValueOnce({ qb: legacyChain });
     vi.spyOn(
-      RequestLogModel as unknown as { getPuri: () => { from: typeof from } },
-      "getPuri",
-    ).mockReturnValue({ from });
+      RequestLogModel as unknown as { getSubsetQueries: typeof getSubsetQueries },
+      "getSubsetQueries",
+    ).mockImplementation(getSubsetQueries);
+    return { sumChain, legacyChain };
+  }
+
+  it("uses exact stored cost for rows with a cost source", async () => {
+    mockTotalCostQueries(3_000, []);
 
     await expect(RequestLogModel.totalCost()).resolves.toBe(0.003);
   });
 
+  it("sums every row in SQL without a cost_source predicate", async () => {
+    const { sumChain, legacyChain } = mockTotalCostQueries(3_000, []);
+
+    await RequestLogModel.totalCost();
+
+    expect(sumChain.select).toHaveBeenCalledTimes(1);
+    // 조건을 걸면 cost_source 가 인덱스에 없어 커버링 인덱스가 무효화된다.
+    expect(sumChain.whereRaw).not.toHaveBeenCalled();
+    expect(legacyChain.whereRaw).toHaveBeenCalledWith(
+      "request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL",
+    );
+  });
+
   it("keeps TTL-aware price-table recomputation for legacy rows", async () => {
-    const chain = {
-      where: vi.fn(),
-      select: vi.fn(async () => [
-        {
-          model_name: "claude-sonnet-4-6",
-          input_tokens: 100_000,
-          output_tokens: 0,
-          cache_read_tokens: 0,
-          cache_creation_tokens: 80_000,
-          cache_creation_5m_tokens: 30_000,
-          cache_creation_1h_tokens: 50_000,
-          cost_usd: null,
-          cost_source: null,
-        },
-      ]),
-    };
-    chain.where.mockReturnValue(chain);
-    const from = vi.fn(() => chain);
-    vi.spyOn(
-      RequestLogModel as unknown as { getPuri: () => { from: typeof from } },
-      "getPuri",
-    ).mockReturnValue({ from });
+    mockTotalCostQueries(0, [
+      {
+        model_name: "claude-sonnet-4-6",
+        input_tokens: 100_000,
+        output_tokens: 0,
+        cache_read_tokens: 0,
+        cache_creation_tokens: 80_000,
+        cache_creation_5m_tokens: 30_000,
+        cache_creation_1h_tokens: 50_000,
+        cost_usd: null,
+        cost_source: null,
+      },
+    ]);
 
     await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
   });
+
+  it("adds only the delta for legacy rows already counted in the SQL sum", async () => {
+    // 전체 SUM 이 저장값 0.2 를 이미 포함하므로, 재계산값 0.4725 와의 차액만 더해야 한다.
+    mockTotalCostQueries(200_000, [
+      {
+        model_name: "claude-sonnet-4-6",
+        input_tokens: 100_000,
+        output_tokens: 0,
+        cache_read_tokens: 0,
+        cache_creation_tokens: 80_000,
+        cache_creation_5m_tokens: 30_000,
+        cache_creation_1h_tokens: 50_000,
+        cost_usd: 200_000,
+        cost_source: null,
+      },
+    ]);
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+  });
+
+  it("leaves the stored value untouched for legacy rows without a model name", async () => {
+    // 모델을 모르면 재계산할 수 없다. 저장값이 SUM 에 이미 들어갔으므로 보정하지 않는다.
+    mockTotalCostQueries(5_000, [
+      {
+        model_name: null,
+        input_tokens: 100,
+        output_tokens: 100,
+        cache_read_tokens: 0,
+        cache_creation_tokens: 0,
+        cache_creation_5m_tokens: null,
+        cache_creation_1h_tokens: null,
+        cost_usd: 5_000,
+        cost_source: null,
+      },
+    ]);
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.005, 10);
+  });
+
+  it("applies list filters to both cost queries so totals match the filtered list", async () => {
+    const { sumChain, legacyChain } = mockTotalCostQueries(0, []);
+
+    await RequestLogModel.totalCost({
+      num: 0,
+      page: 1,
+      project_name: "deti",
+      token_name: "openai/yds",
+      model_name: "openai/gpt-5.5",
+    });
+
+    for (const chain of [sumChain, legacyChain]) {
+      expect(chain.where).toHaveBeenCalledWith("request_logs.project_name", "deti");
+      expect(chain.where).toHaveBeenCalledWith("request_logs.token_name", "openai/yds");
+      expect(chain.where).toHaveBeenCalledWith("request_logs.model_name", "openai/gpt-5.5");
+    }
+  });
+
+  it("applies the unassigned-project filter to both cost queries", async () => {
+    const { sumChain, legacyChain } = mockTotalCostQueries(0, []);
+
+    await RequestLogModel.totalCost({ num: 0, page: 1, project_name_is_null: true });
+
+    for (const chain of [sumChain, legacyChain]) {
+      expect(chain.where).toHaveBeenCalledWith("request_logs.project_name", null);
+    }
+  });
+
+  it("combines the SQL-summed total with the legacy recomputation delta", async () => {
+    mockTotalCostQueries(3_000, [
+      {
+        model_name: "claude-sonnet-4-6",
+        input_tokens: 100_000,
+        output_tokens: 0,
+        cache_read_tokens: 0,
+        cache_creation_tokens: 80_000,
+        cache_creation_5m_tokens: 30_000,
+        cache_creation_1h_tokens: 50_000,
+        cost_usd: null,
+        cost_source: null,
+      },
+    ]);
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4755, 10);
+  });
 });
 
 describe("RequestLogModel PostgreSQL run lock", () => {

package/bundle/src/application/request-log/request-log.model.ts

@@ -3,7 +3,6 @@ import {
   asArray,
   BadRequestException,
   BaseModelClass,
-  exhaustive,
   type ListResult,
   NotFoundException,
   Puri,
@@ -152,6 +151,43 @@ function normalizeLegacyAnthropicRow<T extends RequestLogUsageRow>(row: T): T {
   return normalized;
 }
 
+/**
+ * `orderBy` enum 값(`컬럼-방향`)을 정렬 절로 옮긴다.
+ *
+ * enum 이 18 종이라 케이스를 일일이 적는 대신 파싱하되, 컬럼은 아래 목록으로 한정한다 —
+ * 문자열을 그대로 컬럼명에 넘기면 enum 이 바뀔 때 검증 없는 식별자가 SQL 로 흘러든다.
+ * 목록에 없는 값은 기본 정렬(id desc)로 떨어진다.
+ */
+const ORDERABLE_COLUMNS = {
+  id: "request_logs.id",
+  created_at: "request_logs.created_at",
+  ttft_ms: "request_logs.ttft_ms",
+  duration_ms: "request_logs.duration_ms",
+  input_tokens: "request_logs.input_tokens",
+  output_tokens: "request_logs.output_tokens",
+  cache_read_tokens: "request_logs.cache_read_tokens",
+  cache_creation_tokens: "request_logs.cache_creation_tokens",
+  cost_usd: "request_logs.cost_usd",
+} as const;
+
+function applyOrderBy(
+  qb: ReturnType<RequestLogModelClass["getSubsetQueries"]>["qb"],
+  orderBy: string,
+): void {
+  const separator = orderBy.lastIndexOf("-");
+  const key = orderBy.slice(0, separator) as keyof typeof ORDERABLE_COLUMNS;
+  const direction = orderBy.slice(separator + 1) === "asc" ? "asc" : "desc";
+  const column = ORDERABLE_COLUMNS[key];
+
+  if (!column) {
+    qb.orderBy("request_logs.id", "desc");
+    return;
+  }
+  qb.orderBy(column, direction);
+  // 동점 행의 순서가 페이지마다 흔들리지 않게 고유 컬럼으로 tie-break 한다.
+  if (key !== "id") qb.orderBy("request_logs.id", "desc");
+}
+
 /*
   RequestLog Model
 */
@@ -195,21 +231,15 @@ class RequestLogModelClass extends BaseModelClass<
     return rows[0] ?? null;
   }
 
-  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
-  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
-    subset: T,
-    rawParams?: LP,
-  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
-    const params = {
-      num: 24,
-      page: 1,
-      search: "id" as const,
-      orderBy: "id-desc" as const,
-      ...rawParams,
-    } satisfies RequestLogListParams;
-
-    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
-
+  /**
+   * 목록 필터의 단일 정의. findMany 와 totalCost 가 같은 조건을 보도록 공유한다 —
+   * 화면에서 필터를 걸면 행 수와 비용이 함께 좁혀져야 하는데, 두 쿼리가 각자 필터를
+   * 구현하면 한쪽에 축을 추가할 때 조용히 어긋난다.
+   */
+  private applyListFilters(
+    qb: ReturnType<RequestLogModelClass["getSubsetQueries"]>["qb"],
+    params: RequestLogListParams,
+  ): void {
     if (params.id) {
       qb.whereIn("request_logs.id", asArray(params.id));
     }
@@ -241,19 +271,30 @@ class RequestLogModelClass extends BaseModelClass<
         throw new BadRequestException(SD("error.unknownSearchField")(params.search));
       }
     }
+  }
 
-    // orderBy
-    if (params.orderBy) {
-      // default orderBy
-      if (params.orderBy === "id-desc") {
-        qb.orderBy("request_logs.id", "desc");
-      } else {
-        exhaustive(params.orderBy);
-      }
-    }
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
+  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
+    const params = {
+      num: 24,
+      page: 1,
+      search: "id" as const,
+      orderBy: "id-desc" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+
+    this.applyListFilters(qb, params);
+
+    if (params.orderBy) applyOrderBy(qb, params.orderBy);
 
     const enhancers = this.createEnhancers({
       A: (row) => normalizeLegacyAnthropicRow(row),
+      C: (row) => normalizeLegacyAnthropicRow(row),
     });
 
     return this.executeSubsetQuery({
@@ -606,33 +647,65 @@ class RequestLogModelClass extends BaseModelClass<
     return (row?.max_step ?? -1) + 1;
   }
 
-  // Sonamu findMany는 subset 전체 컬럼(text 포함)을 페치하므로 비용 계산에 필요한 컬럼만 조회한다.
-  async totalCost(params: { token_name?: string } = {}): Promise<number> {
-    // 기존 cost_usd 에는 과거 Anthropic cache 계산 버그로 음수가 저장된 row 가 있을 수 있다.
-    // 화면 집계는 저장값 sum 이 아니라 현재 계산식으로 usage 를 재계산해 과거 로그도 즉시 보정한다.
-    const rows = await this.getPuri("r")
-      .from("request_logs")
-      .where(params.token_name ? { token_name: params.token_name } : {})
+  /**
+   * 화면 표시용 총 비용. 목록과 같은 필터를 적용한다.
+   *
+   * 전체를 조건 없이 SUM 한 뒤, `cost_source` 가 없는 legacy row 의 차액만 보정한다.
+   * 조건 없는 SUM 이어야 `(project_name, cost_usd)` 커버링 인덱스가 Index Only Scan 을
+   * 탄다 — `cost_source IS NOT NULL` 을 걸면 그 컬럼이 인덱스에 없어 heap 을 다시 봐야
+   * 하므로 플래너가 인덱스를 버리고 seq scan 으로 돌아간다(실측 230ms → 814ms).
+   *
+   * legacy 보정을 남겨둔 이유: 백필로 기존 legacy 는 0 이 되었지만, 외부 로거가
+   * `AppendStepInput`/`FinishRunInput` 으로 costSource 없이 넣으면 다시 생길 수 있다.
+   * 그런 row 는 저장값 대신 현재 가격표 재계산값이 맞으므로 차액을 더한다.
+   *
+   * 필터 조건을 여기서 다시 구현하지 않고 `applyListFilters` 를 공유하는 것이 핵심이다 —
+   * 두 쿼리가 각자 필터를 가지면 화면에서 필터를 걸었을 때 행 수와 비용이 조용히 어긋난다.
+   */
+  async totalCost(rawParams: RequestLogListParams = { num: 0, page: 1 }): Promise<number> {
+    const params = {
+      num: 0,
+      page: 1,
+      search: "id" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    const { qb: totalQb } = this.getSubsetQueries("C");
+    this.applyListFilters(totalQb, params);
+    // subset qb 는 컬럼 목록이 이미 SELECT 에 박혀 있어 집계를 얹으면 GROUP BY 에러가 난다.
+    // executeCountQuery 와 같은 방식으로 select 를 비우고 집계만 남긴다.
+    const stored = await totalQb
+      .clear("select")
+      // 음수 저장값(과거 버그)은 0 으로 눌러서 더한다 — JS 쪽 Math.max 와 같은 규칙.
       .select({
-        model_name: "model_name",
-        input_tokens: "input_tokens",
-        output_tokens: "output_tokens",
-        cache_read_tokens: "cache_read_tokens",
-        cache_creation_tokens: "cache_creation_tokens",
-        cache_creation_5m_tokens: "cache_creation_5m_tokens",
-        cache_creation_1h_tokens: "cache_creation_1h_tokens",
-        cost_usd: "cost_usd",
-        cost_source: "cost_source",
+        total: Puri.rawNumber("COALESCE(SUM(GREATEST(request_logs.cost_usd, 0)), 0)"),
+      })
+      .first();
+
+    const { qb: legacyQb } = this.getSubsetQueries("C");
+    this.applyListFilters(legacyQb, params);
+    const legacyRows = await legacyQb
+      .whereRaw("request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL")
+      .clear("select")
+      .select({
+        token_name: "request_logs.token_name",
+        model_name: "request_logs.model_name",
+        input_tokens: "request_logs.input_tokens",
+        output_tokens: "request_logs.output_tokens",
+        cache_read_tokens: "request_logs.cache_read_tokens",
+        cache_creation_tokens: "request_logs.cache_creation_tokens",
+        cache_creation_5m_tokens: "request_logs.cache_creation_5m_tokens",
+        cache_creation_1h_tokens: "request_logs.cache_creation_1h_tokens",
+        cost_usd: "request_logs.cost_usd",
       });
 
-    return rows.reduce((sum, row) => {
-      // cost_source 가 있으면 새 계약으로 확정 저장된 값이다. 프로모션/가격 변경 이후에도
-      // 당시 비용을 유지한다. NULL인 legacy row 만 현재 가격표로 보정한다.
-      if (row.cost_source && row.cost_usd !== null) {
-        return sum + Math.max(row.cost_usd, 0) / MICRO_USD;
-      }
+    const storedTotal = Number(stored?.total ?? 0) / MICRO_USD;
+
+    // legacy row 는 위 SUM 에 저장값으로 이미 포함되어 있다. 재계산값과의 차액만 더한다.
+    return legacyRows.reduce((sum, row) => {
+      const alreadySummed = Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       const usage = normalizedUsageForCost(row);
-      if (!usage.model) return sum + Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
+      if (!usage.model) return sum;
       return (
         sum +
         calculateCostUsd(usage.model, {
@@ -642,9 +715,10 @@ class RequestLogModelClass extends BaseModelClass<
           cacheCreationInputTokens: usage.cacheCreationInputTokens,
           cacheCreationInputTokens5m: usage.cacheCreationInputTokens5m,
           cacheCreationInputTokens1h: usage.cacheCreationInputTokens1h,
-        })
+        }) -
+        alreadySummed
       );
-    }, 0);
+    }, storedTotal);
   }
 
   async distinctProjectNames(): Promise<string[]> {
@@ -659,6 +733,18 @@ class RequestLogModelClass extends BaseModelClass<
     return rows.map((r) => r.project_name!);
   }
 
+  async distinctModelNames(): Promise<string[]> {
+    const rows = await this.getPuri("r")
+      .from("request_logs")
+      .distinct("model_name")
+      .where("model_name", "!=", null)
+      .orderBy("model_name", "asc")
+      .select({
+        model_name: "model_name",
+      });
+    return rows.map((r) => r.model_name!);
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async del(ids: number[]): Promise<number> {
     const wdb = this.getPuri("w");