devez-vibe 1.2.6 → 1.2.8

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

@@ -435,25 +435,25 @@ async function createSession(params, resumeId) {
     turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
-    tools: new Map(),
-    tasks: new Map(),
-    subagents: new Map(),
-    knownSubagents: new Map(),
-    lastContextUsage: null,
+    tools: new Map(),
+    tasks: new Map(),
+    subagents: new Map(),
+    knownSubagents: new Map(),
+    lastContextUsage: null,
     lastContextWindow: 0,
   };
   const agentQuery = await startAgentQuery(queue, makeOptions(params, id, resumeId));
   session.query = agentQuery;
   sessions.set(id, session);
-  const consumer = consume(session).catch((error) => {
+  const consumer = consume(session).catch((error) => {
     notify("error", {
       threadId: id,
       provider: "Claude",
       error: { message: error instanceof Error ? error.message : String(error) },
-      willRetry: false,
-    });
-    clearSubagents(session);
-    if (session.turn) finishTurn(session, error);
+      willRetry: false,
+    });
+    clearSubagents(session);
+    if (session.turn) finishTurn(session, error);
   });
   session.consumer = consumer;
   let initialization;
@@ -501,84 +501,123 @@ function emitDelta(session, method, itemId, delta) {
   notify(method, { threadId: session.id, turnId: session.turn?.id, itemId, delta, provider: "Claude" });
 }
 
-// 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;
-const SMOOTH_TEXT_TARGET_FRAMES = 8;
-const SMOOTH_TEXT_MAX_GRAPHEMES = 24;
-const graphemeSegmenter = typeof Intl.Segmenter === "function"
-  ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
-  : null;
-
-function splitGraphemes(text) {
-  return graphemeSegmenter
-    ? Array.from(graphemeSegmenter.segment(text), ({ segment }) => segment)
-    : Array.from(text);
+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);
 }
 
