@cartanova/qgrid-cli 2.2.0 → 2.3.1

package/bundle/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  type GenerateRequest,
+  type GenerateResult,
+} from "../../utils/providers/common/provider-dispatcher";
+import { QgridDispatcherClass } from "./qgrid.dispatcher";
+
+describe("QgridDispatcherClass", () => {
+  it("provider 가 산출한 costUsd 를 가격표 fallback 보다 우선한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(
+      async (_req: GenerateRequest): Promise<GenerateResult> => ({
+        text: "ok",
+        tokenName: "anthropic/test",
+        usage: {
+          totalTokens: 1_110,
+          inputTokens: 1_000,
+          cachedInputTokens: 0,
+          cacheCreationInputTokens: 600,
+          outputTokens: 110,
+          reasoningOutputTokens: 0,
+        },
+        durationMs: 12,
+        costUsd: 0.123456,
+        model: "claude-sonnet-4-6",
+        threadCoord: { workerId: 1, threadId: "sess-1", epoch: 0 },
+      }),
+    );
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    const result = await dispatcher.query({ prompt: "hi", model: "claude-sonnet-4-6" });
+
+    expect(result.costUsd).toBe(0.123456);
+    expect(result.usage.cache_creation_input_tokens).toBe(600);
+  });
+});

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

@@ -17,12 +17,15 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { getLogger } from "@logtape/logtape";
 
 import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
+import { canonicalAnthropicModel } from "../../utils/providers/anthropic/anthropic-constants";
+import { type AnthropicDispatcher } from "../../utils/providers/anthropic/anthropic-dispatcher";
 import {
   getAccessToken,
   getExpiresAt,
   getRefreshToken,
 } from "../../utils/providers/common/credentials";
 import { calculateCostUsd } from "../../utils/providers/common/model-cost";
+import { type GenerateResult } from "../../utils/providers/common/provider-dispatcher";
 import { strictify } from "../../utils/providers/common/strictifier";
 import { type OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
 import { type TokenSubsetA } from "../sonamu.generated";
@@ -65,6 +68,7 @@ export class QgridDispatcherClass {
   // sonamu.config onStart 에서 처리하는 변수
   subscriber: TokenSubscriber | null = null;
   openaiDispatcher: OpenAIDispatcher | null = null;
+  anthropicDispatcher: AnthropicDispatcher | null = null;
 
   constructor() {
     const settingsJson = JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2);
@@ -149,36 +153,38 @@ export class QgridDispatcherClass {
         });
 
         const issuedCoord = issueConvContext(result.threadCoord, decision);
-        return applyToolCallEmulation(
-          {
-            text: result.text,
-            tokenName: result.tokenName,
-            model: result.model,
-            usage: {
-              input_tokens: result.usage.inputTokens,
-              output_tokens: result.usage.outputTokens,
-              cache_creation_input_tokens: 0,
-              cache_read_input_tokens: result.usage.cachedInputTokens,
-            },
-            durationMs: result.durationMs,
-            costUsd: calculateCostUsd(result.model, {
-              inputTokens: result.usage.inputTokens,
-              outputTokens: result.usage.outputTokens,
-              cachedInputTokens: result.usage.cachedInputTokens,
-            }),
-          },
-          input.tools,
-          issuedCoord,
-        );
+        return applyToolCallEmulation(toEmulationResult(result), input.tools, issuedCoord);
       }
     }
 
+    // Anthropic — AnthropicDispatcher(멀티턴 session resume) 경로. OpenAI 경로와 동형.
+    if (this.anthropicDispatcher) {
+      const decision = decideConvRouting(input);
+      const result = await this.anthropicDispatcher.generate({
+        // model 미지정이면 AnthropicDispatcher 가 ANTHROPIC_DEFAULT_MODEL 적용 — "sonnet" 별칭을
+        // 강제로 끼워 dispatcher default 를 죽이지 않는다. prefix 정규화도 dispatcher 내부에서.
+        model: input.model,
+        systemPrompt: input.system,
+        outputSchema: outputSchema
+          ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
+          : undefined,
+        effort: input.effort,
+        coldInput: decision.coldInput,
+        coldHistory: decision.coldHistory,
+        reuse: decision.reuse,
+        reuseInput: decision.reuseInput,
+      });
+
+      const issuedCoord = issueConvContext(result.threadCoord, decision);
+      return applyToolCallEmulation(toEmulationResult(result), input.tools, issuedCoord);
+    }
+
+    // 폴백: AnthropicDispatcher 미초기화 시 기존 stateless claude -p 경로(멀티턴 없음).
     const executionInput =
       outputSchema && input.tools?.length
         ? { ...input, jsonSchema: JSON.stringify(outputSchema) }
         : input;
 
