@cartanova/qgrid-cli 2.3.2 → 2.3.3

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

@@ -1,27 +1,21 @@
 /**
  * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.
  *
- * 멀티턴: 첫 호출 `--session-id <uuid>`, 후속 `--resume <uuid>`. 입력은 U2 어댑터가 만든
- * JSONL 을 stdin 으로 흘리고(`--input-format stream-json`), 출력은 U3 파서로 처리한다.
+ * 멀티턴: 매 호출 fresh `--session-id <uuid>`로 실행한다. 입력은 어댑터가 만든 JSONL 을
+ * stdin 으로 흘리고(`--input-format stream-json`), 출력은 파서로 처리한다.
  *
  * 핵심 계약:
  *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에
  *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반
  *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.
- *  - resume eligibility 는 systemHash 만으로 부족 → 확장 호환키(system+model+structured 모드)로
- *    판정. 불일치면 cold fallback.
- *  - 같은 세션의 동시 turn 은 per-session 락(session-id 단위 직렬화)으로 transcript 오염 방지.
+ *  - withSessionLock 은 exported primitive 로 유지한다. 기본 경로에서는 매 호출 새 session-id 라
+ *    사실상 no-contention 이지만, 직접 호출자/테스트의 직렬화 보장은 보존한다.
  *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.
  *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).
- *
- * ⚠️ 첫 호출 동시성: resume 가 아닌 "첫 호출"은 여기서 새 랜덤 session-id 를 발급하므로, 같은
- *    qgrid sessionKey 에 대한 두 동시 첫 호출은 서로 다른 id 로 둘 다 실행된다. 현재 IF/owner scope 는
- *    LLM 호출을 순차 실행하고 sessionKey 를 서버로 보내지 않으므로, dispatcher 는 cold 락을 두지 않는다.
- *    병렬 첫 호출을 서버가 지원하게 되면 sessionKey 전달/락 설계부터 다시 잡아야 한다.
  */
 
 import { spawn } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
