@cartanova/qgrid-cli 2.10.10 → 2.11.1

package/bundle/src/sonamu.config.ts

@@ -6,6 +6,7 @@ import { getPrettyFormatter } from "@logtape/pretty";
 import { type FastifyReply, type FastifyRequest } from "fastify";
 import { CachePresets, defineConfig } from "sonamu";
 import { drivers as cacheDrivers, store } from "sonamu/cache";
+import { z } from "zod";
 
 import { monitLogSink } from "./application/monit/log-buffer";
 import {
@@ -14,7 +15,12 @@ import {
   stopExpiredTokenReminder,
 } from "./application/qgrid/expired-token-reminder";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher";
-import { QgridFrame } from "./application/qgrid/qgrid.frame";
+import {
+  mapRequestBodyTooLarge,
+  persistGrokCredentials,
+  QgridFrame,
+} from "./application/qgrid/qgrid.frame";
+import { REQUEST_BODY_LIMIT_BYTES } from "./application/qgrid/qgrid.types";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup";
 import {
@@ -25,9 +31,18 @@ import {
 import { loadSettings, setSettingChangeHandler } from "./application/setting/setting.store";
 import { handleServerError } from "./server-error-handler";
 import { AnthropicDispatcher } from "./utils/providers/anthropic/anthropic-dispatcher";
+import { GrokDispatcher, GrokRefreshCoordinator } from "./utils/providers/grok";
+import { GrokMediaClient } from "./utils/providers/grok/grok-media-client";
+import { GrokVoiceClient } from "./utils/providers/grok/grok-voice-client";
 import { stopOpenAICallbackRelay } from "./utils/providers/openai/openai-callback-relay";
 import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher";
 
+// Repeated query keys arrive as arrays; the callback then treats the request as missing params.
+const oauthCallbackQuerySchema = z.looseObject({
+  code: z.string().optional(),
+  state: z.string().optional(),
+});
+
 const host = process.env.HOST ?? "localhost";
 const port = Number(process.env.PORT ?? 44900);
 
@@ -93,7 +108,8 @@ export default defineConfig({
   server: {
     listen: { port, host },
     fastify: {
-      bodyLimit: 10 * 1024 * 1024,
+      // Grok media input limits are derived from this; see MEDIA_MAX_INLINE_BYTES.
+      bodyLimit: REQUEST_BODY_LIMIT_BYTES,
     },
     plugins: {
       formbody: true,
@@ -106,16 +122,19 @@ export default defineConfig({
       },
       custom: (server) => {
         const oauthCallback = async (request: FastifyRequest, reply: FastifyReply) => {
-          const { code, state } = request.query as { code?: string; state?: string };
+          const { code, state } = oauthCallbackQuerySchema.safeParse(request.query).data ?? {};
+
           if (!code || !state) {
             return reply.redirect("/?oauth=error&reason=missing_params");
           }
+
           try {
             return QgridFrame.handleOAuthCallback(code, state, reply);
           } catch {
             return reply.redirect("/?oauth=error&reason=callback_failed");
           }
         };
+
         server.get("/callback", oauthCallback);
         server.get("/auth/callback", oauthCallback);
       },
@@ -131,7 +150,9 @@ export default defineConfig({
       guardHandler: () => {},
       cacheControlHandler: (req) => {
         if (req.type === "api") return CachePresets.noCache;
+
         if (req.type === "csr") return CachePresets.shortLived;
+
         // Sonamu serves fingerprinted assets with its default immutable policy.
         return undefined;
       },
@@ -155,17 +176,19 @@ export default defineConfig({
           if (key === "slack.expiryReminderMinutes" || key === "slack.remindersEnabled") {
             rescheduleExpiredTokenReminder();
           }
+
           if (key === "qgrid.tokenWindowKeepaliveEnabled") {
             void rescheduleTokenWindowKeepalive();
           }
         });
 
         let triggerReady = true;
+
         try {
           await ensureTokensTrigger(connConfig);
         } catch (e) {
           triggerReady = false;
-          log.warn(`trigger setup failed: ${(e as Error).message}`);
+          log.warn(`trigger setup failed: ${e instanceof Error ? e.message : String(e)}`);
         }
 
         const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);
@@ -182,7 +205,7 @@ export default defineConfig({
           QgridDispatcher.startupState.openai = "ready";
         } catch (e) {
           QgridDispatcher.startupState.openai = "failed";
-          log.warn(`openai dispatcher failed: ${(e as Error).message}`);
+          log.warn(`openai dispatcher failed: ${e instanceof Error ? e.message : String(e)}`);
         }
 
         try {
@@ -192,12 +215,40 @@ export default defineConfig({
           QgridDispatcher.startupState.anthropic = "ready";
         } catch (e) {
           QgridDispatcher.startupState.anthropic = "failed";
-          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);
+          log.warn(`anthropic dispatcher failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+
+        try {
+          const grokRefresher = new GrokRefreshCoordinator({ persist: persistGrokCredentials });
+
+          const grokDispatcher = new GrokDispatcher({
+            refresher: grokRefresher,
+            media: new GrokMediaClient(),
+            voice: new GrokVoiceClient(),
+          });
+
+          await grokDispatcher.start();
+          QgridFrame.grokRefresher = grokRefresher;
+          QgridDispatcher.grokDispatcher = grokDispatcher;
+          QgridDispatcher.startupState.grok = "ready";
+          // The subscriber's startup reconcile ran before this dispatcher existed; a failure here
+          // is retried by the periodic reconcile and does not make the runtime unusable.
+          await subscriber
+            .reconcile()
+            .catch((e) =>
+              log.warn(
+                `grok initial reconcile failed: ${e instanceof Error ? e.message : String(e)}`,
+              ),
+            );
+        } catch (e) {
+          QgridDispatcher.startupState.grok = "failed";
+          log.warn(`grok dispatcher failed: ${e instanceof Error ? e.message : String(e)}`);
         }
 
         subscriber.tokenChangeHandler = () => {
           void rescheduleTokenWindowKeepalive();
         };
+
         startExpiredTokenReminder();
         void startTokenWindowKeepalive();
 
@@ -217,20 +268,31 @@ export default defineConfig({
         stopTokenWindowKeepalive();
         stopOpenAICallbackRelay();
         setSettingChangeHandler(null);
+
         if (QgridDispatcher.subscriber) QgridDispatcher.subscriber.tokenChangeHandler = null;
+
         if (QgridDispatcher.openaiDispatcher) {
           await QgridDispatcher.openaiDispatcher.stop();
         }
+
         if (QgridDispatcher.anthropicDispatcher) {
           await QgridDispatcher.anthropicDispatcher.stop();
         }
+
+        const grokDispatcher = QgridDispatcher.grokDispatcher;
+
+        if (grokDispatcher instanceof GrokDispatcher) {
+          await grokDispatcher.stop();
+        }
+
         if (QgridDispatcher.subscriber) {
           await QgridDispatcher.subscriber.stop();
         }
+
         log.info("graceful shutdown");
       },
       onError: (error, _request, reply) => {
-        handleServerError(error, reply);
+        handleServerError(mapRequestBodyTooLarge(error), reply);
       },
     },
   },

package/bundle/src/startup-migrations.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 
 import { getLogger } from "@logtape/logtape";
 import { type Knex } from "knex";
+import { z } from "zod";
 
 import { TokenModel } from "./application/token/token.model";
 
@@ -30,10 +31,13 @@ export function resolveStartupMigrationDirs(
 // Sonamu 가 만드는 파일명 규칙: `YYYYMMDDHHmmss_<title>.ts`. 타입 선언이나 README 는 제외한다.
 const MIGRATION_FILE_RE = /^\d{14}_.+\.ts$/;
 
-type MigrationModule = {
-  up?: (knex: Knex) => Promise<unknown>;
-  down?: (knex: Knex) => Promise<unknown>;
-};
+// z.function() checks callability; getMigration wraps the calls in knex's migration contract.
+const migrationFunctionSchema = z.function({ input: [z.unknown()], output: z.unknown() });
+
+const migrationModuleSchema = z.object({
+  up: migrationFunctionSchema,
+  down: migrationFunctionSchema.optional(),
+});
 
 /**
  * 패키지된 CLI 는 `bundle/dist` 에서 실행되는데, knex 기본 FsMigrations 에 `../src/migrations` 를
@@ -48,6 +52,7 @@ export function createStartupMigrationSource(
   return {
     async getMigrations() {
       const entries = await readdir(dirs.sourceDir);
+
       return entries
         .filter((name) => MIGRATION_FILE_RE.test(name) && !name.endsWith(".d.ts"))
         .toSorted();
@@ -59,11 +64,18 @@ export function createStartupMigrationSource(
       const compiled = path.join(dirs.compiledDir, name.replace(/\.ts$/, ".js"));
       const source = path.join(dirs.sourceDir, name);
       const target = existsSync(compiled) ? compiled : source;
-      const module = (await import(pathToFileURL(target).href)) as MigrationModule;
-      if (typeof module.up !== "function") {
+      const module = migrationModuleSchema.safeParse(await import(pathToFileURL(target).href));
+
+      if (!module.success) {
         throw new Error(`migration ${name} has no up() export (${target})`);
       }
-      return { up: module.up, down: module.down ?? (async () => undefined) };
+
+      const { up, down } = module.data;
+
+      return {
+        up: async (knex: Knex) => up(knex),
+        down: async (knex: Knex) => down?.(knex),
+      };
     },
   };
 }
@@ -77,19 +89,25 @@ export type StartupMigrationDeps = {
 // 실제 process.exit(1) 이 worker 를 죽여 남은 테스트가 조용히 pending 으로 빠진다.
 export async function runRequiredMigrations(
   dirs: StartupMigrationDirs = resolveStartupMigrationDirs(),
-  deps: StartupMigrationDeps = { getKnex: () => TokenModel.getDB("w"), exit: process.exit },
+  deps: StartupMigrationDeps = {
+    getKnex: () => TokenModel.getDB("w"),
+    exit: (code) => process.exit(code),
+  },
 ): Promise<void> {
   const log = getLogger(["qgrid", "startup"]);
+
   try {
     const knex = deps.getKnex();
+
     const [batch, migrations] = await knex.migrate.latest({
       migrationSource: createStartupMigrationSource(dirs),
     });
+
     if (migrations.length > 0) {
       log.info(`migration: ${migrations.length} applied (batch ${batch})`);
     }
   } catch (error) {
-    log.error(`migration failed: ${(error as Error).message}`);
+    log.error(`migration failed: ${error instanceof Error ? error.message : String(error)}`);
     deps.exit(1);
   }
 }

package/bundle/src/testing/global.ts

@@ -7,14 +7,18 @@ const MAX_WORKERS = 4;
 const TEMPLATE_DB = process.env.QGRID_TEST_DB_NAME ?? "qgrid_test";
 
 type QueryClient = Pick<Client, "query">;
+
 type AdminClient = Pick<Client, "connect" | "end" | "query">;
+
 type AdminClientFactory = () => AdminClient;
+
 type VitestProject = { config?: { maxWorkers?: number } };
 
 function quoteIdentifier(value: string): string {
   if (!/^[A-Za-z0-9_]+$/.test(value)) {
     throw new Error(`invalid database identifier: ${value}`);
   }
+
   return `"${value}"`;
 }
 
@@ -41,15 +45,18 @@ export async function recreateWorkerDatabases(
   maxWorkers: number,
 ): Promise<string[]> {
   const workers = workerDatabaseNames(runDatabase, maxWorkers);
+
   for (const database of [...workers, templateDb]) {
     await terminateConnections(client, database);
   }
+
   for (const database of workers) {
     await client.query(`DROP DATABASE IF EXISTS ${quoteIdentifier(database)}`);
     await client.query(
       `CREATE DATABASE ${quoteIdentifier(database)} TEMPLATE ${quoteIdentifier(templateDb)} STRATEGY FILE_COPY`,
     );
   }
+
   return workers;
 }
 
@@ -59,6 +66,7 @@ export async function dropWorkerDatabases(
   maxWorkers: number,
 ): Promise<void> {
   const errors: unknown[] = [];
+
   for (const database of workerDatabaseNames(templateDb, maxWorkers)) {
     await terminateConnections(client, database).catch((error) => {
       errors.push(error);
@@ -67,10 +75,12 @@ export async function dropWorkerDatabases(
       errors.push(error);
     });
   }
+
   if (errors.length > 0) {
     const cleanupError = new AggregateError(errors, "failed to clean one or more test databases", {
       cause: errors[0],
     });
+
     throw cleanupError;
   }
 }
@@ -88,6 +98,7 @@ function createAdminClient(): Client {
 
 export function resolveMaxWorkers(project?: VitestProject): number {
   const maxWorkers = project?.config?.maxWorkers;
+
   return Number.isInteger(maxWorkers) && maxWorkers !== undefined && maxWorkers > 0
     ? maxWorkers
     : MAX_WORKERS;
@@ -101,12 +112,14 @@ export async function provisionWorkerDatabases(
 ): Promise<void> {
   const client = createClient();
   await client.connect();
+
   try {
     await recreateWorkerDatabases(client, templateDb, runDatabase, maxWorkers);
   } catch (setupError) {
     await client.end().catch(() => {});
     const cleanupClient = createClient();
     let cleanupError: unknown;
+
     try {
       await cleanupClient.connect();
       await dropWorkerDatabases(cleanupClient, runDatabase, maxWorkers);
@@ -117,30 +130,37 @@ export async function provisionWorkerDatabases(
         cleanupError ??= error;
       });
     }
+
     if (cleanupError) {
       const combinedError = new AggregateError(
         [setupError, cleanupError],
         "test database setup and cleanup both failed",
         { cause: setupError },
       );
+
       throw combinedError;
     }
+
     throw setupError;
   }
+
   await client.end();
 }
 
 export async function setup(project?: VitestProject): Promise<() => Promise<void>> {
   const runDatabase = process.env.QGRID_TEST_RUN_DB;
+
   if (!runDatabase || process.env.SONAMU_DB_NAME !== runDatabase) {
     throw new Error("Vitest test database name was not configured consistently");
   }
+
   const maxWorkers = resolveMaxWorkers(project);
   await provisionWorkerDatabases(createAdminClient, TEMPLATE_DB, runDatabase, maxWorkers);
 
   return async () => {
     const teardownClient = createAdminClient();
     await teardownClient.connect();
+
     try {
       await dropWorkerDatabases(teardownClient, runDatabase, maxWorkers);
     } finally {

package/bundle/src/testing/schema-bench.ts

@@ -12,6 +12,13 @@
  *      syntax/contract 와 겹칠 수 있고, 게이트 계수는 이 축 기준이다.
  */
 import Ajv2020, { type ValidateFunction } from "ajv/dist/2020";
+import { z } from "zod";
+
+import {
+  isJsonObject,
+  type JsonObject,
+  type JsonValue,
+} from "../utils/providers/common/provider-types";
 
 export type BenchMode = "generate" | "stream";
 
@@ -26,15 +33,18 @@ export interface BenchClassifyOptions {
    * 검증한다 — top-level 키 존재만 보면 `{"scenes":[{},{},{}]}` 같은 속 빈 응답이
    * 통과한다(SON-495 교훈: 상위 키 판정은 쓰레기를 통과시킨다).
    */
-  schema?: unknown;
+  schema?: JsonValue;
   /** 최상위에 반드시 있어야 하는 키 (schema 미지정 시의 최소 검증) */
   requiredTopLevelKeys?: string[];
   /** 허용되는 최상위 키 전체 — 래퍼 키 판정에 사용 */
   allowedTopLevelKeys?: string[];
   /** fixture 별 추가 계약 검증. 실패 사유 문자열을 반환하면 contract fail. */
-  validate?: (parsed: unknown, rawText: string) => string | undefined;
+  validate?: (parsed: JsonValue, rawText: string) => string | undefined;
 }
 
+// Ajv reports enum violations with the allowed values in `params.allowedValues`.
+const EnumErrorParams = z.looseObject({ allowedValues: z.array(z.json()).optional() });
+
 /**
  * 표준 JSON Schema 검증 (Ajv, Draft 2020-12). 위반 경로 목록을 반환한다.
  *
@@ -43,21 +53,27 @@ export interface BenchClassifyOptions {
  * 뒤집혔다(anyOf 브랜치 내부의 enum 위반을 통째로 건너뜀). 임의 스키마(BENCH_SCHEMA_FILE)
  * 를 게이트로 쓰려면 표준 검증기가 유일하게 신뢰 가능하다.
  */
-export function validateAgainstSchema(node: unknown, schema: unknown): string[] {
-  if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return [];
-  const validate = compileSchema(schema as Record<string, unknown>);
+export function validateAgainstSchema(node: JsonValue, schema: JsonValue): string[] {
+  if (!isJsonObject(schema)) return [];
+  const validate = compileSchema(schema);
+
   if (validate(node)) return [];
-  return (validate.errors ?? []).map(
-    (e) =>
-      `${e.instancePath || "$"}: ${e.message ?? e.keyword}${e.keyword === "enum" ? ` (${JSON.stringify((e.params as { allowedValues?: unknown[] }).allowedValues?.slice(0, 8))})` : ""}`,
-  );
+
+  return (validate.errors ?? []).map((e) => {
+    const allowed = EnumErrorParams.safeParse(e.params).data?.allowedValues;
+
+    const enumDetail = e.keyword === "enum" ? ` (${JSON.stringify(allowed?.slice(0, 8))})` : "";
+
+    return `${e.instancePath || "$"}: ${e.message ?? e.keyword}${enumDetail}`;
+  });
 }
 
 const compiledSchemas = new WeakMap<object, ValidateFunction>();
 let ajvInstance: Ajv2020 | undefined;
 
-function compileSchema(schema: Record<string, unknown>): ValidateFunction {
+function compileSchema(schema: JsonObject): ValidateFunction {
   const cached = compiledSchemas.get(schema);
+
   if (cached) return cached;
   // strict:false — 소비자 스키마의 비표준 어노테이션(description 변형 등)을 컴파일
   // 에러로 만들지 않는다. 검증 시맨틱은 표준 그대로다.
@@ -65,13 +81,16 @@ function compileSchema(schema: Record<string, unknown>): ValidateFunction {
   // $id 가 있는 스키마를 두 번 compile 하면 Ajv 가 중복 등록으로 던진다 — WeakMap 캐시가
   // 같은 객체의 재컴파일을 막고, 다른 객체로 온 같은 $id 는 인스턴스를 새로 만들어 회피한다.
   let validate: ValidateFunction;
+
   try {
     validate = ajvInstance.compile(schema);
   } catch {
     ajvInstance = new Ajv2020({ strict: false, allErrors: true });
     validate = ajvInstance.compile(schema);
   }
+
   compiledSchemas.set(schema, validate);
+
   return validate;
 }
 
@@ -101,17 +120,24 @@ export function classifyBenchText(
 
   if (options.plainText) {
     const reason = options.validate?.(text, text);
-    return {
+
+    const classification: BenchClassification = {
       syntax: "ok",
       contract: reason === undefined ? "ok" : "fail",
-      ...(reason === undefined ? {} : { contractDetail: reason }),
       topLevel: { wrapperKey: false, fenceResidue, prose: false },
     };
+
+    if (reason !== undefined) classification.contractDetail = reason;
+
+    return classification;
   }
 
-  let parsed: unknown;
+  // Placeholder until parsing succeeds; it is read only when `syntax` stays "ok".
+  let parsed: JsonValue = null;
   let syntax: "ok" | "fail" = "ok";
+
   try {
+    // JSON.parse without a reviver yields only JSON values.
     parsed = JSON.parse(text);
   } catch {
     syntax = "fail";
@@ -124,27 +150,24 @@ export function classifyBenchText(
   let contractDetail: string | undefined;
 
   if (syntax === "ok") {
-    const record =
-      parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
-        ? (parsed as Record<string, unknown>)
-        : undefined;
+    const record = isJsonObject(parsed) ? parsed : undefined;
 
     if (record && options.allowedTopLevelKeys) {
       const keys = Object.keys(record);
       const allowed = new Set(options.allowedTopLevelKeys);
+      const only = record[keys[0]!];
       wrapperKey =
-        keys.length === 1 &&
-        !allowed.has(keys[0]!) &&
-        typeof record[keys[0]!] === "object" &&
-        record[keys[0]!] !== null;
+        keys.length === 1 && !allowed.has(keys[0]!) && (isJsonObject(only) || Array.isArray(only));
     }
 
     contract = "ok";
+
     if (record === undefined) {
       contract = "fail";
       contractDetail = "top-level is not an object";
     } else if (options.schema !== undefined) {
       const violations = validateAgainstSchema(parsed, options.schema);
+
       if (violations.length > 0) {
         contract = "fail";
         contractDetail = `${violations.length} schema violations: ${violations.slice(0, 5).join("; ")}`;
@@ -153,13 +176,16 @@ export function classifyBenchText(
       const missing = (options.requiredTopLevelKeys ?? []).filter(
         (key) => !Object.hasOwn(record, key),
       );
+
       if (missing.length > 0) {
         contract = "fail";
         contractDetail = `missing required keys: ${missing.join(", ")}`;
       }
     }
+
     if (contract === "ok" && options.validate) {
       const reason = options.validate(parsed, text);
+
       if (reason !== undefined) {
         contract = "fail";
         contractDetail = reason;
@@ -201,9 +227,11 @@ export function fingerprintFixture(content: {
 }): string {
   const text = `${content.prompt}${content.jsonSchema ?? ""}${JSON.stringify(content.tools ?? null)}`;
   let hash = 5381;
+
   for (let i = 0; i < text.length; i += 1) {
     hash = ((hash << 5) + hash + text.charCodeAt(i)) >>> 0;
   }
+
   return hash.toString(16).padStart(8, "0");
 }
 
@@ -213,18 +241,50 @@ export function checkpointKey(
   return `${record.model}|${record.fixture}|${record.fixtureHash ?? "-"}|${record.mode}|${record.iteration}`;
 }
 
+const TopLevelViolationsSchema = z.object({
+  wrapperKey: z.boolean(),
+  fenceResidue: z.boolean(),
+  prose: z.boolean(),
+});
+
+const BenchRecordSchema = z.object({
+  fixture: z.string(),
+  fixtureHash: z.string().optional(),
+  model: z.string(),
+  mode: z.enum(["generate", "stream"]),
+  iteration: z.number(),
+  transportError: z.string().optional(),
+  classification: z
+    .object({
+      syntax: z.enum(["ok", "fail"]),
+      contract: z.enum(["ok", "fail", "n/a"]),
+      contractDetail: z.string().optional(),
+      topLevel: TopLevelViolationsSchema,
+    })
+    .optional(),
+  deltaDoneMismatch: z.boolean().optional(),
+  durationMs: z.number(),
+  outputTokens: z.number().optional(),
+  costUsd: z.number().optional(),
+}) satisfies z.ZodType<BenchRecord>;
+
 /** JSONL checkpoint 파일 파싱. 깨진 줄(중단 시 부분 기록)은 건너뛴다. */
 export function parseCheckpointLines(jsonl: string): Map<string, BenchRecord> {
   const map = new Map<string, BenchRecord>();
+
   for (const line of jsonl.split("\n")) {
     if (!line.trim()) continue;
+
     try {
-      const record = JSON.parse(line) as BenchRecord;
-      map.set(checkpointKey(record), record);
+      const record = BenchRecordSchema.safeParse(JSON.parse(line));
+
+      // A line that does not match the record shape is skipped like a partial write.
+      if (record.success) map.set(checkpointKey(record.data), record.data);
     } catch {
       // 부분 기록된 마지막 줄 — resume 시 해당 조합만 재발사된다
     }
   }
+
   return map;
 }
 
@@ -251,20 +311,32 @@ export interface BenchAggregateRow {
 }
 
 export function aggregateBench(records: BenchRecord[]): BenchAggregateRow[] {
-  const groups = new Map<string, BenchRecord[]>();
+  const groups = new Map<
+    string,
+    { model: string; fixture: string; mode: BenchMode; bucket: BenchRecord[] }
+  >();
+
   for (const record of records) {
     const key = `${record.model}|${record.fixture}|${record.mode}`;
-    const bucket = groups.get(key);
-    if (bucket) bucket.push(record);
-    else groups.set(key, [record]);
+    const group = groups.get(key);
+
+    if (group) group.bucket.push(record);
+    else {
+      groups.set(key, {
+        model: record.model,
+        fixture: record.fixture,
+        mode: record.mode,
+        bucket: [record],
+      });
+    }
   }
 
-  return [...groups.entries()]
-    .map(([key, bucket]) => {
-      const [model, fixture, mode] = key.split("|") as [string, string, BenchMode];
+  return [...groups.values()]
+    .map(({ model, fixture, mode, bucket }) => {
       const transportErrors = bucket.filter((r) => r.transportError !== undefined).length;
       const syntaxFails = bucket.filter((r) => r.classification?.syntax === "fail").length;
       const contractFails = bucket.filter((r) => r.classification?.contract === "fail").length;
+
       // pass = 모든 축이 깨끗한 응답 — 형태 위반(래퍼/펜스/프로즈)과 스트림 델타≠done 도
       // 실패다. syntax/contract 만 보면 "통과인데 펜스가 남은" 응답이 성공으로 집계된다
       // (2차 검토 #7).
@@ -278,6 +350,7 @@ export function aggregateBench(records: BenchRecord[]): BenchAggregateRow[] {
           !r.classification.topLevel.prose &&
           r.deltaDoneMismatch !== true,
       ).length;
+
       const count = (pick: (v: TopLevelViolations) => boolean) =>
         bucket.filter((r) => r.classification !== undefined && pick(r.classification.topLevel))
           .length;
@@ -328,6 +401,7 @@ export function formatAggregateTable(rows: BenchAggregateRow[]): string {
     "outTok",
     "cost$",
   ];
+
   const lines = rows.map((r) =>
     [
       r.model,
@@ -348,5 +422,6 @@ export function formatAggregateTable(rows: BenchAggregateRow[]): string {
       r.totalCostUsd.toFixed(4),
     ].join("\t"),
   );
+
   return [header.join("\t"), ...lines].join("\n");
 }

package/bundle/src/testing/test-database-name.ts

@@ -6,6 +6,7 @@ export function createTestRunDatabaseName(prefix: string, entropy: string): stri
   const safePrefix = prefix.replaceAll(/[^A-Za-z0-9_]/g, "_");
   const safeEntropy = entropy.replaceAll(/[^A-Za-z0-9_]/g, "_");
   const maxPrefixLength = 63 - safeEntropy.length - 1;
+
   return `${safePrefix.slice(0, maxPrefixLength)}_${safeEntropy}`;
 }
 
@@ -18,5 +19,6 @@ export function configureTestRunDatabaseName(): string {
 
   process.env.QGRID_TEST_RUN_DB = configuredRunDatabase;
   process.env.SONAMU_DB_NAME = configuredRunDatabase;
+
   return configuredRunDatabase;
 }