-    // Anthropic (기존 claude -p 경로)
     const electedToken = this.selectToken();
     if (!electedToken) throw new QuotaError("No tokens available");
 
@@ -205,7 +211,8 @@ export class QgridDispatcherClass {
 
     const result = await executeClaude(executionInput, token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
     return applyToolCallEmulation(
-      { ...result, tokenName: electedToken.name, model: input.model ?? DEFAULT_MODEL },
+      // model 도 canonical 로 — fallback 도 cost/표기가 main 경로와 일치하게.
+      { ...result, tokenName: electedToken.name, model: canonicalAnthropicModel(input.model) },
       input.tools,
     );
   }
@@ -220,7 +227,44 @@ export class QgridDispatcherClass {
       onTurnId?: (turnId: string) => void;
     },
   ): Promise<void> {
+    // Anthropic 스트리밍: openai/ prefix 가 아니면 anthropic 경로.
     if (!input.model?.startsWith("openai/")) {
+      // AnthropicDispatcher 가 있으면 실제 delta 스트리밍. 없으면 기존 query() 폴백(delta 없음).
+      if (this.anthropicDispatcher) {
+        const outputSchema = input.tools?.length
+          ? buildToolCallSchema(input.tools)
+          : input.jsonSchema
+            ? (JSON.parse(input.jsonSchema) as JsonValue)
+            : undefined;
+        const decision = decideConvRouting(input);
+        await this.anthropicDispatcher.generateStream(
+          {
+            // model 미지정 시 dispatcher 가 ANTHROPIC_DEFAULT_MODEL 적용. prefix 정규화도 내부에서.
+            model: input.model,
+            systemPrompt: input.system,
+            outputSchema: outputSchema
+              ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
+              : undefined,
+            effort: input.effort,
+            coldInput: decision.coldInput,
+            coldHistory: decision.coldHistory,
+            reuse: decision.reuse,
+            reuseInput: decision.reuseInput,
+          },
+          {
+            onDelta: cb.onDelta,
+            onThreadId: cb.onThreadId,
+            onComplete: (turnResult) => {
+              const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
+              cb.onComplete(
+                applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord),
+              );
+            },
+            onError: cb.onError,
+          },
+        );
+        return;
+      }
       const result = await this.query(input);
       cb.onComplete(result);
       return;
@@ -259,28 +303,9 @@ export class QgridDispatcherClass {
         onTurnId: cb.onTurnId,
         onComplete: (turnResult) => {
           const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
-          const applied = applyToolCallEmulation(
-            {
-              text: turnResult.text,
-              tokenName: turnResult.tokenName,
-              model: turnResult.model,
-              usage: {
-                input_tokens: turnResult.usage.inputTokens,
-                output_tokens: turnResult.usage.outputTokens,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: turnResult.usage.cachedInputTokens,
-              },
-              durationMs: turnResult.durationMs,
-              costUsd: calculateCostUsd(turnResult.model, {
-                inputTokens: turnResult.usage.inputTokens,
-                outputTokens: turnResult.usage.outputTokens,
-                cachedInputTokens: turnResult.usage.cachedInputTokens,
-              }),
-            },
-            input.tools,
-            issuedCoord,
+          cb.onComplete(
+            applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord),
           );
-          cb.onComplete(applied);
         },
         onError: cb.onError,
       },
@@ -288,6 +313,36 @@ export class QgridDispatcherClass {
   }
 }
 
+// GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.
+// OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.
+// Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.
+// per-request cost 는 Claude Code 가 준 total_cost_usd 를 우선 사용하고 fallback 계산만 공통 cost 함수를 쓴다.
+function toEmulationResult(
+  result: GenerateResult,
+): Omit<QueryOutput, "content" | "finishReason" | "runContext"> {
+  return {
+    text: result.text,
+    tokenName: result.tokenName,
+    model: result.model,
+    usage: {
+      input_tokens: result.usage.inputTokens,
+      output_tokens: result.usage.outputTokens,
+      cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,
+      cache_read_input_tokens: result.usage.cachedInputTokens,
+    },
+    durationMs: result.durationMs,
+    costUsd:
+      result.costUsd !== undefined && result.costUsd > 0
+        ? result.costUsd
+        : calculateCostUsd(result.model, {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedInputTokens: result.usage.cachedInputTokens,
+            cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,
+          }),
+  };
+}
+
 async function executeClaude(
   input: QueryInput,
   token: string,

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

@@ -3,7 +3,7 @@ import { getLogger } from "@logtape/logtape";
 import { Client, type ClientConfig } from "pg";
 
 import { TokenModel } from "../token/token.model";
-import { type OpenAICredentials } from "../token/token.types";
+import { type AnthropicCredentials, type OpenAICredentials } from "../token/token.types";
 import { type QgridDispatcherClass } from "./qgrid.dispatcher";
 import { type SubscriberStatus } from "./qgrid.types";
 
@@ -157,6 +157,8 @@ export class TokenSubscriber {
       this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
+      // anthropic 토큰 이벤트는 동기(void) — provider 를 모르므로 무해하게 항상 제거 시도.
+      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
       return;
     }
@@ -166,6 +168,7 @@ export class TokenSubscriber {
       this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
+      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);
       return;
     }
@@ -186,6 +189,19 @@ export class TokenSubscriber {
       } else {
         this.dispatcher.openaiDispatcher?.onTokenDeactivated(payload.id);
       }
+    } else if (row.provider === "anthropic") {
+      // anthropic 토큰 이벤트는 동기(void). worker 가 없고 풀(Map)만 관리하므로 단순:
+      //  INSERT → 추가, active 면 갱신(onTokenUpdated 가 identity 변경도 처리), inactive 면 풀에서 제거.
+      //  (별도 activate/deactivate 콜백이 없어 active 토글을 add/remove 로 매핑.)
+      const creds = row.credentials as AnthropicCredentials;
+      if (payload.op === "INSERT" && row.active) {
+        this.dispatcher.anthropicDispatcher?.onTokenAdded(payload.id, row.name, creds);
+      } else if (row.active) {
+        this.dispatcher.anthropicDispatcher?.onTokenUpdated(payload.id, row.name, creds);
+      } else {
+        // inactive 면 INSERT 든 UPDATE 든 풀에 넣지 않는다.
+        this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
+      }
     }
     logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=${row.active}`);
   }
@@ -193,6 +209,12 @@ export class TokenSubscriber {
   async reconcile(): Promise<void> {
     const rows = await TokenModel.findActive("A");
     this.dispatcher.replaceCache(rows);
+    // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.
+    // (rows 는 active 만 — inactive/삭제된 토큰은 여기 없으므로 replaceTokens 가 풀에서 제거한다.)
+    const anthropicRows = rows
+      .filter((r) => r.provider === "anthropic")
+      .map((r) => ({ id: r.id, name: r.name, credentials: r.credentials as AnthropicCredentials }));
+    this.dispatcher.anthropicDispatcher?.replaceTokens(anthropicRows);
     this.lastReconcileAt = new Date();
   }
 }

package/bundle/src/application/qgrid/tool-emulation.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+
+import { buildToolCallSchema } from "./tool-emulation";
+import { type QgridTool } from "./qgrid.types";
+
+describe("buildToolCallSchema", () => {
+  it("documents that emulated tools must be requested through StructuredOutput", () => {
+    const tools: QgridTool[] = [
+      {
+        name: "getWeather",
+        description: "Get weather for a city",
+        inputSchema: {
+          type: "object",
+          properties: { city: { type: "string" } },
+          required: ["city"],
+          additionalProperties: false,
+        },
+      },
+    ];
+
+    const schema = buildToolCallSchema(tools) as {
+      description?: string;
+      properties?: {
+        action?: { description?: string };
+        toolCalls?: {
+          description?: string;
+          anyOf?: Array<{
+            items?: {
+              properties?: {
+                toolName?: { description?: string };
+              };
+            };
+          }>;
+        };
+      };
+    };
+
+    expect(schema.description).toContain("StructuredOutput");
+    expect(schema.description).toContain("Do not invoke listed client tools as native Claude Code tools");
+    expect(schema.properties?.action?.description).toContain("tool_call");
+    expect(schema.properties?.toolCalls?.description).toContain("Do not call these tools as native");
+    expect(
+      schema.properties?.toolCalls?.anyOf?.[0]?.items?.properties?.toolName?.description,
+    ).toContain("getWeather");
+  });
+});

package/bundle/src/application/qgrid/tool-emulation.ts

@@ -26,10 +26,19 @@ export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
 
   return {
     type: "object",
+    description:
+      "Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set action to tool_call and include toolCalls. Use action answer only when no further client tool result is needed.",
     properties: {
-      action: { type: "string", enum: ["answer", "tool_call"] },
+      action: {
+        type: "string",
+        enum: ["answer", "tool_call"],
+        description:
+          "Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer.",
+      },
       answer: { anyOf: [{ type: "string" }, { type: "null" }] },
       toolCalls: {
+        description:
+          "Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.",
         anyOf: [
           {
             type: "array",
@@ -39,9 +48,12 @@ export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
                 toolName: {
                   type: "string",
                   enum: tools.map((tool) => tool.name),
-                  description: toolDescriptions,
+                  description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`,
+                },
+                args: {
+                  type: "string",
+                  description: "Tool arguments as a JSON string for the client-side tool.",
                 },
