@cartanova/qgrid-cli 2.4.7 → 2.4.9

package/bundle/src/testing/global.ts

@@ -77,10 +77,10 @@ export async function dropWorkerDatabases(
 
 function createAdminClient(): Client {
   return new Client({
-    host: process.env.QGRID_DB_HOST ?? "localhost",
-    port: Number(process.env.QGRID_DB_PORT ?? 5432),
-    user: process.env.QGRID_DB_USER ?? "postgres",
-    password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+    host: process.env.SONAMU_DB_HOST ?? "localhost",
+    port: Number(process.env.SONAMU_DB_PORT ?? 5432),
+    user: process.env.SONAMU_DB_USER ?? "postgres",
+    password: process.env.SONAMU_DB_PASSWORD ?? "postgres",
     database: "postgres",
     application_name: "qgrid-vitest-global-setup",
   });
@@ -132,7 +132,7 @@ export async function provisionWorkerDatabases(
 
 export async function setup(project?: VitestProject): Promise<() => Promise<void>> {
   const runDatabase = process.env.QGRID_TEST_RUN_DB;
-  if (!runDatabase || process.env.QGRID_DB_NAME !== runDatabase) {
+  if (!runDatabase || process.env.SONAMU_DB_NAME !== runDatabase) {
     throw new Error("Vitest test database name was not configured consistently");
   }
   const maxWorkers = resolveMaxWorkers(project);

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

@@ -6,25 +6,25 @@ import {
 } from "./test-database-name";
 
 const originalRunDatabase = process.env.QGRID_TEST_RUN_DB;
-const originalDatabase = process.env.QGRID_DB_NAME;
+const originalSonamuDatabase = process.env.SONAMU_DB_NAME;
 
 describe("test run database name", () => {
   afterEach(() => {
     if (originalRunDatabase === undefined) delete process.env.QGRID_TEST_RUN_DB;
     else process.env.QGRID_TEST_RUN_DB = originalRunDatabase;
-    if (originalDatabase === undefined) delete process.env.QGRID_DB_NAME;
-    else process.env.QGRID_DB_NAME = originalDatabase;
+    if (originalSonamuDatabase === undefined) delete process.env.SONAMU_DB_NAME;
+    else process.env.SONAMU_DB_NAME = originalSonamuDatabase;
   });
 
   it("uses one run-unique basename for setup and Sonamu workers", () => {
     delete process.env.QGRID_TEST_RUN_DB;
-    process.env.QGRID_DB_NAME = "qgrid";
+    process.env.SONAMU_DB_NAME = "qgrid";
 
     const runDatabase = configureTestRunDatabaseName();
 
     expect(runDatabase).toMatch(/^qgrid_test_[A-Za-z0-9_]+$/);
     expect(process.env.QGRID_TEST_RUN_DB).toBe(runDatabase);
-    expect(process.env.QGRID_DB_NAME).toBe(runDatabase);
+    expect(process.env.SONAMU_DB_NAME).toBe(runDatabase);
   });
 
   it("adds controller-specific entropy when processes share a prefix", () => {

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

@@ -10,12 +10,13 @@ export function createTestRunDatabaseName(prefix: string, entropy: string): stri
 }
 
 export function configureTestRunDatabaseName(): string {
-  if (configuredRunDatabase) return configuredRunDatabase;
-  const prefix = process.env.QGRID_TEST_RUN_DB ?? "qgrid_test";
-  const entropy = `${process.pid}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
-  const runDatabase = createTestRunDatabaseName(prefix, entropy);
-  configuredRunDatabase = runDatabase;
-  process.env.QGRID_TEST_RUN_DB = runDatabase;
-  process.env.QGRID_DB_NAME = runDatabase;
-  return runDatabase;
+  if (!configuredRunDatabase) {
+    const prefix = process.env.QGRID_TEST_RUN_DB ?? "qgrid_test";
+    const entropy = `${process.pid}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+    configuredRunDatabase = createTestRunDatabaseName(prefix, entropy);
+  }
+
+  process.env.QGRID_TEST_RUN_DB = configuredRunDatabase;
+  process.env.SONAMU_DB_NAME = configuredRunDatabase;
+  return configuredRunDatabase;
 }

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

@@ -7,6 +7,7 @@ import {
   hasOneMillionSuffix,
   needsCli1mSuffix,
   supports1MContext,
+  usesAdaptiveThinking,
 } from "./anthropic-constants";
 
 describe("canonicalAnthropicModel", () => {
@@ -16,6 +17,7 @@ describe("canonicalAnthropicModel", () => {
 
   it("provider prefix 를 제거한다", () => {
     expect(canonicalAnthropicModel("anthropic/claude-opus-4-8")).toBe("claude-opus-4-8");
+    expect(canonicalAnthropicModel("anthropic/claude-fable-5")).toBe("claude-fable-5");
   });
 
   it("[1m] suffix 를 base canonical 에서 제거한다", () => {
@@ -26,6 +28,9 @@ describe("canonicalAnthropicModel", () => {
 
 describe("Anthropic 1M context policy", () => {
   it("지원 모델은 실측 확인된 exact set 만 true", () => {
+    expect(supports1MContext("claude-fable-5")).toBe(true);
+    expect(supports1MContext("claude-opus-5")).toBe(true);
+    expect(supports1MContext("claude-sonnet-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-4-6")).toBe(true);
     expect(supports1MContext("claude-opus-4-6")).toBe(true);
     expect(supports1MContext("claude-opus-4-8")).toBe(true);
@@ -37,6 +42,9 @@ describe("Anthropic 1M context policy", () => {
   });
 
   it("CLI suffix 필요 모델과 기본 1M 모델을 분리한다", () => {
+    expect(needsCli1mSuffix("claude-fable-5")).toBe(false);
+    expect(needsCli1mSuffix("claude-opus-5")).toBe(false);
+    expect(needsCli1mSuffix("claude-sonnet-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-4-6")).toBe(true);
     expect(needsCli1mSuffix("claude-opus-4-6")).toBe(true);
     expect(needsCli1mSuffix("claude-opus-4-8")).toBe(false);
@@ -58,3 +66,14 @@ describe("Anthropic 1M context policy", () => {
     expect(() => assertSupportedOneMillionSuffix("anthropic/claude-sonnet-4-6[1m]")).not.toThrow();
   });
 });
+
+describe("Anthropic thinking policy", () => {
+  it("Fable 5 와 Opus 5 는 adaptive thinking 을 보존한다", () => {
+    expect(usesAdaptiveThinking("claude-fable-5")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-fable-5")).toBe(true);
+    expect(usesAdaptiveThinking("claude-opus-5")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-opus-5")).toBe(true);
+    expect(usesAdaptiveThinking("claude-sonnet-5")).toBe(false);
+    expect(usesAdaptiveThinking("claude-opus-4-8")).toBe(false);
+  });
+});

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

@@ -42,15 +42,22 @@ export function hasOneMillionSuffix(model?: string): boolean {
   return model !== undefined && ONE_MILLION_SUFFIX_RE.test(model);
 }
 
-// 1M 지원 여부는 Claude Code 유출본의 prefix 판정이 아니라 qgrid 실측 기준 exact set 으로 고정한다.
-// opus-4-7 은 실측 전까지 미포함. 새 모델 추가 시 실제 claude CLI contextWindow 동작으로 확인한다.
+// 1M 지원 여부는 Claude Code 내부의 광범위한 prefix 판정이 아니라 qgrid에서 확인한 exact set 으로
+// 고정한다. opus-4-7 은 실측 전까지 미포함. 새 모델 추가 시 공식 사양과 실제 CLI 동작을 확인한다.
 const ONE_MILLION_CONTEXT_MODELS = new Set([
+  "claude-fable-5",
+  "claude-opus-5",
+  "claude-sonnet-5",
   "claude-sonnet-4-6",
   "claude-opus-4-6",
   "claude-opus-4-8",
 ]);
 
 const CLI_ONE_MILLION_SUFFIX_MODELS = new Set(["claude-sonnet-4-6", "claude-opus-4-6"]);
+// Fable 5 는 adaptive thinking 이 유일한 모드다. Opus 5 는 disabled 를 high 이하에서 지원하지만,
+// 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid 기본 effort=low 가 비용/지연 제어를
+// 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시 tool/XML 출력 오염도 피한다.
+const ADAPTIVE_THINKING_MODELS = new Set(["claude-fable-5", "claude-opus-5"]);
 
 // 불변 계약: suffix 가 필요한 모델은 반드시 1M 지원 모델의 부분집합이어야 한다. 역방향 불일치(suffix
 // 대상인데 지원 집합엔 없음)면 needsCli1mSuffix=true·supports1MContext=false 가 동시에 나서
@@ -70,6 +77,12 @@ export function needsCli1mSuffix(model?: string): boolean {
   return CLI_ONE_MILLION_SUFFIX_MODELS.has(canonicalAnthropicModel(model));
 }
 
+// qgrid 가 adaptive thinking 을 보존하는 모델인지 판별한다. 나머지 모델은 기존
+// 저비용/비추론 경로를 유지한다.
+export function usesAdaptiveThinking(model?: string): boolean {
+  return ADAPTIVE_THINKING_MODELS.has(canonicalAnthropicModel(model));
+}
+
 export function assertSupportedOneMillionSuffix(model?: string): void {
   if (!hasOneMillionSuffix(model)) return;
   const canonical = canonicalAnthropicModel(model);

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

@@ -347,7 +347,8 @@ export class AnthropicDispatcher implements ProviderDispatcher {
             ? `${session.text.slice(0, 500)}…(${session.text.length} chars)`
             : session.text
           : `empty text, outputTokens=${session.usage.outputTokens}`;
-        throw new Error(`claude error (${token.name}) [${reason}]: ${body}`);
+        const refusal = session.refusal ? ` refusal=${JSON.stringify(session.refusal)}` : "";
+        throw new Error(`claude error (${token.name}) [${reason}]: ${body}${refusal}`);
       }
 
       return {
@@ -357,7 +358,11 @@ export class AnthropicDispatcher implements ProviderDispatcher {
         durationMs: session.durationMs,
         ttftMs: session.ttftMs,
         costUsd: session.costUsd,
-        model,
+        // Claude Code 는 Fable refusal 을 Opus 로 자동 fallback 할 수 있다. 요청 모델을
+        // 그대로 serving model 로 기록하면 비용/감사 로그가 모두 틀어지므로 둘을 구분한다.
+        model: session.servedModel ?? model,
+        requestedModel: model,
+        modelFallbacks: session.modelFallbacks,
         // systemHash 는 상위 issueConvContext 가 채운다(여기선 비운다).
         threadCoord: {
           workerId: makeAnthropicWorkerId(token.id),

package/bundle/src/utils/providers/anthropic/claude-session.test.ts

@@ -12,6 +12,7 @@ import {
   oneMillionEnv,
   runClaudeSession,
   structuredOutputRetriesEnv,
+  thinkingEnv,
   SYSTEM_PROMPT_ARGV_MAX_BYTES,
   withSessionLock,
 } from "./claude-session";
@@ -132,6 +133,17 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(oneMillionEnv(false)).toEqual({ CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" });
   });
 
+  it("thinkingEnv: Fable 5/Opus 5 는 adaptive thinking 을 보존하고 나머지는 비활성화", () => {
+    expect(thinkingEnv("claude-fable-5")).toEqual({});
+    expect(thinkingEnv("anthropic/claude-fable-5")).toEqual({});
+    expect(thinkingEnv("claude-opus-5")).toEqual({});
+    expect(thinkingEnv("anthropic/claude-opus-5")).toEqual({});
+    expect(thinkingEnv("claude-opus-4-8")).toEqual({
+      CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
+      MAX_THINKING_TOKENS: "0",
+    });
+  });
+
   // SON-495: structured output retry 를 1 로 고정한다.
   it("structuredOutputRetriesEnv: 미설정/비정상 값은 1 로 기본 고정", () => {
     expect(structuredOutputRetriesEnv(undefined)).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
@@ -214,11 +226,40 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
 
   it("1M 기본 지원 모델은 CLI --model 에 suffix 를 붙이지 않는다", () => {
     const args = buildClaudeArgs({
-      model: "claude-opus-4-8",
+      model: "claude-opus-5",
       sessionId: "u",
       needsOneMillionSuffix: false,
     });
-    expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-4-8");
+    expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-5");
+  });
+
+  it("Fable 5 는 항상 켜진 adaptive thinking 을 끄지 않고 effort 만 전달한다", () => {
+    const args = buildClaudeArgs({
+      model: "claude-fable-5",
+      sessionId: "u",
+      effort: "low",
+    });
+    expect(args[args.indexOf("--model") + 1]).toBe("claude-fable-5");
+    expect(args).not.toContain("--thinking");
+    expect(args[args.indexOf("--effort") + 1]).toBe("low");
+  });
+
+  it("Opus 5 는 adaptive thinking 을 보존해 xhigh/max effort 조합도 거부되지 않게 한다", () => {
+    for (const effort of ["xhigh", "max"]) {
+      const args = buildClaudeArgs({
+        model: "claude-opus-5",
+        sessionId: "u",
+        effort,
+      });
+      expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-5");
+      expect(args).not.toContain("--thinking");
+      expect(args[args.indexOf("--effort") + 1]).toBe(effort);
+    }
+  });
+
+  it("기존 Anthropic 모델은 thinking disabled 계약을 유지한다", () => {
+    const args = buildClaudeArgs({ model: "claude-opus-4-8", sessionId: "u" });
+    expect(args[args.indexOf("--thinking") + 1]).toBe("disabled");
   });
 
   it("non-structured(jsonSchema 없음): --allowed-tools 미부여 (P2-7)", () => {

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -31,6 +31,7 @@ import {
   canonicalAnthropicModel,
   needsCli1mSuffix,
   supports1MContext,
+  usesAdaptiveThinking,
 } from "./anthropic-constants";
 import {
   buildStreamJsonInput,
@@ -145,6 +146,18 @@ export function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONT
   return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
 }
 
+export function thinkingEnv(model: string): {
+  CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING?: "1";
+  MAX_THINKING_TOKENS?: "0";
+} {
+  return usesAdaptiveThinking(model)
+    ? {}
+    : {
+        CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
+        MAX_THINKING_TOKENS: "0",
+      };
+}
+
 // SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면
 // `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를
 // 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에
@@ -211,8 +224,8 @@ export function buildClaudeArgs(opts: {
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
     // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).
     ...systemArgs,
-    "--thinking",
-    "disabled",
+    // Fable 5 는 adaptive thinking 이 필수이고, Opus 5 는 공식 기본 adaptive 동작을 보존한다.
+    ...(usesAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"]),
     "--effort",
     opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,
     "--disable-slash-commands",
@@ -291,14 +304,13 @@ export function runClaudeSession(
           CLAUDE_CODE_OAUTH_TOKEN: req.token,
           CLAUDE_CONFIG_DIR: configDir,
           CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
-          CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
+          ...thinkingEnv(model),
           ...oneMillionEnv(supportsOneMillion),
           CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
           CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
           CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: "1",
           CLAUDE_CODE_DISABLE_WORKFLOWS: "1",
           CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
-          MAX_THINKING_TOKENS: "0",
           // structured output 일 때만 retry 를 고정한다(SON-495). text 모드는 영향 없음.
           ...(useStructured ? structuredOutputRetriesEnv() : {}),
         },

package/bundle/src/utils/providers/anthropic/stream-json-adapter.test.ts

@@ -340,6 +340,10 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
           input_tokens: 10,
           cache_creation_input_tokens: 2274,
           cache_read_input_tokens: 14853,
+          cache_creation: {
+            ephemeral_5m_input_tokens: 274,
+            ephemeral_1h_input_tokens: 2000,
+          },
           output_tokens: 111,
         },
       }),
@@ -349,6 +353,8 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
       inputTokens: 10 + 2274 + 14853,
       cachedInputTokens: 14853,
       cacheCreationInputTokens: 2274,
+      cacheCreationInputTokens5m: 274,
+      cacheCreationInputTokens1h: 2000,
       outputTokens: 111,
       reasoningOutputTokens: 0,
     });
@@ -392,6 +398,131 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     expect(ok2.result!.isError).toBe(false);
   });
 
+  it("Fable refusal fallback: Opus 응답은 성공으로 유지하고 실제 serving model을 보존", () => {
+    const { result } = runLines([
+      JSON.stringify({
+        type: "system",
+        subtype: "model_refusal_fallback",
+        trigger: "refusal",
+        originalModel: "claude-fable-5",
+        fallbackModel: "claude-opus-4-8",
+        apiRefusalCategory: "cyber",
+        apiRefusalExplanation: "classifier declined the request",
+      }),
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          model: "claude-opus-4-8",
+          stop_reason: "end_turn",
+          content: [{ type: "text", text: "safe answer" }],
+          usage: {
+            iterations: [
+              { type: "message", model: "claude-fable-5", input_tokens: 100 },
+              {
+                type: "fallback_message",
+                model: "claude-opus-4-8",
+                input_tokens: 100,
+                output_tokens: 20,
+              },
+            ],
+          },
+        },
+      }),
+      JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "safe answer",
+        usage: { input_tokens: 100, output_tokens: 20 },
+        total_cost_usd: 0.003,
+      }),
+    ]);
+
+    expect(result).toMatchObject({
+      isError: false,
+      stopReason: "end_turn",
+      servedModel: "claude-opus-4-8",
+      modelFallbacks: [
+        {
+          trigger: "refusal",
+          fromModel: "claude-fable-5",
+          toModel: "claude-opus-4-8",
+          category: "cyber",
+          explanation: "classifier declined the request",
+        },
+      ],
+    });
+  });
+
+  it("Fable final refusal: success envelope라도 fallback이 없으면 에러", () => {
+    const { result } = runLines([
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          model: "claude-fable-5",
+          stop_reason: "refusal",
+          stop_details: { type: "refusal", category: "bio", explanation: "declined" },
+          content: [],
+        },
+      }),
+      JSON.stringify({
+        type: "system",
+        subtype: "model_refusal_no_fallback",
+        trigger: "refusal",
+        originalModel: "claude-fable-5",
+        apiRefusalCategory: "bio",
+        apiRefusalExplanation: "declined",
+      }),
+      JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "",
+        usage: { input_tokens: 412, output_tokens: 0 },
+        total_cost_usd: 0,
+      }),
+    ]);
+
+    expect(result).toMatchObject({
+      isError: true,
+      stopReason: "refusal",
+      servedModel: "claude-fable-5",
+      refusal: { category: "bio", explanation: "declined" },
+    });
+  });
+
+  it("usage.iterations만 있어도 Fable → Opus fallback을 복원", () => {
+    const { result } = runLines([
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          model: "claude-opus-4-8",
+          stop_reason: "end_turn",
+          content: [{ type: "text", text: "answer" }],
+          usage: {
+            iterations: [
+              { type: "message", model: "claude-fable-5" },
+              { type: "fallback_message", model: "claude-opus-4-8" },
+            ],
+          },
+        },
+      }),
+      JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "answer",
+        usage: { input_tokens: 10, output_tokens: 2 },
+      }),
+    ]);
+
+    expect(result!.servedModel).toBe("claude-opus-4-8");
+    expect(result!.modelFallbacks).toEqual([
+      {
+        trigger: "refusal",
+        fromModel: "claude-fable-5",
+        toModel: "claude-opus-4-8",
+      },
+    ]);
+  });
+
   it("quota: result text가 'You've hit'로 시작 → quotaExhausted true", () => {
     const { result } = runLines([
       JSON.stringify({ type: "result", result: "You've hit your limit", usage: {} }),