devez-vibe 1.2.8 → 1.2.10

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,
@@ -435,9 +438,10 @@ async function createSession(params, resumeId) {
     turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
-    tools: new Map(),
-    tasks: new Map(),
-    subagents: new Map(),
+    tools: new Map(),
+    tasks: new Map(),
+    planCreatePending: false,
+    subagents: new Map(),
     knownSubagents: new Map(),
     lastContextUsage: null,
     lastContextWindow: 0,
@@ -497,53 +501,53 @@ function emitItem(session, phase, item) {
   notify(`item/${phase}`, { threadId: session.id, turnId: session.turn?.id, item });
 }
 
-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;
-}
+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;
-const SMOOTH_TEXT_TARGET_FRAMES = 8;
+const SMOOTH_TEXT_TARGET_FRAMES = 10;
 const SMOOTH_TEXT_MAX_GRAPHEMES = 24;
 const graphemeSegmenter = typeof Intl.Segmenter === "function"
   ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
@@ -578,10 +582,21 @@ class SmoothTextStream {
     this.waiters = [];
   }
 
-  push(text) {
-    this.pending += text;
-    if (this.timer == null) this.drain();
-  }
+  push(text) {
+    this.pending += text;
+    this.schedule();
+  }
+
+  schedule() {
+    if (this.timer != null) return;
+    // Wait one visual frame before the first drain. Claude often sends several
+    // tiny deltas back-to-back; batching them removes the uneven one-character
+    // jumps while keeping added latency below one frame.
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.drain();
+    }, this.intervalMs);
+  }
 
   drain() {
     if (!this.pending) {
@@ -590,14 +605,13 @@ class SmoothTextStream {
       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();
-    }
+    this.pending = rest;
+    this.emit(chunk);
+    if (this.pending) {
+      this.schedule();
+    } else {
+      for (const resolve of this.waiters.splice(0)) resolve();
+    }
   }
 
   finish() {
@@ -671,7 +685,7 @@ async function processStreamEvent(session, message) {
     flushSmoothStreams(session);
     session.streamBlocks.clear();
   }
-  if (event.type === "content_block_start") {
+  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);
@@ -681,54 +695,54 @@ 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,
-      languagePending: block.type === "text" && session.turn.koreanRequest ? "" : null,
-      holdEnglishProgress: false,
-    });
+    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") {
+  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.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;
-  }
+    const delta = event.delta?.text || event.delta?.thinking || "";
+    if (!delta) return;
+    current.text += 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 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] };
@@ -753,31 +767,31 @@ function processAssistant(session, message) {
     message.message?.model,
     session.model,
   );
-  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);
-  }
-}
+  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) {
+function processToolUse(session, block) {
   const name = block.name || "Tool";
   const input = block.input || {};
   if (name === "TaskCreate" || name === "TaskUpdate" || name === "TaskList") {
@@ -785,11 +799,13 @@ function processToolUse(session, block) {
     session.tools.set(block.id, { name, input, suppressed: true });
     return;
   }
-  if (name === "AskUserQuestion") {
-    session.tools.set(block.id, { name, input, suppressed: true });
-    return;
-  }
-  const item = toolItem(session, block.id, name, input);
+  if (name === "AskUserQuestion") {
+    flushPendingPlan(session);
+    session.tools.set(block.id, { name, input, suppressed: true });
+    return;
+  }
+  flushPendingPlan(session);
+  const item = toolItem(session, block.id, name, input);
   session.tools.set(block.id, { name, input, item });
   emitItem(session, "started", item);
   if (SUBAGENT_TOOLS.includes(name)) startSubagent(session, block);
@@ -895,21 +911,30 @@ function latestTaskPlan(tasks) {
   return new Map(entries.slice(start));
 }
 
-function updatePlanFromToolUse(session, name, toolUseId, input) {
+function updatePlanFromToolUse(session, name, toolUseId, input) {
   const turnId = session.turn?.id;
   if (name === "TaskCreate") {
     prepareTaskPlanForCreate(session.tasks, input.subject);
-    session.tasks.set(`pending:${toolUseId}`, {
+    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));
-  }
-  emitPlan(session);
-}
+      turnId,
+    });
+    session.planCreatePending = true;
+    return;
+  } else if (name === "TaskUpdate") {
+    session.planCreatePending = false;
+    applyTaskUpdate(session.tasks, input, turnId, () => emitPlan(session));
+  }
+  if (name === "TaskUpdate") emitPlan(session);
+}
+
+function flushPendingPlan(session) {
+  if (!session.planCreatePending) return;
+  session.planCreatePending = false;
+  emitPlan(session);
+}
 
 function updatePlanFromToolResult(session, pending, message) {
   const value = message.tool_use_result;
@@ -1322,8 +1347,9 @@ async function runPendingPrompt(session) {
   }
 }
 
