@cartanova/qgrid-cli 2.4.8 → 2.5.0

package/bundle/dist/utils/providers/openai/openai-quota.js

@@ -1,4 +1,3 @@
-import "../../../_virtual/_rolldown/runtime.js";
 //#region src/utils/providers/openai/openai-quota.ts
 async function readOpenAIQuotaUsage(readRateLimits) {
 	try {
@@ -27,4 +26,4 @@ async function readOpenAIQuotaUsage(readRateLimits) {
 //#endregion
 export { readOpenAIQuotaUsage };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/utils/providers/openai/openai-refresh.js

@@ -1,4 +1,3 @@
-import "../../../_virtual/_rolldown/runtime.js";
 import { TokenModel } from "../../../application/token/token.model.js";
 import { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from "./openai-constants.js";
 import { getLogger } from "@logtape/logtape";
@@ -102,4 +101,4 @@ async function doRefresh(tokenId) {
 //#endregion
 export { handleChatgptAuthTokensRefresh };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}

package/bundle/dist/utils/subset-loaders.js

@@ -1,4 +1,3 @@
-import "../_virtual/_rolldown/runtime.js";
 //#region src/utils/subset-loaders.ts
 function getSubsetLoaders(subsets, subsetQueries) {
 	return subsets.reduce((acc, subset) => {
@@ -9,4 +8,4 @@ function getSubsetLoaders(subsets, subsetQueries) {
 //#endregion
 export { getSubsetLoaders };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2V0LWxvYWRlcnMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3N1YnNldC1sb2FkZXJzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgU3Vic2V0UXVlcnkgfSBmcm9tIFwic29uYW11XCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTdWJzZXRMb2FkZXJzKHN1YnNldHM6IHN0cmluZ1tdLCBzdWJzZXRRdWVyaWVzOiBSZWNvcmQ8c3RyaW5nLCBTdWJzZXRRdWVyeT4pIHtcbiAgcmV0dXJuIHN1YnNldHMucmVkdWNlKFxuICAgIChhY2MsIHN1YnNldCkgPT4ge1xuICAgICAgYWNjW3N1YnNldF0gPSBzdWJzZXRRdWVyaWVzW3N1YnNldF0/LmxvYWRlcnMgPz8gW107XG4gICAgICByZXR1cm4gYWNjO1xuICAgIH0sXG4gICAge30gYXMgUmVjb3JkPHN0cmluZywgU3Vic2V0UXVlcnlbXCJsb2FkZXJzXCJdPixcbiAgKTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7QUFFQSxTQUFnQixpQkFBaUIsU0FBbUIsZUFBNEM7QUFDOUYsUUFBTyxRQUFRLFFBQ1osS0FBSyxXQUFXO0FBQ2YsTUFBSSxVQUFVLGNBQWMsU0FBUyxXQUFXLEVBQUU7QUFDbEQsU0FBTztJQUVULEVBQUUsQ0FDSCJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2V0LWxvYWRlcnMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3N1YnNldC1sb2FkZXJzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgU3Vic2V0UXVlcnkgfSBmcm9tIFwic29uYW11XCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTdWJzZXRMb2FkZXJzKHN1YnNldHM6IHN0cmluZ1tdLCBzdWJzZXRRdWVyaWVzOiBSZWNvcmQ8c3RyaW5nLCBTdWJzZXRRdWVyeT4pIHtcbiAgcmV0dXJuIHN1YnNldHMucmVkdWNlKFxuICAgIChhY2MsIHN1YnNldCkgPT4ge1xuICAgICAgYWNjW3N1YnNldF0gPSBzdWJzZXRRdWVyaWVzW3N1YnNldF0/LmxvYWRlcnMgPz8gW107XG4gICAgICByZXR1cm4gYWNjO1xuICAgIH0sXG4gICAge30gYXMgUmVjb3JkPHN0cmluZywgU3Vic2V0UXVlcnlbXCJsb2FkZXJzXCJdPixcbiAgKTtcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUVBLFNBQWdCLGlCQUFpQixTQUFtQixlQUE0QztDQUM5RixPQUFPLFFBQVEsUUFDWixLQUFLLFdBQVc7RUFDZixJQUFJLFVBQVUsY0FBYyxPQUFPLEVBQUUsV0FBVyxDQUFDO0VBQ2pELE9BQU87Q0FDVCxHQUNBLENBQUMsQ0FDSDtBQUNGIn0=

package/bundle/src/application/monit/monit.frame.test.ts

@@ -156,8 +156,8 @@ describe("MonitFrame.monitInfo", () => {
   it("returns the active DB connection, server url, and pool bounds without secrets", async () => {
     vi.stubEnv("HOST", "0.0.0.0");
     vi.stubEnv("PORT", "45000");
-    vi.stubEnv("QGRID_DB_HOST", "db.internal");
-    vi.stubEnv("QGRID_DB_NAME", "qgrid_dev");
+    vi.stubEnv("SONAMU_DB_HOST", "db.internal");
+    vi.stubEnv("SONAMU_DB_NAME", "qgrid_dev");
 
     // 단위 테스트에선 DB 미초기화 → env 폴백 경로. 부팅된 서버에선 활성 knex 설정을 읽는다
     // (dev 서버의 통합 테스트 러너가 env 를 오염시키는 문제 회피 — curl 로 별도 검증).

package/bundle/src/application/monit/monit.frame.ts

@@ -60,7 +60,7 @@ function currentVitals(): MonitVitals {
   };
 }
 
-// 실제 활성 knex 연결에서 읽는다 — dev 서버의 통합 테스트 러너가 process.env.QGRID_DB_NAME 을
+// 실제 활성 knex 연결에서 읽는다 — dev 서버의 통합 테스트 러너가 process.env.SONAMU_DB_NAME 을
 // 테스트 DB 이름으로 덮어쓰므로 env 는 신뢰할 수 없다. DB 미초기화(부팅 전) 시에만 env 폴백.
 function activeDbConnection(): { host?: string; database?: string } {
   try {
@@ -71,7 +71,7 @@ function activeDbConnection(): { host?: string; database?: string } {
   } catch {
     // DB config 미초기화 — env 폴백으로 진행
   }
-  return { host: process.env.QGRID_DB_HOST, database: process.env.QGRID_DB_NAME };
+  return { host: process.env.SONAMU_DB_HOST, database: process.env.SONAMU_DB_NAME };
 }
 
 export const MonitFrame = new MonitFrameClass();

package/bundle/src/application/qgrid/qgrid-run-lifecycle.test.ts

@@ -1,12 +1,27 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { afterQuery } from "./qgrid-run-lifecycle";
+import {
+  afterQuery,
+  beforeQuery,
+  finishRunAborted,
+  finishRunWithError,
+} from "./qgrid-run-lifecycle";
 import { type QueryOutput } from "./qgrid.types";
 
-const { appendStepMock, aggregateStepUsageMock, finishRunMock } = vi.hoisted(() => ({
+const {
+  appendStepMock,
+  aggregateStepUsageMock,
+  finishRunMock,
+  createRunMock,
+  expireStaleToolWaitingRunsMock,
+  continueToolRunMock,
+} = vi.hoisted(() => ({
   appendStepMock: vi.fn(),
   aggregateStepUsageMock: vi.fn(),
   finishRunMock: vi.fn(),
+  createRunMock: vi.fn(),
+  expireStaleToolWaitingRunsMock: vi.fn(),
+  continueToolRunMock: vi.fn(),
 }));
 
 vi.mock("../request-log/request-log.model", () => ({
@@ -14,6 +29,9 @@ vi.mock("../request-log/request-log.model", () => ({
     appendStep: appendStepMock,
     aggregateStepUsage: aggregateStepUsageMock,
     finishRun: finishRunMock,
+    createRun: createRunMock,
+    expireStaleToolWaitingRuns: expireStaleToolWaitingRunsMock,
+    continueToolRun: continueToolRunMock,
   },
 }));
 
@@ -38,6 +56,126 @@ function queryOutput(overrides: Partial<QueryOutput> = {}): QueryOutput {
   };
 }
 
+let lifecycleNow = Date.now();
+
+describe("qgrid run lifecycle start", () => {
+  beforeEach(() => {
+    lifecycleNow += 60_001;
+    vi.spyOn(Date, "now").mockReturnValue(lifecycleNow);
+    createRunMock.mockReset().mockResolvedValue(10);
+    expireStaleToolWaitingRunsMock.mockReset().mockResolvedValue([]);
+    continueToolRunMock.mockReset().mockResolvedValue(3);
+    aggregateStepUsageMock.mockReset().mockResolvedValue({
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+      duration_ms: 0,
+      fallback_count: 0,
+      cost_usd: 0,
+    });
+    finishRunMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("creates a running parent with the full requested model before an initial query", async () => {
+    const history = JSON.stringify([
+      { type: "message", role: "user", content: "earlier" },
+      { type: "message", role: "system", content: "hidden" },
+      { type: "tool-result", output: "ignored" },
+    ]);
+
+    await expect(
+      beforeQuery({
+        prompt: "hi",
+        system: "system",
+        model: "openai/gpt-5-codex",
+        projectName: "project",
+        history,
+      }),
+    ).resolves.toEqual({ requestLogId: 10, stepIndex: 0 });
+
+    expect(createRunMock).toHaveBeenCalledWith({
+      user_prompt: "hi",
+      system_prompt: "system",
+      requested_model_name: "openai/gpt-5-codex",
+      effort: undefined,
+      project_name: "project",
+      history: [{ type: "message", role: "user", content: "earlier" }],
+      is_image_generation: undefined,
+    });
+  });
+
+  it("continues an existing parent and completes tool results before the next step", async () => {
+    const order: string[] = [];
+    continueToolRunMock.mockImplementationOnce(async () => {
+      order.push("continue-tool-run");
+      return 3;
+    });
+    expireStaleToolWaitingRunsMock.mockImplementationOnce(async () => {
+      order.push("cleanup-stale");
+      return [77];
+    });
+    const args = {
+      prompt: "continue",
+      runContext: { requestLogId: 10 },
+      toolResults: [{ toolCallId: "call-1", output: "sunny" }],
+    };
+
+    await expect(beforeQuery(args)).resolves.toEqual({ requestLogId: 10, stepIndex: 3 });
+
+    expect(createRunMock).not.toHaveBeenCalled();
+    expect(continueToolRunMock).toHaveBeenCalledWith(10, [
+      { toolCallId: "call-1", output: "sunny" },
+    ]);
+    expect(order).toEqual(["continue-tool-run", "cleanup-stale"]);
+    expect(finishRunMock).not.toHaveBeenCalled();
+  });
+
+  it("cleans up only stale unresolved tool-wait runs reported by the model", async () => {
+    expireStaleToolWaitingRunsMock.mockResolvedValueOnce([77]);
+
+    await beforeQuery({ prompt: "hi", model: "openai/gpt-5-codex" });
+
+    expect(expireStaleToolWaitingRunsMock).toHaveBeenCalledWith(
+      30 * 60 * 1000,
+      "tool-call run: no follow-up within 30 minutes",
+    );
+    expect(finishRunMock).not.toHaveBeenCalled();
+  });
+
+  it("throttles stale cleanup while still creating every requested run", async () => {
+    await beforeQuery({ prompt: "one", model: "openai/gpt-5-codex" });
+    await beforeQuery({ prompt: "two", model: "openai/gpt-5-codex" });
+
+    expect(expireStaleToolWaitingRunsMock).toHaveBeenCalledTimes(1);
+    expect(createRunMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("shares one in-flight stale cleanup across concurrent requests", async () => {
+    let resolveCleanup: ((ids: number[]) => void) | undefined;
+    expireStaleToolWaitingRunsMock.mockReturnValueOnce(
+      new Promise<number[]>((resolve) => {
+        resolveCleanup = resolve;
+      }),
+    );
+
+    const first = beforeQuery({ prompt: "one", model: "openai/gpt-5-codex" });
+    await vi.waitFor(() => expect(expireStaleToolWaitingRunsMock).toHaveBeenCalledTimes(1));
+    const second = beforeQuery({ prompt: "two", model: "openai/gpt-5-codex" });
+
+    expect(expireStaleToolWaitingRunsMock).toHaveBeenCalledTimes(1);
+    resolveCleanup?.([]);
+    await Promise.all([first, second]);
+
+    expect(expireStaleToolWaitingRunsMock).toHaveBeenCalledTimes(1);
+    expect(createRunMock).toHaveBeenCalledTimes(2);
+  });
+});
+
 describe("qgrid run lifecycle TTFT", () => {
   beforeEach(() => {
     appendStepMock.mockReset();
@@ -200,7 +338,7 @@ describe("qgrid run lifecycle TTFT", () => {
     );
   });
 
-  it("preserves serving model, fallback count, TTL split, and exact step cost", async () => {
+  it("stores full routed models, fallback count, TTL split, and exact step cost", async () => {
     aggregateStepUsageMock.mockResolvedValueOnce({
       input_tokens: 100_000,
       output_tokens: 20,
@@ -244,8 +382,8 @@ describe("qgrid run lifecycle TTFT", () => {
     expect(appendStepMock).toHaveBeenCalledWith(
       10,
       expect.objectContaining({
-        requested_model_name: "claude-fable-5",
-        model_name: "claude-opus-4-8",
+        requested_model_name: "anthropic/claude-fable-5",
+        model_name: "anthropic/claude-opus-4-8",
         fallback_count: 1,
         cache_creation_5m_tokens: 30_000,
         cache_creation_1h_tokens: 50_000,
@@ -256,8 +394,8 @@ describe("qgrid run lifecycle TTFT", () => {
     expect(finishRunMock).toHaveBeenCalledWith(
       10,
       expect.objectContaining({
-        requested_model_name: "claude-fable-5",
-        model_name: "claude-opus-4-8",
+        requested_model_name: "anthropic/claude-fable-5",
+        model_name: "anthropic/claude-opus-4-8",
         fallback_count: 1,
         cache_creation_5m_tokens: 30_000,
         cache_creation_1h_tokens: 50_000,
@@ -266,4 +404,100 @@ describe("qgrid run lifecycle TTFT", () => {
       }),
     );
   });
+
+  it("preserves the exact Anthropic 1M requested route after provider canonicalization", async () => {
+    await afterQuery(
+      10,
+      2,
+      { prompt: "hi", model: "anthropic/claude-sonnet-4-6[1m]" },
+      queryOutput({
+        model: "claude-sonnet-4-6",
+        requestedModel: "claude-sonnet-4-6",
+      }),
+    );
+
+    expect(appendStepMock).toHaveBeenCalledWith(
+      10,
+      expect.objectContaining({
+        requested_model_name: "anthropic/claude-sonnet-4-6[1m]",
+        model_name: "anthropic/claude-sonnet-4-6",
+      }),
+    );
+    expect(finishRunMock).toHaveBeenCalledWith(
+      10,
+      expect.objectContaining({
+        requested_model_name: "anthropic/claude-sonnet-4-6[1m]",
+        model_name: "anthropic/claude-sonnet-4-6",
+      }),
+    );
+  });
+});
+
+describe("qgrid run lifecycle terminal rollup", () => {
+  beforeEach(() => {
+    aggregateStepUsageMock.mockReset().mockResolvedValue({
+      input_tokens: 120,
+      output_tokens: 30,
+      cache_read_tokens: 20,
+      cache_creation_tokens: 40,
+      cache_creation_5m_tokens: 15,
+      cache_creation_1h_tokens: 25,
+      duration_ms: 900,
+      fallback_count: 1,
+      cost_usd: 7_500,
+      cost_source: "mixed",
+    });
+    finishRunMock.mockReset();
+  });
+
+  it("keeps incurred step usage and cost when a run ends in error", async () => {
+    await finishRunWithError(10, "provider failed", {
+      prompt: "continue",
+      history: JSON.stringify([{ type: "message", role: "user", content: "prior" }]),
+    });
+
+    expect(finishRunMock).toHaveBeenCalledWith(10, {
+      status: "error",
+      error_message: "provider failed",
+      history: [{ type: "message", role: "user", content: "prior" }],
+      input_tokens: 120,
+      output_tokens: 30,
+      cache_read_tokens: 20,
+      cache_creation_tokens: 40,
+      cache_creation_5m_tokens: 15,
+      cache_creation_1h_tokens: 25,
+      duration_ms: 900,
+      fallback_count: 1,
+      cost_usd: 7_500,
+      cost_source: "mixed",
+    });
+  });
+
+  it("keeps incurred step usage and cost when a run is aborted", async () => {
+    await finishRunAborted(10, { prompt: "continue" });
+
+    expect(finishRunMock).toHaveBeenCalledWith(
+      10,
+      expect.objectContaining({
+        status: "aborted",
+        error_message: "client disconnected",
+        input_tokens: 120,
+        output_tokens: 30,
+        cost_usd: 7_500,
+        cost_source: "mixed",
+      }),
+    );
+  });
+
+  it("still writes the terminal status when usage aggregation fails", async () => {
+    aggregateStepUsageMock.mockRejectedValueOnce(new Error("aggregate failed"));
+
+    await finishRunWithError(10, "provider failed");
+
+    expect(finishRunMock).toHaveBeenCalledWith(10, {
+      status: "error",
+      error_message: "provider failed",
+      history: undefined,
+    });
+  });
 });

package/bundle/src/application/qgrid/qgrid-run-lifecycle.ts

@@ -10,15 +10,24 @@ import {
   formatResponseForLog,
   getImageParts,
 } from "./qgrid-response-format";
-import {
-  type QgridRunContext,
-  type QgridToolResultInput,
-  type QueryInput,
-  type QueryOutput,
-} from "./qgrid.types";
+import { type QgridRunContext, type QueryInput, type QueryOutput } from "./qgrid.types";
 
 const logger = getLogger(["qgrid", "run-lifecycle"]);
 const STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;
+const STALE_CLEANUP_INTERVAL_MS = 60 * 1000;
+let staleCleanupInFlight: Promise<void> | undefined;
+let lastStaleCleanupStartedAt = 0;
+
+function withProviderPrefix(
+  routeModel: string | undefined,
+  model: string | undefined,
+): string | undefined {
+  if (!model) return undefined;
+  if (model.includes("/")) return model;
+  const slash = routeModel?.indexOf("/") ?? -1;
+  const provider = slash > 0 ? routeModel?.slice(0, slash) : undefined;
+  return provider ? `${provider}/${model}` : model;
+}
 
 /**
  * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장
@@ -43,36 +52,35 @@ export type RunLifecycleResult = {
 };
 
 /**
- * logMode:"run" 시 query/stream 응답 전후에 호출.
+ * logger-enabled query/stream 응답 전후에 호출.
  *
- * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale cleanup
+ * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale tool-wait cleanup
  * 2) afterQuery: generate step + tool-call step + finish/keep-open
  */
 export async function beforeQuery(args: QueryInput): Promise<{
   requestLogId: number;
   stepIndex: number;
 }> {
-  await cleanupStaleRuns();
-
   let requestLogId: number;
   let stepIndex = 0;
 
   // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.
   if (args.runContext?.requestLogId !== undefined) {
     requestLogId = args.runContext.requestLogId;
-
-    if (args.toolResults && args.toolResults.length > 0) {
-      await completeToolResults(requestLogId, args.toolResults);
-    }
-
-    stepIndex = await RequestLogModel.getNextStepIndex(requestLogId);
+    // cleanup과 같은 DB advisory lock을 잡고 tool 결과 반영 + 다음 step 예약을 한
+    // transaction에서 처리한다. 여러 qgrid 프로세스 사이에서도 stale expiry가
+    // 도착 중인 follow-up을 error로 덮어쓰지 못한다.
+    stepIndex = await RequestLogModel.continueToolRun(requestLogId, args.toolResults ?? []);
+    await cleanupStaleRuns();
   } else {
+    await cleanupStaleRuns();
     requestLogId = await RequestLogModel.createRun({
       user_prompt: args.prompt,
       system_prompt: args.system,
-      model_name: args.model,
+      requested_model_name: args.model,
       effort: args.effort,
       project_name: args.projectName,
+      history: filterHistoryForStorage(args.history),
       is_image_generation: args.imageGeneration,
     });
   }
@@ -86,12 +94,19 @@ export async function afterQuery(
   args: QueryInput,
   result: QueryOutput,
 ): Promise<RunLifecycleResult> {
+  // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.
+  const requestedModelName = withProviderPrefix(
+    args.model,
+    args.model ?? result.requestedModel ?? result.model,
+  );
+  const servedModelName = withProviderPrefix(args.model, result.model);
+
   // generate step 기록
   await RequestLogModel.appendStep(requestLogId, {
     step_index: stepIndex,
     type: "generate",
-    model_name: result.model,
-    requested_model_name: result.requestedModel ?? result.model ?? args.model,
+    model_name: servedModelName,
+    requested_model_name: requestedModelName,
     fallback_count: result.modelFallbacks?.length ?? 0,
     input_tokens: result.usage.input_tokens,
     output_tokens: result.usage.output_tokens,
@@ -116,7 +131,7 @@ export async function afterQuery(
   }
 
   if (result.finishReason === "tool-calls") {
-    // tool-call step 즉시 기록 (result는 나중에 completeToolCall로 채움)
+    // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.
     const toolCalls = result.content.filter((c) => c.type === "tool-call");
     for (let i = 0; i < toolCalls.length; i++) {
       const tc = toolCalls[i]!;
@@ -147,8 +162,9 @@ export async function afterQuery(
     cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
     cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
     duration_ms: agg.duration_ms,
-    requested_model_name: agg.requested_model_name ?? result.requestedModel ?? result.model,
-    model_name: agg.model_name ?? result.model,
+    // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.
+    requested_model_name: requestedModelName,
+    model_name: servedModelName,
     fallback_count: agg.fallback_count,
     cost_usd: agg.cost_usd,
     cost_source: agg.cost_source,
@@ -166,56 +182,80 @@ export async function finishRunWithError(
   errorMessage: string,
   args?: QueryInput,
 ): Promise<void> {
-  try {
-    await RequestLogModel.finishRun(requestLogId, {
-      status: "error",
-      error_message: errorMessage,
-      history: args ? filterHistoryForStorage(args.history) : undefined,
-    });
-  } catch (e) {
-    logger.error(`finishRunWithError failed: ${(e as Error).message}`);
-  }
+  await finishTerminalRun(requestLogId, "error", errorMessage, args);
 }
 
 export async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {
-  try {
-    await RequestLogModel.finishRun(requestLogId, {
-      status: "aborted",
-      error_message: "client disconnected",
-      history: args ? filterHistoryForStorage(args.history) : undefined,
-    });
-  } catch (e) {
-    logger.error(`finishRunAborted failed: ${(e as Error).message}`);
-  }
+  await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
 }
 
-async function completeToolResults(
+async function finishTerminalRun(
   requestLogId: number,
-  toolResults: QgridToolResultInput[],
+  status: "error" | "aborted",
+  errorMessage: string,
+  args?: QueryInput,
 ): Promise<void> {
-  for (const tr of toolResults) {
+  try {
+    let aggregate: Awaited<ReturnType<typeof RequestLogModel.aggregateStepUsage>> | undefined;
     try {
-      await RequestLogModel.completeToolCall(requestLogId, tr.toolCallId, {
-        tool_result: tr.isError ? undefined : tr.output,
-        error: tr.isError ? tr.output : undefined,
-      });
+      aggregate = await RequestLogModel.aggregateStepUsage(requestLogId);
     } catch (e) {
-      logger.error(`completeToolCall failed for ${tr.toolCallId}: ${(e as Error).message}`);
+      logger.error(`aggregateStepUsage failed while finishing ${status}: ${(e as Error).message}`);
     }
+
+    await RequestLogModel.finishRun(requestLogId, {
+      status,
+      error_message: errorMessage,
+      history: args ? filterHistoryForStorage(args.history) : undefined,
+      ...(aggregate
+        ? {
+            input_tokens: aggregate.input_tokens,
+            output_tokens: aggregate.output_tokens,
+            cache_read_tokens: aggregate.cache_read_tokens,
+            cache_creation_tokens: aggregate.cache_creation_tokens,
+            cache_creation_5m_tokens: aggregate.cache_creation_5m_tokens,
+            cache_creation_1h_tokens: aggregate.cache_creation_1h_tokens,
+            duration_ms: aggregate.duration_ms,
+            fallback_count: aggregate.fallback_count,
+            cost_usd: aggregate.cost_usd,
+            cost_source: aggregate.cost_source,
+          }
+        : {}),
+    });
+  } catch (e) {
+    logger.error(`finishTerminalRun(${status}) failed: ${(e as Error).message}`);
   }
 }
 
 async function cleanupStaleRuns(): Promise<void> {
+  if (staleCleanupInFlight) {
+    await staleCleanupInFlight;
+    return;
+  }
+
+  const now = Date.now();
+  if (now - lastStaleCleanupStartedAt < STALE_CLEANUP_INTERVAL_MS) return;
+  lastStaleCleanupStartedAt = now;
+
+  const cleanup = performStaleRunCleanup();
+  staleCleanupInFlight = cleanup;
   try {
-    const staleIds = await RequestLogModel.findStaleRunningIds(STALE_RUN_THRESHOLD_MS);
-    for (const id of staleIds) {
-      await RequestLogModel.finishRun(id, {
-        status: "error",
-        error_message: "tool-call run: no follow-up within 30 minutes",
-      });
-    }
-    if (staleIds.length > 0) {
-      logger.info(`cleaned up ${staleIds.length} stale running request logs`);
+    await cleanup;
+  } finally {
+    if (staleCleanupInFlight === cleanup) staleCleanupInFlight = undefined;
+  }
+}
+
+async function performStaleRunCleanup(): Promise<void> {
+  try {
+    const errorMessage = "tool-call run: no follow-up within 30 minutes";
+    const staleIds = await RequestLogModel.expireStaleToolWaitingRuns(
+      STALE_RUN_THRESHOLD_MS,
+      errorMessage,
+    );
+    const cleanedCount = staleIds.length;
+    if (cleanedCount > 0) {
+      logger.info(`cleaned up ${cleanedCount} stale running request logs`);
     }
   } catch (e) {
     logger.error(`stale cleanup failed: ${(e as Error).message}`);