devez-vibe 1.9.39 → 1.9.41

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

@@ -1857,11 +1857,15 @@ function prepareTaskPlanForCreate(tasks, subject) {
 // 한 단계에 걸린 시간은 진행 중으로 바뀐 순간과 완료된 순간의 차이다. 기록에는
 // 항목마다 시각이 남으므로, 다시 읽을 때도 같은 방식으로 되살릴 수 있다.
 function markTaskStatus(task, status, at) {
-  if (task.status !== status && at != null) {
+  if (task.status !== status) {
     if (status === "in_progress") {
-      task.startedAt = task.startedAt ?? at;
-    } else if (status === "completed" && task.startedAt != null) {
+      task.startedAt = at;
+      delete task.elapsedMs;
+    } else if (status === "completed" && task.startedAt != null && at != null) {
       task.elapsedMs = Math.max(0, at - task.startedAt);
+    } else if (status === "pending") {
+      delete task.startedAt;
+      delete task.elapsedMs;
     }
   }
   task.status = status;
@@ -1985,13 +1989,17 @@ function updatePlanFromToolResult(session, pending, message) {
     session.tasks = new Map();
     for (const task of value.tasks || value) {
       const id = String(task.id);
-      session.tasks.set(id, {
+      const restored = {
         id,
         subject: task.subject || task.description || "작업",
-        status: task.status || "pending",
+        status: previous.get(id)?.status || "pending",
         // 이 턴에서 다룬 적 없는 작업은 이전 턴의 것이므로 원래 turnId를 지켜 준다.
         turnId: previous.get(id)?.turnId ?? turnId,
-      });
+        startedAt: previous.get(id)?.startedAt,
+        elapsedMs: previous.get(id)?.elapsedMs,
+      };
+      markTaskStatus(restored, task.status || "pending", Date.now());
+      session.tasks.set(id, restored);
     }
     session.tasks = latestTaskPlan(session.tasks);
     emitPlan(session);
@@ -2020,8 +2028,10 @@ function emitPlan(session) {
     threadId: session.id,
     turnId: session.turn?.id,
     plan: [...session.tasks.values()].map((task, index) => ({
+      id: task.id,
       step: numberedTaskSubject(task.subject, index),
       status: planStatus(task.status),
+      elapsedMs: task.elapsedMs ?? null,
     })),
   });
 }
@@ -2861,13 +2871,28 @@ async function processResult(session, message) {
     notify("warning", { threadId: session.id, provider: "Claude", message: `Claude response error: ${text}` });
   }
   if (error && waitForUsageLimit(session)) return;
-  finishTurn(session, error, message.duration_ms);
-  notify("claude/account/updated", {
-    threadId: session.id,
-    account: await safeAccount(session.query),
-    usage: await safeUsage(session.query),
-  });
-  await runPendingPrompt(session);
+  // A steer the CLI could not fold into this run gets a run of its own, which
+  // `queued_turn_count` announces. Closing the turn here dropped the host's
+  // spinner and filed a completion until that answer's first frame arrived.
+  // A count of 0 can still hide a steer read just after the result; the steer
+  // debt opens a fresh turn for it then, as before.
+  const steerFollows = !error && !interrupted && !assistantError
+    && session.steerPending > 0 && message.queued_turn_count > 0;
+  if (steerFollows) {
+    session.steerPending -= 1;
+    session.turn.awaitingSteer = true;
+    releaseHeldProgress(session);
+    flushPendingPlan(session);
+    clearForegroundSubagents(session);
+  } else {
+    finishTurn(session, error, message.duration_ms);
+  }
+  // Not awaited: the next run's frames queue behind this message, and the
+  // account lookup used to hold them back.
+  Promise.all([safeAccount(session.query), safeUsage(session.query)])
+    .then(([account, usage]) => notify("claude/account/updated", { threadId: session.id, account, usage }))
+    .catch(() => {});
+  if (!steerFollows) await runPendingPrompt(session);
 }
 
 // Compaction ends the turn's only assistant message, so the context figure would
@@ -2971,6 +2996,7 @@ async function consumeMessage(session, message) {
   // A queued SDK response may beat the timer. It already resumes the work.
   if (!message.parent_tool_use_id && (message.type === "assistant" || message.type === "stream_event")) {
     clearUsageLimitWait(session);
+    if (session.turn) session.turn.awaitingSteer = false;
   }
   if (message.type === "stream_event") {
     if (message.event?.type === "content_block_delta" && (message.event?.delta?.text || message.event?.delta?.thinking)) {
@@ -3348,16 +3374,18 @@ function historyState(messages) {
           tasks.clear();
           for (const task of message.tool_use_result.tasks) {
             const previous = known.get(String(task.id));
-            tasks.set(String(task.id), {
+            const restored = {
               id: String(task.id),
               subject: task.subject || "작업",
-              status: task.status || "pending",
+              status: previous?.status || "pending",
               turnId: previous?.turnId ?? turn.id,
               // A listing restates the plan; it does not re-run it, so the
               // timings already measured for these steps have to survive it.
               startedAt: previous?.startedAt,
               elapsedMs: previous?.elapsedMs,
-            });
+            };
+            markTaskStatus(restored, task.status || "pending", messageTime(message));
+            tasks.set(String(task.id), restored);
           }
           const current = latestTaskPlan(tasks);
           tasks.clear();
@@ -3381,6 +3409,7 @@ function historyState(messages) {
     // The text alone cannot say how long a step took, so the measured times ride
     // alongside it and the restored plan shows its total instead of zero.
     const steps = [...tasks.values()].map((task, index) => ({
+      id: task.id,
       step: numberedTaskSubject(task.subject, index),
       status: task.status || "pending",
       elapsedMs: task.elapsedMs ?? null,
@@ -3871,6 +3900,9 @@ async function dispatch(method, params = {}) {
         if (session.turn === turn) delete turn.interruptRequested;
         throw error;
       }
+      // Kept open for a steer whose run has not begun: nothing is running to
+      // send the result that would close it.
+      if (session.turn === turn && turn.awaitingSteer) finishTurn(session, null);
     }
     return {};
   }
@@ -4450,6 +4482,31 @@ async function runSelfTest() {
   if (timedPlan?.steps?.[0]?.elapsedMs !== 6000 || timedPlan.steps[0].status !== "completed") {
     throw new Error(`Claude plan step timing self-test failed: ${JSON.stringify(timedPlan)}`);
   }
+  const timedLiveSession = {
+    id: "timed-live-plan",
+    turn: { id: "timed-live-turn" },
+    tasks: historyState(timedMessages).tasks,
+  };
+  const timedLiveEvents = [];
+  const timedLiveWrite = process.stdout.write;
+  process.stdout.write = (chunk) => { timedLiveEvents.push(JSON.parse(String(chunk))); return true; };
+  try {
+    updatePlanFromToolResult(timedLiveSession, { name: "TaskList" }, {
+      tool_use_result: { tasks: [{ id: "t1", subject: "1. 확인한 설정", status: "completed" }] },
+    });
+  } finally {
+    process.stdout.write = timedLiveWrite;
+  }
+  const liveMeasured = timedLiveEvents.at(-1)?.params?.plan?.[0];
+  if (liveMeasured?.elapsedMs !== 6000 || timedLiveSession.tasks.get("t1")?.elapsedMs !== 6000) {
+    throw new Error(`Claude live plan timing self-test failed: ${JSON.stringify(liveMeasured)}`);
+  }
+  const restartedTask = { status: "pending" };
+  markTaskStatus(restartedTask, "in_progress", 1000);
+  markTaskStatus(restartedTask, "completed", 7000);
+  markTaskStatus(restartedTask, "in_progress", 9000);
+  markTaskStatus(restartedTask, "completed", 10000);
+  if (restartedTask.elapsedMs !== 1000) throw new Error("Claude restarted task timing self-test failed");
   const skippedTasks = new Map([
     ["1", { id: "1", subject: "1. 조사", status: "pending" }],
     ["2", { id: "2", subject: "2. 분석", status: "pending" }],
@@ -4831,6 +4888,64 @@ async function runSelfTest() {
     if (authTurn?.error?.codexErrorInfo !== "unauthorized" || !authTurn.error.message.includes("401")) {
       throw new Error(`Claude login failure lost its tag: ${JSON.stringify(authTurn)}`);
     }
+    // A steer answered in a run of its own stays in the turn it joined.
+    const steerNotices = [];
+    const steerWrite = process.stdout.write;
+    process.stdout.write = (chunk) => { steerNotices.push(JSON.parse(String(chunk))); return true; };
+    const steerSession = {
+      ...automaticTurnSession,
+      id: "steer-continuation-self-test",
+      turn: null,
+      streamBlocks: new Map(),
+      tools: new Map(),
+      tasks: new Map(),
+      subagents: new Map(),
+      pendingPrompts: [],
+      query: { ...automaticTurnSession.query, async interrupt() {} },
+    };
+    sessions.set(steerSession.id, steerSession);
+    const steerResult = (queued) => ({ type: "result", is_error: false, stop_reason: "end_turn", modelUsage: {}, queued_turn_count: queued });
+    const steerRun = { type: "stream_event", parent_tool_use_id: null, event: { type: "message_start", message: {} } };
+    const steerLifecycle = () => steerNotices
+      .filter((notice) => notice.method === "turn/started" || notice.method === "turn/completed")
+      .map((notice) => notice.method)
+      .join();
+    try {
+      const steerTurn = beginTurn(steerSession);
+      steerSession.steerPending = 1;
+      await consumeMessage(steerSession, steerResult(1));
+      await consumeMessage(steerSession, steerRun);
+      if (steerSession.turn?.id !== steerTurn || steerSession.steerPending !== 0) {
+        throw new Error("Claude steer run left the turn it joined");
+      }
+      await consumeMessage(steerSession, steerResult(0));
+      if (steerLifecycle() !== "turn/started,turn/completed") {
+        throw new Error(`Claude steer run reopened its turn: ${steerLifecycle()}`);
+      }
+      // A steer read only after the result still gets a turn from the debt.
+      steerNotices.length = 0;
+      beginTurn(steerSession);
+      steerSession.steerPending = 1;
+      await consumeMessage(steerSession, steerResult(0));
+      await consumeMessage(steerSession, steerRun);
+      if (steerLifecycle() !== "turn/started,turn/completed,turn/started") {
+        throw new Error(`Claude late steer lost its turn: ${steerLifecycle()}`);
+      }
+      // Esc before the steer's run begins closes the turn instead of stranding it.
+      finishTurn(steerSession, null);
+      beginTurn(steerSession);
+      steerSession.steerPending = 1;
+      await consumeMessage(steerSession, steerResult(1));
+      steerNotices.length = 0;
+      await dispatch("session/interrupt", { sessionId: steerSession.id });
+      const stopped = steerNotices.find((notice) => notice.method === "turn/completed")?.params?.turn;
+      if (steerSession.turn || stopped?.status !== "interrupted") {
+        throw new Error(`Claude steer wait survived Esc: ${JSON.stringify(stopped)}`);
+      }
+    } finally {
+      process.stdout.write = steerWrite;
+      sessions.delete(steerSession.id);
+    }
     beginTurn(limitSession);
     for (let attempt = 0; attempt < 4; attempt++) {
       await rejectLimit();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "1.9.39",
+  "version": "1.9.41",
   "type": "module",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [