devez-vibe 1.2.13 → 1.2.15

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

@@ -438,10 +438,10 @@ async function createSession(params, resumeId) {
     turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
-    tools: new Map(),
-    tasks: new Map(),
-    planCreatePending: false,
-    subagents: new Map(),
+    tools: new Map(),
+    tasks: new Map(),
+    planCreatePending: false,
+    subagents: new Map(),
     knownSubagents: new Map(),
     lastContextUsage: null,
     lastContextWindow: 0,
@@ -519,6 +519,10 @@ function openingNotice(input) {
     : "I’ll review the request and proceed with the necessary work.";
 }
 
+// `Now the tile view logic.` carries nothing a Korean reader needs, and the
+// stand-in that used to replace it carried even less — the same sentence before
+// every tool call, however many calls the turn made. Drop the line instead; the
+// tool item that follows already names what is being read.
 function normalizeProgressText(turn, text) {
   const value = String(text || "");
   const trimmed = value.trim();
@@ -526,7 +530,7 @@ function normalizeProgressText(turn, text) {
     && trimmed.length <= 160
     && !/[\uac00-\ud7a3]/.test(trimmed)
     && /^Now\b[^\r\n]*[.!?]?$/i.test(trimmed)) {
-    return "다음 부분을 이어서 확인하겠습니다.";
+    return "";
   }
   return value;
 }
@@ -547,7 +551,7 @@ function emitOpeningNotice(session) {
 // 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 = 10;
+const SMOOTH_TEXT_TARGET_FRAMES = 10;
 const SMOOTH_TEXT_MAX_GRAPHEMES = 24;
 const graphemeSegmenter = typeof Intl.Segmenter === "function"
   ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
@@ -582,21 +586,21 @@ class SmoothTextStream {
     this.waiters = [];
   }
 
-  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);
-  }
+  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) {
@@ -605,13 +609,13 @@ class SmoothTextStream {
       return;
     }
     const { chunk, rest } = takeSmoothTextChunk(this.pending);
-    this.pending = rest;
-    this.emit(chunk);
-    if (this.pending) {
-      this.schedule();
-    } else {
-      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() {
@@ -678,6 +682,12 @@ function historyTokenUsage(messages, models, model) {
   };
 }
 
+function emitHeldStart(session, current) {
+  if (!current?.pendingStart) return;
+  emitItem(session, "started", current.pendingStart);
+  current.pendingStart = null;
+}
+
 async function processStreamEvent(session, message) {
   if (!session.turn || message.parent_tool_use_id) return;
   const event = message.event || {};
@@ -695,15 +705,20 @@ async function processStreamEvent(session, message) {
     const smooth = block.type === "text"
       ? new SmoothTextStream((delta) => emitDelta(session, "item/agentMessage/delta", id, delta))
       : null;
+    // A held English line can end up dropped entirely, and an item announced
+    // before that decision would stay on screen as an empty bubble. Hold the
+    // start too, and emit it with the first text that survives.
+    const held = block.type === "text" && session.turn.koreanRequest;
     session.streamBlocks.set(event.index, {
       id,
       type: block.type,
       text: "",
       smooth,
-      languagePending: block.type === "text" && session.turn.koreanRequest ? "" : null,
+      languagePending: held ? "" : null,
       holdEnglishProgress: false,
+      pendingStart: held ? item : null,
     });
-    emitItem(session, "started", item);
+    if (!held) emitItem(session, "started", item);
     return;
   }
   if (event.type === "content_block_delta") {
@@ -712,7 +727,9 @@ async function processStreamEvent(session, message) {
     const delta = event.delta?.text || event.delta?.thinking || "";
     if (!delta) return;
     current.text += delta;
-    if (current.type === "text") session.turn.sawVisibleText = true;
+    // Held text may still be dropped, and counting it as visible would suppress
+    // the opening notice in its place — leaving the turn with nothing to show.
+    if (current.type === "text" && current.languagePending == null) session.turn.sawVisibleText = true;
     if (!current.smooth) {
       emitDelta(session, "item/reasoning/summaryTextDelta", current.id, delta);
       return;
@@ -726,6 +743,8 @@ async function processStreamEvent(session, message) {
         current.holdEnglishProgress = true;
         return;
       }
+      emitHeldStart(session, current);
+      session.turn.sawVisibleText = true;
       current.smooth.push(current.languagePending);
       current.languagePending = null;
       return;
@@ -739,9 +758,16 @@ async function processStreamEvent(session, message) {
     if (current.languagePending != null) {
       const visible = normalizeProgressText(session.turn, current.languagePending);
       current.text = visible;
-      current.smooth?.push(visible);
       current.languagePending = null;
+      if (!visible.trim() && current.pendingStart) {
+        session.streamBlocks.delete(event.index);
+        return;
+      }
+      emitHeldStart(session, current);
+      if (visible.trim()) session.turn.sawVisibleText = true;
+      current.smooth?.push(visible);
     }
+    emitHeldStart(session, current);
     await current.smooth?.finish();
     const item = current.type === "text"
       ? { id: current.id, type: "agentMessage", text: current.text, provider: "Claude" }
@@ -777,9 +803,13 @@ function processAssistant(session, message) {
   if (!session.streamBlocks.size && !session.turn.sawStreamText) {
     for (const block of content) {
       if (block.type !== "text" && block.type !== "thinking") continue;
+      const visible = block.type === "text"
+        ? normalizeProgressText(session.turn, block.text)
+        : "";
+      if (block.type === "text" && !visible.trim() && String(block.text || "").trim()) 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: "agentMessage", text: visible, provider: "Claude" }
         : { id, type: "reasoning", summary: [block.thinking || ""] };
       emitItem(session, "started", item);
       emitItem(session, "completed", item);
@@ -791,7 +821,7 @@ function processAssistant(session, message) {
   }
 }
 
-function processToolUse(session, block) {
+function processToolUse(session, block) {
   const name = block.name || "Tool";
   const input = block.input || {};
   if (name === "TaskCreate" || name === "TaskUpdate" || name === "TaskList") {
@@ -799,13 +829,13 @@ function processToolUse(session, block) {
     session.tools.set(block.id, { name, input, suppressed: true });
     return;
   }
-  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);
+  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);
@@ -911,30 +941,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,
-    });
-    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);
-}
+      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;
@@ -1347,9 +1377,9 @@ async function runPendingPrompt(session) {
   }
 }
 
-function finishTurn(session, error, durationMs) {
-  if (!session.turn) return;
-  flushPendingPlan(session);
+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" };
@@ -1936,53 +1966,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 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({
+  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,
@@ -2189,18 +2219,51 @@ async function runSelfTest() {
     .filter((event) => event.method === "item/agentMessage/delta")
     .map((event) => event.params?.delta || "")
     .join("");
-  if (visibleLanguage !== "다음 부분을 이어서 확인하겠습니다."
+  if (visibleLanguage !== ""
+    || languageEvents.length
     || 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 keptCaptured = [];
+  process.stdout.write = (chunk) => {
+    keptCaptured.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: "타일 보기 로직을 고쳤습니다." } },
+    });
+    await processStreamEvent(openingSession, {
+      event: { type: "content_block_stop", index: 0 },
+    });
+  } finally {
+    process.stdout.write = stdoutWrite;
+  }
+  const keptEvents = keptCaptured
+    .join("")
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+  const keptStarted = keptEvents.findIndex((event) =>
+    event.method === "item/started" && event.params?.item?.type === "agentMessage");
+  const keptCompleted = keptEvents.find((event) =>
+    event.method === "item/completed" && event.params?.item?.type === "agentMessage");
+  if (keptStarted !== 0 || keptCompleted?.params?.item?.text !== "타일 보기 로직을 고쳤습니다.") {
+    throw new Error(`Claude held Korean text self-test failed: ${JSON.stringify(keptEvents)}`);
+  }
   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)}`);
-  }
-  await smooth.finish();
+  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)}`);
+  }
+  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.13",
+  "version": "1.2.15",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [
     "codex",