devez-vibe 1.2.7 → 1.2.9

package/LICENSE

@@ -1,33 +1,33 @@
-DevezCode source code license
-
-The MIT License below applies only to the DevezCode source code and to files
-that are not listed in the exception below.
-
-Exceptions:
-
-* `Resources/Images/FileTypes/` and `Resources/Licenses/` are Microsoft Visual
-  Studio Image Library materials, subject to the included Microsoft terms.
-* `Resources/Images/ShellPresets/` contains third-party brand assets, subject
-  to their respective owners' terms.
-
-MIT License
-
-Copyright (c) 2026 DevezCode contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+DevezCode source code license
+
+The MIT License below applies only to the DevezCode source code and to files
+that are not listed in the exception below.
+
+Exceptions:
+
+* `Resources/Images/FileTypes/` and `Resources/Licenses/` are Microsoft Visual
+  Studio Image Library materials, subject to the included Microsoft terms.
+* `Resources/Images/ShellPresets/` contains third-party brand assets, subject
+  to their respective owners' terms.
+
+MIT License
+
+Copyright (c) 2026 DevezCode contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
 import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { createInterface } from "node:readline";
 import {
   deleteSession,
@@ -501,6 +504,45 @@ function emitDelta(session, method, itemId, delta) {
   notify(method, { threadId: session.id, turnId: session.turn?.id, itemId, delta, provider: "Claude" });
 }
 
+function isKoreanPrompt(input) {
+  const prompt = (Array.isArray(input) ? input : [])
+    .filter((item) => item?.type === "text")
+    .map((item) => String(item.text || ""))
+    .join("\n");
+  return /[\uac00-\ud7a3]/.test(prompt);
+}
+
+function openingNotice(input) {
+  return isKoreanPrompt(input)
+    ? "요청 내용을 확인하고 필요한 작업을 진행하겠습니다."
+    : "I’ll review the request and proceed with the necessary work.";
+}
+
+function normalizeProgressText(turn, text) {
+  const value = String(text || "");
+  const trimmed = value.trim();
+  if (turn?.koreanRequest
+    && trimmed.length <= 160
+    && !/[\uac00-\ud7a3]/.test(trimmed)
+    && /^Now\b[^\r\n]*[.!?]?$/i.test(trimmed)) {
+    return "다음 부분을 이어서 확인하겠습니다.";
+  }
+  return value;
+}
+
+// Claude can answer with a tool_use as its first and only content block even
+// when the prompt asks for an opening update. Keep the visible contract stable
+// without duplicating a real model-written update.
+function emitOpeningNotice(session) {
+  if (!session.turn || session.turn.openingNoticeEmitted) return;
+  const text = session.turn.openingNotice;
+  const id = nextItemId(session, "opening");
+  const item = { id, type: "agentMessage", text, provider: "Claude" };
+  emitItem(session, "started", item);
+  emitItem(session, "completed", item);
+  session.turn.openingNoticeEmitted = true;
+}
+
 // Windows rounds larger timer delays up to the next scheduler slice. Ten
 // milliseconds lands near one terminal frame instead of visibly stepping at ~30ms.
 const SMOOTH_TEXT_INTERVAL_MS = 10;
@@ -642,7 +684,14 @@ async function processStreamEvent(session, message) {
     const smooth = block.type === "text"
       ? new SmoothTextStream((delta) => emitDelta(session, "item/agentMessage/delta", id, delta))
       : null;
-    session.streamBlocks.set(event.index, { id, type: block.type, text: "", smooth });
+    session.streamBlocks.set(event.index, {
+      id,
+      type: block.type,
+      text: "",
+      smooth,
+      languagePending: block.type === "text" && session.turn.koreanRequest ? "" : null,
+      holdEnglishProgress: false,
+    });
     emitItem(session, "started", item);
     return;
   }
@@ -652,13 +701,36 @@ async function processStreamEvent(session, message) {
     const delta = event.delta?.text || event.delta?.thinking || "";
     if (!delta) return;
     current.text += delta;
-    if (current.smooth) current.smooth.push(delta);
-    else emitDelta(session, "item/reasoning/summaryTextDelta", current.id, delta);
+    if (current.type === "text") session.turn.sawVisibleText = true;
+    if (!current.smooth) {
+      emitDelta(session, "item/reasoning/summaryTextDelta", current.id, delta);
+      return;
+    }
+    if (current.languagePending != null) {
+      current.languagePending += delta;
+      const probe = current.languagePending.trimStart();
+      const lower = probe.toLowerCase();
+      if (!current.holdEnglishProgress && "now".startsWith(lower)) return;
+      if (/^now(?:\s|$)/i.test(probe)) {
+        current.holdEnglishProgress = true;
+        return;
+      }
+      current.smooth.push(current.languagePending);
+      current.languagePending = null;
+      return;
+    }
+    current.smooth.push(delta);
     return;
   }
   if (event.type === "content_block_stop") {
     const current = session.streamBlocks.get(event.index);
     if (!current) return;
+    if (current.languagePending != null) {
+      const visible = normalizeProgressText(session.turn, current.languagePending);
+      current.text = visible;
+      current.smooth?.push(visible);
+      current.languagePending = null;
+    }
     await current.smooth?.finish();
     const item = current.type === "text"
       ? { id: current.id, type: "agentMessage", text: current.text, provider: "Claude" }
@@ -685,20 +757,27 @@ function processAssistant(session, message) {
     session.model,
   );
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
-  for (const block of content) {
-    if (block.type === "tool_use") processToolUse(session, block);
-  }
+  const hasToolUse = content.some((block) => block.type === "tool_use");
+  const hasVisibleText = session.turn.sawVisibleText || content.some(
+    (block) => block.type === "text" && String(block.text || "").trim(),
+  );
+  // Without partial SDK events, replay completed text before tool items so the
+  // visible order still matches the assistant content order.
   if (!session.streamBlocks.size && !session.turn.sawStreamText) {
     for (const block of content) {
       if (block.type !== "text" && block.type !== "thinking") continue;
       const id = nextItemId(session, block.type);
       const item = block.type === "text"
-        ? { id, type: "agentMessage", text: block.text || "", provider: "Claude" }
+        ? { id, type: "agentMessage", text: normalizeProgressText(session.turn, block.text), provider: "Claude" }
         : { id, type: "reasoning", summary: [block.thinking || ""] };
       emitItem(session, "started", item);
       emitItem(session, "completed", item);
     }
   }
+  if (hasToolUse && !hasVisibleText) emitOpeningNotice(session);
+  for (const block of content) {
+    if (block.type === "tool_use") processToolUse(session, block);
+  }
 }
 
 function processToolUse(session, block) {
@@ -762,51 +841,51 @@ function prepareTaskPlanForCreate(tasks, subject) {
   if (numberedTaskIndex(subject) === 1) tasks.clear();
 }
 
-function applyTaskUpdate(tasks, input, turnId, onIntermediate) {
-  const task = tasks.get(String(input.taskId));
-  if (!task) return false;
-  if (input.subject) task.subject = input.subject;
-  const status = input.status;
-  if (status === "in_progress" || status === "completed") {
-    const entries = [...tasks.values()];
-    const targetIndex = entries.indexOf(task);
-
-    // Claude occasionally closes a later pending task at the end of a turn
-    // without ever starting it. Keep the visible plan truthful and sequential:
-    // every skipped predecessor and the target itself pass through in_progress.
-    for (let index = 0; index < targetIndex; index++) {
-      const previous = entries[index];
-      if (previous.status === "completed") continue;
-      if (previous.status !== "in_progress") {
-        previous.status = "in_progress";
-        previous.turnId = turnId;
-        onIntermediate?.();
-      }
-      previous.status = "completed";
-      previous.turnId = turnId;
-      onIntermediate?.();
-    }
-
-    for (let index = 0; index < entries.length; index++) {
-      const other = entries[index];
-      if (other === task || other.status !== "in_progress") continue;
-      other.status = index < targetIndex ? "completed" : "pending";
-      other.turnId = turnId;
-      onIntermediate?.();
-    }
-
-    if (status === "completed" && task.status !== "in_progress" && task.status !== "completed") {
-      task.status = "in_progress";
-      task.turnId = turnId;
-      onIntermediate?.();
-    }
-    task.status = status;
-  } else if (status) {
-    task.status = status;
-  }
-  task.turnId = turnId;
-  return true;
-}
+function applyTaskUpdate(tasks, input, turnId, onIntermediate) {
+  const task = tasks.get(String(input.taskId));
+  if (!task) return false;
+  if (input.subject) task.subject = input.subject;
+  const status = input.status;
+  if (status === "in_progress" || status === "completed") {
+    const entries = [...tasks.values()];
+    const targetIndex = entries.indexOf(task);
+
+    // Claude occasionally closes a later pending task at the end of a turn
+    // without ever starting it. Keep the visible plan truthful and sequential:
+    // every skipped predecessor and the target itself pass through in_progress.
+    for (let index = 0; index < targetIndex; index++) {
+      const previous = entries[index];
+      if (previous.status === "completed") continue;
+      if (previous.status !== "in_progress") {
+        previous.status = "in_progress";
+        previous.turnId = turnId;
+        onIntermediate?.();
+      }
+      previous.status = "completed";
+      previous.turnId = turnId;
+      onIntermediate?.();
+    }
+
+    for (let index = 0; index < entries.length; index++) {
+      const other = entries[index];
+      if (other === task || other.status !== "in_progress") continue;
+      other.status = index < targetIndex ? "completed" : "pending";
+      other.turnId = turnId;
+      onIntermediate?.();
+    }
+
+    if (status === "completed" && task.status !== "in_progress" && task.status !== "completed") {
+      task.status = "in_progress";
+      task.turnId = turnId;
+      onIntermediate?.();
+    }
+    task.status = status;
+  } else if (status) {
+    task.status = status;
+  }
+  task.turnId = turnId;
+  return true;
+}
 
 // TaskList에는 예전 계획까지 함께 들어올 수 있다. 마지막으로 번호가 1부터
 // 시작한 묶음만 현재 계획으로 삼되, 번호가 없는 목록은 손실 없이 그대로 둔다.
@@ -829,9 +908,9 @@ function updatePlanFromToolUse(session, name, toolUseId, input) {
       status: "pending",
       turnId,
     });
-  } else if (name === "TaskUpdate") {
-    applyTaskUpdate(session.tasks, input, turnId, () => emitPlan(session));
-  }
+  } else if (name === "TaskUpdate") {
+    applyTaskUpdate(session.tasks, input, turnId, () => emitPlan(session));
+  }
   emitPlan(session);
 }
 
