@cartanova/qgrid-cli 2.10.2 → 2.10.4

package/bundle/src/application/monit/log-buffer.ts

@@ -1,12 +1,6 @@
 /**
- * Monit 로그 ring buffer — 프로세스 생존 기간 동안 최근 로그를 구조화 레코드로 보관한다.
- *
- * 콘솔 sink 와 병렬로 등록되는 두 번째 logtape sink 가 이 버퍼를 채우고,
- * monit.frame 이 커서 기반으로 읽어 대시보드 Monit 탭에 제공한다.
- * 재시작하면 리셋된다 — 영속 기록은 request_log 의 몫.
- *
- * timestamp/processStartedAt 은 epoch ms 숫자로 유지한다. web 의 전역 dateReviver 가
- * ISO 문자열을 Date 로 바꿔버리므로, 숫자만이 재시작 감지의 동등성 비교를 보존한다.
+ * 재시작하면 초기화되는 Monit 로그 버퍼.
+ * timestamp/processStartedAt은 web의 dateReviver 변환을 피하고 동등성 비교를 유지하도록 epoch ms를 쓴다.
  */
 import { type LogRecord, type Sink } from "@logtape/logtape";
 
@@ -48,16 +42,14 @@ function renderValue(value: unknown): string {
 
 export class MonitLogBuffer {
   readonly processStartedAt = Date.now();
-  private entries: MonitLogEntry[] = [];
-  private nextSeq = 1;
+  entries: MonitLogEntry[] = [];
+  nextSeq = 1;
 
   constructor(
-    private readonly capacity = DEFAULT_CAPACITY,
-    private readonly maxTextLength = DEFAULT_MAX_TEXT_LENGTH,
+    readonly capacity = DEFAULT_CAPACITY,
+    readonly maxTextLength = DEFAULT_MAX_TEXT_LENGTH,
   ) {}
 
-  // logtape sink 본체. logtape 가 sink 오류를 격리하지만, 버퍼 버그가
-  // meta logger 소음을 만들지 않도록 방어적으로 한 번 더 감싼다.
   push(record: LogRecord): void {
     try {
       let text = flattenMessage(record.message);
@@ -79,31 +71,25 @@ export class MonitLogBuffer {
     }
   }
 
-  get oldestSeq(): number {
-    return this.entries[0]?.seq ?? this.nextSeq;
-  }
-
-  get latestSeq(): number {
-    return this.nextSeq - 1;
-  }
-
-  // cursor 이후의 엔트리를 최대 limit 개 반환한다. cursor 미지정이면 tail.
+  // cursor 미지정이면 최근 엔트리부터 반환한다.
   after(cursor: number | undefined, limit: number): MonitLogChunk {
+    const latestSeq = this.nextSeq - 1;
+    const oldestSeq = this.entries[0]?.seq ?? this.nextSeq;
     if (cursor === undefined) {
       const entries = this.entries.slice(-limit);
       return {
         entries,
-        nextCursor: entries.at(-1)?.seq ?? this.latestSeq,
+        nextCursor: entries.at(-1)?.seq ?? latestSeq,
         dropped: 0,
       };
     }
 
     // 이전 프로세스의 커서 등 미래 커서는 방어적으로 현재 tail 로 재동기화한다.
-    if (cursor > this.latestSeq) {
-      return { entries: [], nextCursor: this.latestSeq, dropped: 0 };
+    if (cursor > latestSeq) {
+      return { entries: [], nextCursor: latestSeq, dropped: 0 };
     }
 
-    const dropped = Math.max(this.oldestSeq - cursor - 1, 0);
+    const dropped = Math.max(oldestSeq - cursor - 1, 0);
     const startIndex = this.entries.findIndex((entry) => entry.seq > cursor);
     const entries = startIndex === -1 ? [] : this.entries.slice(startIndex, startIndex + limit);
     return {

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

@@ -36,12 +36,12 @@ describe("MonitFrame.monitLogs", () => {
     const chunk = await MonitFrame.monitLogs();
     expect(chunk.processStartedAt).toBe(monitLogBuffer.processStartedAt);
     expect(chunk.dropped).toBe(0);
-    expect(chunk.nextCursor).toBe(monitLogBuffer.latestSeq);
+    expect(chunk.nextCursor).toBe(monitLogBuffer.after(undefined, 1).nextCursor);
     expect(chunk.entries.at(-1)?.text).toBe("second line");
   });
 
   it("returns only entries newer than the cursor with no boundary duplicates", async () => {
-    const baseline = monitLogBuffer.latestSeq;
+    const baseline = monitLogBuffer.after(undefined, 1).nextCursor;
     push("after baseline 1");
     push("after baseline 2");
 
@@ -50,7 +50,7 @@ describe("MonitFrame.monitLogs", () => {
       "after baseline 1",
       "after baseline 2",
     ]);
-    expect(chunk.nextCursor).toBe(monitLogBuffer.latestSeq);
+    expect(chunk.nextCursor).toBe(monitLogBuffer.after(undefined, 1).nextCursor);
 
     const followUp = await MonitFrame.monitLogs(chunk.nextCursor);
     expect(followUp.entries).toEqual([]);
@@ -90,7 +90,7 @@ describe("MonitFrame.monitLogs", () => {
       properties: { accessToken: "forbidden-property-secret", refreshToken: "also-forbidden" },
     });
 
-    const chunk = await MonitFrame.monitLogs(monitLogBuffer.latestSeq - 1);
+    const chunk = await MonitFrame.monitLogs(monitLogBuffer.after(undefined, 1).nextCursor - 1);
     const serialized = JSON.stringify(chunk);
     expect(serialized).not.toContain("forbidden-property-secret");
     expect(serialized).not.toContain("also-forbidden");
@@ -115,14 +115,13 @@ describe("MonitFrame.monitLogs", () => {
   it("piggybacks live vitals on every chunk, zeroed before dispatchers boot", async () => {
     QgridDispatcher.openaiDispatcher = {
       inFlight: 3,
-      quotaByToken: [
+      getQuotaSnapshot: () => [
         { name: "openai/haze", usedPercent: 41, threshold: 80, blocked: false, resetsAt: null },
         { name: "openai/nk", usedPercent: null, threshold: null, blocked: false, resetsAt: null },
       ],
     } as never;
     QgridDispatcher.anthropicDispatcher = {
-      tokenCount: 8,
-      tokenNames: ["anthropic/haze", "anthropic/noa"],
+      tokenPool: new Map([[1, {name: "anthropic/noa"}], [2, {name: "anthropic/haze"}]]),
       inFlight: 2,
     } as never;
     try {
@@ -133,7 +132,7 @@ describe("MonitFrame.monitLogs", () => {
           { name: "openai/haze", usedPercent: 41, threshold: 80, blocked: false, resetsAt: null },
           { name: "openai/nk", usedPercent: null, threshold: null, blocked: false, resetsAt: null },
         ],
-        anthropicTokenCount: 8,
+        anthropicTokenCount: 2,
         anthropicTokenNames: ["anthropic/haze", "anthropic/noa"],
         anthropicInFlight: 2,
       });

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

@@ -1,9 +1,4 @@
-/**
- * Monit — 대시보드 Monit 탭용 프로세스 로그 관측 API.
- *
- * 읽기 전용. ring buffer 를 얇게 직접 읽으며(범용 쿼리 기계 없이),
- * request log 를 남기지 않는다. 접근 경계는 다른 대시보드 API 와 동일하다.
- */
+// 읽기 전용 모니터링 API. 조회 자체는 request log에 남기지 않는다.
 import { api, BaseFrameClass, DB } from "sonamu";
 
 import { resolveOpenAITransportKind } from "../../utils/providers/openai/openai-transport-config";
@@ -49,9 +44,7 @@ class MonitFrameClass extends BaseFrameClass {
     };
   }
 
-  // 최근 1시간 provider 별 요청/오류/캐시 통계. vitals 와 달리 request_logs 를 타므로
-  // 분리된 endpoint 로 두고 웹에서 더 느슨한 주기로 폴링한다. 읽기 전용이며 request log 를
-  // 남기지 않는 monit 경계는 동일하다.
+  // DB를 조회하므로 메모리 기반 vitals보다 느린 주기로 폴링한다.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async monitStats(): Promise<MonitStats> {
     const windowMinutes = 60;
@@ -60,14 +53,16 @@ class MonitFrameClass extends BaseFrameClass {
   }
 }
 
-// dispatcher 미초기화(부팅 직후) 시 0 으로 응답한다 — 가벼운 스냅샷이라 오류로 만들지 않는다.
 function currentVitals(): MonitVitals {
+  const anthropic = QgridDispatcher.anthropicDispatcher;
   return {
     openaiInFlight: QgridDispatcher.openaiDispatcher?.inFlight ?? 0,
-    openaiQuotaByToken: QgridDispatcher.openaiDispatcher?.quotaByToken ?? [],
-    anthropicTokenCount: QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0,
-    anthropicTokenNames: QgridDispatcher.anthropicDispatcher?.tokenNames ?? [],
-    anthropicInFlight: QgridDispatcher.anthropicDispatcher?.inFlight ?? 0,
+    openaiQuotaByToken: QgridDispatcher.openaiDispatcher?.getQuotaSnapshot() ?? [],
+    anthropicTokenCount: anthropic?.tokenPool.size ?? 0,
+    anthropicTokenNames: anthropic
+      ? [...anthropic.tokenPool.values()].map((token) => token.name).toSorted()
+      : [],
+    anthropicInFlight: anthropic?.inFlight ?? 0,
   };
 }
 

package/bundle/src/application/qgrid/oauth.ts

@@ -132,7 +132,7 @@ export class RefreshFailedError extends Error {
   }
 
   /** 재로그인 외 복구 불가한 인증 실패인지. 일시 오류(5xx·네트워크)는 제외된다. */
-  get isAuthDead(): boolean {
+  isAuthDead(): boolean {
     return this.status === 400 || this.status === 401;
   }
 }

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

@@ -1,16 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import {
-  beginServerRestart,
-  resetServerRestartForTests,
-} from "../../utils/server-restart";
 import {
   afterQuery,
   beforeQuery,
-  finishActiveNativeRunsForRestart,
   finishRunAborted,
   finishRunWithError,
-  resetNativeRunRegistryForTests,
 } from "./qgrid-run-lifecycle";
 import { type QueryOutput } from "./qgrid.types";
 
@@ -65,11 +59,6 @@ function queryOutput(overrides: Partial<QueryOutput> = {}): QueryOutput {
 
 let lifecycleNow = Date.now();
 
-afterEach(() => {
-  resetServerRestartForTests();
-  resetNativeRunRegistryForTests();
-});
-
 describe("qgrid run lifecycle start", () => {
   beforeEach(() => {
     lifecycleNow += 60_001;
@@ -122,6 +111,13 @@ describe("qgrid run lifecycle start", () => {
     });
   });
 
+  it.each([false, true, undefined])("does not log ignored effort when thinking is %s", async (thinking) => {
+    await beforeQuery({ prompt: "hi", model: "openai/gpt-6-sol", thinking, effort: "high" });
+    expect(createRunMock).toHaveBeenCalledWith(expect.objectContaining({
+      effort: thinking === false ? undefined : "high",
+    }));
+  });
+
   it.each([false, true])("classifies automatic image output only when produced (%s)", async (hasImage) => {
     const args = { prompt: "chat", model: "openai/gpt-6-astra", imageGeneration: "auto" as const };
     const run = await beforeQuery(args);
@@ -214,107 +210,7 @@ describe("qgrid run lifecycle start", () => {
     expect(createRunMock).toHaveBeenCalledTimes(2);
   });
 
-  it("rejects new native runs while a restart is pending", async () => {
-    beginServerRestart();
-
-    await expect(beforeQuery({ prompt: "hi" })).rejects.toMatchObject({ statusCode: 503 });
-    expect(createRunMock).not.toHaveBeenCalled();
-  });
-
-  it("finishes a run prepared during the restart race before rejecting provider execution", async () => {
-    let resolveCreate!: (requestLogId: number) => void;
-    createRunMock.mockReturnValueOnce(
-      new Promise<number>((resolve) => {
-        resolveCreate = resolve;
-      }),
-    );
-
-    const starting = beforeQuery({ prompt: "hi" });
-    await vi.waitFor(() => expect(createRunMock).toHaveBeenCalledOnce());
-    beginServerRestart();
-    resolveCreate(22);
-
-    await expect(starting).rejects.toMatchObject({ statusCode: 503 });
-    expect(finishRunMock).toHaveBeenCalledWith(
-      22,
-      expect.objectContaining({ status: "error", error_message: "server restarted" }),
-    );
-  });
-
-  it("marks only active native runs as restarted and prevents a late success overwrite", async () => {
-    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "hi" });
 
-    await finishActiveNativeRunsForRestart();
-    expect(finishRunMock).toHaveBeenCalledWith(
-      requestLogId,
-      expect.objectContaining({ status: "error", error_message: "server restarted" }),
-    );
-
-    appendStepMock.mockClear();
-    finishRunMock.mockClear();
-    await expect(afterQuery(requestLogId, stepIndex, { prompt: "hi" }, queryOutput())).resolves.toEqual(
-      {},
-    );
-    expect(appendStepMock).not.toHaveBeenCalled();
-    expect(finishRunMock).not.toHaveBeenCalled();
-  });
-
-  it("waits for an in-flight finalizer and writes the restart error last", async () => {
-    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "hi" });
-    let releaseAppend!: () => void;
-    appendStepMock.mockReturnValueOnce(
-      new Promise<void>((resolve) => {
-        releaseAppend = resolve;
-      }),
-    );
-
-    const finishing = afterQuery(requestLogId, stepIndex, { prompt: "hi" }, queryOutput());
-    await vi.waitFor(() => expect(appendStepMock).toHaveBeenCalledOnce());
-    const restarting = finishActiveNativeRunsForRestart();
-
-    await Promise.resolve();
-    expect(finishRunMock).not.toHaveBeenCalledWith(
-      requestLogId,
-      expect.objectContaining({ error_message: "server restarted" }),
-    );
-
-    releaseAppend();
-    await Promise.all([finishing, restarting]);
-
-    const terminalStatuses = finishRunMock.mock.calls
-      .filter(([id]) => id === requestLogId)
-      .map(([, payload]) => payload.status);
-    expect(terminalStatuses.at(-1)).toBe("error");
-    expect(finishRunMock).toHaveBeenLastCalledWith(
-      requestLogId,
-      expect.objectContaining({ status: "error", error_message: "server restarted" }),
-    );
-  });
-
-  it("leaves tool-wait runs alone after their provider turn has completed", async () => {
-    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "use a tool" });
-    await afterQuery(
-      requestLogId,
-      stepIndex,
-      { prompt: "use a tool" },
-      queryOutput({
-        finishReason: "tool-calls",
-        content: [
-          {
-            type: "tool-call",
-            toolCallId: "call-1",
-            toolName: "lookup",
-            input: "{}",
-          },
-        ],
-      }),
-    );
-    finishRunMock.mockClear();
-
-    await finishActiveNativeRunsForRestart();
-
-    expect(finishRunMock).not.toHaveBeenCalled();
-  });
 });
 
 describe("qgrid run lifecycle TTFT", () => {

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

@@ -1,8 +1,5 @@
 import { getLogger } from "@logtape/logtape";
-import { ServiceUnavailableException } from "sonamu";
 
-import { SD } from "../../i18n/sd.generated";
-import { isRestartPending } from "../../utils/server-restart";
 import { RequestLogModel } from "../request-log/request-log.model";
 import {
   estimateImageGenerationCostMicroUsd,
@@ -20,44 +17,6 @@ const STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;
 const STALE_CLEANUP_INTERVAL_MS = 60 * 1000;
 let staleCleanupInFlight: Promise<void> | undefined;
 let lastStaleCleanupStartedAt = 0;
-const activeNativeRunRefs = new Map<number, number>();
-const interruptedNativeRunIds = new Set<number>();
-const activeNativeFinalizers = new Map<number, Set<Promise<void>>>();
-
-function restartUnavailable(): ServiceUnavailableException {
-  return new ServiceUnavailableException(SD("qgrid.restartPending")());
-}
-
-function registerNativeRun(requestLogId: number): void {
-  activeNativeRunRefs.set(requestLogId, (activeNativeRunRefs.get(requestLogId) ?? 0) + 1);
-}
-
-function releaseNativeRun(requestLogId: number): void {
-  const refs = activeNativeRunRefs.get(requestLogId);
-  if (refs === undefined || refs <= 1) activeNativeRunRefs.delete(requestLogId);
-  else activeNativeRunRefs.set(requestLogId, refs - 1);
-}
-
-function trackNativeFinalizer<T>(requestLogId: number, finalize: () => Promise<T>): Promise<T> {
-  const operation = finalize();
-  const settled = operation.then(
-    () => undefined,
-    () => undefined,
-  );
-  const finalizers = activeNativeFinalizers.get(requestLogId) ?? new Set<Promise<void>>();
-  finalizers.add(settled);
-  activeNativeFinalizers.set(requestLogId, finalizers);
-  void settled.then(() => {
-    finalizers.delete(settled);
-    if (finalizers.size === 0) activeNativeFinalizers.delete(requestLogId);
-  });
-  return operation;
-}
-
-export function assertNativeRunAdmission(): void {
-  if (isRestartPending()) throw restartUnavailable();
-}
-
 function withProviderPrefix(
   routeModel: string | undefined,
   model: string | undefined,
@@ -110,8 +69,6 @@ export async function beforeQuery(args: QueryInput): Promise<{
   requestLogId: number;
   stepIndex: number;
 }> {
-  assertNativeRunAdmission();
-
   let requestLogId: number;
   let stepIndex = 0;
 
@@ -131,7 +88,7 @@ export async function beforeQuery(args: QueryInput): Promise<{
       user_prompt: args.prompt,
       system_prompt: args.system,
       requested_model_name: args.model,
-      effort: args.effort,
+      effort: args.thinking === false ? undefined : args.effort,
       project_name: args.projectName,
       history: filterHistoryForStorage(args.history),
       tools: args.tools?.length ? args.tools : undefined,
@@ -140,14 +97,6 @@ export async function beforeQuery(args: QueryInput): Promise<{
     });
   }
 
-  // DB 준비 중에 재시작이 시작됐다면 provider 실행으로 넘어가지 않는다.
-  // 이 요청은 재시작 snapshot에 없었으므로 방금 준비한 run을 직접 마감한다.
-  if (isRestartPending()) {
-    await finishTerminalRun(requestLogId, "error", "server restarted");
-    throw restartUnavailable();
-  }
-
-  registerNativeRun(requestLogId);
   return { requestLogId, stepIndex };
 }
 
@@ -157,102 +106,94 @@ export async function afterQuery(
   args: QueryInput,
   result: QueryOutput,
 ): Promise<RunLifecycleResult> {
-  if (interruptedNativeRunIds.has(requestLogId)) return {};
+  // 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: servedModelName,
+    requested_model_name: requestedModelName,
+    fallback_count: result.modelFallbacks?.length ?? 0,
+    input_tokens: result.usage.input_tokens,
+    output_tokens: result.usage.output_tokens,
+    cache_read_tokens: result.usage.cache_read_input_tokens,
+    cache_creation_tokens: result.usage.cache_creation_input_tokens,
+    cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,
+    cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,
+    cost_usd: Math.round(result.costUsd * 1_000_000),
+    cost_source: result.costSource,
+    duration_ms: result.durationMs,
+    ttft_ms: result.ttftMs,
+    finish_reason: result.finishReason,
+  });
 
-  return trackNativeFinalizer(requestLogId, async () => {
-    try {
-      // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.
-      const requestedModelName = withProviderPrefix(
-        args.model,
-        args.model ?? result.requestedModel ?? result.model,
-      );
-      const servedModelName = withProviderPrefix(args.model, result.model);
+  const imageParts = getImageParts(result);
+  const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(
+    result,
+    args.imageGenerationOptions,
+  );
+  for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {
+    await RequestLogModel.appendStep(requestLogId, step);
+  }
 
-      // generate step 기록
+  if (result.finishReason === "tool-calls") {
+    // 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]!;
+      if (tc.type !== "tool-call") continue;
       await RequestLogModel.appendStep(requestLogId, {
         step_index: stepIndex,
-        type: "generate",
-        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,
-        cache_read_tokens: result.usage.cache_read_input_tokens,
-        cache_creation_tokens: result.usage.cache_creation_input_tokens,
-        cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,
-        cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,
-        cost_usd: Math.round(result.costUsd * 1_000_000),
-        cost_source: result.costSource,
-        duration_ms: result.durationMs,
-        ttft_ms: result.ttftMs,
-        finish_reason: result.finishReason,
+        type: "tool_call",
+        tool_call_index: imageParts.length + i,
+        tool_call_id: tc.toolCallId,
+        tool_name: tc.toolName,
+        tool_args: tc.input,
       });
+    }
 
-      const imageParts = getImageParts(result);
-      const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(
-        result,
-        args.imageGenerationOptions,
-      );
-      for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {
-        await RequestLogModel.appendStep(requestLogId, step);
-      }
-
-      if (result.finishReason === "tool-calls") {
-        // 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]!;
-          if (tc.type !== "tool-call") continue;
-          await RequestLogModel.appendStep(requestLogId, {
-            step_index: stepIndex,
-            type: "tool_call",
-            tool_call_index: imageParts.length + i,
-            tool_call_id: tc.toolCallId,
-            tool_name: tc.toolName,
-            tool_args: tc.input,
-          });
-        }
-
-        return { runContext: { requestLogId } };
-      }
-
-      // finishReason === "stop" → run 종료 (전체 step usage 합산)
-      const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
-      const responseText = formatResponseForLog(result);
-      await RequestLogModel.finishRun(requestLogId, {
-        status: "succeeded",
-        response: responseText,
-        // structured 요청만 판정한다. deti 배치의 broken JSON 류를 목록에서 바로
-        // 구별하기 위한 기록이며, 비structured 요청은 null 로 남는다.
-        response_json_ok: args.jsonSchema ? isParseableJson(responseText) : null,
-        token_name: result.tokenName,
-        input_tokens: agg.input_tokens,
-        output_tokens: agg.output_tokens,
-        cache_read_tokens: agg.cache_read_tokens,
-        cache_creation_tokens: agg.cache_creation_tokens,
-        cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
-        cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
-        duration_ms: agg.duration_ms,
-        // 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,
-        image_cost_usd: imageCostMicroUsd,
-        ...(imageParts.length > 0 ? { is_image_generation: true } : {}),
-        image_cost_method:
-          imageCostMicroUsd !== null
-            ? imageGenerationCostMethod(args.imageGenerationOptions, result)
-            : null,
-        history: filterHistoryForStorage(args.history),
-      });
+    return { runContext: { requestLogId } };
+  }
 
-      return {};
-    } finally {
-      releaseNativeRun(requestLogId);
-    }
+  // finishReason === "stop" → run 종료 (전체 step usage 합산)
+  const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
+  const responseText = formatResponseForLog(result);
+  await RequestLogModel.finishRun(requestLogId, {
+    status: "succeeded",
+    response: responseText,
+    // structured 요청만 판정한다. deti 배치의 broken JSON 류를 목록에서 바로
+    // 구별하기 위한 기록이며, 비structured 요청은 null 로 남는다.
+    response_json_ok: args.jsonSchema ? isParseableJson(responseText) : null,
+    token_name: result.tokenName,
+    input_tokens: agg.input_tokens,
+    output_tokens: agg.output_tokens,
+    cache_read_tokens: agg.cache_read_tokens,
+    cache_creation_tokens: agg.cache_creation_tokens,
+    cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
+    cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
+    duration_ms: agg.duration_ms,
+    // 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,
+    image_cost_usd: imageCostMicroUsd,
+    ...(imageParts.length > 0 ? { is_image_generation: true } : {}),
+    image_cost_method:
+      imageCostMicroUsd !== null
+        ? imageGenerationCostMethod(args.imageGenerationOptions, result)
+        : null,
+    history: filterHistoryForStorage(args.history),
   });
+
+  return {};
 }
 
 export async function finishRunWithError(
@@ -260,48 +201,11 @@ export async function finishRunWithError(
   errorMessage: string,
   args?: QueryInput,
 ): Promise<void> {
-  if (interruptedNativeRunIds.has(requestLogId)) return;
-  return trackNativeFinalizer(requestLogId, async () => {
-    try {
-      await finishTerminalRun(requestLogId, "error", errorMessage, args);
-    } finally {
-      releaseNativeRun(requestLogId);
-    }
-  });
+  await finishTerminalRun(requestLogId, "error", errorMessage, args);
 }
 
 export async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {
-  if (interruptedNativeRunIds.has(requestLogId)) return;
-  return trackNativeFinalizer(requestLogId, async () => {
-    try {
-      await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
-    } finally {
-      releaseNativeRun(requestLogId);
-    }
-  });
-}
-
-/** 현재 이 프로세스가 provider를 실행 중인 native run만 재시작 오류로 마감한다. */
-export async function finishActiveNativeRunsForRestart(): Promise<void> {
-  const requestLogIds = [...activeNativeRunRefs.keys()];
-  for (const requestLogId of requestLogIds) {
-    interruptedNativeRunIds.add(requestLogId);
-    activeNativeRunRefs.delete(requestLogId);
-  }
-
-  await Promise.all(
-    requestLogIds.map(async (requestLogId) => {
-      await Promise.all(activeNativeFinalizers.get(requestLogId) ?? []);
-      await finishTerminalRun(requestLogId, "error", "server restarted");
-    }),
-  );
-}
-
-/** 프로세스 전역 registry를 격리해야 하는 단위 테스트 전용. */
-export function resetNativeRunRegistryForTests(): void {
-  activeNativeRunRefs.clear();
-  interruptedNativeRunIds.clear();
-  activeNativeFinalizers.clear();
+  await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
 }
 
 async function finishTerminalRun(