devez-vibe 0.1.46 → 0.1.47

package/bridge/claude-agent-sdk-bridge.mjs

@@ -7,10 +7,10 @@ import {
   deleteSession,
   forkSession,
   getSessionInfo,
-  getSessionMessages,
-  listSessions,
-  startup,
-} from "@anthropic-ai/claude-agent-sdk";
+  getSessionMessages,
+  listSessions,
+  startup,
+} from "@anthropic-ai/claude-agent-sdk";
 
 const VERSION = process.env.DEVEZ_VIBE_VERSION || "dev";
 const sessions = new Map();
@@ -82,23 +82,23 @@ function hostRequest(method, params, signal) {
   });
 }
 
-function sanitizedEnvironment() {
+function sanitizedEnvironment() {
   const env = { ...process.env };
   delete env.ANTHROPIC_API_KEY;
   delete env.ANTHROPIC_AUTH_TOKEN;
   env.CLAUDE_AGENT_SDK_CLIENT_APP = `devez-vibe/${VERSION}`;
-  return env;
-}
-
-function applyClaudeExecutable(options, params) {
-  const executable = String(params.claudePath || "").trim();
-  if (!executable) return;
-  // On Windows use the SDK's matching native CLI bundle. It reads the same
-  // ~/.claude credentials, settings, hooks, skills, and plugins, while avoiding
-  // EINVAL from command shims and incompatible separately-installed CLI builds.
-  if (process.platform === "win32") return;
-  options.pathToClaudeCodeExecutable = executable;
-}
+  return env;
+}
+
+function applyClaudeExecutable(options, params) {
+  const executable = String(params.claudePath || "").trim();
+  if (!executable) return;
+  // On Windows use the SDK's matching native CLI bundle. It reads the same
+  // ~/.claude credentials, settings, hooks, skills, and plugins, while avoiding
+  // EINVAL from command shims and incompatible separately-installed CLI builds.
+  if (process.platform === "win32") return;
+  options.pathToClaudeCodeExecutable = executable;
+}
 
 function modelCapabilities(models, model) {
   const value = stripClaudeModel(model);
@@ -135,7 +135,7 @@ function compactClaudeModelName(model) {
   return fallback || clean(model.displayName || model.resolvedModel || model.value);
 }
 
-function catalogEntry(model, defaultResolvedModel) {
+function catalogEntry(model, defaultResolvedModel) {
   const value = String(model.value || "");
   const resolved = String(model.resolvedModel || value);
   const efforts = model.supportsEffort && Array.isArray(model.supportedEffortLevels)
@@ -148,7 +148,7 @@ function catalogEntry(model, defaultResolvedModel) {
     displayName: compactClaudeModelName(model),
     defaultReasoningEffort: efforts.includes("high") ? "high" : efforts.at(-1) || "",
     supportedReasoningEfforts: efforts.map((reasoningEffort) => ({ reasoningEffort })),
-    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
+    isDefault: Boolean(defaultResolvedModel) && resolved === defaultResolvedModel,
     ...(contextWindow > 0 ? { contextWindow } : {}),
   };
 }
@@ -166,21 +166,21 @@ async function loadModelCatalog(params) {
       env: sanitizedEnvironment(),
       stderr: (data) => process.stderr.write(data),
     };
-    applyClaudeExecutable(options, params);
-    const agentQuery = await startAgentQuery(input, options);
+    applyClaudeExecutable(options, params);
+    const agentQuery = await startAgentQuery(input, options);
     const consumer = (async () => {
       try { for await (const _message of agentQuery) { /* initialization only */ } }
       catch { /* the caller receives the supportedModels error */ }
     })();
     try {
-      const models = await agentQuery.supportedModels();
-      const defaultResolvedModel = String(
-        models.find((model) => model.value === "default")?.resolvedModel || "",
-      );
-      return {
-        data: models
-          .filter((model) => model.value && model.value !== "default")
-          .map((model) => catalogEntry(model, defaultResolvedModel)),
+      const models = await agentQuery.supportedModels();
+      const defaultResolvedModel = String(
+        models.find((model) => model.value === "default")?.resolvedModel || "",
+      );
+      return {
+        data: models
+          .filter((model) => model.value && model.value !== "default")
+          .map((model) => catalogEntry(model, defaultResolvedModel)),
       };
     } finally {
       input.close();
@@ -215,7 +215,7 @@ function rawSession(id) {
   return id.startsWith("claude:") ? id.slice("claude:".length) : id;
 }
 
-function makeOptions(params, sessionId, resume) {
+function makeOptions(params, sessionId, resume) {
   const options = {
     cwd: params.cwd || process.cwd(),
     includePartialMessages: true,
@@ -236,23 +236,23 @@ function makeOptions(params, sessionId, resume) {
   const model = stripClaudeModel(params.model);
   if (model) options.model = model;
   if (params.effort) options.effort = params.effort;
-  applyClaudeExecutable(options, params);
+  applyClaudeExecutable(options, params);
   if (resume) options.resume = resume;
   else options.sessionId = sessionId;
   options.canUseTool = (toolName, input, permission) =>
     requestToolPermission(toolName, input, permission);
-  return options;
-}
-
-async function startAgentQuery(prompt, options) {
-  const warm = await startup({ options });
-  try {
-    return warm.query(prompt);
-  } catch (error) {
-    warm.close();
-    throw error;
-  }
-}
+  return options;
+}
+
+async function startAgentQuery(prompt, options) {
+  const warm = await startup({ options });
+  try {
+    return warm.query(prompt);
+  } catch (error) {
+    warm.close();
+    throw error;
+  }
+}
 
 async function requestToolPermission(toolName, input, permission) {
   if (toolName === "AskUserQuestion") {
@@ -334,13 +334,17 @@ async function createSession(params, resumeId) {
     queue,
     query: null,
     turn: null,
+    // Prompts that arrived while a turn was running, run in order afterwards.
+    pendingPrompts: [],
     turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
     tools: new Map(),
     tasks: new Map(),
+    lastContextUsage: null,
+    lastContextWindow: 0,
   };
-  const agentQuery = await startAgentQuery(queue, makeOptions(params, id, resumeId));
+  const agentQuery = await startAgentQuery(queue, makeOptions(params, id, resumeId));
   session.query = agentQuery;
   sessions.set(id, session);
   const consumer = consume(session).catch((error) => {
@@ -353,16 +357,16 @@ async function createSession(params, resumeId) {
     if (session.turn) finishTurn(session, error);
   });
   session.consumer = consumer;
-  let initialization;
-  try {
-    initialization = await agentQuery.initializationResult();
-  } catch (error) {
-    sessions.delete(id);
-    queue.close();
-    agentQuery.close();
-    await Promise.race([consumer, new Promise((resolve) => setTimeout(resolve, 1000))]);
-    throw error;
-  }
+  let initialization;
+  try {
+    initialization = await agentQuery.initializationResult();
+  } catch (error) {
+    sessions.delete(id);
+    queue.close();
+    agentQuery.close();
+    await Promise.race([consumer, new Promise((resolve) => setTimeout(resolve, 1000))]);
+    throw error;
+  }
   session.models = Array.isArray(initialization.models) ? initialization.models : [];
   session.effort = supportedEffort(modelCapabilities(session.models, params.model), params.effort);
   const account = initialization.account || await safeAccount(agentQuery);
@@ -391,6 +395,52 @@ function emitDelta(session, method, itemId, delta) {
   notify(method, { threadId: session.id, turnId: session.turn?.id, itemId, delta, provider: "Claude" });
 }
 
+function tokenBreakdown(usage) {
+  if (!usage) return null;
+  const input = Number(usage.input_tokens ?? usage.inputTokens ?? 0);
+  const cached = Number(usage.cache_read_input_tokens ?? usage.cacheReadInputTokens ?? 0);
+  const cacheWrite = Number(usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens ?? 0);
+  const output = Number(usage.output_tokens ?? usage.outputTokens ?? 0);
+  return {
+    inputTokens: input + cached + cacheWrite,
+    cachedInputTokens: cached,
+    cacheWriteInputTokens: cacheWrite,
+    outputTokens: output,
+    totalTokens: input + cached + cacheWrite + output,
+  };
+}
+
+// A resumed session has no turn yet, so the status line would show no context
+// until the next result. Rebuild both figures from the stored transcript.
+function historyTokenUsage(messages, models, model) {
+  const total = {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    cacheWriteInputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+  };
+  let last = null;
+  let counted = false;
+  for (const message of messages) {
+    if (message.type !== "assistant" || message.message?.model === "<synthetic>") continue;
+    const breakdown = tokenBreakdown(message.message?.usage);
+    if (!breakdown) continue;
+    counted = true;
+    for (const key of Object.keys(total)) total[key] += breakdown[key];
+    // Only the main thread occupies the context window; subagents run their own.
+    if (!message.parent_tool_use_id) last = breakdown;
+  }
+  if (!counted) return null;
+  const capabilities = modelCapabilities(models, model);
+  const contextWindow = Number(capabilities?.contextWindow || capabilities?.contextWindowSize || 0);
+  return {
+    total,
+    ...(last ? { last } : {}),
+    ...(contextWindow > 0 ? { modelContextWindow: contextWindow } : {}),
+  };
+}
+
 function processStreamEvent(session, message) {
   if (!session.turn || message.parent_tool_use_id) return;
   const event = message.event || {};
@@ -433,6 +483,14 @@ function processStreamEvent(session, message) {
 
 function processAssistant(session, message) {
   if (!session.turn || message.parent_tool_use_id) return;
+  session.lastContextUsage = tokenBreakdown(message.message?.usage);
+  const capabilities = modelCapabilities(
+    session.models,
+    message.message?.model || session.model,
+  );
+  session.lastContextWindow = Number(
+    capabilities?.contextWindow || capabilities?.contextWindowSize || 0,
+  );
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
   for (const block of content) {
     if (block.type === "tool_use") processToolUse(session, block);
@@ -499,18 +557,30 @@ function fileChanges(name, input) {
   return [{ path, kind: { type: name === "Write" ? "add" : "update" }, diff: `@@ -0,0 +1 @@\n${additions}` }];
 }
 
+// Claude는 Codex의 update_plan처럼 계획 전체를 다시 보내지 않으므로, 새 계획이 시작될 때
+// 이전 턴에서 이미 끝난 작업을 직접 걷어내야 목록이 턴마다 쌓이지 않는다.
+function pruneFinishedTasks(tasks, turnId) {
+  for (const [key, task] of tasks) {
+    if (task.status === "completed" && task.turnId !== turnId) tasks.delete(key);
+  }
+}
+
 function updatePlanFromToolUse(session, name, toolUseId, input) {
+  const turnId = session.turn?.id;
   if (name === "TaskCreate") {
+    pruneFinishedTasks(session.tasks, turnId);
     session.tasks.set(`pending:${toolUseId}`, {
       id: `pending:${toolUseId}`,
       subject: input.subject || input.description || "작업",
       status: "pending",
+      turnId,
     });
   } else if (name === "TaskUpdate") {
     const task = session.tasks.get(String(input.taskId));
     if (task) {
       if (input.subject) task.subject = input.subject;
       if (input.status) task.status = input.status;
+      task.turnId = turnId;
     }
   }
   emitPlan(session);
@@ -535,6 +605,7 @@ function updatePlanFromToolResult(session, pending, message) {
         id: String(task.id),
         subject: task.subject || task.description || "작업",
         status: task.status || "pending",
+        turnId: session.turn?.id,
       });
     }
     emitPlan(session);
@@ -628,8 +699,8 @@ async function processResult(session, message) {
     threadId: session.id,
     tokenUsage: {
       total: totals,
-      last: totals,
-      modelContextWindow: totals.contextWindow || undefined,
+      ...(session.lastContextUsage ? { last: session.lastContextUsage } : {}),
+      modelContextWindow: session.lastContextWindow || totals.contextWindow || undefined,
     },
   });
   const error = message.is_error && !interrupted
@@ -641,6 +712,25 @@ async function processResult(session, message) {
     account: await safeAccount(session.query),
     usage: await safeUsage(session.query),
   });
+  await runPendingPrompt(session);
+}
+
+// The turn that was waiting starts on its own, so the host sees it exactly like a
+// prompt sent the moment the previous turn ended.
+async function runPendingPrompt(session) {
+  const next = session.pendingPrompts.shift();
+  if (!next) return;
+  try {
+    await runPrompt(session, next);
+  } catch (error) {
+    notify("error", {
+      threadId: session.id,
+      provider: "Claude",
+      error: { message: error instanceof Error ? error.message : String(error) },
+      willRetry: false,
+    });
+    await runPendingPrompt(session);
+  }
 }
 
 function finishTurn(session, error, durationMs) {
@@ -673,34 +763,34 @@ async function consume(session) {
   }
 }
 
-const HANDOFF_HEADER = '<devez_provider_handoff chars="';
-const HANDOFF_SEPARATOR = '">\n';
-const HANDOFF_FOOTER = "\n</devez_provider_handoff>\n\n";
-
-function prependHandoff(content, handoffContext) {
-  if (!handoffContext) return content;
-  const handoff = String(handoffContext);
-  const prefix = `${HANDOFF_HEADER}${handoff.length}${HANDOFF_SEPARATOR}${handoff}${HANDOFF_FOOTER}`;
-  const firstText = content.find((item) => item.type === "text");
-  if (firstText) firstText.text = `${prefix}${firstText.text || ""}`;
-  else content.unshift({ type: "text", text: prefix });
-  return content;
-}
-
-function stripHandoff(text) {
-  if (!text.startsWith(HANDOFF_HEADER)) return text;
-  const separator = text.indexOf(HANDOFF_SEPARATOR, HANDOFF_HEADER.length);
-  if (separator < 0) return text;
-  const length = Number(text.slice(HANDOFF_HEADER.length, separator));
-  if (!Number.isSafeInteger(length) || length < 0) return text;
-  const contextStart = separator + HANDOFF_SEPARATOR.length;
-  const contextEnd = contextStart + length;
-  if (text.slice(contextEnd, contextEnd + HANDOFF_FOOTER.length) !== HANDOFF_FOOTER) return text;
-  return text.slice(contextEnd + HANDOFF_FOOTER.length);
-}
-
-async function inputContent(input, handoffContext) {
-  const content = [];
+const HANDOFF_HEADER = '<devez_provider_handoff chars="';
+const HANDOFF_SEPARATOR = '">\n';
+const HANDOFF_FOOTER = "\n</devez_provider_handoff>\n\n";
+
+function prependHandoff(content, handoffContext) {
+  if (!handoffContext) return content;
+  const handoff = String(handoffContext);
+  const prefix = `${HANDOFF_HEADER}${handoff.length}${HANDOFF_SEPARATOR}${handoff}${HANDOFF_FOOTER}`;
+  const firstText = content.find((item) => item.type === "text");
+  if (firstText) firstText.text = `${prefix}${firstText.text || ""}`;
+  else content.unshift({ type: "text", text: prefix });
+  return content;
+}
+
+function stripHandoff(text) {
+  if (!text.startsWith(HANDOFF_HEADER)) return text;
+  const separator = text.indexOf(HANDOFF_SEPARATOR, HANDOFF_HEADER.length);
+  if (separator < 0) return text;
+  const length = Number(text.slice(HANDOFF_HEADER.length, separator));
+  if (!Number.isSafeInteger(length) || length < 0) return text;
+  const contextStart = separator + HANDOFF_SEPARATOR.length;
+  const contextEnd = contextStart + length;
+  if (text.slice(contextEnd, contextEnd + HANDOFF_FOOTER.length) !== HANDOFF_FOOTER) return text;
+  return text.slice(contextEnd + HANDOFF_FOOTER.length);
+}
+
+async function inputContent(input, handoffContext) {
+  const content = [];
   for (const item of Array.isArray(input) ? input : []) {
     if (item.type === "text") content.push({ type: "text", text: item.text || "" });
     else if (item.type === "localImage" && item.path) {
@@ -713,14 +803,24 @@ async function inputContent(input, handoffContext) {
       content.push({ type: "image", source: { type: "base64", media_type: mediaType, data: bytes.toString("base64") } });
     }
   }
-  return prependHandoff(content.length ? content : [{ type: "text", text: "" }], handoffContext);
+  return prependHandoff(content.length ? content : [{ type: "text", text: "" }], handoffContext);
 }
 
 async function startPrompt(params) {
   const id = rawSession(params.sessionId);
   const session = sessions.get(id);
   if (!session) throw new Error(`Claude 세션을 찾을 수 없습니다: ${id}`);
-  if (session.turn) throw new Error("Claude가 이전 작업을 아직 실행 중입니다.");
+  // Claude runs one turn at a time, so extra input waits its turn instead of
+  // failing — the same queueing the CLI does for a prompt typed while it works.
+  if (session.turn) {
+    session.pendingPrompts.push(params);
+    return { turn: { id: session.turn.id }, queued: true };
+  }
+  return runPrompt(session, params);
+}
+
+async function runPrompt(session, params) {
+  const id = session.id;
   if (params.model) {
     const model = stripClaudeModel(params.model);
     await session.query.setModel(model);
@@ -733,10 +833,11 @@ async function startPrompt(params) {
   session.effort = effort;
   const turnId = `claude-turn-${session.turnSequence++}-${randomUUID()}`;
   session.turn = { id: turnId, sawStreamText: false };
+  session.lastContextUsage = null;
   notify("turn/started", { threadId: id, turn: { id: turnId } });
-  session.queue.push({
-    type: "user",
-    message: { role: "user", content: await inputContent(params.input, params.handoffContext) },
+  session.queue.push({
+    type: "user",
+    message: { role: "user", content: await inputContent(params.input, params.handoffContext) },
     parent_tool_use_id: null,
     session_id: id,
     origin: { kind: "human" },
@@ -750,6 +851,23 @@ function contentBlocks(message) {
   return Array.isArray(content) ? content : [];
 }
 
+function isInternalHistoryText(message, text) {
+  if (message.isMeta || message.subtype === "local_command") return true;
+  const trimmed = text.trim();
+  const tag = trimmed.match(/^<([a-z0-9-]+)>/i)?.[1]?.toLowerCase();
+  return trimmed === "[Request interrupted by user]"
+    || [
+      "bash-input",
+      "bash-stdout",
+      "bash-stderr",
+      "command-name",
+      "local-command-caveat",
+      "local-command-stdout",
+      "local-command-stderr",
+      "task-notification",
+    ].includes(tag);
+}
+
 function historyTurns(messages) {
   const turns = [];
   let turn = null;
@@ -757,10 +875,12 @@ function historyTurns(messages) {
   const tasks = new Map();
   for (const message of messages) {
     const blocks = contentBlocks(message.message);
-    const userText = message.type === "user"
-      ? stripHandoff(blocks.filter((block) => block.type === "text").map((block) => block.text || "").join("\n"))
+    const userText = message.type === "user"
+      ? stripHandoff(blocks.filter((block) => block.type === "text").map((block) => block.text || "").join("\n"))
       : "";
-    if (userText && !blocks.some((block) => block.type === "tool_result")) {
+    if (userText
+      && !blocks.some((block) => block.type === "tool_result")
+      && !isInternalHistoryText(message, userText)) {
       turn = {
         id: `claude-turn-${message.uuid}`,
         status: "completed",
@@ -770,16 +890,28 @@ function historyTurns(messages) {
     }
     if (!turn) continue;
     if (message.type === "assistant") {
+      if (message.message?.model === "<synthetic>") {
+        turn.synthetic = true;
+        continue;
+      }
+      turn.synthetic = false;
+      if (!turn.model && message.message?.model) {
+        turn.model = visibleModel(message.message.model);
+        const prompt = turn.items.find((item) => item.type === "userMessage");
+        if (prompt) prompt.model = turn.model;
+      }
       for (const block of blocks) {
         if (block.type === "text") turn.items.push({ id: `${message.uuid}-text`, type: "agentMessage", text: block.text || "", provider: "Claude" });
         else if (block.type === "thinking") turn.items.push({ id: `${message.uuid}-thinking`, type: "reasoning", summary: [block.thinking || ""] });
         else if (block.type === "tool_use") {
           const pending = { name: block.name, input: block.input || {}, item: toolItem({}, block.id, block.name, block.input || {}) };
           tools.set(block.id, pending);
-          if (block.name === "TaskCreate") tasks.set(`pending:${block.id}`, { id: `pending:${block.id}`, subject: block.input?.subject || "작업", status: "pending" });
-          else if (block.name === "TaskUpdate") {
+          if (block.name === "TaskCreate") {
+            pruneFinishedTasks(tasks, turn.id);
+            tasks.set(`pending:${block.id}`, { id: `pending:${block.id}`, subject: block.input?.subject || "작업", status: "pending", turnId: turn.id });
+          } else if (block.name === "TaskUpdate") {
             const task = tasks.get(String(block.input?.taskId));
-            if (task) Object.assign(task, block.input?.subject ? { subject: block.input.subject } : {}, block.input?.status ? { status: block.input.status } : {});
+            if (task) Object.assign(task, block.input?.subject ? { subject: block.input.subject } : {}, block.input?.status ? { status: block.input.status } : {}, { turnId: turn.id });
           } else if (!["TaskList", "AskUserQuestion"].includes(block.name)) turn.items.push(pending.item);
         }
       }
@@ -798,7 +930,7 @@ function historyTurns(messages) {
           }
         } else if (pending.name === "TaskList" && Array.isArray(message.tool_use_result?.tasks)) {
           tasks.clear();
-          for (const task of message.tool_use_result.tasks) tasks.set(String(task.id), { id: String(task.id), subject: task.subject || "작업", status: task.status || "pending" });
+          for (const task of message.tool_use_result.tasks) tasks.set(String(task.id), { id: String(task.id), subject: task.subject || "작업", status: task.status || "pending", turnId: turn.id });
         } else if (pending.item) {
           const output = toolOutput(block.content, message.tool_use_result);
           Object.assign(pending.item, pending.item.type === "commandExecution"
@@ -814,7 +946,9 @@ function historyTurns(messages) {
     const text = [...tasks.values()].map((task, index) => `${task.status === "completed" ? "✓" : task.status === "in_progress" ? "▸" : "□"} ${numberedTaskSubject(task.subject, index)}`).join("\n");
     turn.items.push({ id: "claude-plan-latest", type: "plan", text });
   }
-  return turns;
+  return turns
+    .filter((candidate) => !candidate.synthetic)
+    .map(({ synthetic: _, ...candidate }) => candidate);
 }
 
 async function dispatch(method, params = {}) {
@@ -835,6 +969,7 @@ async function dispatch(method, params = {}) {
     const id = rawSession(params.sessionId);
     const existing = sessions.get(id);
     if (existing) {
+      const messages = await getSessionMessages(id, { dir: existing.cwd, includeSystemMessages: true });
       return {
         id,
         thread: { id, turns: [] },
@@ -844,6 +979,7 @@ async function dispatch(method, params = {}) {
         reasoningEffort: existing.effort,
         account: await safeAccount(existing.query),
         usage: await safeUsage(existing.query),
+        tokenUsage: historyTokenUsage(messages, existing.models, existing.model),
       };
     }
     const info = await getSessionInfo(id, { dir: params.cwd });
@@ -851,6 +987,10 @@ async function dispatch(method, params = {}) {
     const messages = await getSessionMessages(id, { dir: params.cwd, includeSystemMessages: true });
     const lastModel = [...messages].reverse().find((message) => message.type === "assistant")?.message?.model;
     const { session, account, usage } = await createSession({ ...params, cwd: info.cwd || params.cwd, model: params.model || lastModel }, id);
+    const tokenUsage = historyTokenUsage(messages, session.models, session.model);
+    // Seed the live session so the next turn keeps reporting a full context.
+    session.lastContextUsage = tokenUsage?.last || null;
+    session.lastContextWindow = tokenUsage?.modelContextWindow || 0;
     return {
       id,
       thread: { id, turns: [] },
@@ -860,6 +1000,7 @@ async function dispatch(method, params = {}) {
       reasoningEffort: session.effort,
       account,
       usage,
+      tokenUsage,
     };
   }
   if (method === "session/list") {
@@ -888,6 +1029,9 @@ async function dispatch(method, params = {}) {
   if (method === "session/prompt") return startPrompt(params);
   if (method === "session/interrupt") {
     const session = sessions.get(rawSession(params.sessionId));
+    // Stopping the run drops what was waiting behind it too, so nothing the user
+    // just cancelled starts on its own afterwards.
+    if (session) session.pendingPrompts.length = 0;
     if (session?.turn) {
       const turn = session.turn;
       turn.interruptRequested = true;
@@ -944,6 +1088,59 @@ async function dispatch(method, params = {}) {
   throw new Error(`지원하지 않는 Claude 브리지 메서드: ${method}`);
 }
 
+function runSelfTest() {
+  const user = (uuid, text) => ({
+    type: "user",
+    uuid,
+    message: { role: "user", content: [{ type: "text", text }] },
+    origin: { kind: "human" },
+  });
+  const assistant = (uuid, model, text) => ({
+    type: "assistant",
+    uuid,
+    message: { role: "assistant", model, content: [{ type: "text", text }] },
+  });
+  const turns = historyTurns([
+    user("u1", "say hi"),
+    assistant("a1", "claude-opus-5", "hi."),
+    user("command", "<command-name>/model</command-name>"),
+    user("stdout", "<local-command-stdout>Set model to sonnet</local-command-stdout>"),
+    user("u2", "say hello"),
+    assistant("a2", "claude-sonnet-5", "Hello."),
+    user("bash", "<bash-stdout>hidden</bash-stdout>"),
+    user("u3", "hay zzz"),
+    assistant("a3", "claude-haiku-4-5-20251001", "hey."),
+    user("synthetic-user", "duplicate"),
+    assistant("synthetic", "<synthetic>", "No response requested."),
+  ]);
+  const prompts = turns.map((turn) => turn.items.find((item) => item.type === "userMessage"));
+  const expected = [
+    ["say hi", "claude:claude-opus-5"],
+    ["say hello", "claude:claude-sonnet-5"],
+    ["hay zzz", "claude:claude-haiku-4-5-20251001"],
+  ];
+  if (turns.length !== expected.length
+    || prompts.some((prompt, index) => prompt?.content?.[0]?.text !== expected[index][0]
+      || prompt.model !== expected[index][1])) {
+    throw new Error(`Claude history self-test failed: ${JSON.stringify(turns)}`);
+  }
+  const usage = tokenBreakdown({
+    input_tokens: 2,
+    cache_read_input_tokens: 68_000,
+    cache_creation_input_tokens: 500,
+    output_tokens: 300,
+  });
+  if (usage.totalTokens !== 68_802 || usage.inputTokens !== 68_502) {
+    throw new Error(`Claude usage self-test failed: ${JSON.stringify(usage)}`);
+  }
+  process.stdout.write("Claude bridge self-test passed\n");
+}
+
+if (process.argv.includes("--self-test")) {
+  runSelfTest();
+  process.exit(0);
+}
+
 const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
 lines.on("line", async (line) => {
   if (!line.trim()) return;

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "devez-vibe",
-  "version": "0.1.46",
-  "description": "Stable terminal UI for Codex and Claude Agent SDK",
-  "keywords": [
-    "codex",
-    "cli",
-    "tui",
-    "terminal",
-    "app-server",
-    "claude-agent-sdk"
-  ],
-  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
-  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
-  },
-  "license": "MIT",
-  "bin": {
-    "dvz": "bin/dvz.exe"
-  },
-  "files": [
-    "bin/dvz.exe",
-    "bridge/claude-agent-sdk-bridge.mjs",
-    "README.md",
-    "LICENSE"
-  ],
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.223"
-  }
-}
+{
+  "name": "devez-vibe",
+  "version": "0.1.47",
+  "description": "Stable terminal UI for Codex and Claude Agent SDK",
+  "keywords": [
+    "codex",
+    "cli",
+    "tui",
+    "terminal",
+    "app-server",
+    "claude-agent-sdk"
+  ],
+  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
+  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "dvz": "bin/dvz.exe"
+  },
+  "files": [
+    "bin/dvz.exe",
+    "bridge/claude-agent-sdk-bridge.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.223"
+  }
+}