-                args: { type: "string", description: "Tool arguments as JSON string" },
               },
               required: ["toolName", "args"],
               additionalProperties: false,

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

@@ -17,6 +17,59 @@ import { type RequestLogListParams, type RequestLogSaveParams } from "./request-
 // cost_usd는 정수 micro-USD로 저장. 실제 USD = cost_usd / MICRO_USD.
 export const MICRO_USD = 1_000_000;
 
+type RequestLogUsageRow = {
+  token_name?: string | null;
+  model_name?: string | null;
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cache_creation_tokens: number;
+  cost_usd?: number | null;
+};
+
+function isAnthropicUsageRow(row: Pick<RequestLogUsageRow, "token_name" | "model_name">): boolean {
+  return (
+    row.token_name?.startsWith("anthropic/") === true ||
+    row.model_name?.startsWith("claude-") === true ||
+    row.model_name?.startsWith("anthropic/claude-") === true
+  );
+}
+
+function canonicalModelName(modelName: string): string {
+  return modelName.includes("/") ? modelName.split("/").pop()! : modelName;
+}
+
+function normalizedUsageForCost(row: RequestLogUsageRow): {
+  model: string | null;
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens: number;
+  cacheCreationInputTokens: number;
+} {
+  const cacheRead = Number(row.cache_read_tokens ?? 0);
+  const cacheCreation = Number(row.cache_creation_tokens ?? 0);
+  const storedInput = Number(row.input_tokens ?? 0);
+  const legacyAnthropicSplitInput =
+    isAnthropicUsageRow(row) && storedInput < cacheRead + cacheCreation;
+  return {
+    model: row.model_name ? canonicalModelName(row.model_name) : null,
+    inputTokens: legacyAnthropicSplitInput ? storedInput + cacheRead + cacheCreation : storedInput,
+    outputTokens: Number(row.output_tokens ?? 0),
+    cachedInputTokens: cacheRead,
+    cacheCreationInputTokens: cacheCreation,
+  };
+}
+
+function normalizeLegacyAnthropicRow<T extends RequestLogUsageRow>(row: T): T {
+  const usage = normalizedUsageForCost(row);
+  if (usage.inputTokens === Number(row.input_tokens ?? 0)) return row;
+  const normalized = { ...row, input_tokens: usage.inputTokens };
+  if (usage.model) {
+    normalized.cost_usd = Math.round(calculateCostUsd(usage.model, usage) * MICRO_USD);
+  }
+  return normalized;
+}
+
 /*
   RequestLog Model
 */