-function finishTurn(session, error, durationMs) {
-  if (!session.turn) return;
+function finishTurn(session, error, durationMs) {
+  if (!session.turn) return;
+  flushPendingPlan(session);
   flushSmoothStreams(session);
   clearForegroundSubagents(session);
   const turn = { id: session.turn.id, status: error ? "failed" : "completed" };
@@ -1411,7 +1437,7 @@ async function startPrompt(params) {
   return runPrompt(session, params);
 }
 
-async function runPrompt(session, params) {
+async function runPrompt(session, params) {
   const id = session.id;
   if (params.model) {
     const model = stripClaudeModel(params.model);
@@ -1422,13 +1448,13 @@ async function runPrompt(session, params) {
   if (effort) {
     await session.query.applyFlagSettings({ effortLevel: effort });
   }
-  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 },
+  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" },
@@ -1438,16 +1464,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, input = []) {
-  const turnId = `claude-turn-${session.turnSequence++}-${randomUUID()}`;
-  session.turn = {
-    id: turnId,
-    sawStreamText: false,
-    sawVisibleText: false,
-    koreanRequest: isKoreanPrompt(input),
-    openingNotice: openingNotice(input),
-    openingNoticeEmitted: false,
-  };
+function beginTurn(session, input = []) {
+  const turnId = `claude-turn-${session.turnSequence++}-${randomUUID()}`;
+  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;
@@ -1569,6 +1595,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") {
@@ -1608,15 +1703,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);
@@ -1657,7 +1756,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);
@@ -1683,7 +1782,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 {
@@ -1837,9 +1936,53 @@ async function runSelfTest() {
   }
   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({
+  prepareTaskPlanForCreate(restoredTasks, "1. 새 작업");
+  if (restoredTasks.size !== 0) throw new Error("Claude new task plan did not reset the previous plan");
+  const batchedPlanSession = {
+    id: "batched-plan-self-test",
+    turn: { id: "batched-plan-turn" },
+    tasks: new Map(),
+    planCreatePending: false,
+  };
+  const batchedPlanCaptured = [];
+  const batchedPlanWrite = process.stdout.write;
+  process.stdout.write = (chunk) => {
+    batchedPlanCaptured.push(String(chunk));
+    return true;
+  };
+  try {
+    for (let index = 1; index <= 3; index++) {
+      const toolUseId = `batched-create-${index}`;
+      const subject = `${index}. 작업 ${index}`;
+      updatePlanFromToolUse(batchedPlanSession, "TaskCreate", toolUseId, { subject });
+      updatePlanFromToolResult(
+        batchedPlanSession,
+        { name: "TaskCreate", toolUseId },
+        { tool_use_result: { task: { id: String(index), subject } } },
+      );
+    }
+    updatePlanFromToolUse(
+      batchedPlanSession,
+      "TaskUpdate",
+      "batched-update-1",
+      { taskId: "1", status: "in_progress" },
+    );
+  } finally {
+    process.stdout.write = batchedPlanWrite;
+  }
+  const batchedPlanEvents = batchedPlanCaptured
+    .join("")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line))
+    .filter((event) => event.method === "turn/plan/updated");
+  if (batchedPlanEvents.length !== 1
+    || batchedPlanEvents[0].params?.plan?.length !== 3
+    || batchedPlanEvents[0].params.plan[0]?.status !== "inProgress") {
+    throw new Error(`Claude batched plan self-test failed: ${JSON.stringify(batchedPlanEvents)}`);
+  }
+  const usage = tokenBreakdown({
     input_tokens: 2,
     cache_read_input_tokens: 68_000,
     cache_creation_input_tokens: 500,
@@ -1966,95 +2109,98 @@ async function runSelfTest() {
     .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 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)}`);
+  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 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);
+  smooth.push(smoothText);
+  if (emitted.length !== 0) {
+    throw new Error(`Claude smooth stream did not batch its first frame: ${JSON.stringify(emitted)}`);
   }
-  const smoothText = "Claude가 👨‍👩‍👧‍👦 한 문장을 한꺼번에 보내도 부드럽게 표시합니다.";
-  const emitted = [];
-  const smooth = new SmoothTextStream((chunk) => emitted.push(chunk), 0);
-  smooth.push(smoothText);
-  await smooth.finish();
+  await smooth.finish();
   if (emitted.length < 2 || emitted.join("") !== smoothText) {
     throw new Error(`Claude smooth stream self-test failed: ${JSON.stringify(emitted)}`);
   }

package/package.json

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