-// Claude can deliver a whole phrase in one SDK event. Drain roughly one visual
-// frame's share at a time, catching up quickly when a large backlog arrives.
-function takeSmoothTextChunk(text) {
-  const graphemes = splitGraphemes(text);
-  const size = Math.min(
-    SMOOTH_TEXT_MAX_GRAPHEMES,
-    Math.max(1, Math.ceil(graphemes.length / SMOOTH_TEXT_TARGET_FRAMES)),
-  );
-  return {
-    chunk: graphemes.slice(0, size).join(""),
-    rest: graphemes.slice(size).join(""),
-  };
+function openingNotice(input) {
+  return isKoreanPrompt(input)
+    ? "요청 내용을 확인하고 필요한 작업을 진행하겠습니다."
+    : "I’ll review the request and proceed with the necessary work.";
 }
 
-class SmoothTextStream {
-  constructor(emit, intervalMs = SMOOTH_TEXT_INTERVAL_MS) {
-    this.emit = emit;
-    this.intervalMs = intervalMs;
-    this.pending = "";
-    this.timer = null;
-    this.waiters = [];
-  }
-
-  push(text) {
-    this.pending += text;
-    if (this.timer == null) this.drain();
-  }
-
-  drain() {
-    if (!this.pending) {
-      this.timer = null;
-      for (const resolve of this.waiters.splice(0)) resolve();
-      return;
-    }
-    const { chunk, rest } = takeSmoothTextChunk(this.pending);
-    this.pending = rest;
-    this.emit(chunk);
-    if (this.pending) {
-      this.timer = setTimeout(() => this.drain(), this.intervalMs);
-    } else {
-      this.timer = null;
-      for (const resolve of this.waiters.splice(0)) resolve();
-    }
-  }
-
-  finish() {
-    if (!this.pending && this.timer == null) return Promise.resolve();
-    return new Promise((resolve) => this.waiters.push(resolve));
-  }
-
-  flush() {
-    if (this.timer != null) clearTimeout(this.timer);
-    this.timer = null;
-    if (this.pending) this.emit(this.pending);
-    this.pending = "";
-    for (const resolve of this.waiters.splice(0)) resolve();
+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;
 }
 
-function flushSmoothStreams(session) {
-  for (const block of session.streamBlocks.values()) block.smooth?.flush();
+// 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;
+const SMOOTH_TEXT_TARGET_FRAMES = 8;
+const SMOOTH_TEXT_MAX_GRAPHEMES = 24;
+const graphemeSegmenter = typeof Intl.Segmenter === "function"
+  ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+  : null;
+
+function splitGraphemes(text) {
+  return graphemeSegmenter
+    ? Array.from(graphemeSegmenter.segment(text), ({ segment }) => segment)
+    : Array.from(text);
+}
+
+// Claude can deliver a whole phrase in one SDK event. Drain roughly one visual
+// frame's share at a time, catching up quickly when a large backlog arrives.
+function takeSmoothTextChunk(text) {
+  const graphemes = splitGraphemes(text);
+  const size = Math.min(
+    SMOOTH_TEXT_MAX_GRAPHEMES,
+    Math.max(1, Math.ceil(graphemes.length / SMOOTH_TEXT_TARGET_FRAMES)),
+  );
+  return {
+    chunk: graphemes.slice(0, size).join(""),
+    rest: graphemes.slice(size).join(""),
+  };
+}
+
+class SmoothTextStream {
+  constructor(emit, intervalMs = SMOOTH_TEXT_INTERVAL_MS) {
+    this.emit = emit;
+    this.intervalMs = intervalMs;
+    this.pending = "";
+    this.timer = null;
+    this.waiters = [];
+  }
+
+  push(text) {
+    this.pending += text;
+    if (this.timer == null) this.drain();
+  }
+
+  drain() {
+    if (!this.pending) {
+      this.timer = null;
+      for (const resolve of this.waiters.splice(0)) resolve();
+      return;
+    }
+    const { chunk, rest } = takeSmoothTextChunk(this.pending);
+    this.pending = rest;
+    this.emit(chunk);
+    if (this.pending) {
+      this.timer = setTimeout(() => this.drain(), this.intervalMs);
+    } else {
+      this.timer = null;
+      for (const resolve of this.waiters.splice(0)) resolve();
+    }
+  }
+
+  finish() {
+    if (!this.pending && this.timer == null) return Promise.resolve();
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+
+  flush() {
+    if (this.timer != null) clearTimeout(this.timer);
+    this.timer = null;
+    if (this.pending) this.emit(this.pending);
+    this.pending = "";
+    for (const resolve of this.waiters.splice(0)) resolve();
+  }
+}
+
+function flushSmoothStreams(session) {
+  for (const block of session.streamBlocks.values()) block.smooth?.flush();
+}
+
 function tokenBreakdown(usage) {
   if (!usage) return null;
   const input = Number(usage.input_tokens ?? usage.inputTokens ?? 0);
@@ -625,44 +664,74 @@ function historyTokenUsage(messages, models, model) {
   };
 }
 
-async function processStreamEvent(session, message) {
-  if (!session.turn || message.parent_tool_use_id) return;
-  const event = message.event || {};
-  if (event.type === "message_start") {
-    flushSmoothStreams(session);
-    session.streamBlocks.clear();
-  }
+async function processStreamEvent(session, message) {
+  if (!session.turn || message.parent_tool_use_id) return;
+  const event = message.event || {};
+  if (event.type === "message_start") {
+    flushSmoothStreams(session);
+    session.streamBlocks.clear();
+  }
   if (event.type === "content_block_start") {
-    const block = event.content_block || {};
-    if (block.type !== "text" && block.type !== "thinking") return;
-    const id = nextItemId(session, block.type);
+    const block = event.content_block || {};
+    if (block.type !== "text" && block.type !== "thinking") return;
+    const id = nextItemId(session, block.type);
     const item = block.type === "text"
       ? { id, type: "agentMessage", text: "", provider: "Claude" }
       : { id, type: "reasoning", summary: [] };
-    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 });
-    emitItem(session, "started", item);
-    return;
-  }
-  if (event.type === "content_block_delta") {
+    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,
+      languagePending: block.type === "text" && session.turn.koreanRequest ? "" : null,
+      holdEnglishProgress: false,
+    });
+    emitItem(session, "started", item);
+    return;
+  }
+  if (event.type === "content_block_delta") {
     const current = session.streamBlocks.get(event.index);
     if (!current) return;
     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") {
+  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" }
-      : { id: current.id, type: "reasoning", summary: [current.text] };
+    const item = current.type === "text"
+      ? { id: current.id, type: "agentMessage", text: current.text, provider: "Claude" }
+      : { id: current.id, type: "reasoning", summary: [current.text] };
     emitItem(session, "completed", item);
     session.streamBlocks.delete(event.index);
   }
@@ -684,22 +753,29 @@ function processAssistant(session, message) {
     message.message?.model,
     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);
-  }
-  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: "reasoning", summary: [block.thinking || ""] };
-      emitItem(session, "started", item);
-      emitItem(session, "completed", item);
-    }
-  }
-}
+  const content = Array.isArray(message.message?.content) ? message.message.content : [];
+  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: 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) {
   const name = block.name || "Tool";
@@ -751,52 +827,89 @@ function fileChanges(name, input) {
   return [{ path, kind: { type: name === "Write" ? "add" : "update" }, diff: `@@ -0,0 +1 @@\n${additions}` }];
 }
 
-function numberedTaskIndex(subject) {
-  const match = String(subject || "").trim().match(/^(\d+)[.)]\s+/);
-  return match ? Number(match[1]) : null;
-}
-
-// Claude의 Task id는 세션 전체에서 누적된다. 제목 번호가 다시 1부터
-// 시작할 때만 새 계획이며, 3·4번만 갱신되는 턴은 기존 1~6번을 지킨다.
-function prepareTaskPlanForCreate(tasks, subject) {
-  if (numberedTaskIndex(subject) === 1) tasks.clear();
-}
-
-function applyTaskUpdate(tasks, input, turnId) {
-  const task = tasks.get(String(input.taskId));
-  if (!task) return false;
-  if (input.subject) task.subject = input.subject;
-  if (input.status) task.status = input.status;
-  task.turnId = turnId;
-  return true;
-}
-
-// TaskList에는 예전 계획까지 함께 들어올 수 있다. 마지막으로 번호가 1부터
-// 시작한 묶음만 현재 계획으로 삼되, 번호가 없는 목록은 손실 없이 그대로 둔다.
-function latestTaskPlan(tasks) {
-  const entries = [...tasks.entries()];
-  let start = 0;
-  for (let index = 0; index < entries.length; index++) {
-    if (numberedTaskIndex(entries[index][1].subject) === 1) start = index;
-  }
-  return new Map(entries.slice(start));
-}
+function numberedTaskIndex(subject) {
+  const match = String(subject || "").trim().match(/^(\d+)[.)]\s+/);
+  return match ? Number(match[1]) : null;
+}
+
+// Claude의 Task id는 세션 전체에서 누적된다. 제목 번호가 다시 1부터
+// 시작할 때만 새 계획이며, 3·4번만 갱신되는 턴은 기존 1~6번을 지킨다.
+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;
+}
+
+// TaskList에는 예전 계획까지 함께 들어올 수 있다. 마지막으로 번호가 1부터
+// 시작한 묶음만 현재 계획으로 삼되, 번호가 없는 목록은 손실 없이 그대로 둔다.
+function latestTaskPlan(tasks) {
+  const entries = [...tasks.entries()];
+  let start = 0;
+  for (let index = 0; index < entries.length; index++) {
+    if (numberedTaskIndex(entries[index][1].subject) === 1) start = index;
+  }
+  return new Map(entries.slice(start));
+}
 
 function updatePlanFromToolUse(session, name, toolUseId, input) {
-  const turnId = session.turn?.id;
-  if (name === "TaskCreate") {
-    prepareTaskPlanForCreate(session.tasks, input.subject);
-    session.tasks.set(`pending:${toolUseId}`, {
-      id: `pending:${toolUseId}`,
-      subject: input.subject || input.description || "작업",
+  const turnId = session.turn?.id;
+  if (name === "TaskCreate") {
+    prepareTaskPlanForCreate(session.tasks, input.subject);
+    session.tasks.set(`pending:${toolUseId}`, {
+      id: `pending:${toolUseId}`,
+      subject: input.subject || input.description || "작업",
       status: "pending",
-      turnId,
-    });
-  } else if (name === "TaskUpdate") {
-    applyTaskUpdate(session.tasks, input, turnId);
-  }
-  emitPlan(session);
-}
+      turnId,
+    });
+  } else if (name === "TaskUpdate") {
+    applyTaskUpdate(session.tasks, input, turnId, () => emitPlan(session));
+  }
+  emitPlan(session);
+}
 
 function updatePlanFromToolResult(session, pending, message) {
   const value = message.tool_use_result;
@@ -824,10 +937,10 @@ function updatePlanFromToolResult(session, pending, message) {
         turnId: previous.get(id)?.turnId ?? turnId,
       });
     }