@@ -118,10 +171,7 @@ class RequestLogModelClass extends BaseModelClass<
     }
 
     const enhancers = this.createEnhancers({
-      A: (row) => ({
-        ...row,
-        // 서브셋별로 virtual 필드 계산로직 추가
-      }),
+      A: (row) => normalizeLegacyAnthropicRow(row),
     });
 
     return this.executeSubsetQuery({
@@ -238,14 +288,21 @@ class RequestLogModelClass extends BaseModelClass<
         .where("id", requestLogId)
         .limit(1);
       if (row?.model_name) {
-        const model = row.model_name.includes("/")
-          ? row.model_name.split("/").pop()!
-          : row.model_name;
+        const model = canonicalModelName(row.model_name);
+        const usage = normalizedUsageForCost({
+          token_name: params.token_name,
+          model_name: row.model_name,
+          input_tokens: params.input_tokens,
+          output_tokens: params.output_tokens,
+          cache_read_tokens: params.cache_read_tokens ?? 0,
+          cache_creation_tokens: params.cache_creation_tokens ?? 0,
+        });
         update.cost_usd = Math.round(
           calculateCostUsd(model, {
-            inputTokens: params.input_tokens,
-            outputTokens: params.output_tokens,
-            cachedInputTokens: params.cache_read_tokens ?? 0,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cachedInputTokens: usage.cachedInputTokens,
+            cacheCreationInputTokens: usage.cacheCreationInputTokens,
           }) * 1_000_000,
         );
       }
@@ -333,9 +390,37 @@ class RequestLogModelClass extends BaseModelClass<
     if (params.token_name) {
       qb.where("token_name", params.token_name);
     }
-    // knex는 pg에서 numeric aggregate를 string으로 반환.
-    const row = (await qb.sum({ sum: "cost_usd" }).first()) as { sum: string | null } | undefined;
-    return Number(row?.sum ?? 0) / MICRO_USD;
+    // 기존 cost_usd 에는 과거 Anthropic cache 계산 버그로 음수가 저장된 row 가 있을 수 있다.
+    // 화면 집계는 저장값 sum 이 아니라 현재 계산식으로 usage 를 재계산해 과거 로그도 즉시 보정한다.
+    const rows = (await qb.select(
+      "model_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "cost_usd",
+    )) as Array<{
+      model_name: string | null;
+      input_tokens: number;
+      output_tokens: number;
+      cache_read_tokens: number;
+      cache_creation_tokens: number;
+      cost_usd: number | null;
+    }>;
+
+    return rows.reduce((sum, row) => {
+      const usage = normalizedUsageForCost(row);
+      if (!usage.model) return sum + Math.max(Number(row.cost_usd ?? 0), 0) / MICRO_USD;
+      return (
+        sum +
+        calculateCostUsd(usage.model, {
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          cachedInputTokens: usage.cachedInputTokens,
+          cacheCreationInputTokens: usage.cacheCreationInputTokens,
+        })
+      );
+    }, 0);
   }
 
   async distinctProjectNames(): Promise<string[]> {

package/bundle/src/sonamu.config.ts

@@ -12,6 +12,7 @@ import { QgridFrame } from "./application/qgrid/qgrid.frame";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup";
 import { TokenModel } from "./application/token/token.model";
+import { AnthropicDispatcher } from "./utils/providers/anthropic/anthropic-dispatcher";
 import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher";
 
 dotenv.config({ path: path.join(import.meta.dirname, "../.env") });
@@ -202,8 +203,15 @@ export default defineConfig({
           log.warn(`openai dispatcher failed: ${(e as Error).message}`);
         }
 
-        const allTokens = [...QgridDispatcher.tokens.values()];
-        const anthropicCount = allTokens.filter((t) => t.provider === "anthropic").length;
+        try {
+          const anthropicDispatcher = new AnthropicDispatcher();
+          await anthropicDispatcher.start();
+          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;
+        } catch (e) {
+          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);
+        }
+
+        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
         const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
         const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;
 
@@ -219,6 +227,9 @@ export default defineConfig({
         if (QgridDispatcher.openaiDispatcher) {
           await QgridDispatcher.openaiDispatcher.stop();
         }
+        if (QgridDispatcher.anthropicDispatcher) {
+          await QgridDispatcher.anthropicDispatcher.stop();
+        }
         if (QgridDispatcher.subscriber) {
           await QgridDispatcher.subscriber.stop();
         }

package/bundle/src/testing/global.ts

@@ -2,5 +2,19 @@ import dotenv from "dotenv";
 
 dotenv.config();
 
-// sonamu.config.ts의 test 설정을 기반으로 병렬 테스트 환경을 구성합니다.
-export { setup } from "sonamu/test";
+type SonamuGlobalSetupModule = {
+  setup: () => Promise<(() => Promise<void>) | void>;
+};
+
+// sonamu/test 의 barrel export 는 bootstrap.js 를 함께 로드하고, bootstrap.js 는 top-level 에서
+// vitest 를 import 한다. Vitest 4 globalSetup 컨텍스트에서는 이 import 가 internal state 에러를
+// 만들기 때문에 global-setup.js 만 직접 로드한다.
+export async function setup(): Promise<(() => Promise<void>) | void> {
+  const globalSetupUrl = new URL(
+    "../../node_modules/sonamu/dist/testing/global-setup.js",
+    import.meta.url,
+  );
+  const { setup: sonamuSetup } = (await import(globalSetupUrl.href)) as SonamuGlobalSetupModule;
+
+  return sonamuSetup();
+}

package/bundle/src/utils/providers/anthropic/anthropic-constants.ts

@@ -0,0 +1,38 @@
+/**
+ * Anthropic(Claude) provider 상수.
+ *
+ * 기존 qgrid.dispatcher.ts 의 executeClaude 플래그/env 와 정합을 맞추되, 멀티턴용으로 조정한다:
+ *  - `--no-session-persistence` 제거 (멀티턴 필수).
+ *  - `--input-format stream-json` 추가 (stdin 으로 입력 어댑터 JSONL 흘림).
+ *  - `--session-id` / `--resume` 로 세션 소유.
+ */
+
+// CC --model 플래그가 받는 official model id (alias "sonnet" 가 아니라 정확한 식별자로 고정).
+// claude-api 스킬 확인: Sonnet 4.6 official id = "claude-sonnet-4-6" (날짜 suffix 없음).
+// model-cost 테이블에도 "claude-sonnet-4-6" 키 존재. (owner 지시)
+export const ANTHROPIC_DEFAULT_MODEL = "claude-sonnet-4-6";
+export const ANTHROPIC_DEFAULT_EFFORT = "high";
+
+// model id 를 canonical(provider prefix 없는 CLI/cost 키) 로 정규화한다.
+// ai-sdk 는 'anthropic/claude-*' 형태로 보내는데, prefix 가 compatibilityKey/calculateCostUsd 에
+// 새면 호환키가 갈리거나 cost 가 default 단가로 오계산된다. 미지정이면 default.
+export function canonicalAnthropicModel(model?: string): string {
+  const raw = model || ANTHROPIC_DEFAULT_MODEL;
+  return raw.includes("/") ? raw.split("/").pop()! : raw;
+}
+
+// project scope cwd (settings.json 격리). 토큰별 격리는 CLAUDE_CONFIG_DIR 로 한다.
+export const ANTHROPIC_CLAUDE_CWD = "/tmp/qgrid-anthropic";
+
+// per-token CLAUDE_CONFIG_DIR 의 베이스. 실제 경로는 `${BASE}/${tokenId}` (R10 격리).
+export const ANTHROPIC_CONFIG_DIR_BASE = "/tmp/qgrid-anthropic-config";
+
+// 토큰별 CLAUDE_CONFIG_DIR 경로 규칙(R10 격리 계약). tokenId 별로 분리되어, 같은 claude session-id
+// 라도 다른 토큰이면 다른 config dir → transcript 가 섞이지 않는다. 부수효과 없는 순수 함수라
+// 격리 계약을 단위 테스트로 고정할 수 있다(U6 R10 구조 검증). 실제 dir 생성은 ensureConfigDir 가 한다.
+export function anthropicConfigDir(tokenId: number): string {
+  return `${ANTHROPIC_CONFIG_DIR_BASE}/${tokenId}`;
+}
+
+// CC 가 자동 활성화하는 deferred 도구 — 토큰 최적화 위해 차단(기존 executeClaude 와 동일).
+export const ANTHROPIC_DISALLOWED_TOOLS = ["Monitor", "PushNotification", "RemoteTrigger"] as const;