@@ -1348,10 +1427,11 @@ async function runPrompt(session, params) {
   }
   session.effort = effort;
   await applyPermissionMode(session, params.permissionMode);
-  const turnId = beginTurn(session);
+  const content = await inputContent(params.input, params.handoffContext);
+  const turnId = beginTurn(session, params.input);
   session.queue.push({
     type: "user",
-    message: { role: "user", content: await inputContent(params.input, params.handoffContext) },
+    message: { role: "user", content },
     parent_tool_use_id: null,
     session_id: id,
     origin: { kind: "human" },
@@ -1361,9 +1441,16 @@ async function runPrompt(session, params) {
 
 // A background task notification is an internal user message that starts its
 // own Claude response even though the host did not submit a new prompt.
-function beginTurn(session) {
+function beginTurn(session, input = []) {
   const turnId = `claude-turn-${session.turnSequence++}-${randomUUID()}`;
-  session.turn = { id: turnId, sawStreamText: false };
+  session.turn = {
+    id: turnId,
+    sawStreamText: false,
+    sawVisibleText: false,
+    koreanRequest: isKoreanPrompt(input),
+    openingNotice: openingNotice(input),
+    openingNoticeEmitted: false,
+  };
   session.lastContextUsage = null;
   notify("turn/started", { threadId: session.id, turn: { id: turnId } });
   return turnId;
@@ -1485,6 +1572,75 @@ function historyTurns(messages) {
   return historyState(messages).turns;
 }
 
+// A transcript lives in a folder encoded from the cwd string, so two spellings of
+// the same path (Windows differs only in case) resolve to different folders and a
+// session recorded under one spelling is invisible to the other. Remember the
+// spelling the transcript was written with, keyed by session id.
+const transcriptCwds = new Map();
+
+function claudeProjectsDir() {
+  return join(process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude"), "projects");
+}
+
+/** Read the cwd a transcript records. Only the head is scanned: the opening
+ * records carry no cwd, but a real turn shows up long before the limit. */
+async function readTranscriptCwd(path, limit = 200) {
+  const stream = createReadStream(path, { encoding: "utf8" });
+  try {
+    const reader = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+      let seen = 0;
+      for await (const line of reader) {
+        if (++seen > limit) break;
+        let cwd;
+        try {
+          cwd = JSON.parse(line)?.cwd;
+        } catch {
+          continue;
+        }
+        if (typeof cwd === "string" && cwd) return cwd;
+      }
+      return null;
+    } finally {
+      reader.close();
+    }
+  } finally {
+    stream.destroy();
+  }
+}
+
+/** Locate the transcript of `id` under any project folder and report the cwd it
+ * records, which is the spelling the SDK needs to find it again. */
+async function transcriptCwd(id) {
+  if (transcriptCwds.has(id)) return transcriptCwds.get(id);
+  let entries;
+  try {
+    entries = await readdir(claudeProjectsDir(), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    let cwd;
+    try {
+      cwd = await readTranscriptCwd(join(claudeProjectsDir(), entry.name, `${id}.jsonl`));
+    } catch {
+      continue;
+    }
+    if (cwd) {
+      transcriptCwds.set(id, cwd);
+      return cwd;
+    }
+  }
+  return null;
+}
+
+/** The cwd to read `id`'s transcript with: the one the transcript itself records,
+ * falling back to the host's when no transcript is on disk. */
+async function readableCwd(id, cwd) {
+  return await transcriptCwd(id) || cwd;
+}
+
 async function dispatch(method, params = {}) {
   if (method === "model/list") return loadModelCatalog(params);
   if (method === "session/permissionMode") {
@@ -1524,15 +1680,19 @@ async function dispatch(method, params = {}) {
         tokenUsage: historyTokenUsage(messages, existing.models, existing.model),
       };
     }
-    const info = await getSessionInfo(id, { dir: params.cwd });
-    if (!info) throw new Error(`Claude 세션을 찾을 수 없습니다: ${id}`);
-    const messages = await getSessionMessages(id, { dir: params.cwd, includeSystemMessages: true });
+    const dir = await readableCwd(id, params.cwd);
+    // The transcript itself decides whether there is anything to resume:
+    // getSessionInfo only sees sessions the CLI indexed, and a bridge-run session
+    // whose transcript is intact can be missing from that index.
+    const messages = await getSessionMessages(id, { dir, includeSystemMessages: true });
+    if (!messages.length) throw new Error(`Claude 세션을 찾을 수 없습니다: ${id}`);
+    const info = await getSessionInfo(id, { dir });
     const lastModel = [...messages].reverse().find((message) => message.type === "assistant")?.message?.model;
     // The transcript's own model outranks the host's fallback, which is only what
     // a new session would have opened on.
     const { session, account, usage } = await createSession({
       ...params,
-      cwd: info.cwd || params.cwd,
+      cwd: info?.cwd || dir,
       model: params.model || lastModel || params.fallbackModel,
       effort: params.effort || params.fallbackEffort,
     }, id);
@@ -1573,7 +1733,7 @@ async function dispatch(method, params = {}) {
   }
   if (method === "session/history") {
     const id = liveSessionId(params.sessionId);
-    const messages = await getSessionMessages(id, { dir: params.cwd, includeSystemMessages: true });
+    const messages = await getSessionMessages(id, { dir: await readableCwd(id, params.cwd), includeSystemMessages: true });
     return { data: historyTurns(messages), nextCursor: null };
   }
   if (method === "session/prompt") return startPrompt(params);
@@ -1599,7 +1759,7 @@ async function dispatch(method, params = {}) {
   }
   if (method === "session/fork") {
     const source = liveSessionId(params.sessionId);
-    const forked = await forkSession(source, { dir: params.cwd });
+    const forked = await forkSession(source, { dir: await readableCwd(source, params.cwd) });
     const id = forked.sessionId || forked;
     const { session, account, usage } = await createSession(params, id);
     return {
@@ -1717,33 +1877,33 @@ async function runSelfTest() {
   }
   applyTaskUpdate(restoredTasks, { taskId: "26", status: "completed" }, "resumed-turn");
   applyTaskUpdate(restoredTasks, { taskId: "27", status: "in_progress" }, "resumed-turn");
-  if (restoredTasks.size !== 6
-    || restoredTasks.get("25")?.status !== "completed"
-    || restoredTasks.get("26")?.status !== "completed"
-    || restoredTasks.get("27")?.status !== "in_progress"
-    || [...restoredTasks.values()].filter((task) => task.status === "in_progress").length !== 1) {
-    throw new Error(`Claude sequential task update self-test failed: ${JSON.stringify([...restoredTasks])}`);
-  }
-  const skippedTasks = new Map([
-    ["1", { id: "1", subject: "1. 조사", status: "pending" }],
-    ["2", { id: "2", subject: "2. 분석", status: "pending" }],
-    ["3", { id: "3", subject: "3. 검증", status: "pending" }],
-  ]);
-  const transitions = [];
-  const snapshot = () => transitions.push([...skippedTasks.values()].map((task) => task.status).join(","));
-  applyTaskUpdate(skippedTasks, { taskId: "3", status: "completed" }, "turn", snapshot);
-  snapshot();
-  if (transitions.join("|") !== [
-    "in_progress,pending,pending",
-    "completed,pending,pending",
-    "completed,in_progress,pending",
-    "completed,completed,pending",
-    "completed,completed,in_progress",
-    "completed,completed,completed",
-  ].join("|")) {
-    throw new Error(`Claude skipped task transition self-test failed: ${transitions.join("|")}`);
-  }
-  const mixedPlans = new Map([
+  if (restoredTasks.size !== 6
+    || restoredTasks.get("25")?.status !== "completed"
+    || restoredTasks.get("26")?.status !== "completed"
+    || restoredTasks.get("27")?.status !== "in_progress"
+    || [...restoredTasks.values()].filter((task) => task.status === "in_progress").length !== 1) {
+    throw new Error(`Claude sequential task update self-test failed: ${JSON.stringify([...restoredTasks])}`);
+  }
+  const skippedTasks = new Map([
+    ["1", { id: "1", subject: "1. 조사", status: "pending" }],
+    ["2", { id: "2", subject: "2. 분석", status: "pending" }],
+    ["3", { id: "3", subject: "3. 검증", status: "pending" }],
+  ]);
+  const transitions = [];
+  const snapshot = () => transitions.push([...skippedTasks.values()].map((task) => task.status).join(","));
+  applyTaskUpdate(skippedTasks, { taskId: "3", status: "completed" }, "turn", snapshot);
+  snapshot();
+  if (transitions.join("|") !== [
+    "in_progress,pending,pending",
+    "completed,pending,pending",
+    "completed,in_progress,pending",
+    "completed,completed,pending",
+    "completed,completed,in_progress",
+    "completed,completed,completed",
+  ].join("|")) {
+    throw new Error(`Claude skipped task transition self-test failed: ${transitions.join("|")}`);
+  }
+  const mixedPlans = new Map([
     ["old-1", { subject: "1. 이전 작업", status: "completed" }],
     ["old-2", { subject: "2. 이전 검증", status: "completed" }],
     ...[...restoredTasks],
@@ -1888,6 +2048,84 @@ async function runSelfTest() {
       && event.params?.line?.kind === "error")) {
     throw new Error(`Claude subagent lifecycle events self-test failed: ${lifecycleMethods}`);
   }
+  const openingSession = {
+    id: "opening-self-test",
+    model: "claude:default",
+    models: [],
+    turn: null,
+    turnSequence: 1,
+    itemSequence: 1,
+    streamBlocks: new Map(),
+    tools: new Map(),
+    tasks: new Map(),
+    subagents: new Map(),
+    knownSubagents: new Map(),
+    lastContextUsage: null,
+    lastContextWindow: 0,
+  };
+  const openingCaptured = [];
+  process.stdout.write = (chunk) => {
+    openingCaptured.push(String(chunk));
+    return true;
+  };
+  try {
+    beginTurn(openingSession, [{ type: "text", text: "provider 메뉴를 수정해" }]);
+    processAssistant(openingSession, {
+      message: {
+        content: [{ type: "tool_use", id: "read-1", name: "Read", input: { file_path: "src/main.rs" } }],
+      },
+    });
+  } finally {
+    process.stdout.write = stdoutWrite;
+  }
+  const openingEvents = openingCaptured
+    .join("")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+  const openingMessageIndex = openingEvents.findIndex((event) =>
+    event.method === "item/completed"
+      && event.params?.item?.type === "agentMessage"
+      && event.params.item.text === "요청 내용을 확인하고 필요한 작업을 진행하겠습니다.");
+  const openingToolIndex = openingEvents.findIndex((event) =>
+    event.method === "item/started" && event.params?.item?.type === "dynamicToolCall");
+  if (openingMessageIndex < 0 || openingToolIndex < 0 || openingMessageIndex > openingToolIndex) {
+    throw new Error(`Claude opening notice order self-test failed: ${JSON.stringify(openingEvents)}`);
+  }
+  const languageCaptured = [];
+  process.stdout.write = (chunk) => {
+    languageCaptured.push(String(chunk));
+    return true;
+  };
+  try {
+    openingSession.streamBlocks.clear();
+    await processStreamEvent(openingSession, {
+      event: { type: "content_block_start", index: 0, content_block: { type: "text" } },
+    });
+    await processStreamEvent(openingSession, {
+      event: { type: "content_block_delta", index: 0, delta: { text: "Now the tile view logic." } },
+    });
+    await processStreamEvent(openingSession, {
+      event: { type: "content_block_stop", index: 0 },
+    });
+  } finally {
+    process.stdout.write = stdoutWrite;
+  }
+  const languageEvents = languageCaptured
+    .join("")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+  const visibleLanguage = languageEvents
+    .filter((event) => event.method === "item/agentMessage/delta")
+    .map((event) => event.params?.delta || "")
+    .join("");
+  if (visibleLanguage !== "다음 부분을 이어서 확인하겠습니다."
+    || languageEvents.some((event) => JSON.stringify(event).includes("Now the tile view logic."))) {
+    throw new Error(`Claude Korean progress normalization self-test failed: ${JSON.stringify(languageEvents)}`);
+  }
   const smoothText = "Claude가 👨‍👩‍👧‍👦 한 문장을 한꺼번에 보내도 부드럽게 표시합니다.";
   const emitted = [];
   const smooth = new SmoothTextStream((chunk) => emitted.push(chunk), 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [
     "codex",