@@ -32,7 +26,10 @@ import {
   anthropicConfigDir,
   ANTHROPIC_DEFAULT_EFFORT,
   ANTHROPIC_DISALLOWED_TOOLS,
+  assertSupportedOneMillionSuffix,
   canonicalAnthropicModel,
+  needsCli1mSuffix,
+  supports1MContext,
 } from "./anthropic-constants";
 import {
   buildStreamJsonInput,
@@ -42,26 +39,10 @@ import {
   handleStreamJsonLine,
 } from "./stream-json-adapter";
 
-// ── 호환키 ──────────────────────────────────────────────────────────
-
-// resume 가능 여부를 가르는 키. systemHash 만으로는 같은 sessionKey 를 다른 model/schema 로
-// 재사용할 때 context 오염 → system + model + structured 모드까지 묶는다.
-export function compatibilityKey(opts: {
-  system?: string;
-  model: string;
-  // structured output schema 문자열. 없으면 text 모드. 내용이 다르면 다른 키.
-  outputSchema?: string;
-}): string {
-  const schemaPart = opts.outputSchema && opts.outputSchema.length > 0 ? opts.outputSchema : "text";
-  return createHash("sha256")
-    .update(`${opts.system ?? ""}\0${opts.model}\0${schemaPart}`)
-    .digest("hex")
-    .slice(0, 16);
-}
-
 // ── per-session 락 ─────────────────────────────────────────────────
 
-// session-id 단위 직렬화. 같은 세션의 동시 turn 이 같은 transcript 에 동시 resume·append 하는 것 방지.
+// session-id 단위 직렬화 primitive. 기본 경로에서는 매 호출 새 uuid 라 사실상 no-op 이지만,
+// 같은 session-id 를 직접 쓰는 호출자는 여전히 직렬화 보장을 받는다.
 const sessionChains = new Map<string, Promise<unknown>>();
 
 export async function withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {
@@ -93,7 +74,10 @@ export function makeAnthropicWorkerId(tokenId: number): number {
 // ── envelope decorate ──────────────────────────────────────────────
 
 // stream-json 입력 라인에 SDK envelope 부착 후 직렬화. session 소유자인 여기서 한다.
-export function decorateAndSerialize(lines: Array<ClaudeStreamJsonLine>, sessionId: string): string {
+export function decorateAndSerialize(
+  lines: Array<ClaudeStreamJsonLine>,
+  sessionId: string,
+): string {
   return (
     lines
       .map((line) =>
@@ -118,12 +102,10 @@ export interface ClaudeSessionRequest {
   jsonSchema?: string; // 있으면 structured output
   effort?: string;
   timeoutMs: number;
-  // 입력: cold(coldHistory+coldInput) 또는 resume(reuseInput).
   coldHistory?: Array<JsonValue>;
   input: Array<UserInput>;
-  // resume 경로면 기존 session-id, cold 면 undefined(새로 발급).
-  resumeSessionId?: string;
   abortSignal?: AbortSignal;
+  includePartialMessages?: boolean;
 }
 
 export interface ClaudeSessionResult extends ClaudeStreamResult {
@@ -152,13 +134,23 @@ function ensureCwd(): void {
 }
 
 // spawn args 구성. 멀티턴/격리/structured 모드 반영.
+export function applyOneMillionSuffix(model: string, needsSuffix: boolean): string {
+  const base = canonicalAnthropicModel(model);
+  return needsSuffix ? `${base}[1m]` : base;
+}
+
+export function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONTEXT?: "1" } {
+  return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
+}
+
 export function buildClaudeArgs(opts: {
   model: string;
   system?: string;
   effort?: string;
   jsonSchema?: string;
   sessionId: string;
-  isResume: boolean;
+  needsOneMillionSuffix?: boolean;
+  includePartialMessages?: boolean;
 }): Array<string> {
   const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);
   // --tools "" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.
@@ -176,14 +168,13 @@ export function buildClaudeArgs(opts: {
     "--output-format",
     "stream-json",
     "--verbose",
-    "--max-turns",
-    useStructured ? "2" : "1",
+    ...(opts.includePartialMessages ? ["--include-partial-messages"] : []),
     "--permission-mode",
     "bypassPermissions",
     "--setting-sources",
     "project",
     "--model",
-    opts.model,
+    applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
     "--system-prompt",
     opts.system ?? "",
@@ -192,8 +183,8 @@ export function buildClaudeArgs(opts: {
     "--effort",
     opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,
     "--disable-slash-commands",
-    // 멀티턴: 첫 호출은 session-id 발급, 후속은 resume. --no-session-persistence 는 쓰지 않는다.
-    ...(opts.isResume ? ["--resume", opts.sessionId] : ["--session-id", opts.sessionId]),
+    "--session-id",
+    opts.sessionId,
   ];
   if (useStructured) args.push("--json-schema", opts.jsonSchema!);
   return args;
@@ -209,9 +200,11 @@ export function runClaudeSession(
 ): Promise<ClaudeSessionResult> {
   // 정규화 규칙은 canonicalAnthropicModel 이 단독 소유 — dispatcher 가 이미 canonical 을 넘기지만,
   // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).
+  assertSupportedOneMillionSuffix(req.model);
   const model = canonicalAnthropicModel(req.model);
-  const isResume = Boolean(req.resumeSessionId);
-  const sessionId = req.resumeSessionId ?? randomUUID();
+  const supportsOneMillion = supports1MContext(model);
+  const needsOneMillionSuffix = needsCli1mSuffix(model);
+  const sessionId = randomUUID();
   const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);
   const workerId = makeAnthropicWorkerId(req.tokenId);
 
@@ -225,17 +218,22 @@ export function runClaudeSession(
       effort: req.effort,
       jsonSchema: req.jsonSchema,
       sessionId,
-      isResume,
+      needsOneMillionSuffix,
+      includePartialMessages: req.includePartialMessages,
     });
 
     const inputLines = buildStreamJsonInput({
       coldHistory: req.coldHistory,
       input: req.input,
-      isResume,
     });
     const stdinPayload = decorateAndSerialize(inputLines, sessionId);
 
     return new Promise<ClaudeSessionResult>((resolve, reject) => {
+      if (req.abortSignal?.aborted) {
+        reject(new Error("aborted"));
+        return;
+      }
+
       const child = spawn("claude", args, {
         // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가
         // "closed without result" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.
@@ -248,9 +246,13 @@ export function runClaudeSession(
           CLAUDE_CONFIG_DIR: configDir,
           CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
           CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
-          CLAUDE_CODE_DISABLE_1M_CONTEXT: "1",
+          ...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",
         },
       });
 
@@ -264,9 +266,11 @@ export function runClaudeSession(
         stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);
       });
       const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : "");
+      let cleanupAbort: (() => void) | undefined;
       const timer = setTimeout(() => {
         if (settled) return;
         settled = true;
+        cleanupAbort?.();
         child.kill();
         reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));
       }, req.timeoutMs);
@@ -275,16 +279,20 @@ export function runClaudeSession(
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         resolve({ ...result, sessionId, workerId });
       };
 
-      req.abortSignal?.addEventListener("abort", () => {
+      const onAbort = () => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         child.kill();
         reject(new Error("aborted"));
-      });
+      };
+      cleanupAbort = () => req.abortSignal?.removeEventListener("abort", onAbort);
+      req.abortSignal?.addEventListener("abort", onAbort, { once: true });
 
       child.stdout?.on("data", (d: Buffer) => {
         if (settled) return;
@@ -307,12 +315,14 @@ export function runClaudeSession(
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         reject(new Error(`Claude session closed without result${stderrSuffix()}`));
       });
       child.on("error", (err) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        cleanupAbort?.();
         reject(new Error(`Claude session spawn error: ${err.message}`));
       });
 

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

@@ -21,7 +21,7 @@ function userLineCount(lines: Array<ClaudeStreamJsonLine>): number {
 
 describe("buildStreamJsonInput", () => {
   it("happy: 단일 user input → user 1줄", () => {
-    const lines = buildStreamJsonInput({ input: userText("안녕"), isResume: false });
+    const lines = buildStreamJsonInput({ input: userText("안녕") });
     expect(lines).toHaveLength(1);
     expect(userLineCount(lines)).toBe(1);
     expect(lines[0]).toEqual({
@@ -42,7 +42,6 @@ describe("buildStreamJsonInput", () => {
     const lines = buildStreamJsonInput({
       coldHistory,
       input: userText("비밀번호 뭐였지?"),
-      isResume: false,
     });
     // assistant context 1줄 + 실행 user 1줄
     expect(lines).toHaveLength(2);
@@ -57,28 +56,8 @@ describe("buildStreamJsonInput", () => {
     });
   });
 
-  it("resume: reuseInput(delta) user 1줄만, history 미포함", () => {
-    const lines = buildStreamJsonInput({
-      coldHistory: [
-        {
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: "이전 답변" }],
-        },
-      ],
-      input: userText("다음 질문"),
-      isResume: true,
-    });
-    expect(lines).toHaveLength(1);
-    expect(userLineCount(lines)).toBe(1);
-    expect(lines[0]).toEqual({
-      type: "user",
-      message: { role: "user", content: [{ type: "text", text: "다음 질문" }] },
-    });
-  });
-
   it("정규화: content 는 항상 block 배열 (KTD5 구현계약)", () => {
-    const lines = buildStreamJsonInput({ input: userText("x"), isResume: false });
+    const lines = buildStreamJsonInput({ input: userText("x") });
     expect(Array.isArray(lines[0]!.message.content)).toBe(true);
     expect(lines[0]!.message.content[0]).toHaveProperty("type", "text");
   });
@@ -91,7 +70,6 @@ describe("buildStreamJsonInput", () => {
     const lines = buildStreamJsonInput({
       coldHistory,
       input: userText("결과는?"),
-      isResume: false,
     });
     // assistant context 1줄 + 실행 user 1줄
     expect(lines).toHaveLength(2);
@@ -110,7 +88,6 @@ describe("buildStreamJsonInput", () => {
     const lines = buildStreamJsonInput({
       coldHistory: [],
       input: userText("단발"),
-      isResume: false,
     });
     expect(lines).toHaveLength(1);
     expect(lines[0]!.type).toBe("user");
@@ -122,7 +99,7 @@ describe("buildStreamJsonInput", () => {
       { type: "message", role: "assistant", content: [{ type: "output_text", text: "a1" }] },
       { type: "message", role: "assistant", content: [{ type: "output_text", text: "a2" }] },
     ];
-    const lines = buildStreamJsonInput({ coldHistory, input: userText("q"), isResume: false });
+    const lines = buildStreamJsonInput({ coldHistory, input: userText("q") });
     expect(lines).toHaveLength(2);
     expect(userLineCount(lines)).toBe(1);
     expect(lines[0]!.type).toBe("assistant");
@@ -137,7 +114,7 @@ describe("buildStreamJsonInput", () => {
       { type: "message", role: "user", content: [{ type: "input_text", text: "u2" }] },
       { type: "function_call_output", call_id: "x", output: "out" },
     ];
-    const lines = buildStreamJsonInput({ coldHistory, input: userText("final"), isResume: false });
+    const lines = buildStreamJsonInput({ coldHistory, input: userText("final") });
     expect(userLineCount(lines)).toBe(1);
     expect(lines[lines.length - 1]!.message.content[0]!.text).toBe("final");
   });
@@ -145,7 +122,7 @@ describe("buildStreamJsonInput", () => {
 
 describe("serializeStreamJsonInput", () => {
   it("JSONL 한 줄당 하나 + 마지막 개행", () => {
-    const lines = buildStreamJsonInput({ input: userText("hi"), isResume: false });
+    const lines = buildStreamJsonInput({ input: userText("hi") });
     const out = serializeStreamJsonInput(lines);
     expect(out.endsWith("\n")).toBe(true);
     const parsed = out
@@ -230,7 +207,7 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     expect(deltas).not.toContain(" (thinking)");
   });
 
-  it("structured tool-call: 첫 StructuredOutput을 보존하고 max_turns result를 성공 처리", () => {
+  it("structured tool-call: 첫 StructuredOutput은 보존하되 max_turns result는 error 유지", () => {
     const first = {
       action: "tool_call",
       answer: null,
@@ -249,6 +226,18 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
             content: [{ type: "tool_use", name: "StructuredOutput", input: first }],
           },
         }),
+        JSON.stringify({
+          type: "user",
+          message: {
+            content: [
+              {
+                type: "tool_result",
+                is_error: true,
+                content: "Output does not match required schema",
+              },
+            ],
+          },
+        }),
         JSON.stringify({
           type: "assistant",
           message: {
@@ -269,7 +258,7 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     );
 
     expect(JSON.parse(result!.text)).toEqual(first);
-    expect(result!.isError).toBe(false);
+    expect(result!.isError).toBe(true);
     expect(result!.usage.inputTokens).toBe(30);
     expect(result!.usage.outputTokens).toBe(30);
     expect(result!.durationMs).toBe(1234);

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

@@ -1,27 +1,11 @@
 /**
- * stream-json 어댑터 — Anthropic(Claude) provider 의 입력/출력 변환.
+ * Claude CLI stream-json adapter.
  *
- * 이 모듈은 부활의 유일한 본질적 신규 코드다. 두 방향을 분리된 순수 함수로 둔다:
- *  - 입력: 서버 GenerateRequest payload(coldInput/coldHistory/reuseInput)
- *          → `claude -p --input-format stream-json` 의 JSONL 라인.
- *  - 출력: `claude -p --output-format stream-json --verbose` 의 JSONL 라인
- *          → qgrid 서버 delta(onDelta) + 최종 result. (U3, 같은 파일 하단)
+ * Input: qgrid history/input -> Claude JSONL stdin.
+ * Output: Claude JSONL stdout -> qgrid deltas + final result metadata.
  *
- * 중요한 계약:
- *  - 입력은 AI SDK LanguageModelV3Message[] 가 아니라 **서버측 GenerateRequest** 다.
- *    ai-sdk 가 이미 QueryInput.history(JsonValue[]) 로 변환했고, decideConvRouting 이
- *    coldInput/coldHistory/reuseInput 으로 만든 뒤 dispatcher 에 도달한다.
- *  - content 는 user/assistant 모두 block 배열 `[{type:"text",text}]` 로 정규화한다.
- *    문자열 content 는 일부 user 단발만 통과하고 history replay 에서 깨진다
- *    (`W is not an Object (evaluating '"tool_use_id" in W')`).
- *  - stream-json 의 user/assistant 는 비대칭이다: assistant 는 history context 로 push 되고
- *    **user 는 새 prompt 로 enqueue(=실행)된다.** 따라서 cold 경로에서 과거 대화(user/assistant/
- *    tool)를 그대로 줄로 늘어놓으면 과거 user/tool-output 이 실행 prompt 로 재실행된다. 이를 피하려
- *    cold history 는 **단일 assistant context 텍스트로 평탄화**하고, 실행 가능한 `type:"user"` 줄은
- *    **마지막 input 하나뿐**이 되도록 한다. full-fidelity role replay 가 필요하면 session resume
- *    (reuseInput) 또는 JSONL backstop 으로 간다.
- *  - tool 결과는 native Anthropic tool_result 블록을 새로 만들지 않고, 기존 OpenAI 와
- *    동일하게 평탄화된 text 로 처리한다(emulation 공통 계약).
+ * Previous conversation items are flattened into one assistant context line.
+ * The only executable user line is the current input.
  */
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
@@ -30,11 +14,7 @@ import { type ProviderTokenUsageBreakdown } from "../common/provider-dispatcher"
 
 // ── 입력 어댑터 ────────────────────────────────────────────────────
 
-// Claude stream-json 입력 한 줄(JSONL). content 는 항상 block 배열.
-//
-// SDK envelope 필드(uuid / session_id / parent_tool_use_id)는 **여기서 만들지 않는다**.
-// 그 값들은 세션을 발급/소유하는 claude-session 의 책임이다. 이 모듈은 role/content 변환만 하는
-// 순수 함수로 두고, claude-session 이 직렬화 직전에 envelope 를 decorate 한다. 책임 분리.
+// Claude stream-json 입력 한 줄(JSONL). Envelope fields are added in claude-session.
 export interface ClaudeStreamJsonLine {
   type: "user" | "assistant";
   message: {
@@ -43,7 +23,6 @@ export interface ClaudeStreamJsonLine {
   };
 }
 
-// UserInput[] 에서 text 만 뽑아 하나의 문자열로. (image/skill/mention 등은 현재 범위 밖 — text 위주)
 function userInputToText(input: Array<UserInput>): string {
   return input
     .filter((i): i is Extract<UserInput, { type: "text" }> => i.type === "text")
@@ -51,12 +30,11 @@ function userInputToText(input: Array<UserInput>): string {
     .join("\n");
 }
 
-// content 를 항상 block 배열로 정규화(문자열 content 는 history replay 에서 깨짐).
 function textBlock(text: string): Array<{ type: "text"; text: string }> {
   return [{ type: "text", text }];
 }
 
-// codex ResponseItem(coldHistory 의 한 항목) 형태 판별용 최소 shape.
+// codex ResponseItem(coldHistory item) 최소 shape.
 // extractPromptAndHistory(ai-sdk/utils.ts) 가 만드는 형식:
 //   { type:"message", role:"user", content:[{type:"input_text", text}] }
 //   { type:"message", role:"assistant", content:[{type:"output_text", text}] }
@@ -68,8 +46,6 @@ function asObject(v: JsonValue | undefined): ResponseItem | null {
   return typeof v === "object" && v !== null && !Array.isArray(v) ? (v as ResponseItem) : null;
 }
 
-// codex message content([{type:input_text|output_text, text}]) 에서 text 추출.
-// 여러 content 블록은 줄바꿈으로 구분(token-adjacent 붙음 방지).
 function responseItemText(item: ResponseItem): string {
   const content = item.content;
   if (!Array.isArray(content)) return "";
@@ -82,11 +58,6 @@ function responseItemText(item: ResponseItem): string {
     .join("\n");
 }
 
-/**
- * cold history(codex ResponseItem[])를 **단일 평탄 텍스트**로 변환한다.
- * user/assistant/tool 모두 라벨 붙은 한 덩어리로 — 실행되지 않는 assistant context 로 들어간다.
- * (cold 의 user/tool-output 을 type:"user" 로 내보내면 새 prompt 로 재실행되므로 금지.)
- */
 function flattenColdHistory(coldHistory: Array<JsonValue>): string {
   const parts: Array<string> = [];
   for (const raw of coldHistory) {
@@ -111,30 +82,13 @@ function flattenColdHistory(coldHistory: Array<JsonValue>): string {
   return parts.join("\n");
 }
 
-/**
- * 서버 GenerateRequest payload 를 Claude stream-json JSONL 라인 배열로 변환한다.
- *
- * @param opts.coldHistory  cold 경로의 codex ResponseItem 배열(JsonValue[]). resume 경로면 미사용.
- * @param opts.input        실행할 input — cold 면 coldInput, resume 면 reuseInput.
- * @param opts.isResume     resume 경로 여부. true 면 history 재주입 없이 input(delta)만.
- *
- * 출력 규칙:
- *  - 실행 가능한 `type:"user"` 줄은 **항상 정확히 1개** — 마지막 input.
- *  - resume: user(delta) 1줄만. thread 가 이전 turn 을 누적하므로 history 미포함.
- *  - cold: coldHistory 전체를 **단일 assistant context 텍스트**로 평탄화(실행 안 됨) + user(input) 1줄.
- *          user/assistant/tool 모두 평탄화되므로 과거 user/tool-output 이 재실행되지 않는다.
- *          full-fidelity role replay 가 필요하면 session resume 또는 JSONL backstop(범위 밖).
- *  - tool(function_call/output): native 블록 없이 평탄 텍스트로.
- */
 export function buildStreamJsonInput(opts: {
   coldHistory?: Array<JsonValue>;
   input: Array<UserInput>;
-  isResume: boolean;
 }): Array<ClaudeStreamJsonLine> {
   const lines: Array<ClaudeStreamJsonLine> = [];
 
-  // cold 경로: history 를 단일 assistant context 로 평탄화(실행 안 됨).
-  if (!opts.isResume && opts.coldHistory && opts.coldHistory.length > 0) {
+  if (opts.coldHistory && opts.coldHistory.length > 0) {
     const flattened = flattenColdHistory(opts.coldHistory);
     if (flattened) {
       lines.push({
@@ -147,7 +101,6 @@ export function buildStreamJsonInput(opts: {
     }
   }
 
-  // 실행할 input — resume/cold 공통, 항상 마지막의 단일 user 줄.
   lines.push({
     type: "user",
     message: { role: "user", content: textBlock(userInputToText(opts.input)) },
@@ -156,26 +109,14 @@ export function buildStreamJsonInput(opts: {
   return lines;
 }
 
-// JSONL 문자열(claude stdin 으로 흘릴 형태)로 직렬화.
 export function serializeStreamJsonInput(lines: Array<ClaudeStreamJsonLine>): string {
   return lines.map((l) => JSON.stringify(l)).join("\n") + "\n";
 }
 
 // ── 출력 어댑터 ────────────────────────────────────────────────────
 //
-// claude -p --output-format stream-json --verbose 의 stdout(JSONL)을
-// qgrid 서버 delta(onDelta) + 최종 result 로 변환한다.
-//
-// 계약:
-//  - 이 어댑터는 qgrid **서버** 계층이다. AI SDK stream part(text-delta 등)는
-//    packages/ai-sdk(client provider)가 만든다 — 여기서 만들지 않는다.
-//  - text_delta → onDelta(text). structured output 일 때 input_json_delta.partial_json
-//    조각도 onDelta(text) 로 흘린다(client provider 가 partialObjectStream 으로 누적).
-//  - 최종 result → structured_output(우선) 또는 result(폴백, 자연어 가능) + usage + 종료.
-//  - usage 는 input/cache_creation/cache_read/output 4 카테고리를 받아 TokenUsageBreakdown 으로.
-//    payload 크기 비교는 3 카테고리 합으로(과거 학습 — input 단독 비교 무의미).
+// Claude stdout(JSONL)을 qgrid deltas + final result 로 변환한다.
 
-// claude stream-json 출력에서 우리가 보는 usage shape(부분). Anthropic 네이티브 필드.
 interface ClaudeUsage {
   input_tokens?: number;
   output_tokens?: number;
@@ -183,7 +124,6 @@ interface ClaudeUsage {
   cache_read_input_tokens?: number;
 }
 
-// 최종 result 파싱 산출물. dispatcher(U1)가 GenerateResult 조립에 쓴다.
 export interface ClaudeStreamResult {
   text: string;
   usage: ProviderTokenUsageBreakdown;
@@ -220,8 +160,6 @@ function toUsageBreakdown(u: ClaudeUsage): ProviderTokenUsageBreakdown {
   };
 }
 
-// result.result 의 코드펜스(```json ... ```) 제거. structured_output 이 없을 때만 쓴다.
-// 앞뒤 공백/개행을 먼저 trim 해 `\n```json\n...\n```\n` 같은 형태도 깨끗이 제거.
 function stripCodeFence(s: string): string {
   return s
     .trim()
@@ -237,26 +175,18 @@ function structuredOutputToolUseText(j: ResponseItem): string | undefined {
   for (const raw of content) {
     const block = asObject(raw);
     if (!block) continue;
-    if (block.type === "tool_use" && block.name === "StructuredOutput" && block.input !== undefined) {
+    if (
+      block.type === "tool_use" &&
+      block.name === "StructuredOutput" &&
+      block.input !== undefined
+    ) {
       return JSON.stringify(block.input);
     }
   }
   return undefined;
 }
 
-/**
- * stream-json 출력 라인 하나를 처리한다. 순수 함수 — side effect 는 onDelta 콜백뿐.
- *
- * @param opts.structuredOutput  structured output(jsonSchema) 모드 여부.
- *   structured 모드에서 Claude 는 자연어 text_delta 와 input_json_delta.partial_json 을
- *   **함께** 흘릴 수 있다(PoC 확인). 이때 text_delta 를 그대로 onDelta 로 보내면 client 의
- *   streamObject 파서가 prose 를 JSON 앞에서 만나 깨진다. 그래서:
- *     - structured 모드: text_delta 무시, partial_json 만 onDelta.
- *     - text 모드: text_delta 만 onDelta (partial_json 은 안 옴).
- *
- * @returns result 이벤트면 ClaudeStreamResult, 그 외(delta/system 등)면 null.
- *          호출부는 라인 스트림을 돌며 이 함수를 호출하고, non-null 이 나오면 종료.
- */
+// Processes one Claude stdout JSONL line. Returns final result on result event.
 export function handleStreamJsonLine(
   line: string,
   onDelta: (text: string) => void,
@@ -271,23 +201,19 @@ export function handleStreamJsonLine(
   try {
     j = JSON.parse(trimmed) as { [key: string]: JsonValue | undefined };
   } catch {
-    // 깨진 JSON 라인은 graceful skip.
     return null;
   }
 
-  // 점진 delta: stream_event > content_block_delta > {text_delta | input_json_delta}.
   if (j.type === "stream_event") {
     const event = asObject(j.event);
     if (event && event.type === "content_block_delta") {
       const delta = asObject(event.delta);
       if (delta) {
         if (structuredOutput) {
-          // structured: JSON 조각만. 자연어 text_delta 는 버린다(streamObject 파서 보호).
           if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
             onDelta(delta.partial_json);
           }
         } else {
-          // text: 자연어 delta 만.
           if (delta.type === "text_delta" && typeof delta.text === "string") {
             onDelta(delta.text);
           }
@@ -297,13 +223,17 @@ export function handleStreamJsonLine(
     return null;
   }
 
-  if (j.type === "assistant" && structuredOutput && state && state.structuredOutputText === undefined) {
+  if (
+    j.type === "assistant" &&
+    structuredOutput &&
+    state &&
+    state.structuredOutputText === undefined
+  ) {
     const text = structuredOutputToolUseText(j);
     if (text !== undefined) state.structuredOutputText = text;
     return null;
   }
 
-  // 최종 result.
   if (j.type === "result") {
     let text: string;
     const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : undefined;
@@ -317,18 +247,11 @@ export function handleStreamJsonLine(
 
     const usage = toUsageBreakdown((asObject(j.usage) ?? {}) as ClaudeUsage);
     const quotaExhausted = text.startsWith("You've hit");
-    // 에러 판정: is_error true, terminal model_error,
-    // 또는 subtype 이 있고 "success" 가 아니면(error_during_execution / error_max_turns /
-    // error_max_budget_usd / error_max_structured_output_retries 등) 에러로 본다.
     const subtype = typeof j.subtype === "string" ? j.subtype : undefined;
-    const structuredMaxTurnsCompleted =
-      preservedStructuredOutput !== undefined &&
-      (subtype === "error_max_turns" || j.terminal_reason === "max_turns");
     const isError =
-      !structuredMaxTurnsCompleted &&
-      (j.is_error === true ||
-        j.terminal_reason === "model_error" ||
-        (subtype !== undefined && subtype !== "success"));
+      j.is_error === true ||
+      j.terminal_reason === "model_error" ||
+      (subtype !== undefined && subtype !== "success");
 
     return {
       text,