-    session.tasks = latestTaskPlan(session.tasks);
-    emitPlan(session);
-  }
-}
+    session.tasks = latestTaskPlan(session.tasks);
+    emitPlan(session);
+  }
+}
 
 function taskCreatedResult(structured, content) {
   const created = structured?.task || structured;
@@ -868,78 +981,78 @@ function numberedTaskSubject(subject, index) {
 // 그 ID로 묶어 두면 지금 어떤 에이전트가 무슨 도구를 돌리는지 그대로 복원할 수 있다.
 const SUBAGENT_TOOLS = ["Agent", "Task"];
 
-function startSubagent(session, block) {
-  const input = block.input || {};
-  session.subagents.set(block.id, {
-    id: block.id,
-    taskId: "",
-    background: false,
-    name: firstLine(input.subagent_type || input.agentType || "agent", 40),
+function startSubagent(session, block) {
+  const input = block.input || {};
+  session.subagents.set(block.id, {
+    id: block.id,
+    taskId: "",
+    background: false,
+    name: firstLine(input.subagent_type || input.agentType || "agent", 40),
     description: firstLine(input.description || input.prompt || "", 120),
     tool: "",
     startedAt: Date.now(),
   });
-  emitSubagents(session);
-}
-
-function isBackgroundSubagentResult(result) {
-  return result?.isAsync === true || result?.status === "async_launched";
-}
-
-// Claude Code treats an async Agent result as a launch receipt. The agent remains
-// live until its later task-notification names the same task or tool-use id.
-function keepBackgroundSubagent(session, toolUseId, result) {
-  if (!isBackgroundSubagentResult(result)) return false;
-  const running = session.subagents.get(toolUseId);
-  if (!running) return false;
-  running.background = true;
-  running.taskId = firstLine(result?.agentId || result?.taskId || "", 80);
-  if (running.taskId) {
-    session.knownSubagents.set(running.taskId, {
-      name: running.name,
-      description: running.description,
-    });
-  }
-  return true;
-}
-
-// SendMessage can wake a completed agent from its transcript. Its new parent
-// tool-use id owns this run, while the stable agent id lets later notifications
-// and further resumes recover the original label.
-function resumeBackgroundSubagent(session, toolUseId, pending, result) {
-  const taskId = firstLine(result?.resumedAgentId || "", 80);
-  if (!taskId) return false;
-  const existing = [...session.subagents.values()].find((agent) => agent.taskId === taskId);
-  if (existing) return true;
-  const known = session.knownSubagents.get(taskId);
-  const input = pending?.input || {};
-  const running = {
-    id: toolUseId,
-    taskId,
-    background: true,
-    name: known?.name || "agent",
-    description: known?.description || firstLine(input.summary || input.message || "", 120),
-    tool: "",
-    startedAt: Date.now(),
-  };
-  session.subagents.set(toolUseId, running);
-  session.knownSubagents.set(taskId, {
-    name: running.name,
-    description: running.description,
-  });
-  emitSubagents(session);
-  return true;
-}
-
-function findSubagent(session, id) {
-  return session.subagents.get(id)
-    || [...session.subagents.values()].find((agent) => agent.taskId === id);
-}
+  emitSubagents(session);
+}
+
+function isBackgroundSubagentResult(result) {
+  return result?.isAsync === true || result?.status === "async_launched";
+}
+
+// Claude Code treats an async Agent result as a launch receipt. The agent remains
+// live until its later task-notification names the same task or tool-use id.
+function keepBackgroundSubagent(session, toolUseId, result) {
+  if (!isBackgroundSubagentResult(result)) return false;
+  const running = session.subagents.get(toolUseId);
+  if (!running) return false;
+  running.background = true;
+  running.taskId = firstLine(result?.agentId || result?.taskId || "", 80);
+  if (running.taskId) {
+    session.knownSubagents.set(running.taskId, {
+      name: running.name,
+      description: running.description,
+    });
+  }
+  return true;
+}
+
+// SendMessage can wake a completed agent from its transcript. Its new parent
+// tool-use id owns this run, while the stable agent id lets later notifications
+// and further resumes recover the original label.
+function resumeBackgroundSubagent(session, toolUseId, pending, result) {
+  const taskId = firstLine(result?.resumedAgentId || "", 80);
+  if (!taskId) return false;
+  const existing = [...session.subagents.values()].find((agent) => agent.taskId === taskId);
+  if (existing) return true;
+  const known = session.knownSubagents.get(taskId);
+  const input = pending?.input || {};
+  const running = {
+    id: toolUseId,
+    taskId,
+    background: true,
+    name: known?.name || "agent",
+    description: known?.description || firstLine(input.summary || input.message || "", 120),
+    tool: "",
+    startedAt: Date.now(),
+  };
+  session.subagents.set(toolUseId, running);
+  session.knownSubagents.set(taskId, {
+    name: running.name,
+    description: running.description,
+  });
+  emitSubagents(session);
+  return true;
+}
+
+function findSubagent(session, id) {
+  return session.subagents.get(id)
+    || [...session.subagents.values()].find((agent) => agent.taskId === id);
+}
 
 // 서브에이전트가 실제로 무엇을 했는지는 자식 메시지에만 남는다. 열람용 기록은 여기서
 // 한 줄씩 흘려보내고, 목록 행에 쓸 현재 도구만 따로 갱신한다.
-function recordSubagentMessage(session, message) {
-  const running = findSubagent(session, message.parent_tool_use_id);
+function recordSubagentMessage(session, message) {
+  const running = findSubagent(session, message.parent_tool_use_id);
   if (!running) return;
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
   let toolChanged = false;
@@ -960,8 +1073,8 @@ function recordSubagentMessage(session, message) {
   if (toolChanged) emitSubagents(session);
 }
 
-function recordSubagentResult(session, message) {
-  const running = findSubagent(session, message.parent_tool_use_id);
+function recordSubagentResult(session, message) {
+  const running = findSubagent(session, message.parent_tool_use_id);
   if (!running) return;
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
   for (const block of content) {
@@ -997,32 +1110,32 @@ function subagentToolLabel(block) {
   return text ? `${name}(${text})` : name;
 }
 
-function finishSubagent(session, toolUseId) {
-  if (!session.subagents.delete(toolUseId)) return;
-  emitSubagents(session);
-}
-
-function finishSubagentTask(session, taskId) {
-  if (!taskId) return false;
-  const entry = [...session.subagents.entries()].find(([, agent]) => agent.taskId === taskId);
-  if (!entry) return false;
-  session.subagents.delete(entry[0]);
-  emitSubagents(session);
-  return true;
-}
-
-function clearForegroundSubagents(session) {
-  let changed = false;
-  for (const [id, agent] of session.subagents) {
-    if (agent.background) continue;
-    session.subagents.delete(id);
-    changed = true;
-  }
-  if (changed) emitSubagents(session);
-}
-
-function clearSubagents(session) {
-  if (!session.subagents.size) return;
+function finishSubagent(session, toolUseId) {
+  if (!session.subagents.delete(toolUseId)) return;
+  emitSubagents(session);
+}
+
+function finishSubagentTask(session, taskId) {
+  if (!taskId) return false;
+  const entry = [...session.subagents.entries()].find(([, agent]) => agent.taskId === taskId);
+  if (!entry) return false;
+  session.subagents.delete(entry[0]);
+  emitSubagents(session);
+  return true;
+}
+
+function clearForegroundSubagents(session) {
+  let changed = false;
+  for (const [id, agent] of session.subagents) {
+    if (agent.background) continue;
+    session.subagents.delete(id);
+    changed = true;
+  }
+  if (changed) emitSubagents(session);
+}
+
+function clearSubagents(session) {
+  if (!session.subagents.size) return;
   session.subagents.clear();
   emitSubagents(session);
 }
@@ -1042,87 +1155,87 @@ function emitSubagents(session) {
       tool: agent.tool,
       elapsedMs: Date.now() - agent.startedAt,
     })),
-  });
-}
-
-function messageTextParts(message) {
-  const content = message.message?.content;
-  if (typeof content === "string") return [content];
-  if (!Array.isArray(content)) return [];
-  return content
-    .filter((block) => block?.type === "text" && typeof block.text === "string")
-    .map((block) => block.text);
-}
-
-function notificationTag(body, name) {
-  const match = body.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
-  return match?.[1]?.trim() || "";
-}
-
-function taskNotifications(message) {
-  if (message.origin?.kind !== "task-notification"
-    && !messageTextParts(message).some((text) => text.includes("<task-notification>"))) {
-    return [];
-  }
-  const notifications = [];
-  for (const text of messageTextParts(message)) {
-    for (const match of text.matchAll(/<task-notification>([\s\S]*?)<\/task-notification>/g)) {
-      const body = match[1];
-      notifications.push({
-        taskId: notificationTag(body, "task-id"),
-        toolUseId: notificationTag(body, "tool-use-id"),
-        status: notificationTag(body, "status"),
-        summary: notificationTag(body, "summary"),
-      });
-    }
-  }
-  return notifications;
-}
-
-function finishNotifiedSubagents(session, notifications) {
-  for (const notification of notifications) {
-    const byToolUse = notification.toolUseId
-      ? session.subagents.get(notification.toolUseId)
-      : null;
-    const running = byToolUse || (notification.taskId
-      ? [...session.subagents.values()].find((agent) => agent.taskId === notification.taskId)
-      : null);
-    if (!running) continue;
-    emitSubagentLine(session, running.id, {
-      kind: notification.status === "completed" ? "result" : "error",
-      text: notification.summary || notification.status || "완료됨",
-    });
-    session.subagents.delete(running.id);
-    emitSubagents(session);
-  }
-}
-
-function processUser(session, message) {
+  });
+}
+
+function messageTextParts(message) {
+  const content = message.message?.content;
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter((block) => block?.type === "text" && typeof block.text === "string")
+    .map((block) => block.text);
+}
+
+function notificationTag(body, name) {
+  const match = body.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
+  return match?.[1]?.trim() || "";
+}
+
+function taskNotifications(message) {
+  if (message.origin?.kind !== "task-notification"
+    && !messageTextParts(message).some((text) => text.includes("<task-notification>"))) {
+    return [];
+  }
+  const notifications = [];
+  for (const text of messageTextParts(message)) {
+    for (const match of text.matchAll(/<task-notification>([\s\S]*?)<\/task-notification>/g)) {
+      const body = match[1];
+      notifications.push({
+        taskId: notificationTag(body, "task-id"),
+        toolUseId: notificationTag(body, "tool-use-id"),
+        status: notificationTag(body, "status"),
+        summary: notificationTag(body, "summary"),
+      });
+    }
+  }
+  return notifications;
+}
+
+function finishNotifiedSubagents(session, notifications) {
+  for (const notification of notifications) {
+    const byToolUse = notification.toolUseId
+      ? session.subagents.get(notification.toolUseId)
+      : null;
+    const running = byToolUse || (notification.taskId
+      ? [...session.subagents.values()].find((agent) => agent.taskId === notification.taskId)
+      : null);
+    if (!running) continue;
+    emitSubagentLine(session, running.id, {
+      kind: notification.status === "completed" ? "result" : "error",
+      text: notification.summary || notification.status || "완료됨",
+    });
+    session.subagents.delete(running.id);
+    emitSubagents(session);
+  }
+}
+
+function processUser(session, message) {
   // 자식 tool_result의 tool_use_id는 부모 세션의 것과 다른 공간이므로, 부모 흐름에
   // 섞이기 전에 서브에이전트 기록으로 보낸다.
   if (message.parent_tool_use_id) {
-    recordSubagentResult(session, message);
-    return;
-  }
-  const notifications = taskNotifications(message);
-  if (notifications.length) {
-    if (!session.turn) beginTurn(session);
-    finishNotifiedSubagents(session, notifications);
-    return;
-  }
-  const content = Array.isArray(message.message?.content) ? message.message.content : [];
-  for (const block of content) {
-    if (block.type !== "tool_result") continue;
-    const pending = session.tools.get(block.tool_use_id);
-    const staysInBackground = SUBAGENT_TOOLS.includes(pending?.name)
-      && keepBackgroundSubagent(session, block.tool_use_id, message.tool_use_result);
-    if (!staysInBackground) finishSubagent(session, block.tool_use_id);
-    if (pending?.name === "SendMessage") {
-      resumeBackgroundSubagent(session, block.tool_use_id, pending, message.tool_use_result);
-    } else if (pending?.name === "TaskStop" && message.tool_use_result?.success !== false) {
-      finishSubagentTask(session, firstLine(pending.input?.task_id || "", 80));
-    }
-    if (!pending) continue;
+    recordSubagentResult(session, message);
+    return;
+  }
+  const notifications = taskNotifications(message);
+  if (notifications.length) {
+    if (!session.turn) beginTurn(session);
+    finishNotifiedSubagents(session, notifications);
+    return;
+  }
+  const content = Array.isArray(message.message?.content) ? message.message.content : [];
+  for (const block of content) {
+    if (block.type !== "tool_result") continue;
+    const pending = session.tools.get(block.tool_use_id);
+    const staysInBackground = SUBAGENT_TOOLS.includes(pending?.name)
+      && keepBackgroundSubagent(session, block.tool_use_id, message.tool_use_result);
+    if (!staysInBackground) finishSubagent(session, block.tool_use_id);
+    if (pending?.name === "SendMessage") {
+      resumeBackgroundSubagent(session, block.tool_use_id, pending, message.tool_use_result);
+    } else if (pending?.name === "TaskStop" && message.tool_use_result?.success !== false) {
+      finishSubagentTask(session, firstLine(pending.input?.task_id || "", 80));
+    }
+    if (!pending) continue;
     pending.toolUseId = block.tool_use_id;
     if (pending.suppressed) {
       updatePlanFromToolResult(session, pending, message);
@@ -1209,10 +1322,10 @@ async function runPendingPrompt(session) {
   }
 }
 
-function finishTurn(session, error, durationMs) {
-  if (!session.turn) return;
-  flushSmoothStreams(session);
-  clearForegroundSubagents(session);
+function finishTurn(session, error, durationMs) {
+  if (!session.turn) return;
+  flushSmoothStreams(session);
+  clearForegroundSubagents(session);
   const turn = { id: session.turn.id, status: error ? "failed" : "completed" };
   if (error) turn.error = { message: error instanceof Error ? error.message : error.message || String(error) };
   if (durationMs != null) turn.durationMs = durationMs;
@@ -1228,7 +1341,7 @@ async function consume(session) {
       if (message.event?.type === "content_block_delta" && (message.event?.delta?.text || message.event?.delta?.thinking)) {
         if (session.turn) session.turn.sawStreamText = true;
       }
-      await processStreamEvent(session, message);
+      await processStreamEvent(session, message);
     } else if (message.type === "assistant") processAssistant(session, message);
     else if (message.type === "user") processUser(session, message);
     else if (message.type === "result") await processResult(session, message);
@@ -1309,28 +1422,36 @@ async function runPrompt(session, params) {
   if (effort) {
     await session.query.applyFlagSettings({ effortLevel: effort });
   }
-  session.effort = effort;
-  await applyPermissionMode(session, params.permissionMode);
-  const turnId = beginTurn(session);
-  session.queue.push({
-    type: "user",
-    message: { role: "user", content: await inputContent(params.input, params.handoffContext) },
+  session.effort = effort;
+  await applyPermissionMode(session, params.permissionMode);
+  const content = await inputContent(params.input, params.handoffContext);
+  const turnId = beginTurn(session, params.input);
+  session.queue.push({
+    type: "user",
+    message: { role: "user", content },
     parent_tool_use_id: null,
     session_id: id,
     origin: { kind: "human" },
   });
-  return { turn: { id: turnId } };
-}
-
-// 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) {
+  return { turn: { id: turnId } };
+}
+
+// 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, input = []) {
   const turnId = `claude-turn-${session.turnSequence++}-${randomUUID()}`;
-  session.turn = { id: turnId, sawStreamText: false };
-  session.lastContextUsage = null;
-  notify("turn/started", { threadId: session.id, turn: { id: turnId } });
-  return turnId;
-}
+  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;
+}
 
 function contentBlocks(message) {
   const content = message?.content;
@@ -1355,7 +1476,7 @@ function isInternalHistoryText(message, text) {
     ].includes(tag);
 }
 
-function historyState(messages) {
+function historyState(messages) {
   const turns = [];
   let turn = null;
   const tools = new Map();
@@ -1391,14 +1512,14 @@ function historyState(messages) {
         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") {
-            prepareTaskPlanForCreate(tasks, block.input?.subject);
-            tasks.set(`pending:${block.id}`, { id: `pending:${block.id}`, subject: block.input?.subject || "작업", status: "pending", turnId: turn.id });
-          } else if (block.name === "TaskUpdate") {
-            applyTaskUpdate(tasks, block.input || {}, turn.id);
-          } else if (!["TaskList", "AskUserQuestion"].includes(block.name)) turn.items.push(pending.item);
+          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") {
+            prepareTaskPlanForCreate(tasks, block.input?.subject);
+            tasks.set(`pending:${block.id}`, { id: `pending:${block.id}`, subject: block.input?.subject || "작업", status: "pending", turnId: turn.id });
+          } else if (block.name === "TaskUpdate") {
+            applyTaskUpdate(tasks, block.input || {}, turn.id);
+          } else if (!["TaskList", "AskUserQuestion"].includes(block.name)) turn.items.push(pending.item);
         }
       }
     } else if (message.type === "user") {
@@ -1415,12 +1536,12 @@ function historyState(messages) {
             tasks.set(temporary.id, temporary);
           }
         } else if (pending.name === "TaskList" && Array.isArray(message.tool_use_result?.tasks)) {
-          const known = new Map(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", turnId: known.get(String(task.id))?.turnId ?? turn.id });
-          const current = latestTaskPlan(tasks);
-          tasks.clear();
-          for (const [id, task] of current) tasks.set(id, task);
+          const known = new Map(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", turnId: known.get(String(task.id))?.turnId ?? turn.id });
+          const current = latestTaskPlan(tasks);
+          tasks.clear();
+          for (const [id, task] of current) tasks.set(id, task);
         } else if (pending.item) {
           const output = toolOutput(block.content, message.tool_use_result);
           Object.assign(pending.item, pending.item.type === "commandExecution"
@@ -1436,17 +1557,17 @@ function historyState(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 {
-    tasks,
-    turns: turns
-    .filter((candidate) => !candidate.synthetic)
-    .map(({ synthetic: _, ...candidate }) => candidate),
-  };
-}
-
-function historyTurns(messages) {
-  return historyState(messages).turns;
-}
+  return {
+    tasks,
+    turns: turns
+    .filter((candidate) => !candidate.synthetic)
+    .map(({ synthetic: _, ...candidate }) => candidate),
+  };
+}
+
+function historyTurns(messages) {
+  return historyState(messages).turns;
+}
 
 async function dispatch(method, params = {}) {
   if (method === "model/list") return loadModelCatalog(params);
@@ -1471,11 +1592,11 @@ async function dispatch(method, params = {}) {
   }
   if (method === "session/resume") {
     const id = liveSessionId(params.sessionId);
-    const existing = sessions.get(id);
-    if (existing) {
-      const messages = await getSessionMessages(id, { dir: existing.cwd, includeSystemMessages: true });
-      if (!existing.tasks.size) existing.tasks = historyState(messages).tasks;
-      return {
+    const existing = sessions.get(id);
+    if (existing) {
+      const messages = await getSessionMessages(id, { dir: existing.cwd, includeSystemMessages: true });
+      if (!existing.tasks.size) existing.tasks = historyState(messages).tasks;
+      return {
         id,
         thread: { id, turns: [] },
         initialTurnsPage: { data: [], nextCursor: null },
@@ -1499,11 +1620,11 @@ async function dispatch(method, params = {}) {
       model: params.model || lastModel || params.fallbackModel,
       effort: params.effort || params.fallbackEffort,
     }, 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;
-    session.tasks = historyState(messages).tasks;
+    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;
+    session.tasks = historyState(messages).tasks;
     return {
       id,
       thread: { id, turns: [] },
@@ -1605,7 +1726,7 @@ async function dispatch(method, params = {}) {
   throw new Error(`지원하지 않는 Claude 브리지 메서드: ${method}`);
 }
 
-async function runSelfTest() {
+async function runSelfTest() {
   const user = (uuid, text) => ({
     type: "user",
     uuid,
@@ -1636,70 +1757,89 @@ async function runSelfTest() {
     ["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 taskUse = (uuid, id, name, input) => ({
-    type: "assistant",
-    uuid,
-    message: {
-      role: "assistant",
-      model: "claude-opus-5",
-      content: [{ type: "tool_use", id, name, input }],
-    },
-  });
-  const taskResult = (uuid, id, toolUseResult, content) => ({
-    type: "user",
-    uuid,
-    message: { role: "user", content: [{ type: "tool_result", tool_use_id: id, content }] },
-    tool_use_result: toolUseResult,
-  });
-  const taskMessages = [user("plan", "작업을 진행해")];
-  for (let index = 1; index <= 6; index++) {
-    const id = String(24 + index);
-    const toolId = `create-${id}`;
-    const subject = `${index}. 작업 ${index}`;
-    taskMessages.push(
-      taskUse(`create-use-${id}`, toolId, "TaskCreate", { subject }),
-      taskResult(`create-result-${id}`, toolId, { task: { id, subject } }, `Task #${id} created successfully: ${subject}`),
-    );
-  }
-  taskMessages.push(
-    taskUse("update-25-start", "update-25-start", "TaskUpdate", { taskId: "25", status: "in_progress" }),
-    taskUse("update-25-done", "update-25-done", "TaskUpdate", { taskId: "25", status: "completed" }),
-    taskUse("update-26-start", "update-26-start", "TaskUpdate", { taskId: "26", status: "in_progress" }),
-  );
-  const restoredTasks = historyState(taskMessages).tasks;
-  if ([...restoredTasks.keys()].join(",") !== "25,26,27,28,29,30"
-    || restoredTasks.get("25")?.status !== "completed"
-    || restoredTasks.get("26")?.status !== "in_progress"
-    || [...restoredTasks.values()].filter((task) => task.status === "in_progress").length !== 1) {
-    throw new Error(`Claude task resume self-test failed: ${JSON.stringify([...restoredTasks])}`);
-  }
-  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 mixedPlans = new Map([
-    ["old-1", { subject: "1. 이전 작업", status: "completed" }],
-    ["old-2", { subject: "2. 이전 검증", status: "completed" }],
-    ...[...restoredTasks],
-  ]);
-  if ([...latestTaskPlan(mixedPlans).keys()].join(",") !== "25,26,27,28,29,30") {
-    throw new Error(`Claude latest task plan self-test failed: ${JSON.stringify([...mixedPlans])}`);
-  }
-  prepareTaskPlanForCreate(restoredTasks, "7. 추가 작업");
-  if (restoredTasks.size !== 6) throw new Error("Claude appended task unexpectedly reset the plan");
-  prepareTaskPlanForCreate(restoredTasks, "1. 새 작업");
-  if (restoredTasks.size !== 0) throw new Error("Claude new task plan did not reset the previous plan");
-  const usage = tokenBreakdown({
+  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 taskUse = (uuid, id, name, input) => ({
+    type: "assistant",
+    uuid,
+    message: {
+      role: "assistant",
+      model: "claude-opus-5",
+      content: [{ type: "tool_use", id, name, input }],
+    },
+  });
+  const taskResult = (uuid, id, toolUseResult, content) => ({
+    type: "user",
+    uuid,
+    message: { role: "user", content: [{ type: "tool_result", tool_use_id: id, content }] },
+    tool_use_result: toolUseResult,
+  });
+  const taskMessages = [user("plan", "작업을 진행해")];
+  for (let index = 1; index <= 6; index++) {
+    const id = String(24 + index);
+    const toolId = `create-${id}`;
+    const subject = `${index}. 작업 ${index}`;
+    taskMessages.push(
+      taskUse(`create-use-${id}`, toolId, "TaskCreate", { subject }),
+      taskResult(`create-result-${id}`, toolId, { task: { id, subject } }, `Task #${id} created successfully: ${subject}`),
+    );
+  }
+  taskMessages.push(
+    taskUse("update-25-start", "update-25-start", "TaskUpdate", { taskId: "25", status: "in_progress" }),
+    taskUse("update-25-done", "update-25-done", "TaskUpdate", { taskId: "25", status: "completed" }),
+    taskUse("update-26-start", "update-26-start", "TaskUpdate", { taskId: "26", status: "in_progress" }),
+  );
+  const restoredTasks = historyState(taskMessages).tasks;
+  if ([...restoredTasks.keys()].join(",") !== "25,26,27,28,29,30"
+    || restoredTasks.get("25")?.status !== "completed"
+    || restoredTasks.get("26")?.status !== "in_progress"
+    || [...restoredTasks.values()].filter((task) => task.status === "in_progress").length !== 1) {
+    throw new Error(`Claude task resume self-test failed: ${JSON.stringify([...restoredTasks])}`);
+  }
+  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([
+    ["old-1", { subject: "1. 이전 작업", status: "completed" }],
+    ["old-2", { subject: "2. 이전 검증", status: "completed" }],
+    ...[...restoredTasks],
+  ]);
+  if ([...latestTaskPlan(mixedPlans).keys()].join(",") !== "25,26,27,28,29,30") {
+    throw new Error(`Claude latest task plan self-test failed: ${JSON.stringify([...mixedPlans])}`);
+  }
+  prepareTaskPlanForCreate(restoredTasks, "7. 추가 작업");
+  if (restoredTasks.size !== 6) throw new Error("Claude appended task unexpectedly reset the plan");
+  prepareTaskPlanForCreate(restoredTasks, "1. 새 작업");
+  if (restoredTasks.size !== 0) throw new Error("Claude new task plan did not reset the previous plan");
+  const usage = tokenBreakdown({
     input_tokens: 2,
     cache_read_input_tokens: 68_000,
     cache_creation_input_tokens: 500,
@@ -1713,148 +1853,226 @@ async function runSelfTest() {
     catalogEntry({ value: "sonnet", resolvedModel: "claude-sonnet-5" }, "").contextWindow,
     catalogEntry({ value: "haiku", resolvedModel: "x", contextWindow: 300_000 }, "").contextWindow,
   ];
-  if (windows.join(",") !== "1000000,200000,300000") {
-    throw new Error(`Claude context window self-test failed: ${windows.join(",")}`);
-  }
-  const notification = taskNotifications({
-    origin: { kind: "task-notification" },
-    message: {
-      content: `<task-notification>
-<task-id>agent-1</task-id>
-<tool-use-id>toolu_1</tool-use-id>
-<status>completed</status>
-<summary>Agent "Explore" finished</summary>
-<result>done</result>
-</task-notification>`,
-    },
-  });
-  if (notification.length !== 1
-    || notification[0].taskId !== "agent-1"
-    || notification[0].toolUseId !== "toolu_1"
-    || notification[0].status !== "completed"
-    || notification[0].summary !== 'Agent "Explore" finished') {
-    throw new Error(`Claude task notification self-test failed: ${JSON.stringify(notification)}`);
+  if (windows.join(",") !== "1000000,200000,300000") {
+    throw new Error(`Claude context window self-test failed: ${windows.join(",")}`);
+  }
+  const notification = taskNotifications({
+    origin: { kind: "task-notification" },
+    message: {
+      content: `<task-notification>
+<task-id>agent-1</task-id>
+<tool-use-id>toolu_1</tool-use-id>
+<status>completed</status>
+<summary>Agent "Explore" finished</summary>
+<result>done</result>
+</task-notification>`,
+    },
+  });
+  if (notification.length !== 1
+    || notification[0].taskId !== "agent-1"
+    || notification[0].toolUseId !== "toolu_1"
+    || notification[0].status !== "completed"
+    || notification[0].summary !== 'Agent "Explore" finished') {
+    throw new Error(`Claude task notification self-test failed: ${JSON.stringify(notification)}`);
+  }
+  const lifecycleSession = {
+    id: "self-test-session",
+    turn: { id: "parent-turn", sawStreamText: false },
+    turnSequence: 1,
+    streamBlocks: new Map(),
+    tools: new Map([[
+      "toolu_1",
+      {
+        name: "Agent",
+        input: { subagent_type: "Explore", description: "Inspect files" },
+        item: { id: "toolu_1", type: "collabAgentToolCall", tool: { name: "Agent", arguments: {} } },
+      },
+    ]]),
+    subagents: new Map([[
+      "toolu_1",
+      {
+        id: "toolu_1",
+        taskId: "",
+        background: false,
+        name: "Explore",
+        description: "Inspect files",
+        tool: "",
+        startedAt: Date.now(),
+      },
+    ]]),
+    knownSubagents: new Map(),
+    lastContextUsage: null,
+  };
+  const captured = [];
+  const stdoutWrite = process.stdout.write;
+  process.stdout.write = (chunk) => {
+    captured.push(String(chunk));
+    return true;
+  };
+  try {
+    processUser(lifecycleSession, {
+      message: { content: [{ type: "tool_result", tool_use_id: "toolu_1", content: "launched" }] },
+      tool_use_result: { isAsync: true, status: "async_launched", agentId: "agent-1" },
+    });
+    finishTurn(lifecycleSession, null, 1);
+    if (!lifecycleSession.subagents.has("toolu_1") || lifecycleSession.turn !== null) {
+      throw new Error("Claude background subagent did not survive its parent turn");
+    }
+    processUser(lifecycleSession, {
+      origin: { kind: "task-notification" },
+      message: { content: notification[0] && `<task-notification>
+<task-id>agent-1</task-id><tool-use-id>toolu_1</tool-use-id>
+<status>completed</status><summary>Agent finished</summary>
+</task-notification>` },
+    });
+    if (lifecycleSession.subagents.size !== 0 || lifecycleSession.turn === null) {
+      throw new Error("Claude task notification did not finish the agent in an automatic turn");
+    }
+    finishTurn(lifecycleSession, null, 1);
+
+    beginTurn(lifecycleSession);
+    lifecycleSession.tools.set("toolu_2", {
+      name: "SendMessage",
+      input: { to: "agent-1", summary: "Continue inspection" },
+      item: { id: "toolu_2", type: "dynamicToolCall", tool: "SendMessage", arguments: {} },
+    });
+    processUser(lifecycleSession, {
+      message: { content: [{ type: "tool_result", tool_use_id: "toolu_2", content: "resumed" }] },
+      tool_use_result: { success: true, resumedAgentId: "agent-1" },
+    });
+    const resumed = lifecycleSession.subagents.get("toolu_2");
+    if (!resumed?.background || resumed.taskId !== "agent-1" || resumed.name !== "Explore") {
+      throw new Error(`Claude resumed subagent self-test failed: ${JSON.stringify(resumed)}`);
+    }
+    finishTurn(lifecycleSession, null, 1);
+    processUser(lifecycleSession, {
+      origin: { kind: "task-notification" },
+      message: { content: `<task-notification>
+<task-id>agent-1</task-id><tool-use-id>toolu_2</tool-use-id>
+<status>failed</status><summary>Agent failed</summary>
+</task-notification>` },
+    });
+    if (lifecycleSession.subagents.size !== 0 || lifecycleSession.turn === null) {
+      throw new Error("Claude failed task notification did not finish the resumed agent");
+    }
+    finishTurn(lifecycleSession, null, 1);
+  } finally {
+    process.stdout.write = stdoutWrite;
+  }
+  const lifecycleEvents = captured
+    .join("")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+  const lifecycleMethods = lifecycleEvents.map((event) => event.method);
+  if (!lifecycleMethods.includes("turn/subagents/updated")
+    || lifecycleMethods.filter((method) => method === "turn/started").length < 3
+    || !lifecycleEvents.some((event) => event.method === "turn/subagent/line"
+      && event.params?.line?.kind === "error")) {
+    throw new Error(`Claude subagent lifecycle events self-test failed: ${lifecycleMethods}`);
   }
-  const lifecycleSession = {
-    id: "self-test-session",
-    turn: { id: "parent-turn", sawStreamText: false },
+  const openingSession = {
+    id: "opening-self-test",
+    model: "claude:default",
+    models: [],
+    turn: null,
     turnSequence: 1,
+    itemSequence: 1,
     streamBlocks: new Map(),
-    tools: new Map([[
-      "toolu_1",
-      {
-        name: "Agent",
-        input: { subagent_type: "Explore", description: "Inspect files" },
-        item: { id: "toolu_1", type: "collabAgentToolCall", tool: { name: "Agent", arguments: {} } },
-      },
-    ]]),
-    subagents: new Map([[
-      "toolu_1",
-      {
-        id: "toolu_1",
-        taskId: "",
-        background: false,
-        name: "Explore",
-        description: "Inspect files",
-        tool: "",
-        startedAt: Date.now(),
-      },
-    ]]),
+    tools: new Map(),
+    tasks: new Map(),
+    subagents: new Map(),
     knownSubagents: new Map(),
     lastContextUsage: null,
+    lastContextWindow: 0,
   };
-  const captured = [];
-  const stdoutWrite = process.stdout.write;
+  const openingCaptured = [];
   process.stdout.write = (chunk) => {
-    captured.push(String(chunk));
+    openingCaptured.push(String(chunk));
     return true;
   };
   try {
-    processUser(lifecycleSession, {
-      message: { content: [{ type: "tool_result", tool_use_id: "toolu_1", content: "launched" }] },
-      tool_use_result: { isAsync: true, status: "async_launched", agentId: "agent-1" },
-    });
-    finishTurn(lifecycleSession, null, 1);
-    if (!lifecycleSession.subagents.has("toolu_1") || lifecycleSession.turn !== null) {
-      throw new Error("Claude background subagent did not survive its parent turn");
-    }
-    processUser(lifecycleSession, {
-      origin: { kind: "task-notification" },
-      message: { content: notification[0] && `<task-notification>
-<task-id>agent-1</task-id><tool-use-id>toolu_1</tool-use-id>
-<status>completed</status><summary>Agent finished</summary>
-</task-notification>` },
+    beginTurn(openingSession, [{ type: "text", text: "provider 메뉴를 수정해" }]);
+    processAssistant(openingSession, {
+      message: {
+        content: [{ type: "tool_use", id: "read-1", name: "Read", input: { file_path: "src/main.rs" } }],
+      },
     });
-    if (lifecycleSession.subagents.size !== 0 || lifecycleSession.turn === null) {
-      throw new Error("Claude task notification did not finish the agent in an automatic turn");
-    }
-    finishTurn(lifecycleSession, null, 1);
-
-    beginTurn(lifecycleSession);
-    lifecycleSession.tools.set("toolu_2", {
-      name: "SendMessage",
-      input: { to: "agent-1", summary: "Continue inspection" },
-      item: { id: "toolu_2", type: "dynamicToolCall", tool: "SendMessage", arguments: {} },
+  } 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" } },
     });
-    processUser(lifecycleSession, {
-      message: { content: [{ type: "tool_result", tool_use_id: "toolu_2", content: "resumed" }] },
-      tool_use_result: { success: true, resumedAgentId: "agent-1" },
+    await processStreamEvent(openingSession, {
+      event: { type: "content_block_delta", index: 0, delta: { text: "Now the tile view logic." } },
     });
-    const resumed = lifecycleSession.subagents.get("toolu_2");
-    if (!resumed?.background || resumed.taskId !== "agent-1" || resumed.name !== "Explore") {
-      throw new Error(`Claude resumed subagent self-test failed: ${JSON.stringify(resumed)}`);
-    }
-    finishTurn(lifecycleSession, null, 1);
-    processUser(lifecycleSession, {
-      origin: { kind: "task-notification" },
-      message: { content: `<task-notification>
-<task-id>agent-1</task-id><tool-use-id>toolu_2</tool-use-id>
-<status>failed</status><summary>Agent failed</summary>
-</task-notification>` },
+    await processStreamEvent(openingSession, {
+      event: { type: "content_block_stop", index: 0 },
     });
-    if (lifecycleSession.subagents.size !== 0 || lifecycleSession.turn === null) {
-      throw new Error("Claude failed task notification did not finish the resumed agent");
-    }
-    finishTurn(lifecycleSession, null, 1);
   } finally {
     process.stdout.write = stdoutWrite;
   }
-  const lifecycleEvents = captured
+  const languageEvents = languageCaptured
     .join("")
     .trim()
     .split("\n")
     .filter(Boolean)
     .map((line) => JSON.parse(line));
-  const lifecycleMethods = lifecycleEvents.map((event) => event.method);
-  if (!lifecycleMethods.includes("turn/subagents/updated")
-    || lifecycleMethods.filter((method) => method === "turn/started").length < 3
-    || !lifecycleEvents.some((event) => event.method === "turn/subagent/line"
-      && event.params?.line?.kind === "error")) {
-    throw new Error(`Claude subagent lifecycle events self-test failed: ${lifecycleMethods}`);
+  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);
-  smooth.push(smoothText);
-  await smooth.finish();
-  if (emitted.length < 2 || emitted.join("") !== smoothText) {
-    throw new Error(`Claude smooth stream self-test failed: ${JSON.stringify(emitted)}`);
-  }
-  const flushed = [];
-  const interrupted = new SmoothTextStream((chunk) => flushed.push(chunk), 1000);
-  interrupted.push(smoothText);
-  interrupted.flush();
-  await interrupted.finish();
-  if (flushed.join("") !== smoothText) {
-    throw new Error(`Claude smooth stream flush self-test failed: ${JSON.stringify(flushed)}`);
-  }
-  process.stdout.write("Claude bridge self-test passed\n");
-}
-
-if (process.argv.includes("--self-test")) {
-  await runSelfTest();
-  process.exit(0);
-}
+  const emitted = [];
+  const smooth = new SmoothTextStream((chunk) => emitted.push(chunk), 0);
+  smooth.push(smoothText);
+  await smooth.finish();
+  if (emitted.length < 2 || emitted.join("") !== smoothText) {
+    throw new Error(`Claude smooth stream self-test failed: ${JSON.stringify(emitted)}`);
+  }
+  const flushed = [];
+  const interrupted = new SmoothTextStream((chunk) => flushed.push(chunk), 1000);
+  interrupted.push(smoothText);
+  interrupted.flush();
+  await interrupted.finish();
+  if (flushed.join("") !== smoothText) {
+    throw new Error(`Claude smooth stream flush self-test failed: ${JSON.stringify(flushed)}`);
+  }
+  process.stdout.write("Claude bridge self-test passed\n");
+}
+
+if (process.argv.includes("--self-test")) {
+  await runSelfTest();
+  process.exit(0);
+}
 
 const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
 lines.on("line", async (line) => {